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