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