UI text element renderer (SDF) DONE(sorta)
Particle system thing for ball collision
Level descriptions / titles HALF
- Row Gridlines for I/O
- Play button / Speed controller
+ Row Gridlines for I/O DONE
+ Play button / Speed controller ( play buttern, pause, speed control, step button )
After release:
"thirds"
};
-#pragma pack(push,1)
-struct career_state
-{
- u32 version;
-
- struct career_level
- {
- u32 score;
- u32 time;
- u32 completed;
- }
- levels[ vg_list_size( level_pack_1 ) ];
-}
-career = { .version = 1 };
-#pragma pack(pop)
-
-static void career_serialize(void)
-{
- vg_asset_write( "sav/game.sav", &career, sizeof( struct career_state ) );
-}
-
-static void career_load(void)
-{
- i64 sz;
- struct career_state *cr = vg_asset_read_s( "sav/game.sav", &sz );
-
- memset( (void*)career.levels, 0, vg_list_size(level_pack_1) * sizeof(struct career_level) );
-
- if( cr )
- {
- if( sz > sizeof( struct career_state ) )
- vg_warn( "This save file is too big! Some levels will be lost\n" );
-
- if( sz <= offsetof( struct career_state, levels ) )
- {
- vg_error( "This save file is too small to have a header\n" );
- free( cr );
- return;
- }
-
- u32 const size_header = offsetof(struct career_state, levels);
- u32 const size_levels = sizeof(struct career_state)-size_header;
- u32 const size_levels_input = sz - size_header;
-
- memcpy( (void*)career.levels, (void*)cr->levels, size_levels_input );
-
- if( sz < sizeof( struct career_state ) )
- {
- memset( ((void*)career.levels) + size_levels_input, 0, size_levels-size_levels_input );
- }
-
- free( cr );
- vg_success( "Loaded save file... Info:\n" );
-
- for( int i = 0; i < vg_list_size( career.levels ); i ++ )
- {
- struct career_level *lvl = &career.levels[i];
- vg_info( "Score: %u, Time: %u, Completed: %u\n", lvl->score, lvl->time, lvl->completed );
- }
- }
- else
- {
- vg_info( "No save file... Using blank one\n" );
- }
-}
-
m3x3f m_projection;
m3x3f m_view;
m3x3f m_mdl;
v3f colour_sets[] =
{ { 1.0f, 0.9f, 0.3f },
{ 0.2f, 0.9f, 0.14f },
- { 0.4f, 0.8f, 1.00f } };
+ { 0.4f, 0.8f, 1.00f },
+ { 0.882f, 0.204f, 0.922f }
+};
static void colour_code_v3( char cc, v3f target )
{
k_fish_state_soon_alive
};
+enum e_world_button
+{
+ k_world_button_none = -1,
+ k_world_button_sim = 0,
+ k_world_button_ff = 1,
+ k_world_button_wire_mode = 2
+};
+
struct world
{
#pragma pack(push,1)
int sim_frame;
float sim_start;
- int simulating;
int sim_run, max_runs;
float sim_speed;
}
*io;
+ struct cell_button
+ {
+ float light_target, light;
+ int pressed;
+ }
+ buttons[4];
+
int w, h;
- struct mesh tile, circle, numbers;
+ struct mesh shapes, numbers;
struct mesh_wire
{
GLuint vao, vbo, ebo;
int num_fishes;
char map_name[64];
- struct career_level *ptr_career_level;
+ //struct career_level *ptr_career_level;
+ struct cmp_level *pCmpLevel;
u32 score;
u32 completed;
u32 time;
-} world = {};
+} world;
+
+static struct cell_button *get_wbutton( enum e_world_button btn )
+{
+ return &world.buttons[ btn ];
+}
+
+void leaderboard_set_score( struct cmp_level *cmp_level, u32 score );
static void map_free(void)
{
}
}
+int random_noise[] = {
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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,
+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
+};
+
+static int hash21i( v2i p, u32 umod )
+{
+ return random_noise[ (random_noise[p[1] & 1023] + p[0]) & 1023 ] & umod;
+}
+
+static struct cell *pcell( v2i pos )
+{
+ return &world.data[ pos[1]*world.w + pos[0] ];
+}
+
static void map_reclassify( v2i start, v2i end, int update_texbuffer );
static int map_load( const char *str, const char *name )
{
char link_id_buffer[32];
int link_id_n = 0;
-
+
for(;;)
{
if( !*c )
// Update data texture to fill out the background
{
u8 info_buffer[64*64*4];
- for( int i = 0; i < 64*64; i ++ )
+ for( int x = 0; x < 64; x ++ )
{
- u8 *px = &info_buffer[i*4];
- px[0] = 255;
- px[1] = 0;
- px[2] = 0;
- px[3] = 0;
+ for( int y = 0; y < 64; y ++ )
+ {
+ u8 *px = &info_buffer[((x*64)+y)*4];
+
+ px[0] = 0xFF-0x3F + hash21i( (v2i){x,y}, 0x3F );
+ px[1] = 0;
+ px[2] = 0;
+ px[3] = 0;
+ }
+ }
+
+ // Random walks.. kinda
+ for( int i = 0; i < arrlen(world.io); i ++ )
+ {
+ struct cell_terminal *term = &world.io[ i ];
+ int posx = term->id % world.w;
+ int posy = (term->id - posx)/world.w;
+
+ v2i turtle;
+ v2i turtle_dir;
+ int original_y;
+
+ turtle[0] = 16+posx;
+ turtle[1] = 16+posy;
+
+ turtle_dir[0] = 0;
+ turtle_dir[1] = pcell((v2i){ posx,posy })->state & FLAG_INPUT? 1: -1;
+ original_y = turtle_dir[1];
+
+ for( int i = 0; i < 100; i ++ )
+ {
+ info_buffer[((turtle[1]*64)+turtle[0])*4] = 0;
+
+ v2i_add( turtle_dir, turtle, turtle );
+
+ if( turtle[0] == 0 ) break;
+ if( turtle[0] == 63 ) break;
+ if( turtle[1] == 0 ) break;
+ if( turtle[1] == 63 ) break;
+
+ int random_value = hash21i( turtle, 0xFF );
+ if( random_value > 255-40 && !turtle_dir[0] )
+ {
+ turtle_dir[0] = -1;
+ turtle_dir[1] = 0;
+ }
+ else if( random_value > 255-80 && !turtle_dir[0] )
+ {
+ turtle_dir[0] = 1;
+ turtle_dir[1] = 0;
+ }
+ else if( random_value > 255-100 )
+ {
+ turtle_dir[0] = 0;
+ turtle_dir[1] = original_y;
+ }
+ }
}
glBindTexture( GL_TEXTURE_2D, world.background_data );
return 0;
}
-static struct cell *pcell( v2i pos )
-{
- return &world.data[ pos[1]*world.w + pos[0] ];
-}
-
static void map_serialize( FILE *stream )
{
for( int y = 0; y < world.h; y ++ )
if( text_source )
{
vg_info( "Loading map: '%s'\n", map_path );
- world.ptr_career_level = NULL;
+ world.pCmpLevel = NULL;
if( !map_load( text_source, argv[0] ) )
{
return 0;
}
- free( text_source );
-
- for( int i = 0; i < vg_list_size( level_pack_1 ); i ++ )
- {
- if( !strcmp( level_pack_1[i], argv[0] ) )
- {
- world.ptr_career_level = career.levels + i;
- break;
- }
- }
-
+ free( text_source );
return 1;
}
else
static void simulation_stop(void)
{
- world.simulating = 0;
+ get_wbutton( k_world_button_sim )->pressed = 0;
+ get_wbutton( k_world_button_ff )->pressed = 0;
+
world.num_fishes = 0;
world.sim_frame = 0;
world.sim_run = 0;
vg_info( "Stopping simulation!\n" );
}
+static void wbutton_run( enum e_world_button btn_name )
+{
+ struct cell_button *btn = &world.buttons[btn_name];
+
+ // Interaction
+
+ int is_hovering = (world.tile_x == world.w-1 && world.tile_y == world.h-btn_name-2)?1:0;
+ if( vg_get_button_up( "primary" ) && is_hovering )
+ {
+ // Click event
+ btn->pressed ^= 0x1;
+
+ if( btn_name == k_world_button_sim )
+ {
+ if( btn->pressed )
+ {
+ vg_success( "Starting simulation!\n" );
+
+ sfx_set_playrnd( &audio_rolls, &audio_system_balls_rolling, 0, 1 );
+
+ world.num_fishes = 0;
+ world.sim_frame = 0;
+ world.sim_start = vg_time;
+ world.sim_run = 0;
+ world.sim_speed = 2.5f;
+
+ for( int i = 0; i < world.w*world.h; i ++ )
+ world.data[ i ].state &= ~FLAG_FLIP_FLOP;
+
+ io_reset();
+ }
+ else
+ {
+ simulation_stop();
+ }
+ }
+ }
+
+ // Drawing
+ if( btn->pressed ) btn->light_target = is_hovering? 0.9f: 0.8f;
+ else btn->light_target = is_hovering? 0.2f: 0.0f;
+
+ if( vg_get_button( "primary" ) && is_hovering )
+ btn->light_target = 1.0f;
+
+ btn->light = vg_lerpf( btn->light, btn->light_target, vg_time_delta*26.0f );
+
+ glUniform4f( SHADER_UNIFORM( shader_buttons, "uOffset" ),
+ world.w-1,
+ world.h-btn_name-2,
+ (float)btn_name,
+ 3.0f
+ );
+ glUniform4f( SHADER_UNIFORM( shader_buttons, "uColour" ), 0.204f, 0.345f, 0.553f, btn->light );
+
+ draw_mesh( 0, 2 );
+}
+
static int console_changelevel( int argc, char const *argv[] )
{
if( argc >= 1 )
return 0;
}
+#pragma pack(push,1)
+struct dcareer_state
+{
+ u32 version;
+ i32 in_map;
+
+ u32 reserved[14];
+
+ struct dlevel_state
+ {
+ i32 score;
+ i32 unlocked;
+ i32 reserved[2];
+ }
+ levels[ NUM_CAMPAIGN_LEVELS ];
+};
+#pragma pack(pop)
+
+static void career_serialize(void)
+{
+ struct dcareer_state encoded;
+ encoded.version = 2;
+ encoded.in_map = world.pCmpLevel? world.pCmpLevel->serial_id: -1;
+
+ memset( encoded.reserved, 0, sizeof( encoded.reserved ) );
+
+ for( int i = 0; i < vg_list_size( career_serializable ); i ++ )
+ {
+ struct serializable_set *set = &career_serializable[i];
+
+ for( int j = 0; j < set->count; j ++ )
+ {
+ struct cmp_level *lvl = &set->pack[j];
+ struct dlevel_state *dest = &encoded.levels[lvl->serial_id];
+
+ dest->score = lvl->completed_score;
+ dest->unlocked = lvl->unlocked;
+ dest->reserved[0] = 0;
+ dest->reserved[1] = 0;
+ }
+ }
+
+ vg_asset_write( "sav/game.sv2", &encoded, sizeof( struct dcareer_state ) );
+}
+
+static void career_unlock_level( struct cmp_level *lvl );
+static void career_unlock_level( struct cmp_level *lvl )
+{
+ lvl->unlocked = 1;
+
+ if( lvl->linked )
+ career_unlock_level( lvl->linked );
+}
+
+static void career_pass_level( struct cmp_level *lvl, int score, int upload )
+{
+ if( score > 0 )
+ {
+ if( score < lvl->completed_score || lvl->completed_score == 0 )
+ {
+ if( !lvl->is_tutorial && upload )
+ leaderboard_set_score( lvl, score );
+
+ lvl->completed_score = score;
+ }
+
+ if( lvl->unlock ) career_unlock_level( lvl->unlock );
+ }
+}
+
+static void career_reset_level( struct cmp_level *lvl )
+{
+ lvl->unlocked = 0;
+ lvl->completed_score = 0;
+}
+
+static void career_load(void)
+{
+ i64 sz;
+ struct dcareer_state encoded;
+
+ // Blank save state
+ memset( (void*)&encoded, 0, sizeof( struct dcareer_state ) );
+ encoded.in_map = -1;
+ encoded.levels[0].unlocked = 1;
+
+ // Load and copy data into encoded
+ void *cr = vg_asset_read_s( "sav/game.sv2", &sz );
+
+ if( cr )
+ {
+ if( sz > sizeof( struct dcareer_state ) )
+ vg_warn( "This save file is too big! Some levels will be lost\n" );
+
+ if( sz <= offsetof( struct dcareer_state, levels ) )
+ {
+ vg_warn( "This save file is too small to have a header. Creating a blank one\n" );
+ free( cr );
+ return;
+ }
+
+ memcpy( (void*)&encoded, cr, VG_MIN( sizeof( struct dcareer_state ), sz ) );
+ free( cr );
+ }
+ else
+ vg_info( "No save file... Using blank one\n" );
+
+ // Reset memory
+ for( int i = 0; i < vg_list_size( career_serializable ); i ++ )
+ {
+ struct serializable_set *set = &career_serializable[i];
+
+ for( int j = 0; j < set->count; j ++ )
+ career_reset_level( &set->pack[j] );
+ }
+
+ // Header information
+ // =================================
+
+ // Decode everything from dstate
+ for( int i = 0; i < vg_list_size( career_serializable ); i ++ )
+ {
+ struct serializable_set *set = &career_serializable[i];
+
+ for( int j = 0; j < set->count; j ++ )
+ {
+ struct cmp_level *lvl = &set->pack[j];
+ struct dlevel_state *src = &encoded.levels[lvl->serial_id];
+
+ if( src->unlocked ) career_unlock_level( lvl );
+ if( src->score ) lvl->completed_score = src->score;
+
+ // ...
+ if( lvl->serial_id == encoded.in_map )
+ {
+ if( console_changelevel( 1, &lvl->map_name ) )
+ world.pCmpLevel = lvl;
+ }
+ }
+ }
+}
+
+void leaderboard_found( LeaderboardFindResult_t *pCallback );
+void leaderboard_downloaded( LeaderboardScoresDownloaded_t *pCallback );
+
void vg_start(void)
{
+ // Steamworks callbacks
+ sw_leaderboard_found = &leaderboard_found;
+ sw_leaderboard_downloaded = &leaderboard_downloaded;
+
vg_function_push( (struct vg_cmd){
.name = "_map_write",
.function = console_save_map
.function = console_credits
});
- // Quad mesh
+ // Combined quad, long quad / empty circle / filled circle mesh
{
- float quad_mesh[] =
- {
+ float combined_mesh[6*8 + 32*6*3] = {
0.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
0.0f, 0.0f, 1.0f, 1.0f, 1.0f, 0.0f,
- 0.0f, 0.0f, 0.0f, 1.0f, 4.0f, 1.0f,
- 0.0f, 0.0f, 4.0f, 1.0f, 4.0f, 0.0f
+ 0.0f, 0.0f, 0.0f, 0.2f, 1.0f, 0.2f,
+ 0.0f, 0.0f, 1.0f, 0.2f, 1.0f, 0.0f
};
- init_mesh( &world.tile, quad_mesh, vg_list_size(quad_mesh) );
- }
-
- // Circle mesh
- {
- float circle_mesh[32*6*3];
- int res = vg_list_size( circle_mesh ) / (6*3);
+ float *circle_mesh = combined_mesh + 6*4;
+ int const res = 32;
for( int i = 0; i < res; i ++ )
{
v2_copy( v1, circle_mesh+i*6+2 );
}
- init_mesh( &world.circle, circle_mesh, vg_list_size( circle_mesh ) );
+ init_mesh( &world.shapes, combined_mesh, vg_list_size( combined_mesh ) );
}
// Numbers mesh
resource_load_main();
// Restore gamestate
+ career_local_data_init();
career_load();
- console_load_map( 1, level_pack_1 );
}
void vg_free(void)
{
+ sw_free_opengl();
console_save_map( 0, NULL );
career_serialize();
glDeleteBuffers( 1, &world.wire.vbo );
glDeleteBuffers( 1, &world.wire.ebo );
- free_mesh( &world.tile );
- free_mesh( &world.circle );
+ free_mesh( &world.shapes );
free_mesh( &world.numbers );
map_free();
else
{
if( cell->state & FLAG_WALL )
- height = 255;
+ height = 0xFF-0x3F + hash21i( (v2i){x,y}, 0x3F );
config = 0xF;
}
world.tile_y = floorf( world.tile_pos[1] );
// Tilemap editing
- if( !world.simulating && !gui_want_mouse() )
+ if( !get_wbutton( k_world_button_sim )->pressed && !gui_want_mouse() )
{
v2_copy( vg_mouse_ws, drag_to_co );
}
}
else
+ {
world.selected = -1;
+ }
if( !(vg_get_button("secondary") && id_drag_from) )
id_drag_from = 0;
id_drag_from = 0;
}
- // Simulation stop/start
- if( vg_get_button_down("go") )
- {
- if( world.simulating )
- {
- simulation_stop();
- }
- else
- {
- vg_success( "Starting simulation!\n" );
-
- sfx_set_playrnd( &audio_rolls, &audio_system_balls_rolling, 0, 1 );
-
- world.simulating = 1;
- world.num_fishes = 0;
- world.sim_frame = 0;
- world.sim_start = vg_time;
- world.sim_run = 0;
- world.sim_speed = 2.5f;
-
- for( int i = 0; i < world.w*world.h; i ++ )
- world.data[ i ].state &= ~FLAG_FLIP_FLOP;
-
- io_reset();
- }
- }
-
// Fish ticks
- if( world.simulating )
+ if( get_wbutton( k_world_button_sim )->pressed )
{
while( world.sim_frame < (int)((vg_time-world.sim_start)*world.sim_speed) )
{
world.score = score;
world.time = world.sim_frame;
+
+ // Copy into career data
+ if( world.pCmpLevel )
+ {
+ career_pass_level( world.pCmpLevel, world.score, 1 );
+ }
}
}
else
vg_error( "Level failed :(\n" );
}
- // Copy into career data
- if( world.ptr_career_level )
- {
- world.ptr_career_level->score = world.score;
- world.ptr_career_level->time = world.time;
- world.ptr_career_level->completed = world.completed;
- }
-
- simulation_stop(); // TODO: Async?
+ simulation_stop();
break;
}
// NOTE: this is for final optimisations ONLY!
// ======================================================================
- use_mesh( &world.tile );
+ use_mesh( &world.shapes );
// Draw background
// Level title
+ // TODO: Fix this?
+ /*
ui_begin( &ui_global_ctx, 512, 256 );
ui_global_ctx.override_colour = 0xff9a8a89;
m3x3_scale( world_text, (v3f){0.01f,-0.01f,0.01f} );
ui_draw( &ui_global_ctx, world_text );
+ */
// Main
// =========================================================================================
- use_mesh( &world.tile );
+ use_mesh( &world.shapes );
SHADER_USE( shader_tile_main );
m2x2f subtransform;
glUniform1i( SHADER_UNIFORM( shader_ball, "uTexMain" ), 0 );
// Draw 'fish'
- if( world.simulating )
+ if( get_wbutton( k_world_button_sim )->pressed )
{
for( int i = 0; i < world.num_fishes; i ++ )
{
//glDisable(GL_BLEND);
+ SHADER_USE( shader_buttons );
+ glUniformMatrix3fv( SHADER_UNIFORM( shader_buttons, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
+
+ vg_tex2d_bind( &tex_buttons, 0 );
+ glUniform1i( SHADER_UNIFORM( shader_buttons, "uTexMain" ), 0 );
+
+ wbutton_run( k_world_button_sim );
+ wbutton_run( k_world_button_ff );
+
+
// Draw connecting wires
glDisable(GL_BLEND);
SHADER_USE( shader_tile_colour );
glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)vg_pv );
- use_mesh( &world.circle );
+ use_mesh( &world.shapes );
- int const filled_start = 0;
- int const filled_count = 32;
- int const empty_start = 32;
- int const empty_count = 32*2;
+ int const circle_base = 4;
+ int const filled_start = circle_base+0;
+ int const filled_count = circle_base+32;
+ int const empty_start = circle_base+32;
+ int const empty_count = circle_base+32*2;
+
+ glEnable(GL_BLEND);
// Draw i/o arrays
for( int i = 0; i < arrlen( world.io ); i ++ )
for( int k = 0; k < term->run_count; k ++ )
{
+ float y_offset = is_input? 1.2f: -0.2f;
+ float y_h = (is_input? 0.2f: -0.2f) * (float)k;
+ float y_row = is_input?
+ (y_offset + (float)posy + (float)(term->run_count-1)*0.2f) - y_h:
+ (float)posy + y_offset + y_h;
+
+ if( k & 0x1 )
+ {
+ glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1.0f, 1.0f, 1.0f, 0.1f );
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx, y_row - 0.1f, 1.0f );
+ draw_mesh( 2, 2 );
+ }
+
for( int j = 0; j < term->runs[k].condition_count; j ++ )
{
- float y_offset = is_input? 1.2f: -0.2f;
- y_offset += (is_input? 0.2f: -0.2f) * (float)k;
-
- glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + y_offset, 0.1f );
-
if( is_input )
{
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, y_row, 0.1f );
+
colour_code_v3( term->runs[k].conditions[j], dot_colour );
glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
}
else
{
+ glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, y_row, 0.1f );
+
if( term->runs[k].recv_count > j )
{
colour_code_v3( term->runs[k].recieved[j], dot_colour );
}
}
- if( world.simulating )
- {
- glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.0f, 0.0f, 0.0f, 1.0f );
- glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), -0.5f + cosf( vg_time * 4.0f ) * 0.2f, sinf( vg_time * 4.0f ) * 0.2f + (float)world.h * 0.5f, 0.05f );
- draw_mesh( filled_start, filled_count );
- }
+ glDisable(GL_BLEND);
// Draw score
float const score_bright = 1.25f;
.hover = 0xff655959,
.active = 0xff655959
};
+
+static struct
+{
+ SteamLeaderboard_t steam_leaderboard;
+ int leaderboard_show;
+
+ struct leaderboard_player
+ {
+ // Internal
+ u64_steamid id;
+ i32 score;
+ int is_local_player;
+
+ // To be displayed
+ char score_text[ 16 ];
+ char player_name[ 48 ];
+ GLuint texture; // Not dynamic
+ }
+ leaderboard_players[10];
+ int leaderboard_count;
+
+ struct
+ {
+ struct cmp_level *level;
+
+ i32 score;
+ int is_waiting;
+ }
+ upload_request;
+
+ struct cmp_level *level_selected;
+}
+ui_data;
+
void vg_ui(void)
{
// UI memory
}
};
- static struct cmp_level *level_selected = NULL;
-
// UI Code
ui_global_ctx.cursor[0] = 0;
ui_global_ctx.cursor[1] = 0;
gui_new_node();
{
gui_capture_mouse( 9999 );
- gui_fill_rect( ui_global_ctx.cursor, 0xff5577ff );
+ gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
gui_text( "ASSIGNMENTS", 8, 0 );
{
struct cmp_level *levels = pack_infos[ pack_selection ].levels;
int count = pack_infos[ pack_selection ].level_count;
- int unlocked = 3000;
-
+
static struct ui_scrollbar sb = {
.bar_height = 400
};
{
struct cmp_level *lvl_info = &levels[i];
- if( i < unlocked )
+ if( lvl_info->unlocked )
{
if( lvl_info->completed_score != 0 )
gui_override_colours( i&0x1? &flcol_list_complete_a: &flcol_list_complete_b );
else
gui_override_colours( &flcol_list_locked );
- if( i < unlocked )
+ if( lvl_info->unlocked )
{
if( gui_button( 2 + i ) == k_button_click )
- level_selected = &levels[i];
-
+ {
+ ui_data.level_selected = &levels[i];
+ ui_data.leaderboard_show = 0;
+
+ if( pack_selection >= 1 )
+ sw_find_leaderboard( ui_data.level_selected->map_name );
+ }
+
ui_global_ctx.override_colour = 0xffffffff;
gui_text( lvl_info->title, 6, 0 );
ui_global_ctx.cursor[1] += 18;
- gui_text( "incomplete", 4, 0 );
+ gui_text( lvl_info->completed_score>0? "passed": "incomplete", 4, 0 );
}
else
{
// Selected level UI
// ============================================================
- if( level_selected )
+ if( ui_data.level_selected )
{
ui_global_ctx.cursor[0] += 16;
ui_global_ctx.cursor[1] += 16;
gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
ui_global_ctx.cursor[1] += 4;
- gui_text( level_selected->title, 6, 0 );
+ gui_text( ui_data.level_selected->title, 6, 0 );
ui_global_ctx.cursor[1] += 30;
ui_rect_pad( ui_global_ctx.cursor, 8 );
ui_text_use_paragraph( &ui_global_ctx );
ui_global_ctx.cursor[1] += 2;
- gui_text( level_selected->description, 5, 0 );
+ gui_text( ui_data.level_selected->description, 5, 0 );
ui_text_use_title( &ui_global_ctx );
// Buttons at the bottom
- ui_global_ctx.cursor[3] = 30;
+ ui_global_ctx.cursor[3] = 25;
ui_global_ctx.cursor[2] = 80;
gui_align_bottom();
if( gui_button( 3000 ) == k_button_click )
{
- level_selected = NULL;
+ ui_data.level_selected = NULL;
}
- gui_text( "Back", 6, 0 );
+ gui_text( "BACK", 6, k_text_alignment_center );
gui_end();
gui_align_right();
gui_override_colours( &flcol_list_locked );
if( gui_button( 3001 ) == k_button_click )
vg_error( "UNIMPLEMENTED\n" );
-
- gui_text( "Restore Solution", 6, 0 );
+
+ ui_global_ctx.override_colour = 0xff888888;
+
+ gui_text( "RESTORE SOLUTION", 6, k_text_alignment_center );
gui_end_right();
+ ui_global_ctx.override_colour = 0xffffffff;
}
ui_global_ctx.cursor[0] += 2;
{
gui_override_colours( &flcol_list_complete_a );
if( gui_button( 3002 ) == k_button_click )
- console_changelevel( 1, &level_selected->map_name );
- gui_text( "Play", 6, 0 );
+ {
+ if( console_changelevel( 1, &ui_data.level_selected->map_name ) )
+ {
+ world.pCmpLevel = ui_data.level_selected;
+
+ ui_data.level_selected = NULL;
+ ui_data.leaderboard_show = 0;
+ }
+ }
+ gui_text( "PLAY", 6, k_text_alignment_center );
gui_end();
}
}
gui_end_right();
- ui_global_ctx.cursor[0] += 16;
- ui_global_ctx.cursor[3] = 250;
+ if( ui_data.leaderboard_show )
+ {
+ ui_global_ctx.cursor[0] += 16;
+ ui_global_ctx.cursor[2] = 350;
+ ui_global_ctx.cursor[3] = 25;
+
+ // If has results
+ gui_new_node();
+ {
+ gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
+ gui_text( "FRIEND LEADERBOARD", 6, 0 );
+ }
+ gui_end_down();
+
+ ui_global_ctx.cursor[1] += 2;
+
+ gui_new_node();
+ {
+ ui_global_ctx.cursor[3] = 32+8;
+
+ for( int i = 0; i < ui_data.leaderboard_count; i ++ )
+ {
+ gui_new_node();
+ {
+ gui_fill_rect( ui_global_ctx.cursor, i&0x1? flcol_list_a.main: flcol_list_b.main );
+
+ ui_global_ctx.cursor[0] += 4;
+ ui_global_ctx.cursor[1] += 4;
+
+ // 1,2,3 ...
+ static const char *places[] = { "1", "2", "3", "4", "5", "6", "7", "8", "9", "10" };
+ gui_text( places[i], 7, 0 );
+ ui_global_ctx.cursor[0] += 32;
+
+ struct leaderboard_player *player = &ui_data.leaderboard_players[i];
+
+ // Players image
+ ui_global_ctx.cursor[2] = 32;
+ ui_global_ctx.cursor[3] = 32;
+
+ gui_new_node();
+ {
+ gui_push_image( ui_global_ctx.cursor, player->texture );
+ }
+ gui_end_right();
+
+ // Players name
+ gui_text( player->player_name, 7, 0 );
+
+ ui_global_ctx.cursor[2] = 50;
+ gui_align_right();
+
+ gui_text( player->score_text, 7, k_text_alignment_right );
+ }
+ gui_end_down();
+
+ ui_global_ctx.cursor[1] += 2;
+ }
+ }
+ gui_end();
+ }
+ }
+}
+
+void leaderboard_dispatch_score(void)
+{
+ sw_upload_leaderboard_score(
+ ui_data.upload_request.level->steam_leaderboard,
+ k_ELeaderboardUploadScoreMethodKeepBest,
+ ui_data.upload_request.score,
+ NULL,
+ 0
+ );
+
+ ui_data.upload_request.is_waiting = 0;
+
+ vg_success( "Dispatched leaderboard score\n" );
+}
+
+void leaderboard_found( LeaderboardFindResult_t *pCallback )
+{
+ if( !pCallback->m_bLeaderboardFound )
+ {
+ vg_error( "Leaderboard could not be found\n" );
+ ui_data.steam_leaderboard = 0;
+ }
+ else
+ {
+ const char *recieved_name = sw_get_leaderboard_name( pCallback->m_hSteamLeaderboard );
- // If has results
- gui_new_node();
+ // Update UI state and request entries if this callback found the current UI level
+ if( ui_data.level_selected )
{
- gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
+ if( !strcmp( recieved_name, ui_data.level_selected->map_name ) )
+ {
+ sw_download_leaderboard_entries( pCallback->m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 0, 8 );
+ ui_data.level_selected->steam_leaderboard = pCallback->m_hSteamLeaderboard;
+ }
+ }
+
+ // Dispatch the waiting request if there was one
+ if( ui_data.upload_request.is_waiting )
+ {
+ if( !strcmp( recieved_name, ui_data.upload_request.level->map_name ) )
+ {
+ ui_data.upload_request.level->steam_leaderboard = pCallback->m_hSteamLeaderboard;
+ leaderboard_dispatch_score();
+ }
}
- gui_end();
}
}
+
+void leaderboard_downloaded( LeaderboardScoresDownloaded_t *pCallback )
+{
+ // Update UI if this leaderboard matches what we currently have in view
+ if( ui_data.level_selected->steam_leaderboard == pCallback->m_hSteamLeaderboard )
+ {
+ vg_info( "Recieved %d entries\n", pCallback->m_cEntryCount );
+ ui_data.leaderboard_count = VG_MIN( pCallback->m_cEntryCount, 8 );
+
+ u64_steamid local_player = sw_get_steamid();
+
+ for( int i = 0; i < ui_data.leaderboard_count; i ++ )
+ {
+ LeaderboardEntry_t entry;
+ sw_get_downloaded_entry( pCallback->m_hSteamLeaderboardEntries, i, &entry, NULL, 0 );
+
+ struct leaderboard_player *player = &ui_data.leaderboard_players[i];
+
+ player->id = entry.m_steamIDUser.m_unAll64Bits;
+ strncpy( player->player_name, sw_get_friend_persona_name( player->id ), vg_list_size( player->player_name )-1 );
+ player->score = entry.m_nScore;
+
+ snprintf( player->score_text, vg_list_size(player->score_text), "%d", player->score );
+ player->texture = sw_get_player_image( player->id );
+
+ if( player->texture == 0 )
+ player->texture = tex_unkown.name;
+
+ player->is_local_player = local_player == player->id? 1: 0;
+ }
+
+ if( ui_data.leaderboard_count )
+ ui_data.leaderboard_show = 1;
+ else
+ ui_data.leaderboard_show = 0;
+ }
+ else vg_warn( "Downloaded leaderboard does not match requested!\n" );
+}
+
+void leaderboard_set_score( struct cmp_level *cmp_level, u32 score )
+{
+ if( ui_data.upload_request.is_waiting )
+ vg_warn( "You are uploading leaderboard entries too quickly!\n" );
+
+ ui_data.upload_request.level = cmp_level;
+ ui_data.upload_request.score = score;
+ ui_data.upload_request.is_waiting = 1;
+
+ // If leaderboard ID has been downloaded already then just immediately dispatch this
+ if( cmp_level->steam_leaderboard )
+ leaderboard_dispatch_score();
+ else
+ sw_find_leaderboard( cmp_level->map_name );
+}
projects / fishladder.git / blobdiff