X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=fishladder.c;h=19e3fb42b54f681bfa913e4a45201686ae55dc0f;hb=aad3ce335e5a67018359442ee1c3a849d675ea18;hp=74a39ce4de1bcd955e8c5db78b89b5ca3e6222b9;hpb=499bcabb125cdf2618a6be89ccade08b007254f3;p=fishladder.git

diff --git a/fishladder.c b/fishladder.c
index 74a39ce..19e3fb4 100644
--- a/fishladder.c
+++ b/fishladder.c
@@ -23,9 +23,9 @@
 			Reverse order
 		
 		New things to program:
-			UI text element renderer (SDF)
-			Particle system thing for ball collision
-			Level descriptions / titles
+			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
 			
@@ -48,72 +48,6 @@ const char *level_pack_1[] = {
 	"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;
@@ -355,13 +289,16 @@ struct world
 	
 	int num_fishes;
 	
-	char map_name[128];
-	struct career_level *ptr_career_level;
+	char map_name[64];
+	//struct career_level *ptr_career_level;
+	struct cmp_level *pCmpLevel;
 	
 	u32 score;
 	u32 completed;
 	u32 time;
-} world = {};
+} world;
+
+void leaderboard_set_score( struct cmp_level *cmp_level, u32 score );
 
 static void map_free(void)
 {	
@@ -390,6 +327,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 )
 {
@@ -402,9 +379,9 @@ static int map_load( const char *str, const char *name )
 	// Scan for width
 	for(;; world.w ++)
 	{
-		if( str[world.w] == ';' )
+		if( c[world.w] == ';' )
 			break;
-		else if( !str[world.w] )
+		else if( !c[world.w] )
 		{
 			vg_error( "Unexpected EOF when parsing level\n" );
 			return 0;
@@ -596,13 +573,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 ++ )
 		{
-			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] = 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 );
@@ -806,7 +835,7 @@ static int console_load_map( int argc, char const *argv[] )
 		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] ) )
 			{
@@ -814,17 +843,7 @@ static int console_load_map( int argc, char const *argv[] )
 				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
@@ -874,8 +893,157 @@ static int console_changelevel( int argc, char const *argv[] )
 	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
@@ -1028,12 +1196,13 @@ void vg_start(void)
 	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();
 
@@ -1188,7 +1357,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;
 			}
@@ -1266,7 +1435,7 @@ void vg_update(void)
 	world.tile_y = floorf( world.tile_pos[1] );
 
 	// Tilemap editing
-	if( !world.simulating )
+	if( !world.simulating && !gui_want_mouse() )
 	{
 		v2_copy( vg_mouse_ws, drag_to_co );
 	
@@ -1745,6 +1914,12 @@ void vg_update(void)
 						
 						world.score = score;
 						world.time = world.sim_frame;
+						
+						// Copy into career data
+						if( world.pCmpLevel )
+						{
+							career_pass_level( world.pCmpLevel, world.score, 1 );
+						}
 					}
 				}
 				else
@@ -1755,13 +1930,6 @@ void vg_update(void)
 					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?
 				break;
@@ -1965,6 +2133,30 @@ void vg_render(void)
 	}
 	
 	
+	// Level title
+	// TODO: Fix this?
+	/*
+	ui_begin( &ui_global_ctx, 512, 256 );
+	
+	ui_global_ctx.override_colour = 0xff9a8a89;
+	//ui_text( &ui_global_ctx, world.map_title, 6, 0 );
+	ui_global_ctx.override_colour = 0xffffffff;
+	
+	ui_resolve( &ui_global_ctx );
+	
+	m3x3f world_text;
+	m3x3_copy( vg_pv, world_text );
+	m3x3_translate( world_text, (v3f){ 1.55f, 1.9f, 0.0f } );
+	m3x3_rotate( world_text, VG_PIf*0.5f );
+	m3x3_scale( world_text, (v3f){0.01f,-0.01f,0.01f} );
+	
+	ui_draw( &ui_global_ctx, world_text );
+	*/
+	
+	// Main
+	// =========================================================================================
+	
+	use_mesh( &world.tile );
 	SHADER_USE( shader_tile_main );
 
 	m2x2f subtransform;
@@ -2170,12 +2362,13 @@ void vg_render(void)
 			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 );
+				float y_h = (is_input? 0.2f: -0.2f) * (float)k;
 				
 				if( is_input )
 				{
+					glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, 
+						(y_offset + (float)posy + (float)(term->run_count-1)*0.2f) - y_h, 0.1f );
+				
 					colour_code_v3( term->runs[k].conditions[j], dot_colour );
 					glUniform4fv( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 1, dot_colour );
 				
@@ -2187,6 +2380,8 @@ void vg_render(void)
 				}
 				else
 				{
+					glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), (float)posx + 0.2f + 0.2f * (float)j, (float)posy + y_offset + y_h, 0.1f );
+				
 					if( term->runs[k].recv_count > j )
 					{
 						colour_code_v3( term->runs[k].recieved[j], dot_colour );
@@ -2219,104 +2414,478 @@ void vg_render(void)
 		
 	use_mesh( &world.numbers );
 	draw_numbers( (v3f){ 2.0f, (float)world.h-1.875f, 0.3333f }, world.score );
+}
+
+static ui_colourset flcol_list_a = {
+	.main = 0xff877979,
+	.hover = 0xffa09393,
+	.active = 0xffbfb1b0
+};
+static ui_colourset flcol_list_b = {
+	.main = 0xff7c6e6e,
+	.hover = 0xffa09393,
+	.active = 0xffbfb1b0
+};
+
+static ui_colourset flcol_list_complete_a = {
+	.main = 0xff62a064,
+	.hover = 0xff8dc18f,
+	.active = 0xffb2ddb3
+};
+
+static ui_colourset flcol_list_complete_b = {
+	.main = 0xff79b37b,
+	.hover = 0xff8dc18f,
+	.active = 0xffb2ddb3
+};
+
+static ui_colourset flcol_list_locked = {
+	.main = 0xff655959,
+	.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;
 		
-	// Level selection UI
-	use_mesh( &world.circle );
-	float ratio = ((float)vg_window_x/(float)vg_window_y);
+		// 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;
 	
-	m3x3f ui_view = M3X3_IDENTITY;
-	m3x3_scale( ui_view, (v3f){ 1.0f, ratio, 1.0f } );
-	glUniformMatrix3fv( SHADER_UNIFORM( shader_tile_colour, "uPv" ), 1, GL_FALSE, (float *)ui_view );
+	struct cmp_level *level_selected;
+} 
+ui_data;
 
-	// Calculate mouse in UIsp
-	v3f mouse_ui_space = { ((float)vg_mouse[0] / (float)(vg_window_x)) * 2.0f - 1.0f,
-								  (((float)vg_mouse[1] / (float)(vg_window_y)) * 2.0f - 1.0f)*(-1.0f/ratio), 0.0125f };
+void vg_ui(void)
+{
+	// UI memory
+	static int pack_selection = 0;
+	static struct pack_info
+	{
+		struct cmp_level *levels;
+		u32 level_count;
+		const char *name;
+	}
+	pack_infos[] = 
+	{
+		{
+			.levels = cmp_levels_tutorials,
+			.level_count = vg_list_size(cmp_levels_tutorials),
+			.name = "Training"
+		},
+		{
+			.levels = cmp_levels_basic,
+			.level_count = vg_list_size(cmp_levels_basic),
+			.name = "Main"
+		},
+		{
+			.levels = cmp_levels_grad,
+			.level_count = vg_list_size(cmp_levels_tutorials),
+			.name = "Expert"
+		}
+	};
+	
+	// UI Code
+	ui_global_ctx.cursor[0] = 0;
+	ui_global_ctx.cursor[1] = 0;
+	ui_global_ctx.cursor[2] = 256;
 
-	// Get selected level
-	const float selection_scale = 0.05f;
-	int const level_count = vg_list_size( level_pack_1 );
-	int level_select = -1;
+	gui_fill_y();
+	
+	ui_global_ctx.id_base = 4 << 16;
 	
-	if( mouse_ui_space[0] <= -0.8f )
+	gui_new_node();
 	{
-		float levels_range = (float)level_count*selection_scale*0.6f;
-		float level_offset = ((-mouse_ui_space[1] + levels_range) / levels_range) * 0.5f * (float)level_count;
-		level_select = ceilf( level_offset );
+		gui_capture_mouse( 9999 );
+		gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
+		
+		gui_text( "ASSIGNMENTS", 8, 0 );
+		
+		ui_global_ctx.cursor[1] += 30;
+		ui_global_ctx.cursor[3] = 25;
+		
+		gui_new_node();
+		{
+			ui_rect_pad( ui_global_ctx.cursor, 2 );
+			ui_global_ctx.cursor[2] = 84;
+			
+			for( int i = 0; i < 3; i ++ )
+			{
+				if( i == pack_selection )
+					gui_override_colours( &flcol_list_locked );
 
-		// Draw selector
-		if( level_select >= 0 && level_select < vg_list_size( level_pack_1 ) )
+				if( gui_button( 2000 + i ) == k_button_click )
+					pack_selection = i;
+				
+				ui_global_ctx.cursor[1] += 2;
+				gui_text( pack_infos[i].name, 4, 0 );
+				gui_end_right();
+				
+				gui_reset_colours();
+			} 
+		}
+		gui_end_down();
+		
+		ui_global_ctx.cursor[3] = 500;
+		
+		// DRAW LEVEL SELECTION LIST
 		{
-			glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.369768f, 0.3654f, 0.42f, 1.0f );
+			struct cmp_level *levels = pack_infos[ pack_selection ].levels;
+			int count = pack_infos[ pack_selection ].level_count;
+
+			static struct ui_scrollbar sb = {
+				.bar_height = 400
+			};
 			
-			use_mesh( &world.tile );
-			glUniform3f( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 
-				-1.0f, 
-				((float)level_count - (float)level_select * 2.0f ) * selection_scale * 0.6f,
-				selection_scale
-			);
-			draw_mesh( 2, 2 );
+			ui_px view_height = ui_global_ctx.cursor[3];
+			ui_px level_height = 50;
+
+			// Level scroll view
+			gui_new_node();
+			{
+				gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
+				gui_set_clip( ui_global_ctx.cursor );
+				
+				ui_global_ctx.cursor[2] = 14;
+				gui_align_right();
+				
+				ui_px content_height = count*level_height;
+				if( content_height > view_height )
+				{
+					ui_scrollbar( &ui_global_ctx, &sb, 1 );
+					ui_global_ctx.cursor[1] -= ui_calculate_content_scroll( &sb, content_height );
+				}
+				else
+				{
+					gui_fill_rect( ui_global_ctx.cursor, 0xff807373 );
+				}
+				
+				ui_global_ctx.cursor[2] = 240;
+				ui_global_ctx.cursor[3] = level_height;
+				gui_align_left();
+				
+				for( int i = 0; i < count; i ++ )
+				{
+					struct cmp_level *lvl_info = &levels[i];
+				
+					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( i&0x1? &flcol_list_a: &flcol_list_b );
+					}
+					else
+						gui_override_colours( &flcol_list_locked );
+					
+					if( lvl_info->unlocked )
+					{
+						if( gui_button( 2 + i ) == k_button_click )
+						{
+							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 );
+					}
+					else
+					{
+						gui_button( 2 + i );
+						
+						ui_global_ctx.override_colour = 0xff786f6f;
+						gui_text( "???", 6, 0 );
+						ui_global_ctx.cursor[1] += 18;
+						gui_text( "locked", 4, 0 );
+					}
+					
+					gui_end_down();
+				}
+				
+				gui_reset_colours();		
+				gui_release_clip();
+			}
+			gui_end_down();
+		}
+	}
+	gui_end_right();
+	
+	// Selected level UI
+	// ============================================================
+	
+	if( ui_data.level_selected )
+	{
+		ui_global_ctx.cursor[0] += 16;
+		ui_global_ctx.cursor[1] += 16;
+		ui_global_ctx.cursor[2] = 512-40;
+		ui_global_ctx.cursor[3] = 560-16;
+		
+		gui_new_node();
+		{
+			gui_capture_mouse( 9999 );
+			
+			gui_fill_rect( ui_global_ctx.cursor, 0xff5a4e4d );
+			ui_global_ctx.cursor[1] += 4;
+			gui_text( ui_data.level_selected->title, 6, 0 );
 			
-			use_mesh( &world.circle );
+			ui_global_ctx.cursor[1] += 30;
+			ui_rect_pad( ui_global_ctx.cursor, 8 );
+			ui_global_ctx.cursor[3] = 300;
 			
-			if( vg_get_button_down( "primary" ) )
+			gui_new_node();
 			{
-				console_changelevel( 1, level_pack_1 + level_select );
+				gui_fill_rect( ui_global_ctx.cursor, 0xff655959 );
 			}
+			gui_end_down();
+			
+			ui_text_use_paragraph( &ui_global_ctx );
+			ui_global_ctx.cursor[1] += 2;
+			
+			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] = 25;
+			ui_global_ctx.cursor[2] = 80;
+			
+			gui_align_bottom();
+			ui_global_ctx.cursor[1] -= 8;
+			
+			if( gui_button( 3000 ) == k_button_click )
+			{
+				ui_data.level_selected = NULL;
+			}
+			gui_text( "BACK", 6, k_text_alignment_center );
+			gui_end();
+			
+			gui_align_right();
+			ui_global_ctx.cursor[2] = 170;
+			ui_global_ctx.cursor[0] -= 8 + 170 + 2;
+			
+			{
+				gui_override_colours( &flcol_list_locked );
+				if( gui_button( 3001 ) == k_button_click )
+					vg_error( "UNIMPLEMENTED\n" );
+				
+				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;
+			ui_global_ctx.cursor[2] = 80;
+			
+			{
+				gui_override_colours( &flcol_list_complete_a );
+				if( gui_button( 3002 ) == k_button_click )
+				{
+					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_reset_colours();
+		}
+		gui_end_right();
+		
+		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();
 		}
 	}
-	else mouse_ui_space[1] = INFINITY;
+}
 
-	glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.4f, 0.39f, 0.45f, 1.0f );
+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" );
+}
 
-	// Draw levels
-	for( int i = 0; i < level_count; i ++ )
+void leaderboard_found( LeaderboardFindResult_t *pCallback )
+{
+	if( !pCallback->m_bLeaderboardFound )
 	{
-		struct career_level *clevel = &career.levels[i];
-	
-		v3f level_ui_space = { 
-			-0.97f, 
-			((float)level_count - (float)i * 2.0f ) * selection_scale * 0.6f + selection_scale * 0.5f,
-			selection_scale * 0.5f
-		};
-		
-		float scale = vg_clampf( 1.0f - fabsf(level_ui_space[1] - mouse_ui_space[1]) * 2.0f, 0.9f, 1.0f );
-		level_ui_space[2] *= scale;
+		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 );
 		
-		glUniform3fv( SHADER_UNIFORM( shader_tile_colour, "uOffset" ), 1, level_ui_space );
+		// Update UI state and request entries if this callback found the current UI level
+		if( ui_data.level_selected )
+		{
+			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;
+			}
+		}
 		
-		if( clevel->completed )
-			draw_mesh( filled_start, filled_count );
-		else
-			draw_mesh( empty_start, empty_count );
+		// 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();
+			}
+		}
 	}
-	
-	// Level scores
-	glUniform4f( SHADER_UNIFORM( shader_tile_colour, "uColour" ), 0.4f*1.25f, 0.39f*1.25f, 0.45f*1.25f, 1.0f );
-	
-	use_mesh( &world.numbers );
-	for( int i = 0; i < level_count; i ++ )
+}
+
+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 )
 	{
-		struct career_level *clevel = &career.levels[i];
-	
-		v3f level_ui_space = { 
-			-0.94f, 
-			((float)level_count - (float)i * 2.0f ) * selection_scale * 0.6f + selection_scale * 0.5f,
-			0.02f
-		};
+		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();
 		
-		if( clevel->completed )
-			draw_numbers( level_ui_space, clevel->score );
+		for( int i = 0; i < ui_data.leaderboard_count; i ++ )
+		{
+			LeaderboardEntry_t entry;
+			sw_get_downloaded_entry( pCallback->m_hSteamLeaderboardEntries, i, &entry, NULL, 0 );
 			
-		level_ui_space[0] = -0.975f;
-		level_ui_space[1] -= 0.01f;
-		draw_numbers( level_ui_space, i );
+			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;
 	}
-	
-	//use_mesh( &world.numbers );
-	//draw_numbers( (v3f){ 0.0f, -0.5f, 0.1f }, 128765 );
+	else vg_warn( "Downloaded leaderboard does not match requested!\n" );
 }
 
-void vg_ui(void)
+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 );
 }