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