projects / fishladder.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
added stuff
[fishladder.git] / fishladder.c
1 // Copyright (C) 2021 Harry Godden (hgn) - All Rights Reserved
2
3 #define VG_STEAM
4 #define VG_STEAM_APPID 1218140U
5 #include "vg/vg.h"
6 #include "fishladder_resources.h"
7
8 /*
9 Todo for release:
10 Tutorial levels:
11 1. Transport
12 2. Split
13 3. Merge (and explode)
14 4. Principle 1 (divide colours)
15 5. Principle 2 (combine colours)
16
17 Trainee levels:
18 Simple maths (x3)
19 Colour ordering (x2)
20 Routing problems (x2)
21
22 Medium levels:
23 Reverse order
24
25 New things to program:
26 UI text element renderer (SDF) DONE(sorta)
27 Particle system thing for ball collision
28 Level descriptions / titles HALF
29 Row Gridlines for I/O
30 Play button / Speed controller
31
32
33 After release:
34
35 */
36
37 const char *level_pack_1[] = {
38 "level0",
39 "level1",
40 "level2",
41 "level3",
42 "level4",
43 "level5",
44 "level6",
45 "level7_combine",
46 "xor_small",
47 "sort",
48 "thirds"
49 };
50
51 m3x3f m_projection;
52 m3x3f m_view;
53 m3x3f m_mdl;
54
55 #define FLAG_CANAL 0x1
56 #define FLAG_IS_TRIGGER 0x2
57 #define FLAG_RESERVED0 0x4
58 #define FLAG_RESERVED1 0x8
59
60 #define FLAG_INPUT 0x10
61 #define FLAG_OUTPUT 0x20
62 #define FLAG_WALL 0x40
63
64 #define FLAG_FLIP_FLOP 0x100
65 #define FLAG_TRIGGERED 0x200
66 #define FLAG_FLIP_ROTATING 0x400
67 #define FLAG_TARGETED 0x800
68
69 /*
70 0000 0 | 0001 1 | 0010 2 | 0011 3
71 | | | | |
72 X | X= | X | X=
73 | | |
74 0100 4 | 0101 5 | 0110 6 | 0111 7
75 | | | | |
76 =X | =X= | =X | =X=
77 | | |
78 1000 8 | 1001 9 | 1010 10 | 1011 11
79 | | | | |
80 X | X= | X | X=
81 | | | | | | |
82 1100 12 | 1101 13 | 1110 14 | 1111 15
83 | | | | |
84 =X | =X= | =X | =X=
85 | | | | | | |
86 */
87
88 struct cell_description
89 {
90 v2i start;
91 v2i end;
92
93 int is_special;
94 int is_linear;
95 }
96 cell_descriptions[] =
97 {
98 // 0-3
99 {},
100 { .start = { 1, 0 }, .end = { -1, 0 } },
101 { .start = { 0, 1 }, .end = { 0, -1 } },
102 { .start = { 0, 1 }, .end = { 1, 0 } },
103 // 4-7
104 { .start = { -1, 0 }, .end = { 1, 0 } },
105 { .start = { -1, 0 }, .end = { 1, 0 }, .is_linear = 1 },
106 { .start = { 0, 1 }, .end = { -1, 0 } },
107 { .start = { 0, 1 }, .is_special = 1 },
108 // 8-11
109 { .start = { 0, -1 }, .end = { 0, 1 } },
110 { .start = { 1, 0 }, .end = { 0, -1 } },
111 { .start = { 0, 1 }, .end = { 0, -1 }, .is_linear = 1 },
112 { },
113 // 12-15
114 { .start = { -1, 0 }, .end = { 0, -1 } },
115 { .end = { 0, -1 }, .is_special = 1 },
116 { },
117 { }
118 };
119
120 enum cell_type
121 {
122 k_cell_type_stub = 0,
123 k_cell_type_ramp_right = 3,
124 k_cell_type_ramp_left = 6,
125 k_cell_type_split = 7,
126 k_cell_type_merge = 13,
127 k_cell_type_con_r = 1,
128 k_cell_type_con_u = 2,
129 k_cell_type_con_l = 4,
130 k_cell_type_con_d = 8
131 };
132
133 v2f const curve_3[] = {{0.5f,1.0f},{0.5f,0.625f},{0.625f,0.5f},{1.0f,0.5f}};
134 v2f const curve_6[] = {{0.5f,1.0f},{0.5f,0.625f},{0.375f,0.5f},{0.0f,0.5f}};
135 v2f const curve_9[] = {{1.0f,0.5f},{0.625f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
136 v2f const curve_12[]= {{0.0f,0.5f},{0.375f,0.5f},{0.5f,0.375f},{0.5f,0.0f}};
137
138 v2f const curve_1[] = {{1.0f,0.5f},{0.8f,0.5f},{0.3f,0.5f},{0.2f,0.5f}};
139 v2f const curve_4[] = {{0.0f,0.5f},{0.3f,0.5f},{0.5f,0.5f},{0.8f,0.5f}};
140 v2f const curve_2[] = {{0.5f,1.0f},{0.5f,0.8f},{0.5f,0.3f},{0.5f,0.2f}};
141 v2f const curve_8[] = {{0.5f,0.0f},{0.5f,0.3f},{0.5f,0.5f},{0.5f,0.8f}};
142
143 v2f const curve_7[] = {{0.5f,0.8438f},{0.875f,0.8438f},{0.625f,0.5f},{1.0f,0.5f}};
144 v2f const curve_7_1[] = {{0.5f,0.8438f},{1.0f-0.875f,0.8438f},{1.0-0.625f,0.5f},{0.0f,0.5f}};
145
146 float const curve_7_linear_section = 0.1562f;
147
148 v3f colour_sets[] =
149 { { 1.0f, 0.9f, 0.3f },
150 { 0.2f, 0.9f, 0.14f },
151 { 0.4f, 0.8f, 1.00f } };
152
153 static void colour_code_v3( char cc, v3f target )
154 {
155 if( cc >= 'a' && cc <= 'z' )
156 {
157 int id = cc - 'a';
158
159 if( id < vg_list_size( colour_sets ) )
160 {
161 v3_copy( colour_sets[ id ], target );
162 return;
163 }
164 }
165
166 v3_copy( (v3f){0.0f,0.0f,0.0f}, target );
167 }
168
169 struct mesh
170 {
171 GLuint vao, vbo;
172 u32 elements;
173 };
174
175 static void init_mesh( struct mesh *m, float const *tris, u32 length )
176 {
177 m->elements = length/3;
178 glGenVertexArrays( 1, &m->vao );
179 glGenBuffers( 1, &m->vbo );
180
181 glBindVertexArray( m->vao );
182 glBindBuffer( GL_ARRAY_BUFFER, m->vbo );
183 glBufferData( GL_ARRAY_BUFFER, length*sizeof(float), tris, GL_STATIC_DRAW );
184
185 glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 2 * sizeof(float), (void*)0 );
186 glEnableVertexAttribArray( 0 );
187
188 VG_CHECK_GL();
189 }
190
191 static void free_mesh( struct mesh *m )
192 {
193 glDeleteVertexArrays( 1, &m->vao );
194 glDeleteBuffers( 1, &m->vbo );
195 }
196
197 static void draw_mesh( int const start, int const count )
198 {
199 glDrawArrays( GL_TRIANGLES, start*3, count*3 );
200 }
201
202 static void use_mesh( struct mesh *m )
203 {
204 glBindVertexArray( m->vao );
205 }
206
207 enum e_fish_state
208 {
209 k_fish_state_soon_dead = -1,
210 k_fish_state_dead = 0,
211 k_fish_state_alive,
212 k_fish_state_bg,
213 k_fish_state_soon_alive
214 };
215
216 struct world
217 {
218 #pragma pack(push,1)
219 struct cell
220 {
221 u16 state;
222 u16 links[2];
223 u8 config;
224 u8 pad0;
225 }
226 *data;
227 #pragma pack(pop)
228
229 int frame;
230
231 int initialzed;
232
233 int sim_frame;
234 float sim_start;
235 int simulating;
236 int sim_run, max_runs;
237
238 float sim_speed;
239 float frame_lerp;
240
241 struct cell_terminal
242 {
243 //char *conditions;
244 //char recv[12];
245
246 struct terminal_run
247 {
248 char conditions[8];
249 char recieved[8];
250
251 int condition_count, recv_count;
252 }
253 runs[8];
254
255 int run_count;
256
257 int id;
258 }
259 *io;
260
261 int w, h;
262
263 struct mesh tile, circle, numbers;
264 struct mesh_wire
265 {
266 GLuint vao, vbo, ebo;
267 u32 em;
268 }
269 wire;
270
271 GLuint background_data;
272 GLuint random_samples;
273
274 int selected, tile_x, tile_y;
275 v2f tile_pos;
276
277 struct fish
278 {
279 v2i pos;
280 v2i dir;
281 enum e_fish_state state;
282 char payload;
283 int flow_reversed;
284 float death_time;
285 v2f physics_v;
286 v2f physics_co;
287 }
288 fishes[16];
289
290 int num_fishes;
291
292 char map_name[64];
293 //struct career_level *ptr_career_level;
294 struct cmp_level *pCmpLevel;
295
296 u32 score;
297 u32 completed;
298 u32 time;
299 } world;
300
301 void leaderboard_set_score( struct cmp_level *cmp_level, u32 score );
302
303 static void map_free(void)
304 {
305 arrfree( world.data );
306 arrfree( world.io );
307
308 world.w = 0;
309 world.h = 0;
310 world.data = NULL;
311 world.io = NULL;
312 world.score = 0;
313 world.time = 0;
314 world.completed = 0;
315 world.max_runs = 0;
316 world.initialzed = 0;
317 }
318
319 static void io_reset(void)
320 {
321 for( int i = 0; i < arrlen( world.io ); i ++ )
322 {
323 struct cell_terminal *term = &world.io[i];
324
325 for( int j = 0; j < term->run_count; j ++ )
326 term->runs[j].recv_count = 0;
327 }
328 }
329
330 int random_noise[] = {
331 0x46,0xD5,0xB8,0xD3,0xF2,0xE5,0xCC,0x07,0xD0,0xB3,0x7A,0xA2,0xC3,0xDA,0xDC,0x7F,0xE0,0xB7,0x42,0xA0,0xBF,0x41,0x92,0x32,0x6F,0x0D,0x45,0xC7,0x54,0xDB,0x30,0xC2,
332 0xD5,0xDA,0x55,0x09,0xDE,0x74,0x48,0x20,0xE1,0x24,0x5C,0x4D,0x6F,0x36,0xD8,0xE9,0x8D,0x8F,0x54,0x99,0x98,0x51,0xFE,0xDB,0x26,0x04,0x65,0x57,0x56,0xF3,0x53,0x30,
333 0x3D,0x16,0xC0,0xB6,0xF2,0x47,0xCF,0x62,0xB0,0x6C,0x8F,0x4F,0x8C,0x4C,0x17,0xF0,0x19,0x7E,0x2D,0x81,0x8D,0xFB,0x10,0xD3,0x49,0x50,0x60,0xFD,0x38,0x15,0x3B,0xEE,
334 0x05,0xC1,0xCF,0x62,0x97,0x75,0xDF,0x4E,0x4D,0x89,0x5E,0x88,0x5C,0x30,0x8C,0x54,0x1D,0x39,0x41,0xEA,0xA2,0x63,0x12,0x1B,0x8E,0x35,0x22,0x9B,0x98,0xA3,0x7F,0x80,
335 0xD6,0x27,0x94,0x66,0xB5,0x1D,0x7E,0xDF,0x96,0x28,0x38,0x3A,0xA0,0xE8,0x71,0x09,0x62,0x5E,0x9D,0x53,0x58,0x1B,0x7D,0x0D,0x2D,0x99,0x77,0x83,0xC3,0x89,0xC2,0xA2,
336 0xA7,0x1D,0x78,0x80,0x37,0xC1,0x87,0xFF,0x65,0xBF,0x2C,0xF1,0xE5,0xB3,0x09,0xE0,0x25,0x92,0x83,0x0F,0x8A,0x57,0x3C,0x0B,0xC6,0xBC,0x44,0x16,0xE3,0xCE,0xC3,0x0D,
337 0x69,0xD3,0xC6,0x99,0xB8,0x46,0x44,0xC4,0xF3,0x1E,0xBF,0xF5,0xB4,0xDB,0xFB,0x93,0xA1,0x7B,0xC9,0x08,0x77,0x22,0xE5,0x02,0xEF,0x9E,0x90,0x94,0x8A,0xA6,0x3D,0x7E,
338 0xA2,0xA0,0x10,0x82,0x47,0x5C,0xAA,0xF8,0x2F,0x0D,0x9F,0x76,0xDA,0x99,0x0F,0xCB,0xE2,0x02,0x0C,0x75,0xCA,0x35,0x29,0xA6,0x49,0x83,0x6D,0x91,0xB4,0xEC,0x31,0x69,
339 0xBA,0x13,0xF3,0xC7,0x21,0x06,0xC8,0x79,0xEF,0xB1,0x9C,0x6A,0xEE,0x64,0x9A,0xDC,0x1E,0xC6,0x18,0x93,0xA9,0x7E,0x89,0x7D,0x96,0xE5,0x44,0xB8,0x00,0x15,0xAF,0x8C,
340 0x78,0x8F,0xA8,0x05,0xA7,0x07,0x25,0x9A,0xC8,0x5D,0x90,0x1A,0x41,0x53,0x30,0xD3,0x24,0x33,0x71,0xB4,0x50,0x6E,0xE4,0xEA,0x0D,0x2B,0x6D,0xF5,0x17,0x08,0x74,0x49,
341 0x71,0xC2,0xAC,0xF7,0xDC,0xB2,0x7E,0xCC,0xB6,0x1B,0xB8,0xA9,0x52,0xCF,0x6B,0x51,0xD2,0x4E,0xC9,0x43,0xEE,0x2E,0x92,0x24,0xBB,0x47,0x4D,0x0C,0x3E,0x21,0x53,0x19,
342 0xD4,0x82,0xE2,0xC6,0x93,0x85,0x0A,0xF8,0xFA,0x04,0x07,0xD3,0x1D,0xEC,0x03,0x66,0xFD,0xB1,0xFB,0x8F,0xC5,0xDE,0xE8,0x29,0xDF,0x23,0x09,0x9D,0x7C,0x43,0x3D,0x4D,
343 0x89,0xB9,0x6F,0xB4,0x6B,0x4A,0x51,0xC3,0x94,0xF4,0x7C,0x5E,0x19,0x87,0x79,0xC1,0x80,0x0C,0x45,0x12,0xEC,0x95,0xF3,0x31,0x68,0x42,0xE1,0x06,0x57,0x0E,0xA7,0xFB,
344 0x78,0x96,0x87,0x23,0xA5,0x20,0x7A,0x09,0x3A,0x45,0xE6,0xD9,0x5E,0x6A,0xD6,0xAA,0x29,0x50,0x92,0x4E,0xD0,0xB5,0x91,0xC2,0x9A,0xCF,0x07,0xFE,0xB2,0x15,0xEB,0xE4,
345 0x84,0x40,0x14,0x47,0xFA,0x93,0xB9,0x06,0x69,0xDB,0xBD,0x4E,0xEA,0x52,0x9B,0xDE,0x5B,0x50,0x36,0xAB,0xB3,0x1F,0xD2,0xCD,0x9C,0x13,0x07,0x7E,0x8B,0xED,0x72,0x62,
346 0x74,0x77,0x3B,0x88,0xAC,0x5B,0x6A,0xBC,0xDA,0x99,0xE8,0x24,0x90,0x5A,0xCA,0x8D,0x5C,0x2B,0xF8,0xF1,0xE1,0x1D,0x94,0x11,0xEA,0xCC,0x02,0x09,0x1E,0xA2,0x48,0x67,
347 0x87,0x5A,0x7E,0xC6,0xCC,0xA3,0xFB,0xC5,0x36,0xEB,0x5C,0xE1,0xAF,0x1E,0xBE,0xE7,0xD8,0x8F,0x70,0xAE,0x42,0x05,0xF5,0xCD,0x2D,0xA2,0xB0,0xFD,0xEF,0x65,0x2C,0x22,
348 0xCB,0x8C,0x8B,0xAA,0x3D,0x86,0xE2,0xCD,0xBE,0xC3,0x42,0x38,0xE3,0x9C,0x08,0xB5,0xAE,0xBD,0x54,0x73,0x83,0x70,0x24,0x47,0xCA,0x4C,0x04,0xC4,0xE0,0x1D,0x40,0xED,
349 0xF4,0x2B,0x50,0x8E,0x97,0xB3,0xF0,0xA6,0x76,0xDB,0x49,0x30,0xE5,0xD9,0x71,0x07,0xB2,0xF1,0x0F,0xD6,0x77,0xAA,0x72,0xC0,0xAF,0x66,0xD8,0x40,0xC6,0x08,0x19,0x8C,
350 0xD9,0x8F,0x5A,0x75,0xAC,0xBE,0xC2,0x40,0x5B,0xBD,0x0D,0x1D,0x00,0xAF,0x26,0x5E,0x78,0x43,0xAA,0xC6,0x4F,0xF3,0xD8,0xE2,0x7F,0x0C,0x1E,0x77,0x4D,0x35,0x96,0x23,
351 0x32,0x44,0x03,0x8D,0x92,0xE7,0xFD,0x48,0x07,0xD0,0x58,0xFC,0x6D,0xC9,0x91,0x33,0xF0,0x23,0x45,0xA4,0x29,0xB9,0xF5,0xB0,0x68,0x8F,0x7B,0x59,0x15,0x8E,0xA6,0x66,
352 0x15,0xA0,0x76,0x9B,0x69,0xCB,0x38,0xA5,0xF4,0xB4,0x6B,0xDC,0x1F,0xAB,0xAE,0x12,0x77,0xC0,0x8C,0x4A,0x03,0xB9,0x73,0xD3,0x6D,0x52,0xC5,0xF5,0x6E,0x4E,0x4B,0xA3,
353 0x24,0x02,0x58,0xEE,0x5F,0xF9,0xD6,0xD0,0x1D,0xBC,0xF4,0xB8,0x4F,0xFD,0x4B,0x2D,0x34,0x77,0x46,0xE5,0xD4,0x33,0x7B,0x9C,0x35,0xCD,0xB0,0x5D,0x06,0x39,0x99,0xEB,
354 0x0C,0xD0,0x0F,0xF7,0x92,0xB5,0x58,0x5B,0x5E,0x79,0x12,0xF4,0x05,0xF6,0x21,0x07,0x0B,0x49,0x1A,0xFB,0xD4,0x98,0xC4,0xEF,0x7A,0xD6,0xCA,0xA1,0xDA,0xB3,0x51,0x00,
355 0x76,0xEC,0x08,0x48,0x40,0x35,0xD7,0x94,0xBE,0xF5,0x7B,0xA4,0x20,0x81,0x5F,0x82,0xF3,0x6F,0x96,0x24,0x98,0xB6,0x49,0x18,0xC8,0xC5,0x8C,0xD2,0x38,0x7F,0xC4,0xF6,
356 0xAA,0x87,0xDC,0x73,0x5B,0xA1,0xAF,0xE5,0x3D,0x37,0x6B,0x85,0xED,0x38,0x62,0x7D,0x57,0xBD,0xCF,0xB5,0x1B,0xA8,0xBB,0x32,0x33,0xD3,0x34,0x5A,0xC1,0x5D,0xFB,0x28,
357 0x6E,0xE1,0x67,0x51,0xBB,0x31,0x92,0x83,0xAC,0xAA,0x72,0x52,0xFD,0x13,0x4F,0x73,0xD3,0xF0,0x5E,0xFC,0xBA,0xB1,0x3C,0x7B,0x08,0x76,0x03,0x38,0x1E,0xD1,0xCC,0x33,
358 0xA3,0x1E,0xFC,0xE0,0x82,0x30,0x27,0x93,0x71,0x35,0x75,0x77,0xBA,0x78,0x10,0x33,0xCD,0xAB,0xCF,0x8E,0xAD,0xF9,0x32,0xC9,0x15,0x9F,0xD6,0x6D,0xA8,0xAE,0xB1,0x3F,
359 0x90,0xEB,0xD4,0xF9,0x31,0x81,0xA3,0x53,0x99,0x4B,0x3C,0x93,0x3B,0xFE,0x55,0xFF,0x25,0x9F,0xCC,0x07,0xC5,0x2C,0x14,0xA7,0xA4,0x1E,0x6C,0xB6,0x91,0x2A,0xE0,0x3E,
360 0x7F,0x39,0x0A,0xD9,0x24,0x3C,0x01,0xA0,0x30,0x99,0x8E,0xB8,0x1D,0xF9,0xA7,0x78,0x86,0x95,0x35,0x0E,0x21,0xDA,0x7A,0x7B,0xAD,0x9F,0x4E,0xF6,0x63,0x5B,0x96,0xBB,
361 0x87,0x36,0x3F,0xA7,0x1A,0x66,0x91,0xCD,0xB0,0x3B,0xC0,0x4F,0x54,0xD2,0x5F,0xBB,0x38,0x89,0x1C,0x79,0x7E,0xA2,0x02,0xE4,0x80,0x84,0x1E,0x33,0xAB,0x74,0xFA,0xBE,
362 0x31,0x46,0x2E,0xC5,0x15,0xB9,0x12,0xE9,0xD3,0x73,0x43,0xEA,0x74,0x11,0xA7,0xC0,0xD5,0xD8,0x39,0x08,0x9F,0x4F,0xC7,0x71,0x25,0x09,0x51,0x65,0xD6,0xA8,0x02,0x1F
363 };
364
365 static int hash21i( v2i p, u32 umod )
366 {
367 return random_noise[ (random_noise[p[1] & 1023] + p[0]) & 1023 ] & umod;
368 }
369
370 static void map_reclassify( v2i start, v2i end, int update_texbuffer );
371 static int map_load( const char *str, const char *name )
372 {
373 //TODO: It may be worthwhile, at this point, to switch to binary encoding for save data
374
375 map_free();
376
377 char const *c = str;
378
379 // Scan for width
380 for(;; world.w ++)
381 {
382 if( c[world.w] == ';' )
383 break;
384 else if( !c[world.w] )
385 {
386 vg_error( "Unexpected EOF when parsing level\n" );
387 return 0;
388 }
389 }
390
391 struct cell *row = arraddnptr( world.data, world.w );
392 int cx = 0;
393 int reg_start = 0, reg_end = 0;
394
395 u32 *links_to_make = NULL;
396 int links_satisfied = 0;
397
398 char link_id_buffer[32];
399 int link_id_n = 0;
400
401 for(;;)
402 {
403 if( !*c )
404 break;
405
406 if( *c == '\r' ) { c ++; continue; } // fuck off windows
407
408 if( *c == ';' )
409 {
410 c ++;
411
412 if( *c == '\r' ) c ++;
413
414 // Parse attribs
415 if( *c != '\n' )
416 {
417 while( *c )
418 {
419 if( *c == '\r' ) { c ++; continue; }
420
421 if( reg_start < reg_end )
422 {
423 struct cell_terminal *terminal = &world.io[ reg_start ];
424 struct terminal_run *run = &terminal->runs[ terminal->run_count-1 ];
425
426 if( *c >= 'a' && *c <= 'z' )
427 {
428 run->conditions[ run->condition_count ++ ] = *c;
429 }
430 else
431 {
432 if( *c == ',' || *c == '\n' )
433 {
434 reg_start ++;
435
436 if( *c == '\n' )
437 break;
438 }
439 else if( *c == ':' )
440 {
441 terminal->runs[ terminal->run_count ].condition_count = 0;
442 terminal->run_count ++;
443 world.max_runs = vg_max( world.max_runs, terminal->run_count );
444 }
445 else
446 {
447 vg_error( "Unkown attribute '%c' (row: %u)\n", *c, world.h );
448 goto IL_REG_ERROR;
449 }
450 }
451 }
452 else
453 {
454 if( links_satisfied < arrlen( links_to_make ) )
455 {
456 struct cell *target = &world.data[ links_to_make[ links_satisfied ] ];
457
458 if( (((u32)*c >= (u32)'0') && ((u32)*c <= (u32)'9')) || *c == '-' )
459 {
460 if( link_id_n >= vg_list_size( link_id_buffer )-1 )
461 {
462 vg_error( "Number was way too long to be parsed (row: %u)\n", world.h );
463 goto IL_REG_ERROR;
464 }
465
466 link_id_buffer[ link_id_n ++ ] = *c;
467 }
468 else if( *c == ',' || *c == '\n' )
469 {
470 link_id_buffer[ link_id_n ] = 0x00;
471 int value = atoi( link_id_buffer );
472
473 target->links[value >= 0? 1:0] = abs(value);
474 links_satisfied ++;
475 link_id_n = 0;
476
477 if( *c == '\n' )
478 break;
479 }
480 else
481 {
482 vg_error( "Invalid character '%c' (row: %u)\n", *c, world.h );
483 goto IL_REG_ERROR;
484 }
485 }
486 else
487 {
488 vg_error( "Too many values to assign (row: %u)\n", world.h );
489 goto IL_REG_ERROR;
490 }
491 }
492
493 c ++;
494 }
495 }
496
497 // Registry length-error checks
498 if( reg_start != reg_end )
499 {
500 vg_error( "Not enough spawn values assigned (row: %u, %u of %u)\n", world.h, reg_start, reg_end );
501 goto IL_REG_ERROR;
502 }
503
504 if( links_satisfied != arrlen( links_to_make ) )
505 {
506 vg_error( "Not enough link values assigned (row: %u, %u of %u)\n", world.h, links_satisfied, arrlen( links_to_make ) );
507 goto IL_REG_ERROR;
508 }
509
510 if( cx != world.w )
511 {
512 vg_error( "Not enough cells to match previous row definition (row: %u, %u<%u)\n", world.h, cx, world.w );
513 goto IL_REG_ERROR;
514 }
515
516 row = arraddnptr( world.data, world.w );
517 cx = 0;
518 world.h ++;
519 reg_end = reg_start = arrlen( world.io );
520
521 arrsetlen( links_to_make, 0 );
522 links_satisfied = 0;
523 }
524 else
525 {
526 if( cx == world.w )
527 {
528 vg_error( "Too many cells to match previous row definition (row: %u, %u>%u)\n", world.h, cx, world.w );
529 goto IL_REG_ERROR;
530 }
531
532 // Tile initialization
533 // row[ cx ] .. etc
534 struct cell *cell = &row[ cx ];
535 cell->config = 0xF;
536
537 if( *c == '+' || *c == '-' )
538 {
539 struct cell_terminal *term = arraddnptr( world.io, 1 );
540 term->id = cx + world.h*world.w;
541 term->run_count = 1;
542 term->runs[0].condition_count = 0;
543
544 cell->state = *c == '+'? FLAG_INPUT: FLAG_OUTPUT;
545 reg_end ++;
546 }
547 else if( *c == '#' ) cell->state = FLAG_WALL;
548 else if( ((u32)*c >= (u32)'A') && ((u32)*c <= (u32)'A'+0xf) )
549 {
550 // Canal flag bits (4bit/16 value):
551 // 0: Canal present
552 // 1: Is trigger
553 // 2: Reserved
554 // 3: Reserved
555
556 cell->state = ((u32)*c - (u32)'A') & (FLAG_CANAL|FLAG_IS_TRIGGER);
557
558 if( cell->state & FLAG_IS_TRIGGER )
559 arrpush( links_to_make, cx + world.h*world.w );
560
561 cell->links[0] = 0;
562 cell->links[1] = 0;
563 world.score ++;
564 }
565 else cell->state = 0x00;
566
567 cx ++;
568 }
569
570 c ++;
571 }
572
573 // Update data texture to fill out the background
574 {
575 u8 info_buffer[64*64*4];
576 for( int x = 0; x < 64; x ++ )
577 {
578 for( int y = 0; y < 64; y ++ )
579 {
580 u8 *px = &info_buffer[((x*64)+y)*4];
581
582 px[0] = 0xFF-0x3F + hash21i( (v2i){x,y}, 0x3F );
583 px[1] = 0;
584 px[2] = 0;
585 px[3] = 0;
586 }
587 }
588
589 // Random walks.. kinda
590 for( int i = 0; i < arrlen(world.io); i ++ )
591 {
592 struct cell_terminal *term = &world.io[ i ];
593 int posx = term->id % world.w;
594 int posy = (term->id - posx)/world.w;
595
596 v2i turtle;
597 v2i turtle_dir;
598 int original_y;
599
600 turtle[0] = 16+posx;
601 turtle[1] = 16+posy;
602
603 turtle_dir[0] = 0;
604 turtle_dir[1] = posy <= 4? -1: 1;
605 original_y = turtle_dir[1];
606
607 for( int i = 0; i < 100; i ++ )
608 {
609 info_buffer[((turtle[1]*64)+turtle[0])*4] = 0;
610
611 v2i_add( turtle_dir, turtle, turtle );
612
613 if( turtle[0] == 0 ) break;
614 if( turtle[0] == 63 ) break;
615 if( turtle[1] == 0 ) break;
616 if( turtle[1] == 63 ) break;
617
618 int random_value = hash21i( turtle, 0xFF );
619 if( random_value > 255-40 && !turtle_dir[0] )
620 {
621 turtle_dir[0] = -1;
622 turtle_dir[1] = 0;
623 }
624 else if( random_value > 255-80 && !turtle_dir[0] )
625 {
626 turtle_dir[0] = 1;
627 turtle_dir[1] = 0;
628 }
629 else if( random_value > 255-100 )
630 {
631 turtle_dir[0] = 0;
632 turtle_dir[1] = original_y;
633 }
634 }
635 }
636
637 glBindTexture( GL_TEXTURE_2D, world.background_data );
638 glTexSubImage2D( GL_TEXTURE_2D, 0, 0, 0, 64, 64, GL_RGBA, GL_UNSIGNED_BYTE, info_buffer );
639 }
640
641 arrfree( links_to_make );
642
643 map_reclassify( NULL, NULL, 1 );
644
645 // Validate links
646 for( int i = 0; i < world.h*world.w; i ++ )
647 {
648 struct cell *src = &world.data[i];
649 if( src->state & FLAG_IS_TRIGGER )
650 {
651 int link_id = src->links[0]?0:1;
652 if( src->links[link_id] <= world.h*world.w )
653 {
654 struct cell *target = &world.data[ src->links[link_id] ];
655 if( (target->state & FLAG_CANAL) && (target->config == k_cell_type_split) )
656 {
657 if( target->links[ link_id ] )
658 {
659 vg_error( "Link target was already targeted\n" );
660 goto IL_REG_ERROR;
661 }
662 else
663 {
664 // Valid link
665 target->links[ link_id ] = i;
666 target->state |= FLAG_TARGETED;
667 }
668 }
669 else
670 {
671 vg_error( "Link target was invalid\n" );
672 goto IL_REG_ERROR;
673 }
674 }
675 else
676 {
677 vg_error( "Link target out of bounds\n" );
678 goto IL_REG_ERROR;
679 }
680 }
681 }
682
683 vg_success( "Map '%s' loaded! (%u:%u)\n", name, world.w, world.h );
684
685 io_reset();
686
687 strncpy( world.map_name, name, vg_list_size( world.map_name )-1 );
688 world.initialzed = 1;
689 return 1;
690
691 IL_REG_ERROR:
692 arrfree( links_to_make );
693 map_free();
694 return 0;
695 }
696
697 static struct cell *pcell( v2i pos )
698 {
699 return &world.data[ pos[1]*world.w + pos[0] ];
700 }
701
702 static void map_serialize( FILE *stream )
703 {
704 for( int y = 0; y < world.h; y ++ )
705 {
706 for( int x = 0; x < world.w; x ++ )
707 {
708 struct cell *cell = pcell( (v2i){ x, y } );
709
710 if( cell->state & FLAG_WALL ) fputc( '#', stream );
711 else if( cell->state & FLAG_INPUT ) fputc( '+', stream );
712 else if( cell->state & FLAG_OUTPUT ) fputc( '-', stream );
713 else if( cell->state & (FLAG_CANAL|FLAG_IS_TRIGGER|FLAG_RESERVED0|FLAG_RESERVED1) )
714 {
715 fputc( (cell->state & (FLAG_CANAL|FLAG_IS_TRIGGER|FLAG_RESERVED0|FLAG_RESERVED1)) + (u32)'A', stream );
716 }
717 else fputc( ' ', stream );
718 }
719
720 fputc( ';', stream );
721
722 int terminal_write_count = 0;
723
724 for( int x = 0; x < world.w; x ++ )
725 {
726 for( int i = 0; i < arrlen( world.io ); i ++ )
727 {
728 struct cell_terminal *term = &world.io[i];
729 if( term->id == y*world.w+x )
730 {
731 if( terminal_write_count )
732 fputc( ',', stream );
733 terminal_write_count ++;
734
735 for( int j = 0; j < term->run_count; j ++ )
736 {
737 struct terminal_run *run = &term->runs[j];
738
739 for( int k = 0; k < run->condition_count; k ++ )
740 fputc( run->conditions[k], stream );
741
742 if( j < term->run_count-1 )
743 fputc( ':', stream );
744 }
745 }
746 }
747 }
748
749 for( int x = 0; x < world.w; x ++ )
750 {
751 struct cell *cell = pcell( (v2i){ x,y } );
752 if( cell->state & FLAG_IS_TRIGGER )
753 {
754 if( terminal_write_count )
755 fputc( ',', stream );
756 terminal_write_count ++;
757
758 fprintf( stream, "%d", cell->links[0]? -cell->links[0]: cell->links[1] );
759 }
760 }
761
762 fputc( '\n', stream );
763 }
764 }
765
766 int main( int argc, char *argv[] )
767 {
768 vg_init( argc, argv, "Marble Computing | SPACE: Test | LeftClick: Toggle tile | RightClick: Drag wire" );
769 return 0;
770 }
771
772 static int console_credits( int argc, char const *argv[] )
773 {
774 vg_info( "Aknowledgements:\n" );
775 vg_info( " GLFW zlib/libpng glfw.org\n" );
776 vg_info( " miniaudio MIT0 miniaud.io\n" );
777 vg_info( " QOI MIT phoboslab.org\n" );
778 vg_info( " STB library MIT nothings.org\n" );
779 vg_info( " Weiholmir font justfredrik.itch.io\n" );
780 return 0;
781 }
782
783 static int console_save_map( int argc, char const *argv[] )
784 {
785 if( !world.initialzed )
786 {
787 vg_error( "Tried to save uninitialized map!\n" );
788 return 0;
789 }
790
791 char map_path[ 256 ];
792
793 strcpy( map_path, "sav/" );
794 strcat( map_path, world.map_name );
795 strcat( map_path, ".map" );
796
797 FILE *test_writer = fopen( map_path, "wb" );
798 if( test_writer )
799 {
800 vg_info( "Saving map to '%s'\n", map_path );
801 map_serialize( test_writer );
802
803 fclose( test_writer );
804 return 1;
805 }
806 else
807 {
808 vg_error( "Unable to open stream for writing\n" );
809 return 0;
810 }
811 }
812
813 static int console_load_map( int argc, char const *argv[] )
814 {
815 char map_path[ 256 ];
816
817 if( argc >= 1 )
818 {
819 // try from saves
820 strcpy( map_path, "sav/" );
821 strcat( map_path, argv[0] );
822 strcat( map_path, ".map" );
823
824 char *text_source = vg_textasset_read( map_path );
825
826 if( !text_source )
827 {
828 strcpy( map_path, "maps/" );
829 strcat( map_path, argv[0] );
830 strcat( map_path, ".map" );
831
832 text_source = vg_textasset_read( map_path );
833 }
834
835 if( text_source )
836 {
837 vg_info( "Loading map: '%s'\n", map_path );
838 world.pCmpLevel = NULL;
839
840 if( !map_load( text_source, argv[0] ) )
841 {
842 free( text_source );
843 return 0;
844 }
845
846 free( text_source );
847 return 1;
848 }
849 else
850 {
851 vg_error( "Missing maps '%s'\n", argv[0] );
852 return 0;
853 }
854 }
855 else
856 {
857 vg_error( "Missing argument <map_path>\n" );
858 return 0;
859 }
860 }
861
862 static void simulation_stop(void)
863 {
864 world.simulating = 0;
865 world.num_fishes = 0;
866 world.sim_frame = 0;
867 world.sim_run = 0;
868
869 io_reset();
870
871 sfx_system_fadeout( &audio_system_balls_rolling, 44100 );
872
873 vg_info( "Stopping simulation!\n" );
874 }
875
876 static int console_changelevel( int argc, char const *argv[] )
877 {
878 if( argc >= 1 )
879 {
880 // Save current level
881 console_save_map( 0, NULL );
882 if( console_load_map( argc, argv ) )
883 {
884 simulation_stop();
885 return 1;
886 }
887 }
888 else
889 {
890 vg_error( "Missing argument <map_path>\n" );
891 }
892
893 return 0;
894 }
895
896 #pragma pack(push,1)
897 struct dcareer_state
898 {
899 u32 version;
900 i32 in_map;
901
902 u32 reserved[14];
903
904 struct dlevel_state
905 {
906 i32 score;
907 i32 unlocked;
908 i32 reserved[2];
909 }
910 levels[ NUM_CAMPAIGN_LEVELS ];
911 };
912 #pragma pack(pop)
913
914 static void career_serialize(void)
915 {
916 struct dcareer_state encoded;
917 encoded.version = 2;
918 encoded.in_map = world.pCmpLevel? world.pCmpLevel->serial_id: -1;
919
920 memset( encoded.reserved, 0, sizeof( encoded.reserved ) );
921
922 for( int i = 0; i < vg_list_size( career_serializable ); i ++ )
923 {
924 struct serializable_set *set = &career_serializable[i];
925
926 for( int j = 0; j < set->count; j ++ )
927 {
928 struct cmp_level *lvl = &set->pack[j];
929 struct dlevel_state *dest = &encoded.levels[lvl->serial_id];
930
931 dest->score = lvl->completed_score;
932 dest->unlocked = lvl->unlocked;
933 dest->reserved[0] = 0;
934 dest->reserved[1] = 0;
935 }
936 }
937
938 vg_asset_write( "sav/game.sv2", &encoded, sizeof( struct dcareer_state ) );
939 }
940
941 static void career_unlock_level( struct cmp_level *lvl );
942 static void career_unlock_level( struct cmp_level *lvl )
943 {
944 lvl->unlocked = 1;
945
946 if( lvl->linked )
947 career_unlock_level( lvl->linked );
948 }
949
950 static void career_pass_level( struct cmp_level *lvl, int score, int upload )
951 {
952 if( score > 0 )
953 {
954 if( score < lvl->completed_score || lvl->completed_score == 0 )
955 {
956 if( !lvl->is_tutorial && upload )
957 leaderboard_set_score( lvl, score );
958
959 lvl->completed_score = score;
960 }
961
962 if( lvl->unlock ) career_unlock_level( lvl->unlock );
963 }
964 }
965
966 static void career_reset_level( struct cmp_level *lvl )
967 {
968 lvl->unlocked = 0;
969 lvl->completed_score = 0;
970 }
971
972 static void career_load(void)
973 {
974 i64 sz;
975 struct dcareer_state encoded;
976
977 // Blank save state
978 memset( (void*)&encoded, 0, sizeof( struct dcareer_state ) );
979 encoded.in_map = -1;
980 encoded.levels[0].unlocked = 1;
981
982 // Load and copy data into encoded
983 void *cr = vg_asset_read_s( "sav/game.sv2", &sz );
984
985 if( cr )
986 {
987 if( sz > sizeof( struct dcareer_state ) )
988 vg_warn( "This save file is too big! Some levels will be lost\n" );
989
990 if( sz <= offsetof( struct dcareer_state, levels ) )
991 {
992 vg_warn( "This save file is too small to have a header. Creating a blank one\n" );
993 free( cr );
994 return;
995 }
996
997 memcpy( (void*)&encoded, cr, VG_MIN( sizeof( struct dcareer_state ), sz ) );
998 free( cr );
999 }
1000 else
1001 vg_info( "No save file... Using blank one\n" );
1002
1003 // Reset memory
1004 for( int i = 0; i < vg_list_size( career_serializable ); i ++ )
1005 {
1006 struct serializable_set *set = &career_serializable[i];
1007
1008 for( int j = 0; j < set->count; j ++ )
1009 career_reset_level( &set->pack[j] );
1010 }
1011
1012 // Header information
1013 // =================================
1014
1015 // Decode everything from dstate
1016 for( int i = 0; i < vg_list_size( career_serializable ); i ++ )
1017 {
1018 struct serializable_set *set = &career_serializable[i];
1019
1020 for( int j = 0; j < set->count; j ++ )
1021 {
1022 struct cmp_level *lvl = &set->pack[j];
1023 struct dlevel_state *src = &encoded.levels[lvl->serial_id];
1024
1025 if( src->unlocked ) career_unlock_level( lvl );
1026 if( src->score ) lvl->completed_score = src->score;
1027
1028 // ...
1029 if( lvl->serial_id == encoded.in_map )
1030 {
1031 if( console_changelevel( 1, &lvl->map_name ) )
1032 world.pCmpLevel = lvl;
1033 }
1034 }
1035 }
1036 }
1037
1038 void leaderboard_found( LeaderboardFindResult_t *pCallback );
1039 void leaderboard_downloaded( LeaderboardScoresDownloaded_t *pCallback );
1040
1041 void vg_start(void)
1042 {
1043 // Steamworks callbacks
1044 sw_leaderboard_found = &leaderboard_found;
1045 sw_leaderboard_downloaded = &leaderboard_downloaded;
1046
1047 vg_function_push( (struct vg_cmd){
1048 .name = "_map_write",
1049 .function = console_save_map
1050 });
1051
1052 vg_function_push( (struct vg_cmd){
1053 .name = "_map_load",
1054 .function = console_load_map
1055 });
1056
1057 vg_function_push( (struct vg_cmd){
1058 .name = "map",
1059 .function = console_changelevel
1060 });
1061
1062 vg_function_push( (struct vg_cmd){
1063 .name = "credits",
1064 .function = console_credits
1065 });
1066
1067 // Quad mesh
1068 {
1069 float quad_mesh[] =
1070 {
1071 0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
1072 0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f,
1073
1074 0.0f, 0.0f, 0.0f, 1.0f, 4.0f, 1.0f,
1075 0.0f, 0.0f, 4.0f, 1.0f, 4.0f, 0.0f
1076 };
1077
1078 init_mesh( &world.tile, quad_mesh, vg_list_size(quad_mesh) );
1079 }
1080
1081 // Circle mesh
1082 {
1083 float circle_mesh[32*6*3];
1084 int res = vg_list_size( circle_mesh ) / (6*3);
1085
1086 for( int i = 0; i < res; i ++ )
1087 {
1088 v2f v0 = { sinf( ((float)i/(float)res)*VG_TAUf ), cosf( ((float)i/(float)res)*VG_TAUf ) };
1089 v2f v1 = { sinf( ((float)(i+1)/(float)res)*VG_TAUf ), cosf( ((float)(i+1)/(float)res)*VG_TAUf ) };
1090
1091 circle_mesh[ i*6+0 ] = 0.0f;
1092 circle_mesh[ i*6+1 ] = 0.0f;
1093
1094 v2_copy( v0, circle_mesh + 32*6 + i*12 );
1095 v2_muls( v0, 0.8f, circle_mesh + 32*6 + i*12+2 );
1096 v2_copy( v1, circle_mesh + 32*6 + i*12+4 );
1097
1098 v2_copy( v1, circle_mesh + 32*6 + i*12+6 );
1099 v2_muls( v1, 0.8f, circle_mesh + 32*6 + i*12+8 );
1100 v2_muls( v0, 0.8f, circle_mesh + 32*6 + i*12+10 );
1101
1102 v2_copy( v0, circle_mesh + i*6+4 );
1103 v2_copy( v1, circle_mesh + i*6+2 );
1104 v2_copy( v0, circle_mesh+i*6+4 );
1105 v2_copy( v1, circle_mesh+i*6+2 );
1106 }
1107
1108 init_mesh( &world.circle, circle_mesh, vg_list_size( circle_mesh ) );
1109 }
1110
1111 // Numbers mesh
1112 {
1113 init_mesh( &world.numbers,
1114 MESH_NUMBERS_BUFFER,
1115 vg_list_size( MESH_NUMBERS_BUFFER )
1116 );
1117
1118 for( int i = 0; i < 10; i ++ )
1119 {
1120 vg_info( "offset: %u, length: %u\n", MESH_NUMBERS_OFFSETS[i][0], MESH_NUMBERS_OFFSETS[i][1] );
1121 }
1122 }
1123
1124 // Create wire mesh
1125 {
1126 int const num_segments = 64;
1127
1128 struct mesh_wire *mw = &world.wire;
1129
1130 v2f wire_points[ num_segments * 2 ];
1131 u16 wire_indices[ 6*(num_segments-1) ];
1132
1133 for( int i = 0; i < num_segments; i ++ )
1134 {
1135 float l = (float)i / (float)(num_segments-1);
1136
1137 v2_copy( (v2f){ l, -0.5f }, wire_points[i*2+0] );
1138 v2_copy( (v2f){ l, 0.5f }, wire_points[i*2+1] );
1139
1140 if( i < num_segments-1 )
1141 {
1142 wire_indices[ i*6+0 ] = i*2 + 0;
1143 wire_indices[ i*6+1 ] = i*2 + 1;
1144 wire_indices[ i*6+2 ] = i*2 + 3;
1145 wire_indices[ i*6+3 ] = i*2 + 0;
1146 wire_indices[ i*6+4 ] = i*2 + 3;
1147 wire_indices[ i*6+5 ] = i*2 + 2;
1148 }
1149 }
1150
1151 glGenVertexArrays( 1, &mw->vao );
1152 glGenBuffers( 1, &mw->vbo );
1153 glGenBuffers( 1, &mw->ebo );
1154 glBindVertexArray( mw->vao );
1155
1156 glBindBuffer( GL_ARRAY_BUFFER, mw->vbo );
1157
1158 glBufferData( GL_ARRAY_BUFFER, sizeof( wire_points ), wire_points, GL_STATIC_DRAW );
1159 glBindVertexArray( mw->vao );
1160
1161 glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, mw->ebo );
1162 glBufferData( GL_ELEMENT_ARRAY_BUFFER, sizeof( wire_indices ), wire_indices, GL_STATIC_DRAW );
1163
1164 // XY
1165 glVertexAttribPointer( 0, 2, GL_FLOAT, GL_FALSE, 2*sizeof(float), (void*)0 );
1166 glEnableVertexAttribArray( 0 );
1167
1168 VG_CHECK_GL();
1169
1170 mw->em = vg_list_size( wire_indices );
1171 }
1172
1173 // Create info data texture
1174 {
1175 glGenTextures( 1, &world.background_data );
1176 glBindTexture( GL_TEXTURE_2D, world.background_data );
1177 glTexImage2D( GL_TEXTURE_2D, 0, GL_RGBA, 64, 64, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL );
1178 vg_tex2d_nearest();
1179 }
1180
1181 // Create random smaples texture
1182 {
1183 u8 *data = malloc(512*512*2);
1184 for( int i = 0; i < 512*512*2; i ++ )
1185 data[ i ] = rand()/(RAND_MAX/255);
1186
1187 glGenTextures( 1, &world.random_samples );
1188 glBindTexture( GL_TEXTURE_2D, world.random_samples );
1189 glTexImage2D( GL_TEXTURE_2D, 0, GL_RG, 512, 512, 0, GL_RG, GL_UNSIGNED_BYTE, data );
1190 vg_tex2d_linear();
1191 vg_tex2d_repeat();
1192
1193 free( data );
1194 }
1195
1196 resource_load_main();
1197
1198 // Restore gamestate
1199 career_local_data_init();
1200 career_load();
1201 }
1202
1203 void vg_free(void)
1204 {
1205 sw_free_opengl();
1206 console_save_map( 0, NULL );
1207 career_serialize();
1208
1209 resource_free_main();
1210
1211 glDeleteTextures( 1, &world.background_data );
1212 glDeleteTextures( 1, &world.random_samples );
1213
1214 glDeleteVertexArrays( 1, &world.wire.vao );
1215 glDeleteBuffers( 1, &world.wire.vbo );
1216 glDeleteBuffers( 1, &world.wire.ebo );
1217
1218 free_mesh( &world.tile );
1219 free_mesh( &world.circle );
1220 free_mesh( &world.numbers );
1221
1222 map_free();
1223 }
1224
1225 static int world_check_pos_ok( v2i co )
1226 {
1227 return (co[0] < 2 || co[0] >= world.w-2 || co[1] < 2 || co[1] >= world.h-2)? 0: 1;
1228 }
1229
1230 static int cell_interactive( v2i co )
1231 {
1232 // Bounds check
1233 if( !world_check_pos_ok( co ) )
1234 return 0;
1235
1236 // Flags check
1237 if( world.data[ world.w*co[1] + co[0] ].state & (FLAG_WALL|FLAG_INPUT|FLAG_OUTPUT) )
1238 return 0;
1239
1240 // List of 3x3 configurations that we do not allow
1241 static u32 invalid_src[][9] =
1242 {
1243 { 0,1,0,
1244 1,1,1,
1245 0,1,0
1246 },
1247 { 0,0,0,
1248 0,1,1,
1249 0,1,1
1250 },
1251 { 0,0,0,
1252 1,1,0,
1253 1,1,0
1254 },
1255 { 0,1,1,
1256 0,1,1,
1257 0,0,0
1258 },
1259 { 1,1,0,
1260 1,1,0,
1261 0,0,0
1262 },
1263 { 0,1,0,
1264 0,1,1,
1265 0,1,0
1266 },
1267 { 0,1,0,
1268 1,1,0,
1269 0,1,0
1270 }
1271 };
1272
1273 // Statically compile invalid configurations into bitmasks
1274 static u32 invalid[ vg_list_size(invalid_src) ];
1275
1276 for( int i = 0; i < vg_list_size(invalid_src); i ++ )
1277 {
1278 u32 comped = 0x00;
1279
1280 for( int j = 0; j < 3; j ++ )
1281 for( int k = 0; k < 3; k ++ )
1282 comped |= invalid_src[i][ j*3+k ] << ((j*5)+k);
1283
1284 invalid[i] = comped;
1285 }
1286
1287 // Extract 5x5 grid surrounding tile
1288 u32 blob = 0x1000;
1289 for( int y = co[1]-2; y < co[1]+3; y ++ )
1290 for( int x = co[0]-2; x < co[0]+3; x ++ )
1291 {
1292 struct cell *cell = pcell((v2i){x,y});
1293
1294 if( cell && (cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT)) )
1295 blob |= 0x1 << ((y-(co[1]-2))*5 + x-(co[0]-2));
1296 }
1297
1298 // Run filter over center 3x3 grid to check for invalid configurations
1299 int kernel[] = { 0, 1, 2, 5, 6, 7, 10, 11, 12 };
1300 for( int i = 0; i < vg_list_size(kernel); i ++ )
1301 {
1302 if( blob & (0x1 << (6+kernel[i])) )
1303 {
1304 u32 window = blob >> kernel[i];
1305
1306 for( int j = 0; j < vg_list_size(invalid); j ++ )
1307 if((window & invalid[j]) == invalid[j])
1308 return 0;
1309 }
1310 }
1311
1312 return 1;
1313 }
1314
1315 static void map_reclassify( v2i start, v2i end, int update_texbuffer )
1316 {
1317 v2i full_start = { 1,1 };
1318 v2i full_end = { world.w-1, world.h-1 };
1319
1320 if( !start || !end )
1321 {
1322 start = full_start;
1323 end = full_end;
1324 }
1325
1326 // Texture data
1327 u8 info_buffer[64*64*4];
1328 u32 pixel_id = 0;
1329
1330 int px0 = vg_max( start[0], full_start[0] ),
1331 px1 = vg_min( end[0], full_end[0] ),
1332 py0 = vg_max( start[1], full_start[1] ),
1333 py1 = vg_min( end[1], full_end[1] );
1334
1335 for( int y = py0; y < py1; y ++ )
1336 {
1337 for( int x = px0; x < px1; x ++ )
1338 {
1339 struct cell *cell = pcell((v2i){x,y});
1340
1341 v2i dirs[] = {{1,0},{0,1},{-1,0},{0,-1}};
1342
1343 u8 height = 0;
1344 u8 config = 0x00;
1345
1346 if( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
1347 {
1348 for( int i = 0; i < vg_list_size( dirs ); i ++ )
1349 {
1350 struct cell *neighbour = pcell((v2i){x+dirs[i][0], y+dirs[i][1]});
1351 if( neighbour->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
1352 config |= 0x1 << i;
1353 }
1354
1355 height = 128;
1356 }
1357 else
1358 {
1359 if( cell->state & FLAG_WALL )
1360 height = 0xFF-0x3F + hash21i( (v2i){x,y}, 0x3F );
1361
1362 config = 0xF;
1363 }
1364
1365 pcell((v2i){x,y})->config = config;
1366
1367 u8 *info_px = &info_buffer[ (pixel_id ++)*4 ];
1368 info_px[0] = height;
1369 info_px[1] = cell->state & FLAG_WALL? 0: 255;
1370 info_px[2] = 0;
1371 info_px[3] = 0;
1372
1373 if(
1374 (
1375 ((cell->state & FLAG_IS_TRIGGER) && (cell->config == 0xF || cell->config == k_cell_type_split)) ||
1376 ((cell->state & FLAG_TARGETED) && (cell->config != k_cell_type_split))
1377 ) && update_texbuffer
1378 ){
1379 cell->state &= ~(FLAG_TARGETED|FLAG_IS_TRIGGER);
1380 for( u32 i = 0; i < 2; i ++ )
1381 {
1382 if( cell->links[i] )
1383 {
1384 struct cell *other_ptr = &world.data[ cell->links[i] ];
1385 other_ptr->links[ i ] = 0;
1386 other_ptr->state &= ~FLAG_IS_TRIGGER;
1387
1388 if( other_ptr->links[ i ^ 0x1 ] == 0 )
1389 other_ptr->state &= ~FLAG_TARGETED;
1390 }
1391 }
1392
1393 cell->links[0] = 0;
1394 cell->links[1] = 0;
1395 }
1396 }
1397 }
1398
1399 if( update_texbuffer )
1400 {
1401 glBindTexture( GL_TEXTURE_2D, world.background_data );
1402 glTexSubImage2D( GL_TEXTURE_2D, 0, px0 + 16, py0 + 16, px1-px0, py1-py0, GL_RGBA, GL_UNSIGNED_BYTE, info_buffer );
1403 }
1404 }
1405
1406 u16 id_drag_from = 0;
1407 v2f drag_from_co;
1408 v2f drag_to_co;
1409
1410 void vg_update(void)
1411 {
1412 // Fit within screen
1413
1414 float r1 = (float)vg_window_y / (float)vg_window_x,
1415 r2 = (float)world.h / (float)world.w,
1416 size;
1417
1418 size = ( r2 < r1? (float)world.w * 0.5f: ((float)world.h * 0.5f) / r1 ) + 2.5f;
1419 m3x3_projection( m_projection, -size, size, -size*r1, size*r1 );
1420
1421 v3f origin;
1422 origin[0] = floorf( -0.5f * world.w );
1423 origin[1] = floorf( -0.5f * world.h );
1424 origin[2] = 0.0f;
1425
1426 m3x3_identity( m_view );
1427 m3x3_translate( m_view, origin );
1428 m3x3_mul( m_projection, m_view, vg_pv );
1429 vg_projection_update();
1430
1431 // Input stuff
1432 v2_copy( vg_mouse_ws, world.tile_pos );
1433
1434 world.tile_x = floorf( world.tile_pos[0] );
1435 world.tile_y = floorf( world.tile_pos[1] );
1436
1437 // Tilemap editing
1438 if( !world.simulating && !gui_want_mouse() )
1439 {
1440 v2_copy( vg_mouse_ws, drag_to_co );
1441
1442 if( cell_interactive( (v2i){ world.tile_x, world.tile_y } ))
1443 {
1444 world.selected = world.tile_y * world.w + world.tile_x;
1445
1446 static u32 modify_state = 0;
1447
1448 struct cell *cell_ptr = &world.data[world.selected];
1449
1450 if( vg_get_button_down("primary") )
1451 {
1452 modify_state = (cell_ptr->state & FLAG_CANAL) ^ FLAG_CANAL;
1453 }
1454
1455 if( vg_get_button("primary") && ((cell_ptr->state & FLAG_CANAL) != modify_state) )
1456 {
1457 cell_ptr->state &= ~FLAG_CANAL;
1458 cell_ptr->state |= modify_state;
1459
1460 if( cell_ptr->state & FLAG_CANAL )
1461 {
1462 cell_ptr->links[0] = 0;
1463 cell_ptr->links[1] = 0;
1464
1465 sfx_set_playrnd( &audio_tile_mod, &audio_system_sfx, 3, 6 );
1466 world.score ++;
1467 }
1468 else
1469 {
1470 sfx_set_playrnd( &audio_tile_mod, &audio_system_sfx, 0, 3 );
1471 world.score --;
1472 }
1473
1474 map_reclassify( (v2i){ world.tile_x -2, world.tile_y -2 },
1475 (v2i){ world.tile_x +2, world.tile_y +2 }, 1 );
1476 }
1477
1478 if( vg_get_button_down("secondary") && !(cell_ptr->config == k_cell_type_split) )
1479 {
1480 id_drag_from = world.selected;
1481 drag_from_co[0] = world.tile_x + 0.5f;
1482 drag_from_co[1] = world.tile_y + 0.5f;
1483 }
1484
1485 if( id_drag_from && (cell_ptr->config == k_cell_type_split) )
1486 {
1487 float local_x = vg_mouse_ws[0] - (float)world.tile_x;
1488 drag_to_co[0] = (float)world.tile_x + (local_x > 0.5f? 0.75f: 0.25f);
1489 drag_to_co[1] = (float)world.tile_y + 0.25f;
1490
1491 if( vg_get_button_up("secondary") )
1492 {
1493 struct cell *drag_ptr = &world.data[id_drag_from];
1494 u32 link_id = local_x > 0.5f? 1: 0;
1495
1496 // Cleanup existing connections
1497 if( cell_ptr->links[ link_id ] )
1498 {
1499 vg_warn( "Destroying existing connection on link %u (%hu)\n", link_id, cell_ptr->links[ link_id ] );
1500
1501 struct cell *current_connection = &world.data[ cell_ptr->links[ link_id ]];
1502 current_connection->state &= ~FLAG_IS_TRIGGER;
1503 current_connection->links[ link_id ] = 0;
1504 }
1505
1506 if( drag_ptr->links[ link_id ^ 0x1 ] )
1507 {
1508 vg_warn( "Destroying alternate link %u (%hu)\n", link_id ^ 0x1, drag_ptr->links[ link_id ^ 0x1 ] );
1509
1510 struct cell *current_connection = &world.data[ drag_ptr->links[ link_id ^ 0x1 ]];
1511 if( !current_connection->links[ link_id ] )
1512 current_connection->state &= ~FLAG_TARGETED;
1513
1514 current_connection->links[ link_id ^ 0x1 ] = 0;
1515 drag_ptr->links[ link_id ^ 0x1 ] = 0;
1516 }
1517
1518 // Create the new connection
1519 vg_success( "Creating connection on link %u (%hu)\n", link_id, id_drag_from );
1520
1521 cell_ptr->links[ link_id ] = id_drag_from;
1522 drag_ptr->links[ link_id ] = world.selected;
1523
1524 cell_ptr->state |= FLAG_TARGETED;
1525 drag_ptr->state |= FLAG_IS_TRIGGER;
1526 id_drag_from = 0;
1527 }
1528 }
1529 }
1530 else
1531 world.selected = -1;
1532
1533 if( !(vg_get_button("secondary") && id_drag_from) )
1534 id_drag_from = 0;
1535 }
1536 else
1537 {
1538 world.selected = -1;
1539 id_drag_from = 0;
1540 }
1541
1542 // Simulation stop/start
1543 if( vg_get_button_down("go") )
1544 {
1545 if( world.simulating )
1546 {
1547 simulation_stop();
1548 }
1549 else
1550 {
1551 vg_success( "Starting simulation!\n" );
1552
1553 sfx_set_playrnd( &audio_rolls, &audio_system_balls_rolling, 0, 1 );
1554
1555 world.simulating = 1;
1556 world.num_fishes = 0;
1557 world.sim_frame = 0;
1558 world.sim_start = vg_time;
1559 world.sim_run = 0;
1560 world.sim_speed = 2.5f;
1561
1562 for( int i = 0; i < world.w*world.h; i ++ )
1563 world.data[ i ].state &= ~FLAG_FLIP_FLOP;
1564
1565 io_reset();
1566 }
1567 }
1568
1569 // Fish ticks
1570 if( world.simulating )
1571 {
1572 while( world.sim_frame < (int)((vg_time-world.sim_start)*world.sim_speed) )
1573 {
1574 //vg_info( "frame: %u\n", world.sim_frame );
1575 sfx_set_playrnd( &audio_random, &audio_system_balls_switching, 0, 9 );
1576
1577 // Update splitter deltas
1578 for( int i = 0; i < world.h*world.w; i ++ )
1579 {
1580 struct cell *cell = &world.data[i];
1581 if( cell->config == k_cell_type_split )
1582 {
1583 cell->state &= ~FLAG_FLIP_ROTATING;
1584 }
1585 if( cell->state & FLAG_IS_TRIGGER )
1586 cell->state &= ~FLAG_TRIGGERED;
1587 }
1588
1589 int alive_count = 0;
1590
1591 // Update fish positions
1592 for( int i = 0; i < world.num_fishes; i ++ )
1593 {
1594 struct fish *fish = &world.fishes[i];
1595
1596 if( fish->state == k_fish_state_soon_dead )
1597 fish->state = k_fish_state_dead;
1598
1599 if( fish->state == k_fish_state_soon_alive )
1600 fish->state = k_fish_state_alive;
1601
1602 if( fish->state < k_fish_state_alive )
1603 continue;
1604
1605 struct cell *cell_current = pcell( fish->pos );
1606
1607 if( fish->state == k_fish_state_alive )
1608 {
1609 // Apply to output
1610 if( cell_current->state & FLAG_OUTPUT )
1611 {
1612 for( int j = 0; j < arrlen( world.io ); j ++ )
1613 {
1614 struct cell_terminal *term = &world.io[j];
1615
1616 if( term->id == fish->pos[1]*world.w + fish->pos[0] )
1617 {
1618 struct terminal_run *run = &term->runs[ world.sim_run ];
1619 if( run->recv_count < vg_list_size( run->recieved ) )
1620 run->recieved[ run->recv_count ++ ] = fish->payload;
1621
1622 break;
1623 }
1624 }
1625
1626 fish->state = k_fish_state_dead;
1627 continue;
1628 }
1629
1630
1631 if( cell_current->config == k_cell_type_merge )
1632 {
1633 // Can only move up
1634 fish->dir[0] = 0;
1635 fish->dir[1] = -1;
1636 fish->flow_reversed = 0;
1637 }
1638 else
1639 {
1640 if( cell_current->config == k_cell_type_split )
1641 {
1642 // Flip flop L/R
1643 fish->dir[0] = cell_current->state&FLAG_FLIP_FLOP?1:-1;
1644 fish->dir[1] = 0;
1645
1646 if( !(cell_current->state & FLAG_TARGETED) )
1647 cell_current->state ^= FLAG_FLIP_FLOP;
1648 }
1649 else
1650 {
1651 // Apply cell out-flow
1652 struct cell_description *desc = &cell_descriptions[ cell_current->config ];
1653
1654 v2i_copy( fish->flow_reversed? desc->start: desc->end, fish->dir );
1655 }
1656
1657 v2i pos_next;
1658 v2i_add( fish->pos, fish->dir, pos_next );
1659
1660 struct cell *cell_next = pcell( pos_next );
1661
1662 if( cell_next->state & (FLAG_CANAL|FLAG_OUTPUT) )
1663 {
1664 struct cell_description *desc = &cell_descriptions[ cell_next->config ];
1665
1666 if( cell_next->config == k_cell_type_merge )
1667 {
1668 if( fish->dir[0] == 0 )
1669 fish->state = k_fish_state_dead;
1670 else
1671 fish->flow_reversed = 0;
1672 }
1673 else
1674 {
1675 if( cell_next->config == k_cell_type_split )
1676 {
1677 if( fish->dir[0] == 0 )
1678 {
1679 sfx_set_playrnd( &audio_splitter, &audio_system_balls_important, 0, 1 );
1680 cell_next->state |= FLAG_FLIP_ROTATING;
1681
1682 fish->flow_reversed = 0;
1683 }
1684 else
1685 fish->state = k_fish_state_dead;
1686 }
1687 else
1688 fish->flow_reversed = ( fish->dir[0] != -desc->start[0] ||
1689 fish->dir[1] != -desc->start[1] )? 1: 0;
1690 }
1691 }
1692 else
1693 fish->state = world_check_pos_ok( fish->pos )? k_fish_state_bg: k_fish_state_dead;
1694 }
1695
1696 //v2i_add( fish->pos, fish->dir, fish->pos );
1697 }
1698 else if( fish->state == k_fish_state_bg )
1699 {
1700 v2i_add( fish->pos, fish->dir, fish->pos );
1701
1702 if( !world_check_pos_ok( fish->pos ) )
1703 fish->state = k_fish_state_dead;
1704 else
1705 {
1706 struct cell *cell_entry = pcell( fish->pos );
1707
1708 if( cell_entry->state & FLAG_CANAL )
1709 {
1710 if( cell_entry->config == k_cell_type_con_r || cell_entry->config == k_cell_type_con_u
1711 || cell_entry->config == k_cell_type_con_l || cell_entry->config == k_cell_type_con_d )
1712 {
1713 sw_set_achievement( "CAN_DO_THAT" );
1714
1715 fish->state = k_fish_state_soon_alive;
1716
1717 fish->dir[0] = 0;
1718 fish->dir[1] = 0;
1719 fish->flow_reversed = 1;
1720
1721 switch( cell_entry->config )
1722 {
1723 case k_cell_type_con_r: fish->dir[0] = 1; break;
1724 case k_cell_type_con_l: fish->dir[0] = -1; break;
1725 case k_cell_type_con_u: fish->dir[1] = 1; break;
1726 case k_cell_type_con_d: fish->dir[1] = -1; break;
1727 }
1728 }
1729 }
1730 }
1731 }
1732 else { vg_error( "fish behaviour unimplemented for behaviour type (%d)\n" ); }
1733
1734 if( fish->state >= k_fish_state_alive )
1735 alive_count ++;
1736 }
1737
1738 // Second pass (triggers)
1739 for( int i = 0; i < world.num_fishes; i ++ )
1740 {
1741 struct fish *fish = &world.fishes[i];
1742
1743 if( fish->state == k_fish_state_alive )
1744 {
1745 v2i_add( fish->pos, fish->dir, fish->pos );
1746 struct cell *cell_current = pcell( fish->pos );
1747
1748 if( cell_current->state & FLAG_IS_TRIGGER )
1749 {
1750 int trigger_id = cell_current->links[0]?0:1;
1751 int connection_id = cell_current->links[trigger_id];
1752 int target_px = connection_id % world.w;
1753 int target_py = (connection_id - target_px)/world.w;
1754
1755 vg_line2( (v2f){ fish->pos[0], fish->pos[1] }, (v2f){ target_px, target_py }, 0xffffffff, 0xffffffff );
1756
1757 struct cell *target_peice = &world.data[ cell_current->links[trigger_id] ];
1758
1759 cell_current->state |= FLAG_TRIGGERED;
1760
1761 if( trigger_id )
1762 target_peice->state |= FLAG_FLIP_FLOP;
1763 else
1764 target_peice->state &= ~FLAG_FLIP_FLOP;
1765 }
1766 }
1767 }
1768
1769 // Third pass (collisions)
1770 struct fish *fi, *fj;
1771
1772 for( int i = 0; i < world.num_fishes; i ++ )
1773 {
1774 fi = &world.fishes[i];
1775
1776 if( fi->state == k_fish_state_alive )
1777 {
1778 int continue_again = 0;
1779
1780 for( int j = i+1; j < world.num_fishes; j ++ )
1781 {
1782 fj = &world.fishes[j];
1783
1784 if( (fj->state == k_fish_state_alive) )
1785 {
1786 v2i fi_prev;
1787 v2i fj_prev;
1788
1789 v2i_sub( fi->pos, fi->dir, fi_prev );
1790 v2i_sub( fj->pos, fj->dir, fj_prev );
1791
1792 int
1793 collide_next_frame = (
1794 (fi->pos[0] == fj->pos[0]) &&
1795 (fi->pos[1] == fj->pos[1]))? 1: 0,
1796 collide_this_frame = (
1797 (fi_prev[0] == fj->pos[0]) &&
1798 (fi_prev[1] == fj->pos[1]) &&
1799 (fj_prev[0] == fi->pos[0]) &&
1800 (fj_prev[1] == fi->pos[1])
1801 )? 1: 0;
1802
1803 if( collide_next_frame || collide_this_frame )
1804 {
1805 sw_set_achievement( "BANG" );
1806
1807 // Shatter death (+0.5s)
1808 float death_time = collide_this_frame? 0.0f: 0.5f;
1809
1810 fi->state = k_fish_state_soon_dead;
1811 fj->state = k_fish_state_soon_dead;
1812 fi->death_time = death_time;
1813 fj->death_time = death_time;
1814
1815 continue_again = 1;
1816 break;
1817 }
1818 }
1819 }
1820 if( continue_again )
1821 continue;
1822 }
1823 }
1824
1825 // Spawn fishes
1826 for( int i = 0; i < arrlen( world.io ); i ++ )
1827 {
1828 struct cell_terminal *term = &world.io[ i ];
1829 int posx = term->id % world.w;
1830 int posy = (term->id - posx)/world.w;
1831 int is_input = world.data[ term->id ].state & FLAG_INPUT;
1832
1833 if( is_input )
1834 {
1835 if( world.sim_frame < term->runs[ world.sim_run ].condition_count )
1836 {
1837 struct fish *fish = &world.fishes[ world.num_fishes ];
1838 fish->pos[0] = posx;
1839 fish->pos[1] = posy;
1840 fish->state = k_fish_state_alive;
1841 fish->payload = term->runs[ world.sim_run ].conditions[ world.sim_frame ];
1842
1843 struct cell *cell_ptr = pcell( fish->pos );
1844
1845 if( cell_ptr->config != k_cell_type_stub )
1846 {
1847 struct cell_description *desc = &cell_descriptions[ cell_ptr->config ];
1848
1849 v2i_copy( desc->start, fish->dir );
1850 fish->flow_reversed = 1;
1851
1852 world.num_fishes ++;
1853 alive_count ++;
1854 }
1855 }
1856 }
1857 }
1858
1859 if( alive_count == 0 )
1860 {
1861 world.completed = 1;
1862
1863 for( int i = 0; i < arrlen( world.io ); i ++ )
1864 {
1865 struct cell_terminal *term = &world.io[ i ];
1866 int is_input = world.data[ term->id ].state & FLAG_INPUT;
1867
1868 if( !is_input )
1869 {
1870 struct terminal_run *run = &term->runs[ world.sim_run ];
1871
1872 if( run->recv_count == run->condition_count )
1873 {
1874 for( int j = 0; j < run->condition_count; j ++ )
1875 {
1876 if( run->recieved[j] != run->conditions[j] )
1877 {
1878 world.completed = 0;
1879 break;
1880 }
1881 }
1882 }
1883 else
1884 {
1885 world.completed = 0;
1886 break;
1887 }
1888 }
1889 }
1890
1891 if( world.completed )
1892 {
1893 if( world.sim_run < world.max_runs-1 )
1894 {
1895 vg_success( "Run passed, starting next\n" );
1896 world.sim_run ++;
1897 world.sim_frame = 0;
1898 world.sim_start = vg_time;
1899 world.num_fishes = 0;
1900
1901 for( int i = 0; i < world.w*world.h; i ++ )
1902 world.data[ i ].state &= ~FLAG_FLIP_FLOP;
1903
1904 continue;
1905 }
1906 else
1907 {
1908 vg_success( "Level passed!\n" );
1909
1910 u32 score = 0;
1911 for( int i = 0; i < world.w*world.h; i ++ )
1912 if( world.data[ i ].state & FLAG_CANAL )
1913 score ++;
1914
1915 world.score = score;
1916 world.time = world.sim_frame;
1917
1918 // Copy into career data
1919 if( world.pCmpLevel )
1920 {
1921 career_pass_level( world.pCmpLevel, world.score, 1 );
1922 }
1923 }
1924 }
1925 else
1926 {
1927 if( world.sim_run > 0 )
1928 sw_set_achievement( "GOOD_ENOUGH" );
1929
1930 vg_error( "Level failed :(\n" );
1931 }
1932
1933
1934 simulation_stop(); // TODO: Async?
1935 break;
1936 }
1937
1938 world.sim_frame ++;
1939 }
1940
1941 float scaled_time = 0.0f;
1942 scaled_time = (vg_time-world.sim_start)*world.sim_speed;
1943 world.frame_lerp = scaled_time - (float)world.sim_frame;
1944
1945 // Update positions
1946 for( int i = 0; i < world.num_fishes; i ++ )
1947 {
1948 struct fish *fish = &world.fishes[i];
1949
1950 if( fish->state == k_fish_state_dead )
1951 continue;
1952
1953 if( fish->state == k_fish_state_soon_dead && (world.frame_lerp > fish->death_time) )
1954 continue; // Todo: particle thing?
1955
1956 struct cell *cell = pcell(fish->pos);
1957 struct cell_description *desc = &cell_descriptions[ cell->config ];
1958
1959 v2f const *curve;
1960
1961 float t = world.frame_lerp;
1962 if( fish->flow_reversed && !desc->is_linear )
1963 t = 1.0f-t;
1964
1965 v2_copy( fish->physics_co, fish->physics_v );
1966
1967 switch( cell->config )
1968 {
1969 case k_cell_type_merge:
1970 if( fish->dir[0] == 1 )
1971 curve = curve_12;
1972 else
1973 curve = curve_9;
1974 break;
1975 case k_cell_type_con_r: curve = curve_1; break;
1976 case k_cell_type_con_l: curve = curve_4; break;
1977 case k_cell_type_con_u: curve = curve_2; break;
1978 case k_cell_type_con_d: curve = curve_8; break;
1979 case 3: curve = curve_3; break;
1980 case 6: curve = curve_6; break;
1981 case 9: curve = curve_9; break;
1982 case 12: curve = curve_12; break;
1983 case 7:
1984 if( t > curve_7_linear_section )
1985 {
1986 t -= curve_7_linear_section;
1987 t *= (1.0f/(1.0f-curve_7_linear_section));
1988
1989 curve = cell->state & FLAG_FLIP_FLOP? curve_7: curve_7_1;
1990 }
1991 else curve = NULL;
1992 break;
1993 default: curve = NULL; break;
1994 }
1995
1996 if( curve )
1997 {
1998 float t2 = t * t;
1999 float t3 = t * t * t;
2000
2001 float cA = 3.0f*t2 - 3.0f*t3;
2002 float cB = 3.0f*t3 - 6.0f*t2 + 3.0f*t;
2003 float cC = 3.0f*t2 - t3 - 3.0f*t + 1.0f;
2004
2005 fish->physics_co[0] = t3*curve[3][0] + cA*curve[2][0] + cB*curve[1][0] + cC*curve[0][0];
2006 fish->physics_co[1] = t3*curve[3][1] + cA*curve[2][1] + cB*curve[1][1] + cC*curve[0][1];
2007 fish->physics_co[0] += (float)fish->pos[0];
2008 fish->physics_co[1] += (float)fish->pos[1];
2009 }
2010 else
2011 {
2012 v2f origin;
2013 origin[0] = (float)fish->pos[0] + (float)fish->dir[0]*-0.5f + 0.5f;
2014 origin[1] = (float)fish->pos[1] + (float)fish->dir[1]*-0.5f + 0.5f;
2015
2016 fish->physics_co[0] = origin[0] + (float)fish->dir[0]*t;
2017 fish->physics_co[1] = origin[1] + (float)fish->dir[1]*t;
2018 }
2019 }
2020 }
2021 }
2022
2023 static void render_tiles( v2i start, v2i end, v4f const regular_colour, v4f const selected_colour )
2024 {
2025 v2i full_start = { 0,0 };
2026 v2i full_end = { world.w, world.h };
2027
2028 if( !start || !end )
2029 {
2030 start = full_start;
2031 end = full_end;
2032 }
2033
2034 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
2035
2036 for( int y = start[1]; y < end[1]; y ++ )
2037 {
2038 for( int x = start[0]; x < end[0]; x ++ )
2039 {
2040 struct cell *cell = pcell((v2i){x,y});
2041 int selected = world.selected == y*world.w + x;
2042
2043 int tile_offsets[][2] =
2044 {
2045 {2, 0}, {0, 3}, {0, 2}, {2, 2},
2046 {1, 0}, {2, 3}, {3, 2}, {1, 3},
2047 {3, 1}, {0, 1}, {1, 2}, {2, 1},
2048 {1, 1}, {3, 3}, {2, 1}, {2, 1}
2049 };
2050
2051 int uv[2] = { 3, 0 };
2052
2053 if( cell->state & (FLAG_CANAL|FLAG_INPUT|FLAG_OUTPUT) )
2054 {
2055 uv[0] = tile_offsets[ cell->config ][0];
2056 uv[1] = tile_offsets[ cell->config ][1];
2057 } else continue;
2058
2059 glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y, uv[0], uv[1] );
2060 if( selected )
2061 {
2062 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, selected_colour );
2063 draw_mesh( 0, 2 );
2064 glUniform4fv( SHADER_UNIFORM( shader_tile_main, "uColour" ), 1, regular_colour );
2065 }
2066 else
2067 draw_mesh( 0, 2 );
2068 }
2069 }
2070 }
2071
2072 static void draw_numbers( v3f coord, int number )
2073 {
2074 v3f pos;
2075 v3_copy( coord, pos );
2076 int digits[8]; int i = 0;
2077
2078 while( number > 0 && i < 8 )
2079 {
2080 digits[i ++] = number % 10;
2081 number = number / 10;
2082 }
2083
2084 for( int j = 0; j < i; j ++ )
2085 {
2086 glUniform3fv( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 1, pos );
2087 draw_mesh( MESH_NUMBERS_OFFSETS[digits[i-j-1]][0], MESH_NUMBERS_OFFSETS[digits[i-j-1]][1] );
2088 pos[0] += pos[2] * 0.75f;
2089 }
2090 }
2091
2092 void vg_render(void)
2093 {
2094 glViewport( 0,0, vg_window_x, vg_window_y );
2095
2096 glDisable( GL_DEPTH_TEST );
2097 glClearColor( 0.369768f, 0.3654f, 0.42f, 1.0f );
2098 glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
2099
2100 v4f const colour_default = {1.0f, 1.0f, 1.0f, 1.0f};
2101 v4f const colour_selected = {0.90f, 0.92f, 1.0f, 1.0f};
2102
2103 // TILE SET RENDERING
2104 // todo: just slam everything into a mesh...
2105 // when user modifies a tile the neighbours can be easily uploaded to gpu mem
2106 // in ~3 subBuffers
2107 // Currently we're uploading a fair amount of data every frame anyway.
2108 // NOTE: this is for final optimisations ONLY!
2109 // ======================================================================
2110
2111 use_mesh( &world.tile );
2112
2113 // Draw background
2114
2115 if(1){
2116
2117 SHADER_USE( shader_background );
2118 glUniformMatrix3fv( SHADER_UNIFORM( shader_background, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
2119
2120 glActiveTexture( GL_TEXTURE0 );
2121 glBindTexture( GL_TEXTURE_2D, world.background_data );
2122 glUniform1i( SHADER_UNIFORM( shader_background, "uTexMain" ), 0 );
2123
2124 glUniform3f( SHADER_UNIFORM( shader_background, "uOffset" ), -16, -16, 64 );
2125 glUniform1f( SHADER_UNIFORM( shader_background, "uVariance" ), 0.02f );
2126
2127 glActiveTexture( GL_TEXTURE1 );
2128 glBindTexture( GL_TEXTURE_2D, world.random_samples );
2129 glUniform1i( SHADER_UNIFORM( shader_background, "uSamplerNoise" ), 1 );
2130
2131 draw_mesh( 0, 2 );
2132
2133 }
2134
2135
2136 // Level title
2137 // TODO: Fix this?
2138 /*
2139 ui_begin( &ui_global_ctx, 512, 256 );
2140
2141 ui_global_ctx.override_colour = 0xff9a8a89;
2142 //ui_text( &ui_global_ctx, world.map_title, 6, 0 );
2143 ui_global_ctx.override_colour = 0xffffffff;
2144
2145 ui_resolve( &ui_global_ctx );
2146
2147 m3x3f world_text;
2148 m3x3_copy( vg_pv, world_text );
2149 m3x3_translate( world_text, (v3f){ 1.55f, 1.9f, 0.0f } );
2150 m3x3_rotate( world_text, VG_PIf*0.5f );
2151 m3x3_scale( world_text, (v3f){0.01f,-0.01f,0.01f} );
2152
2153 ui_draw( &ui_global_ctx, world_text );
2154 */
2155
2156 // Main
2157 // =========================================================================================
2158
2159 use_mesh( &world.tile );
2160 SHADER_USE( shader_tile_main );
2161
2162 m2x2f subtransform;
2163 m2x2_identity( subtransform );
2164 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
2165 glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_main, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
2166 glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 0.0f );
2167 glUniform1f( SHADER_UNIFORM( shader_tile_main, "uForeground" ), 0.0f );
2168
2169 glEnable(GL_BLEND);
2170 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
2171 glBlendEquation(GL_FUNC_ADD);
2172
2173 // Bind textures
2174 vg_tex2d_bind( &tex_tile_data, 0 );
2175 glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexGlyphs" ), 0 );
2176
2177 vg_tex2d_bind( &tex_wood, 1 );
2178 glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
2179
2180 render_tiles( NULL, NULL, colour_default, colour_default );
2181
2182
2183
2184 SHADER_USE( shader_ball );
2185 glUniformMatrix3fv( SHADER_UNIFORM( shader_ball, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
2186
2187 vg_tex2d_bind( &tex_ball_noise, 0 );
2188 glUniform1i( SHADER_UNIFORM( shader_ball, "uTexMain" ), 0 );
2189
2190 // Draw 'fish'
2191 if( world.simulating )
2192 {
2193 for( int i = 0; i < world.num_fishes; i ++ )
2194 {
2195 struct fish *fish = &world.fishes[i];
2196
2197 if( fish->state == k_fish_state_dead || fish->state == k_fish_state_bg )
2198 continue;
2199
2200 if( fish->state == k_fish_state_soon_dead && (world.frame_lerp > fish->death_time) )
2201 continue;
2202
2203 v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
2204 colour_code_v3( fish->payload, dot_colour );
2205
2206 glUniform3fv( SHADER_UNIFORM( shader_ball, "uColour" ), 1, dot_colour );
2207 glUniform2fv( SHADER_UNIFORM( shader_ball, "uOffset" ), 1, fish->physics_co );
2208 glUniform2f( SHADER_UNIFORM( shader_ball, "uTexOffset" ), (float)i * 1.2334, (float)i * -0.3579f );
2209 draw_mesh( 0, 2 );
2210 }
2211 }
2212
2213 SHADER_USE( shader_tile_main );
2214
2215 // Bind textures
2216 vg_tex2d_bind( &tex_tile_data, 0 );
2217 glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexGlyphs" ), 0 );
2218
2219 vg_tex2d_bind( &tex_wood, 1 );
2220 glUniform1i( SHADER_UNIFORM( shader_tile_main, "uTexWood" ), 1 );
2221
2222 glUniform1f( SHADER_UNIFORM( shader_tile_main, "uForeground" ), 1.0f );
2223 render_tiles( NULL, NULL, colour_default, colour_selected );
2224
2225 // Draw splitters
2226 for( int y = 2; y < world.h-2; y ++ )
2227 {
2228 for( int x = 2; x < world.w-2; x ++ )
2229 {
2230 struct cell *cell = pcell((v2i){x,y});
2231
2232 if( cell->state & FLAG_CANAL )
2233 {
2234 if( cell->config == k_cell_type_split )
2235 {
2236 float rotation = cell->state & FLAG_FLIP_FLOP? vg_rad( -45.0f ): vg_rad( 45.0f );
2237
2238 if( cell->state & FLAG_FLIP_ROTATING )
2239 {
2240 if( (world.frame_lerp > curve_7_linear_section) )
2241 {
2242 float const rotation_speed = 0.4f;
2243 if( (world.frame_lerp < 1.0f-rotation_speed) )
2244 {
2245 float t = world.frame_lerp - curve_7_linear_section;
2246 t *= -2.0f * (1.0f/(1.0f-(curve_7_linear_section+rotation_speed)));
2247 t += 1.0f;
2248
2249 rotation *= t;
2250 }
2251 else
2252 rotation *= -1.0f;
2253 }
2254 }
2255
2256 m2x2_create_rotation( subtransform, rotation );
2257
2258 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
2259 glUniform4f( SHADER_UNIFORM( shader_tile_main, "uOffset" ), (float)x, (float)y + 0.125f, cell->state & FLAG_TARGETED? 3.0f: 0.0f, 0.0f );
2260 draw_mesh( 0, 2 );
2261 }
2262 }
2263 }
2264 }
2265
2266 // Edit overlay
2267 if( world.selected != -1 && !(world.data[ world.selected ].state & FLAG_CANAL) && !id_drag_from )
2268 {
2269 v2i new_begin = { world.tile_x - 2, world.tile_y - 2 };
2270 v2i new_end = { world.tile_x + 2, world.tile_y + 2 };
2271
2272 world.data[ world.selected ].state ^= FLAG_CANAL;
2273 map_reclassify( new_begin, new_end, 0 );
2274
2275 m2x2_identity( subtransform );
2276 glUniform1f( SHADER_UNIFORM( shader_tile_main, "uGhost" ), 1.0f );
2277 glUniformMatrix2fv( SHADER_UNIFORM( shader_tile_main, "uSubTransform" ), 1, GL_FALSE, (float *)subtransform );
2278 glUniform2fv( SHADER_UNIFORM( shader_tile_main, "uMousePos" ), 1, world.tile_pos );
2279
2280 render_tiles( new_begin, new_end, colour_default, colour_default );
2281
2282 world.data[ world.selected ].state ^= FLAG_CANAL;
2283 map_reclassify( new_begin, new_end, 0 );
2284 }
2285
2286 //glDisable(GL_BLEND);
2287
2288 // Draw connecting wires
2289 glDisable(GL_BLEND);
2290
2291 SHADER_USE( shader_wire );
2292 glBindVertexArray( world.wire.vao );
2293
2294 glUniformMatrix3fv( SHADER_UNIFORM( shader_wire, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
2295 glUniform4f( SHADER_UNIFORM( shader_wire, "uColour" ), 0.2f, 0.2f, 0.2f, 1.0f );
2296
2297 if( id_drag_from )
2298 {
2299 glUniform1f( SHADER_UNIFORM( shader_wire, "uCurve" ), 0.4f );
2300 glUniform3f( SHADER_UNIFORM( shader_wire, "uStart" ), drag_from_co[0], drag_from_co[1], 0.06f );
2301 glUniform3f( SHADER_UNIFORM( shader_wire, "uEnd" ), drag_to_co[0], drag_to_co[1], 0.06f );
2302 glDrawElements( GL_TRIANGLES, world.wire.em, GL_UNSIGNED_SHORT, (void*)(0) );
2303 }
2304
2305 float rp_x1 = world.frame_lerp*9.0f;
2306 float rp_x2 = 1.0f-rp_x1*expf(1.0f-rp_x1)* 0.36f;
2307
2308 for( int y = 2; y < world.h-2; y ++ )
2309 {
2310 for( int x = 2; x < world.w-2; x ++ )
2311 {
2312 struct cell *cell = pcell((v2i){x,y});
2313
2314 if( cell->state & FLAG_CANAL )
2315 {
2316 if( cell->state & FLAG_IS_TRIGGER )
2317 {
2318 int trigger_id = cell->links[0]?0:1;
2319
2320 int x2 = cell->links[trigger_id] % world.w;
2321 int y2 = (cell->links[trigger_id] - x2) / world.w;
2322
2323 v2f startpoint;
2324 v2f endpoint;
2325
2326 startpoint[0] = (float)x2 + (trigger_id? 0.75f: 0.25f);
2327 startpoint[1] = (float)y2 + 0.25f;
2328
2329 endpoint[0] = x+0.5f;
2330 endpoint[1] = y+0.5f;
2331
2332 glUniform1f( SHADER_UNIFORM( shader_wire, "uCurve" ), cell->state & FLAG_TRIGGERED? rp_x2 * 0.4f: 0.4f );
2333 glUniform3f( SHADER_UNIFORM( shader_wire, "uStart" ), startpoint[0], startpoint[1], 0.04f );
2334 glUniform3f( SHADER_UNIFORM( shader_wire, "uEnd" ), endpoint[0], endpoint[1], 0.04f );
2335 glDrawElements( GL_TRIANGLES, world.wire.em, GL_UNSIGNED_SHORT, (void*)(0) );
2336 }
2337 }
2338 }
2339 }
2340
2341 SHADER_USE( shader_tile_colour );
2342 glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
2343 use_mesh( &world.circle );
2344
2345 int const filled_start = 0;
2346 int const filled_count = 32;
2347 int const empty_start = 32;
2348 int const empty_count = 32*2;
2349
2350 // Draw i/o arrays
2351 for( int i = 0; i < arrlen( world.io ); i ++ )
2352 {
2353 struct cell_terminal *term = &world.io[ i ];
2354 int posx = term->id % world.w;
2355 int posy = (term->id - posx)/world.w;
2356 int is_input = world.data[ term->id ].state & FLAG_INPUT;
2357
2358 v4f dot_colour = { 0.0f, 0.0f, 0.0f, 1.0f };
2359
2360 for( int k = 0; k < term->run_count; k ++ )
2361 {
2362 for( int j = 0; j < term->runs[k].condition_count; j ++ )
2363 {
2364 float y_offset = is_input? 1.2f: -0.2f;
2365 float y_h = (is_input? 0.2f: -0.2f) * (float)k;
2366
2367 if( is_input )
2368 {
2369 glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j,
2370 (y_offset + (float)posy + (float)(term->run_count-1)*0.2f) - y_h, 0.1f );
2371
2372 colour_code_v3( term->runs[k].conditions[j], dot_colour );
2373 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
2374
2375 // Draw filled if tick not passed, draw empty if empty
2376 if( (world.sim_frame > j && world.sim_run >= k) || world.sim_run > k )
2377 draw_mesh( empty_start, empty_count );
2378 else
2379 draw_mesh( filled_start, filled_count );
2380 }
2381 else
2382 {
2383 glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + y_offset + y_h, 0.1f );
2384
2385 if( term->runs[k].recv_count > j )
2386 {
2387 colour_code_v3( term->runs[k].recieved[j], dot_colour );
2388 v3_muls( dot_colour, 0.8f, dot_colour );
2389 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
2390
2391 draw_mesh( filled_start, filled_count );
2392 }
2393
2394 colour_code_v3( term->runs[k].conditions[j], dot_colour );
2395 glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
2396
2397 draw_mesh( empty_start, empty_count );
2398 }
2399 }
2400 }
2401 }
2402
2403 if( world.simulating )
2404 {
2405 glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.0f, 0.0f, 0.0f, 1.0f );
2406 glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), -0.5f + cosf( vg_time * 4.0f ) * 0.2f, sinf( vg_time * 4.0f ) * 0.2f + (float)world.h * 0.5f, 0.05f );
2407 draw_mesh( filled_start, filled_count );
2408 }
2409
2410 // Draw score
2411 float const score_bright = 1.25f;
2412 glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ),
2413 0.4f*score_bright, 0.39f*score_bright, 0.45f*score_bright, 1.0f );
2414
2415 use_mesh( &world.numbers );
2416 draw_numbers( (v3f){ 2.0f, (float)world.h-1.875f, 0.3333f }, world.score );
2417 }
2418
2419 static ui_colourset flcol_list_a = {
2420 .main = 0xff877979,
2421 .hover = 0xffa09393,
2422 .active = 0xffbfb1b0
2423 };
2424 static ui_colourset flcol_list_b = {
2425 .main = 0xff7c6e6e,
2426 .hover = 0xffa09393,
2427 .active = 0xffbfb1b0
2428 };
2429
2430 static ui_colourset flcol_list_complete_a = {
2431 .main = 0xff62a064,
2432 .hover = 0xff8dc18f,
2433 .active = 0xffb2ddb3
2434 };
2435
2436 static ui_colourset flcol_list_complete_b = {
2437 .main = 0xff79b37b,
2438 .hover = 0xff8dc18f,
2439 .active = 0xffb2ddb3
2440 };
2441
2442 static ui_colourset flcol_list_locked = {
2443 .main = 0xff655959,
2444 .hover = 0xff655959,
2445 .active = 0xff655959
2446 };
2447
2448 static struct
2449 {
2450 SteamLeaderboard_t steam_leaderboard;
2451 int leaderboard_show;
2452
2453 struct leaderboard_player
2454 {
2455 // Internal
2456 u64_steamid id;
2457 i32 score;
2458 int is_local_player;
2459
2460 // To be displayed
2461 char score_text[ 16 ];
2462 char player_name[ 48 ];
2463 GLuint texture; // Not dynamic
2464 }
2465 leaderboard_players[10];
2466 int leaderboard_count;
2467
2468 struct
2469 {
2470 struct cmp_level *level;
2471
2472 i32 score;
2473 int is_waiting;
2474 }
2475 upload_request;
2476
2477 struct cmp_level *level_selected;
2478 }
2479 ui_data;
2480
2481 void vg_ui(void)
2482 {
2483 // UI memory
2484 static int pack_selection = 0;
2485 static struct pack_info
2486 {
2487 struct cmp_level *levels;
2488 u32 level_count;
2489 const char *name;
2490 }
2491 pack_infos[] =
2492 {
2493 {
2494 .levels = cmp_levels_tutorials,
2495 .level_count = vg_list_size(cmp_levels_tutorials),
2496 .name = "Training"
2497 },
2498 {
2499 .levels = cmp_levels_basic,
2500 .level_count = vg_list_size(cmp_levels_basic),
2501 .name = "Main"
2502 },
2503 {
2504 .levels = cmp_levels_grad,
2505 .level_count = vg_list_size(cmp_levels_tutorials),
2506 .name = "Expert"
2507 }
2508 };
2509
2510 // UI Code
2511 ui_global_ctx.cursor[0] = 0;
2512 ui_global_ctx.cursor[1] = 0;
2513 ui_global_ctx.cursor[2] = 256;
2514
2515 gui_fill_y();
2516
2517 ui_global_ctx.id_base = 4 << 16;
2518
2519 gui_new_node();
2520 {
2521 gui_capture_mouse( 9999 );
2522 gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
2523
2524 gui_text( "ASSIGNMENTS", 8, 0 );
2525
2526 ui_global_ctx.cursor[1] += 30;
2527 ui_global_ctx.cursor[3] = 25;
2528
2529 gui_new_node();
2530 {
2531 ui_rect_pad( ui_global_ctx.cursor, 2 );
2532 ui_global_ctx.cursor[2] = 84;
2533
2534 for( int i = 0; i < 3; i ++ )
2535 {
2536 if( i == pack_selection )
2537 gui_override_colours( &flcol_list_locked );
2538
2539 if( gui_button( 2000 + i ) == k_button_click )
2540 pack_selection = i;
2541
2542 ui_global_ctx.cursor[1] += 2;
2543 gui_text( pack_infos[i].name, 4, 0 );
2544 gui_end_right();
2545
2546 gui_reset_colours();
2547 }
2548 }
2549 gui_end_down();
2550
2551 ui_global_ctx.cursor[3] = 500;
2552
2553 // DRAW LEVEL SELECTION LIST
2554 {
2555 struct cmp_level *levels = pack_infos[ pack_selection ].levels;
2556 int count = pack_infos[ pack_selection ].level_count;
2557
2558 static struct ui_scrollbar sb = {
2559 .bar_height = 400
2560 };
2561
2562 ui_px view_height = ui_global_ctx.cursor[3];
2563 ui_px level_height = 50;
2564
2565 // Level scroll view
2566 gui_new_node();
2567 {
2568 gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
2569 gui_set_clip( ui_global_ctx.cursor );
2570
2571 ui_global_ctx.cursor[2] = 14;
2572 gui_align_right();
2573
2574 ui_px content_height = count*level_height;
2575 if( content_height > view_height )
2576 {
2577 ui_scrollbar( &ui_global_ctx, &sb, 1 );
2578 ui_global_ctx.cursor[1] -= ui_calculate_content_scroll( &sb, content_height );
2579 }
2580 else
2581 {
2582 gui_fill_rect( ui_global_ctx.cursor, 0xff807373 );
2583 }
2584
2585 ui_global_ctx.cursor[2] = 240;
2586 ui_global_ctx.cursor[3] = level_height;
2587 gui_align_left();
2588
2589 for( int i = 0; i < count; i ++ )
2590 {
2591 struct cmp_level *lvl_info = &levels[i];
2592
2593 if( lvl_info->unlocked )
2594 {
2595 if( lvl_info->completed_score != 0 )
2596 gui_override_colours( i&0x1? &flcol_list_complete_a: &flcol_list_complete_b );
2597 else
2598 gui_override_colours( i&0x1? &flcol_list_a: &flcol_list_b );
2599 }
2600 else
2601 gui_override_colours( &flcol_list_locked );
2602
2603 if( lvl_info->unlocked )
2604 {
2605 if( gui_button( 2 + i ) == k_button_click )
2606 {
2607 ui_data.level_selected = &levels[i];
2608 ui_data.leaderboard_show = 0;
2609
2610 if( pack_selection >= 1 )
2611 sw_find_leaderboard( ui_data.level_selected->map_name );
2612 }
2613
2614 ui_global_ctx.override_colour = 0xffffffff;
2615 gui_text( lvl_info->title, 6, 0 );
2616 ui_global_ctx.cursor[1] += 18;
2617 gui_text( "incomplete", 4, 0 );
2618 }
2619 else
2620 {
2621 gui_button( 2 + i );
2622
2623 ui_global_ctx.override_colour = 0xff786f6f;
2624 gui_text( "???", 6, 0 );
2625 ui_global_ctx.cursor[1] += 18;
2626 gui_text( "locked", 4, 0 );
2627 }
2628
2629 gui_end_down();
2630 }
2631
2632 gui_reset_colours();
2633 gui_release_clip();
2634 }
2635 gui_end_down();
2636 }
2637 }
2638 gui_end_right();
2639
2640 // Selected level UI
2641 // ============================================================
2642
2643 if( ui_data.level_selected )
2644 {
2645 ui_global_ctx.cursor[0] += 16;
2646 ui_global_ctx.cursor[1] += 16;
2647 ui_global_ctx.cursor[2] = 512-40;
2648 ui_global_ctx.cursor[3] = 560-16;
2649
2650 gui_new_node();
2651 {
2652 gui_capture_mouse( 9999 );
2653
2654 gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
2655 ui_global_ctx.cursor[1] += 4;
2656 gui_text( ui_data.level_selected->title, 6, 0 );
2657
2658 ui_global_ctx.cursor[1] += 30;
2659 ui_rect_pad( ui_global_ctx.cursor, 8 );
2660 ui_global_ctx.cursor[3] = 300;
2661
2662 gui_new_node();
2663 {
2664 gui_fill_rect( ui_global_ctx.cursor, 0xff655959 );
2665 }
2666 gui_end_down();
2667
2668 ui_text_use_paragraph( &ui_global_ctx );
2669 ui_global_ctx.cursor[1] += 2;
2670
2671 gui_text( ui_data.level_selected->description, 5, 0 );
2672 ui_text_use_title( &ui_global_ctx );
2673
2674 // Buttons at the bottom
2675 ui_global_ctx.cursor[3] = 25;
2676 ui_global_ctx.cursor[2] = 80;
2677
2678 gui_align_bottom();
2679 ui_global_ctx.cursor[1] -= 8;
2680
2681 if( gui_button( 3000 ) == k_button_click )
2682 {
2683 ui_data.level_selected = NULL;
2684 }
2685 gui_text( "BACK", 6, k_text_alignment_center );
2686 gui_end();
2687
2688 gui_align_right();
2689 ui_global_ctx.cursor[2] = 170;
2690 ui_global_ctx.cursor[0] -= 8 + 170 + 2;
2691
2692 {
2693 gui_override_colours( &flcol_list_locked );
2694 if( gui_button( 3001 ) == k_button_click )
2695 vg_error( "UNIMPLEMENTED\n" );
2696
2697 ui_global_ctx.override_colour = 0xff888888;
2698
2699 gui_text( "RESTORE SOLUTION", 6, k_text_alignment_center );
2700 gui_end_right();
2701 ui_global_ctx.override_colour = 0xffffffff;
2702 }
2703
2704 ui_global_ctx.cursor[0] += 2;
2705 ui_global_ctx.cursor[2] = 80;
2706
2707 {
2708 gui_override_colours( &flcol_list_complete_a );
2709 if( gui_button( 3002 ) == k_button_click )
2710 {
2711 if( console_changelevel( 1, &ui_data.level_selected->map_name ) )
2712 {
2713 world.pCmpLevel = ui_data.level_selected;
2714
2715 ui_data.level_selected = NULL;
2716 ui_data.leaderboard_show = 0;
2717 }
2718 }
2719 gui_text( "PLAY", 6, k_text_alignment_center );
2720 gui_end();
2721 }
2722
2723 gui_reset_colours();
2724 }
2725 gui_end_right();
2726
2727 if( ui_data.leaderboard_show )
2728 {
2729 ui_global_ctx.cursor[0] += 16;
2730 ui_global_ctx.cursor[2] = 350;
2731 ui_global_ctx.cursor[3] = 25;
2732
2733 // If has results
2734 gui_new_node();
2735 {
2736 gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
2737 gui_text( "FRIEND LEADERBOARD", 6, 0 );
2738 }
2739 gui_end_down();
2740
2741 ui_global_ctx.cursor[1] += 2;
2742
2743 gui_new_node();
2744 {
2745 ui_global_ctx.cursor[3] = 32+8;
2746
2747 for( int i = 0; i < ui_data.leaderboard_count; i ++ )
2748 {
2749 gui_new_node();
2750 {
2751 gui_fill_rect( ui_global_ctx.cursor, i&0x1? flcol_list_a.main: flcol_list_b.main );
2752
2753 ui_global_ctx.cursor[0] += 4;
2754 ui_global_ctx.cursor[1] += 4;
2755
2756 // 1,2,3 ...
2757 static const char *places[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
2758 gui_text( places[i], 7, 0 );
2759 ui_global_ctx.cursor[0] += 32;
2760
2761 struct leaderboard_player *player = &ui_data.leaderboard_players[i];
2762
2763 // Players image
2764 ui_global_ctx.cursor[2] = 32;
2765 ui_global_ctx.cursor[3] = 32;
2766
2767 gui_new_node();
2768 {
2769 gui_push_image( ui_global_ctx.cursor, player->texture );
2770 }
2771 gui_end_right();
2772
2773 // Players name
2774 gui_text( player->player_name, 7, 0 );
2775
2776 ui_global_ctx.cursor[2] = 50;
2777 gui_align_right();
2778
2779 gui_text( player->score_text, 7, k_text_alignment_right );
2780 }
2781 gui_end_down();
2782
2783 ui_global_ctx.cursor[1] += 2;
2784 }
2785 }
2786 gui_end();
2787 }
2788 }
2789 }
2790
2791 void leaderboard_dispatch_score(void)
2792 {
2793 sw_upload_leaderboard_score(
2794 ui_data.upload_request.level->steam_leaderboard,
2795 k_ELeaderboardUploadScoreMethodKeepBest,
2796 ui_data.upload_request.score,
2797 NULL,
2798 0
2799 );
2800
2801 ui_data.upload_request.is_waiting = 0;
2802
2803 vg_success( "Dispatched leaderboard score\n" );
2804 }
2805
2806 void leaderboard_found( LeaderboardFindResult_t *pCallback )
2807 {
2808 if( !pCallback->m_bLeaderboardFound )
2809 {
2810 vg_error( "Leaderboard could not be found\n" );
2811 ui_data.steam_leaderboard = 0;
2812 }
2813 else
2814 {
2815 const char *recieved_name = sw_get_leaderboard_name( pCallback->m_hSteamLeaderboard );
2816
2817 // Update UI state and request entries if this callback found the current UI level
2818 if( ui_data.level_selected )
2819 {
2820 if( !strcmp( recieved_name, ui_data.level_selected->map_name ) )
2821 {
2822 sw_download_leaderboard_entries( pCallback->m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 0, 8 );
2823 ui_data.level_selected->steam_leaderboard = pCallback->m_hSteamLeaderboard;
2824 }
2825 }
2826
2827 // Dispatch the waiting request if there was one
2828 if( ui_data.upload_request.is_waiting )
2829 {
2830 if( !strcmp( recieved_name, ui_data.upload_request.level->map_name ) )
2831 {
2832 ui_data.upload_request.level->steam_leaderboard = pCallback->m_hSteamLeaderboard;
2833 leaderboard_dispatch_score();
2834 }
2835 }
2836 }
2837 }
2838
2839 void leaderboard_downloaded( LeaderboardScoresDownloaded_t *pCallback )
2840 {
2841 // Update UI if this leaderboard matches what we currently have in view
2842 if( ui_data.level_selected->steam_leaderboard == pCallback->m_hSteamLeaderboard )
2843 {
2844 vg_info( "Recieved %d entries\n", pCallback->m_cEntryCount );
2845 ui_data.leaderboard_count = VG_MIN( pCallback->m_cEntryCount, 8 );
2846
2847 u64_steamid local_player = sw_get_steamid();
2848
2849 for( int i = 0; i < ui_data.leaderboard_count; i ++ )
2850 {
2851 LeaderboardEntry_t entry;
2852 sw_get_downloaded_entry( pCallback->m_hSteamLeaderboardEntries, i, &entry, NULL, 0 );
2853
2854 struct leaderboard_player *player = &ui_data.leaderboard_players[i];
2855
2856 player->id = entry.m_steamIDUser.m_unAll64Bits;
2857 strncpy( player->player_name, sw_get_friend_persona_name( player->id ), vg_list_size( player->player_name )-1 );
2858 player->score = entry.m_nScore;
2859
2860 snprintf( player->score_text, vg_list_size(player->score_text), "%d", player->score );
2861 player->texture = sw_get_player_image( player->id );
2862
2863 if( player->texture == 0 )
2864 player->texture = tex_unkown.name;
2865
2866 player->is_local_player = local_player == player->id? 1: 0;
2867 }
2868
2869 if( ui_data.leaderboard_count )
2870 ui_data.leaderboard_show = 1;
2871 else
2872 ui_data.leaderboard_show = 0;
2873 }
2874 else vg_warn( "Downloaded leaderboard does not match requested!\n" );
2875 }
2876
2877 void leaderboard_set_score( struct cmp_level *cmp_level, u32 score )
2878 {
2879 if( ui_data.upload_request.is_waiting )
2880 vg_warn( "You are uploading leaderboard entries too quickly!\n" );
2881
2882 ui_data.upload_request.level = cmp_level;
2883 ui_data.upload_request.score = score;
2884 ui_data.upload_request.is_waiting = 1;
2885
2886 // If leaderboard ID has been downloaded already then just immediately dispatch this
2887 if( cmp_level->steam_leaderboard )
2888 leaderboard_dispatch_score();
2889 else
2890 sw_find_leaderboard( cmp_level->map_name );
2891 }
Nothing to see here...