save file .sv2 format read/write

diff --git a/fishladder.c b/fishladder.c
index 3b2c09f599c903741d874ebb04e1e6f087d45b8a..ecd46814f29908b149143f235d1a52547aa1d331 100644 (file)
--- a/fishladder.c
+++ b/fishladder.c
@@ -49,68 +49,87 @@ const char *level_pack_1[] = {
 };
 
 #pragma pack(push,1)
-struct career_state
+struct dcareer_state
 {
        u32 version;
+       i32 total_unlocked;
+       
+       u32 reserved[14];
 
-       struct career_level
+       struct dlevel_state
        {
-               u32 score;
-               u32 time;
-               u32 completed;
+               i32 score;
+               i32 reserved[3];
        }
-       levels[ vg_list_size( level_pack_1 ) ]; 
-}
-career = { .version = 1 };
+       levels[ NUM_CAMPAIGN_LEVELS ];  
+};
 #pragma pack(pop)
 
 static void career_serialize(void)
 {
-       vg_asset_write( "sav/game.sav", &career, sizeof( struct career_state ) );
+       struct dcareer_state encoded;
+       encoded.version = 2;
+       encoded.total_unlocked = career_local.total_unlocked;
+
+       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->reserved[0] = 0;
+                       dest->reserved[1] = 0;
+                       dest->reserved[2] = 0;
+               }
+       }
+
+       vg_asset_write( "sav/game.sv2", &encoded, sizeof( struct dcareer_state ) );
 }
 
 static void career_load(void)
 {
        i64 sz;
-       struct career_state *cr = vg_asset_read_s( "sav/game.sav", &sz );
+       struct dcareer_state encoded;
+       memset( (void*)&encoded, 0, sizeof( struct dcareer_state ) );
        
-       memset( (void*)career.levels, 0, vg_list_size(level_pack_1) * sizeof(struct career_level) );
+       // Load and copy data into encoded
+       void *cr = vg_asset_read_s( "sav/game.sv2", &sz );
        
        if( cr )
        {
-               if( sz > sizeof( struct career_state ) )
+               if( sz > sizeof( struct dcareer_state ) )
                        vg_warn( "This save file is too big! Some levels will be lost\n" );
                
-               if( sz <= offsetof( struct career_state, levels ) )
+               if( sz <= offsetof( struct dcareer_state, levels ) )
                {
-                       vg_error( "This save file is too small to have a header\n" );
+                       vg_warn( "This save file is too small to have a header. Creating a blank one\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 );
-               }
-               
+               memcpy( (void*)&encoded, cr, VG_MIN( sizeof( struct dcareer_state ), sz ) );
                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" );
+               
+       // 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];
+                       
+                       lvl->completed_score = src->score;
+                       // ...
+               }
        }
 }
 
@@ -393,6 +412,46 @@ static void io_reset(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 void map_reclassify( v2i start, v2i end, int update_texbuffer );
 static int map_load( const char *str, const char *name )
 {
@@ -599,13 +658,65 @@ static int map_load( const char *str, const char *name )
        // 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 ++ )
+               {
+                       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 ++ )
                {
-                       u8 *px = &info_buffer[i*4];
-                       px[0] = 255;
-                       px[1] = 0;
-                       px[2] = 0;
-                       px[3] = 0;
+                       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] = posy <= 4? -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 );
@@ -1189,7 +1300,7 @@ static void map_reclassify( v2i start, v2i end, int update_texbuffer )
                        else 
                        {
                                if( cell->state & FLAG_WALL )
-                                       height = 255;
+                                       height = 0xFF-0x3F + hash21i( (v2i){x,y}, 0x3F );
                                
                                config = 0xF;
                        }
@@ -1759,7 +1870,7 @@ void vg_update(void)
                                // Copy into career data
                                if( world.pCmpLevel )
                                {
-                                       if( world.score > world.pCmpLevel->completed_score )
+                                       if( world.score < world.pCmpLevel->completed_score || world.pCmpLevel->completed_score == 0 )
                                                leaderboard_set_score( world.pCmpLevel, world.score );
                                        
                                        world.pCmpLevel->completed_score = world.score;
@@ -2283,6 +2394,7 @@ static struct
                // Internal
                u64_steamid id;
                i32 score;
+               int is_local_player;
                
                // To be displayed
                char score_text[ 16 ];
@@ -2346,7 +2458,7 @@ void vg_ui(void)
        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 );
                
@@ -2434,7 +2546,9 @@ void vg_ui(void)
                                                {
                                                        ui_data.level_selected = &levels[i];
                                                        ui_data.leaderboard_show = 0;
-                                                       sw_find_leaderboard( ui_data.level_selected->map_name );
+                                                       
+                                                       if( pack_selection >= 1 )
+                                                               sw_find_leaderboard( ui_data.level_selected->map_name );
                                                }
                                                
                                                ui_global_ctx.override_colour = 0xffffffff;
@@ -2498,7 +2612,7 @@ void vg_ui(void)
                        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();
@@ -2508,7 +2622,7 @@ void vg_ui(void)
                        {
                                ui_data.level_selected = NULL;
                        }
-                       gui_text( "Back", 6, 0 );
+                       gui_text( "BACK", 6, k_text_alignment_center );
                        gui_end();
                        
                        gui_align_right();
@@ -2519,9 +2633,12 @@ void vg_ui(void)
                                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;
@@ -2537,7 +2654,7 @@ void vg_ui(void)
                                        ui_data.level_selected = NULL;
                                        ui_data.leaderboard_show = 0;
                                }
-                               gui_text( "Play", 6, 0 );
+                               gui_text( "PLAY", 6, k_text_alignment_center );
                                gui_end();
                        }
                        
@@ -2548,50 +2665,61 @@ void vg_ui(void)
                if( ui_data.leaderboard_show )
                {
                        ui_global_ctx.cursor[0] += 16;
-                       ui_global_ctx.cursor[3] = 250;
+                       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;
                                
-                               ui_rect_pad( ui_global_ctx.cursor, 8 );
+                       gui_new_node();
+                       {
+                               ui_global_ctx.cursor[3] = 32+8;
                                
-                               gui_new_node();
+                               for( int i = 0; i < ui_data.leaderboard_count; i ++ )
                                {
-                                       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();
                                                {
-                                                       struct leaderboard_player *player = &ui_data.leaderboard_players[i];
-                                                       
-                                                       ui_global_ctx.cursor[0] += 4;
-                                                       ui_global_ctx.cursor[1] += 4;                                                   
-                                                       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();
-                                                       
-                                                       gui_text( player->player_name, 6, 0 );
-                                                       
-                                                       ui_global_ctx.cursor[2] = 50;
-                                                       gui_align_right();
-                                                       
-                                                       gui_text( player->score_text, 6, 0 );
+                                                       gui_push_image( ui_global_ctx.cursor, player->texture );
                                                }
-                                               gui_end_down();
+                                               gui_end_right();
+                                               
+                                               // Players name
+                                               gui_text( player->player_name, 7, 0 );
                                                
-                                               ui_global_ctx.cursor[1] += 2;
+                                               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();
                        }
                        gui_end();
                }
@@ -2629,7 +2757,7 @@ void leaderboard_found( LeaderboardFindResult_t *pCallback )
                {
                        if( !strcmp( recieved_name, ui_data.level_selected->map_name ) )
                        {
-                               sw_download_leaderboard_entries( pCallback->m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 0, 10 );
+                               sw_download_leaderboard_entries( pCallback->m_hSteamLeaderboard, k_ELeaderboardDataRequestFriends, 0, 8 );
                                ui_data.level_selected->steam_leaderboard = pCallback->m_hSteamLeaderboard;
                        }
                }
@@ -2652,7 +2780,9 @@ void leaderboard_downloaded( LeaderboardScoresDownloaded_t *pCallback )
        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, 10 );
+               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 ++ )
                {
@@ -2670,6 +2800,8 @@ void leaderboard_downloaded( LeaderboardScoresDownloaded_t *pCallback )
                        
                        if( player->texture == 0 )
                                player->texture = tex_unkown.name;
+                               
+                       player->is_local_player = local_player == player->id? 1: 0;
                }
                
                if( ui_data.leaderboard_count )

diff --git a/fishladder_resources.h b/fishladder_resources.h
index fca9152da0e1fc9b032a856b8bfbaecaecd634c3..c06c17de94edf307c635bb00ea0134c4dc3662b8 100644 (file)
--- a/fishladder_resources.h
+++ b/fishladder_resources.h
@@ -255,7 +255,7 @@ SHADER_DEFINE( shader_tile_main,
        ""
        "void main()"
        "{"
-               "vec3 shadowing_colour = vec3( 0.93, 0.88536, 0.8184 );"
+               "vec3 shadowing_colour = vec3( 0.93, 0.88536, 0.8184 ) * 0.97;"
                "vec4 glyph = texture( uTexGlyphs, aTexCoords.xy );"
                "vec4 wood = texture( uTexWood, aTexCoords.zw );"
                "vec4 wood_secondary = texture( uTexWood, aTexCoords.zw + 0.25 );"
@@ -313,7 +313,7 @@ SHADER_DEFINE( shader_background,
                
                "ao_accum -= data_this_tile.r;"
                
-               "vec3 colour_main = vec3( 0.369768, 0.3654, 0.42 );"
+               "vec3 colour_main = mix( vec3( 0.369768, 0.3654, 0.42 ),vec3( 0.275, 0.388, 0.553 ), data_this_tile.g );"
                
                "vec2 square_coords = fract( aTexCoords * 64.0 );"
                "vec2 grid_coords = abs( square_coords - 0.5 );"
@@ -589,7 +589,8 @@ struct cmp_level cmp_levels_tutorials[] =
        {
                .title = "PRINCIPLE 2",
                .map_name = "cmp_t02",
-               .description = "Utilize the twisty turny(TM) piece",
+               .description = "Utilize the twisty turny(TM) piece to split\n"
+                                                       "the marble stream into two",
                
                .serial_id = 1,
                .unlocks = 1
@@ -605,7 +606,8 @@ struct cmp_level cmp_levels_tutorials[] =
        {
                .title = "PRINCIPLE 4",
                .map_name = "cmp_t04",
-               .description = "Some stages require multiple runs to succeed in order to pass",
+               .description = "Some stages require multiple runs to succeed\n" 
+                                                       "in order to pass",
                
                .serial_id = 12,
                .unlocks = 3
@@ -625,7 +627,7 @@ struct cmp_level cmp_levels_basic[] =
        {
                .title = "SUBDIVISION 2",
                .map_name = "cmp_b02",
-               .description = "Simple maths. Futher.",
+               .description = "Simple maths, except more.",
 
                .serial_id = 4,
                .unlocks = 1
@@ -806,6 +808,8 @@ struct cmp_level cmp_levels_grad[] =
        }
 };
 
+#define NUM_CAMPAIGN_LEVELS (vg_list_size( cmp_levels_tutorials ) + vg_list_size( cmp_levels_basic ) + vg_list_size( cmp_levels_grad ))
+
 struct
 {
        int total_unlocked;
@@ -814,3 +818,24 @@ career_local =
 {
        .total_unlocked = 1
 };
+
+struct serializable_set 
+{
+       struct cmp_level *pack;
+       int count;
+} 
+career_serializable[] =
+{
+       {
+               .pack = cmp_levels_tutorials,
+               .count = vg_list_size( cmp_levels_tutorials )
+       },
+       {
+               .pack = cmp_levels_basic,
+               .count = vg_list_size( cmp_levels_basic )
+       },
+       {
+               .pack = cmp_levels_grad,
+               .count = vg_list_size( cmp_levels_grad )
+       }
+};

diff --git a/vg/vg.h b/vg/vg.h
index ba392bb99adba028461ce7278a6775880a1c9632..5d67f714807264699dbda5a33984ffe6e7f2cbba 100644 (file)
--- a/vg/vg.h
+++ b/vg/vg.h
@@ -35,6 +35,10 @@ m3x3f vg_pv;
 
 // Engine globals
 GLFWwindow* vg_window;
+
+// 1366, 768
+// 1920, 1080
+
 int vg_window_x = 1366;
 int vg_window_y = 768;
 

diff --git a/vg/vg_ui.h b/vg/vg_ui.h
index 3e4ae5e3717d272c90af5d9832368b5f5bb032c5..7e676545546355c7819f9f5c81b2e68a6ae8b5c8 100644 (file)
--- a/vg/vg_ui.h
+++ b/vg/vg_ui.h
@@ -573,10 +573,11 @@ static void ui_text_use_paragraph( ui_ctx *ctx )
 enum text_alignment
 {
        k_text_alignment_left = 0,
-       k_text_alignment_center
+       k_text_alignment_center,
+       k_text_alignment_right
 };
 
-static void ui_text( ui_ctx *ctx, const char *str, ui_px scale, enum text_alignment alignment )
+static ui_px ui_text( ui_ctx *ctx, const char *str, ui_px scale, enum text_alignment alignment )
 {
        ui_rect text_cursor;
 
@@ -587,6 +588,24 @@ static void ui_text( ui_ctx *ctx, const char *str, ui_px scale, enum text_alignm
 
        u32 current_colour = ctx->override_colour;
 
+       ui_px offset = 0;
+       if( alignment != k_text_alignment_left )
+       {
+               const char *pch = str;
+               for(;;)
+               {
+                       offset += (ui_glyph_spacing_x*scale)/4;
+                       if( !(*pch) || *pch == '\n' )
+                               break;
+                       pch ++;
+               }
+               
+               if( alignment == k_text_alignment_right )
+                       text_cursor[0] = ctx->cursor[0]+ctx->cursor[2]-offset;
+               else
+                       text_cursor[0] = (ctx->cursor[0]+(ctx->cursor[2]/2))-(offset/2);
+       }
+
        const char *_c = str;
        char c;
        while( (c = *(_c ++)) )
@@ -655,6 +674,8 @@ static void ui_text( ui_ctx *ctx, const char *str, ui_px scale, enum text_alignm
                
                text_cursor[0] += (ui_glyph_spacing_x*scale)/4;
        }
+       
+       return text_cursor[0];
 }
 
 // API control