X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world_entity.c;h=02bbeb2b342d26141ef52c4a674688106cc50732;hb=fbc68c65e01838feb77f47b30994b45fcc39ebaf;hp=38bf86f7e650a0f4660f901db07a70fdae00cb33;hpb=342fcbf6fda017bdd38d56ce0fa7c9e59e589f3b;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/world_entity.c b/world_entity.c
index 38bf86f..02bbeb2 100644
--- a/world_entity.c
+++ b/world_entity.c
@@ -1,14 +1,108 @@
 #ifndef WORLD_ENTITY_C
 #define WORLD_ENTITY_C
 
+#include "model.h"
+#include "entity.h"
 #include "world.h"
 #include "world_load.h"
-#include "entity.h"
+#include "save.h"
+#include "vg/vg_msg.h"
+#include "menu.h"
+#include "ent_challenge.h"
+#include "ent_skateshop.h"
+#include "ent_route.h"
+
+static void world_entity_focus( u32 entity_id ){
+   localplayer.immobile = 1;
+   menu.disable_open = 1;
+
+   v3_zero( localplayer.rb.v );
+   v3_zero( localplayer.rb.w );
+   player_walk.move_speed = 0.0f;
+   world_static.focused_entity = entity_id;
+   skaterift.activity = k_skaterift_ent_focus;
+}
 
-VG_STATIC void world_gen_entities_init(void)
-{
-   world_instance *world = world_loading_instance();
+static void world_entity_unfocus(void){
+   localplayer.immobile = 0;
+   skaterift.activity = k_skaterift_default;
+   menu.disable_open = 0;
+   srinput.state = k_input_state_resume;
+}
+
+static void world_entity_focus_camera( world_instance *world, u32 uid ){
+   if( mdl_entity_id_type( uid ) == k_ent_camera ){
+      u32 index = mdl_entity_id_id( uid );
+      ent_camera *cam = mdl_arritm( &world->ent_camera, index );
+
+      v3f dir = {0.0f,-1.0f,0.0f};
+      mdl_transform_vector( &cam->transform, dir, dir );
+      v3_angles( dir, world_static.focus_cam.angles );
+      v3_copy( cam->transform.co, world_static.focus_cam.pos );
+      world_static.focus_cam.fov = cam->fov;
+   }
+   else {
+      camera_copy( &localplayer.cam, &world_static.focus_cam );
+
+      /* TODO ? */
+      world_static.focus_cam.nearz = localplayer.cam.nearz;
+      world_static.focus_cam.farz = localplayer.cam.farz;
+   }
+}
+
+/* logic preupdate */
+static void world_entity_focus_preupdate(void){
+   f32 rate = vg_minf( 1.0f, vg.time_frame_delta * 2.0f );
+   int active = 0;
+   if( skaterift.activity == k_skaterift_ent_focus )
+      active = 1;
+
+   vg_slewf( &world_static.focus_strength, active, 
+             vg.time_frame_delta * (1.0f/0.5f) );
+
+   u32 type = mdl_entity_id_type( world_static.focused_entity ),
+       index = mdl_entity_id_id( world_static.focused_entity );
+   world_instance *world = world_current_instance();
 
+   /* TODO: Table. */
+   if( type == k_ent_skateshop ){
+      ent_skateshop *skateshop = mdl_arritm( &world->ent_skateshop, index );
+      ent_skateshop_preupdate( skateshop, active );
+   }
+   else if( type == k_ent_challenge ){
+      ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
+      ent_challenge_preupdate( challenge, active );
+   }
+   else if( type == k_ent_route ){
+      ent_route *route = mdl_arritm( &world->ent_route, index );
+      ent_route_preupdate( route, active );
+   }
+}
+
+/* additional renderings like text etc.. */
+static void world_entity_focus_render(void){
+   world_instance *world = world_current_instance();
+   if( skaterift.activity != k_skaterift_ent_focus ){
+      skateshop_render_nonfocused( world, &skaterift.cam );
+      return;
+   }
+
+   u32 type = mdl_entity_id_type( world_static.focused_entity ),
+       index = mdl_entity_id_id( world_static.focused_entity );
+
+   if( type == k_ent_skateshop ){
+      ent_skateshop *skateshop = mdl_arritm( &world->ent_skateshop, index );
+      skateshop_render( skateshop );
+   }
+   else if( type == k_ent_challenge ){}
+   else if( type == k_ent_route ){}
+   else if( type == k_ent_miniworld ){}
+   else {
+      vg_fatal_error( "Programming error\n" );
+   }
+}
+
+static void world_gen_entities_init( world_instance *world ){
    /* lights */
    for( u32 j=0; j<mdl_arrcount(&world->ent_light); j ++ ){
       ent_light *light = mdl_arritm( &world->ent_light, j );
@@ -26,10 +120,11 @@ VG_STATIC void world_gen_entities_init(void)
    for( u32 j=0; j<mdl_arrcount(&world->ent_gate); j ++ ){
       ent_gate *gate = mdl_arritm( &world->ent_gate, j );
 
-      if( gate->type == k_gate_type_teleport ){
+      if( !(gate->flags & k_ent_gate_nonlocal) ) {
          gate_transform_update( gate );
       }
    }
+      
    vg_async_call( world_link_nonlocal_async, world, 0 );
 
    /* water */
@@ -59,37 +154,82 @@ VG_STATIC void world_gen_entities_init(void)
          ent_audio_clip *clip = mdl_arritm( &world->ent_audio_clip,  
                                              audio->clip_start+k );
 
-         if( clip->file.pack_size ){
-            u32 size = clip->file.pack_size,
-                offset = clip->file.pack_offset;
+         if( clip->_.file.pack_size ){
+            u32 size = clip->_.file.pack_size,
+                offset = clip->_.file.pack_offset;
 
             /* embedded files are fine to clear the scratch buffer, only
              * external audio uses it */
 
             vg_linear_clear( vg_mem.scratch );
             void *data = vg_linear_alloc( vg_mem.scratch, 
-                                          clip->file.pack_size );
+                                          clip->_.file.pack_size );
 
-            mdl_fread_pack_file( &world->meta, &clip->file, data );
+            mdl_fread_pack_file( &world->meta, &clip->_.file, data );
 
-            clip->clip.path = NULL;
-            clip->clip.flags = audio->flags;
-            clip->clip.data = data;
-            clip->clip.size = size;
+            clip->_.clip.path = NULL;
+            clip->_.clip.flags = audio->flags;
+            clip->_.clip.data = data;
+            clip->_.clip.size = size;
          }
          else{
-            clip->clip.path = mdl_pstr( &world->meta, clip->file.pstr_path );
-            clip->clip.flags = audio->flags;
-            clip->clip.data = NULL;
-            clip->clip.size = 0;
+            clip->_.clip.path = mdl_pstr(&world->meta,clip->_.file.pstr_path);
+            clip->_.clip.flags = audio->flags;
+            clip->_.clip.data = NULL;
+            clip->_.clip.size = 0;
          }
 
-         audio_clip_load( &clip->clip, world->heap );
+         audio_clip_load( &clip->_.clip, world->heap );
       }
    }
+
+   /* create generic entity hierachy for those who need it */
+   u32 indexed_count = 0;
+   struct {
+      u32 type;
+      mdl_array_ptr *array;
+   }
+   indexables[] = {
+      { k_ent_gate, &world->ent_gate },
+      { k_ent_objective, &world->ent_objective },
+      { k_ent_volume, &world->ent_volume },
+      { k_ent_challenge, &world->ent_challenge }
+   };
+
+   for( u32 i=0; i<vg_list_size(indexables); i++ )
+      indexed_count += mdl_arrcount( indexables[i].array );
+   vg_info( "indexing %u entities\n", indexed_count );
+
+   world->entity_list = vg_linear_alloc( world->heap, 
+                                         vg_align8(indexed_count*sizeof(u32)));
+
+   u32 index=0;
+   for( u32 i=0; i<vg_list_size(indexables); i++ ){
+      u32 type  = indexables[i].type,
+          count = mdl_arrcount( indexables[i].array );
+      
+      for( u32 j=0; j<count; j ++ )
+         world->entity_list[index ++] = mdl_entity_id( type, j );
+   }
+
+   world->entity_bh = bh_create( world->heap, &bh_system_entity_list, world,
+                                 indexed_count, 2 );
+
+   world->tar_min = world->entity_bh->nodes[0].bbx[0][1];
+   world->tar_max = world->entity_bh->nodes[0].bbx[1][1] + 20.0f;
+
+   for( u32 i=0; i<mdl_arrcount(&world->ent_marker); i++ ){
+      ent_marker *marker = mdl_arritm( &world->ent_marker, i );
+
+      if( MDL_CONST_PSTREQ( &world->meta, marker->pstr_alias, "tar_min" ) )
+         world->tar_min = marker->transform.co[1];
+
+      if( MDL_CONST_PSTREQ( &world->meta, marker->pstr_alias, "tar_max" ) )
+         world->tar_max = marker->transform.co[1];
+   }
 }
 
-VG_STATIC
+static
 ent_spawn *world_find_closest_spawn( world_instance *world, v3f position )
 {
    ent_spawn *rp = NULL, *r;
@@ -118,7 +258,7 @@ ent_spawn *world_find_closest_spawn( world_instance *world, v3f position )
    return rp;
 }
 
-VG_STATIC
+static
 ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name )
 {
    ent_spawn *rp = NULL, *r;
@@ -136,7 +276,7 @@ ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name )
    return rp;
 }
 
-VG_STATIC void ent_volume_call( world_instance *world, ent_call *call )
+static void ent_volume_call( world_instance *world, ent_call *call )
 {
    u32 index = mdl_entity_id_id( call->id );
    ent_volume *volume = mdl_arritm( &world->ent_volume, index );
@@ -145,7 +285,7 @@ VG_STATIC void ent_volume_call( world_instance *world, ent_call *call )
    if( call->function == k_ent_function_trigger ){
       call->id = volume->target;
 
-      if( volume->type == k_volume_subtype_particle ){
+      if( volume->flags & k_ent_volume_flag_particles ){
          float *co = alloca( sizeof(float)*3 );
          co[0] = vg_randf64()*2.0f-1.0f;
          co[1] = vg_randf64()*2.0f-1.0f;
@@ -157,19 +297,30 @@ VG_STATIC void ent_volume_call( world_instance *world, ent_call *call )
          entity_call( world, call );
       }
       else{
+         call->function = volume->trigger.event;
+         entity_call( world, call );
+      }
+   }
+   else if( call->function == k_ent_function_trigger_leave ){
+      call->id = volume->target;
+
+      if( volume->flags & k_ent_volume_flag_particles ){
+         assert(0);
+      }
+      else{
+         call->function = volume->trigger.event_leave;
          entity_call( world, call );
       }
    }
 }
 
-VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
-{
+static void ent_audio_call( world_instance *world, ent_call *call ){
    if( world->status == k_world_status_unloading ){
       vg_warn( "cannot modify audio while unloading world\n" );
       return;
    }
 
-   u8 world_id = (world - world_static.worlds) + 1;
+   u8 world_id = (world - world_static.instances) + 1;
    u32 index = mdl_entity_id_id( call->id );
    ent_audio *audio = mdl_arritm( &world->ent_audio, index );
 
@@ -182,7 +333,7 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
       v3_copy( audio->transform.co, sound_co );
    }
    else
-      vg_fatal_error( "ent_audio_call (invalid function id)" );
+      return;
 
    float chance = vg_randf64()*100.0f,
          bar = 0.0f;
@@ -195,12 +346,11 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
             p   = clip->probability * mod;
 
       bar += p;
-
       if( chance < bar ){
          audio_lock();
 
          if( audio->behaviour == k_channel_behaviour_unlimited ){
-            audio_oneshot_3d( &clip->clip, sound_co,
+            audio_oneshot_3d( &clip->_.clip, sound_co,
                               audio->transform.s[0],
                               audio->volume );
          }
@@ -210,7 +360,7 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
                                              audio->max_channels );
 
             if( ch ){
-               audio_channel_init( ch, &clip->clip, audio->flags );
+               audio_channel_init( ch, &clip->_.clip, audio->flags );
                audio_channel_group( ch, audio->group );
                audio_channel_world( ch, world_id );
                audio_channel_set_spacial( ch, sound_co, audio->transform.s[0] );
@@ -229,7 +379,7 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
                   audio_get_group_first_active_channel( audio->group );
 
                if( existing ){
-                  if( existing->source == &clip->clip ){
+                  if( existing->source == &clip->_.clip ){
                      audio_unlock();
                      return;
                   }
@@ -242,7 +392,7 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
             }
 
             if( ch ){
-               audio_channel_init( ch, &clip->clip, audio->flags );
+               audio_channel_init( ch, &clip->_.clip, audio->flags );
                audio_channel_group( ch, audio->group );
                audio_channel_world( ch, world_id );
                audio_channel_fadein( ch, audio->crossfade );
@@ -256,4 +406,333 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call )
    }
 }
 
+
+static void ent_ccmd_call( world_instance *world, ent_call *call ){
+   if( call->function == k_ent_function_trigger ){
+      u32 index = mdl_entity_id_id( call->id );
+      ent_ccmd *ccmd = mdl_arritm( &world->ent_ccmd, index );
+      vg_execute_console_input( mdl_pstr(&world->meta, ccmd->pstr_command) );
+   }
+}
+
+/*
+ * BVH implementation
+ * ----------------------------------------------------------------------------
+ */
+
+static void 
+entity_bh_expand_bound( void *user, boxf bound, u32 item_index ){
+   world_instance *world = user;
+
+   u32 id    = world->entity_list[ item_index ],
+       type  = mdl_entity_id_type( id ),
+       index = mdl_entity_id_id( id );
+
+   if( type == k_ent_gate ){
+      ent_gate *gate = mdl_arritm( &world->ent_gate, index );
+      boxf box = {{ -gate->dimensions[0], -gate->dimensions[1], -0.1f },
+                  {  gate->dimensions[0],  gate->dimensions[1],  0.1f }};
+
+      m4x3_expand_aabb_aabb( gate->to_world, bound, box );
+   }
+   else if( type == k_ent_objective ){
+      ent_objective *objective = mdl_arritm( &world->ent_objective, index );
+      
+      /* TODO: This might be more work than necessary. could maybe just get
+       *       away with representing them as points */
+
+      boxf box;
+      box_init_inf( box );
+
+      for( u32 i=0; i<objective->submesh_count; i++ ){
+         mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
+                                       objective->submesh_start+i );
+         box_concat( box, sm->bbx );
+      }
+
+      m4x3f transform;
+      mdl_transform_m4x3( &objective->transform, transform );
+      m4x3_expand_aabb_aabb( transform, bound, box );
+   }
+   else if( type == k_ent_volume ){
+      ent_volume *volume = mdl_arritm( &world->ent_volume, index );
+      m4x3_expand_aabb_aabb( volume->to_world, bound,
+                              (boxf){{-1.0f,-1.0f,-1.0f},{ 1.0f, 1.0f, 1.0f}} );
+   }
+   else if( type == k_ent_challenge ){
+      ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
+
+      boxf box = {{-1.2f*0.5f,-0.72f*0.5f,-0.01f*0.5f},
+                  { 1.2f*0.5f, 0.72f*0.5f, 0.01f*0.5f}};
+      m4x3f transform;
+      mdl_transform_m4x3( &challenge->transform, transform );
+      m4x3_expand_aabb_aabb( transform, bound, box );
+   }
+   else{
+      vg_fatal_error( "Programming error\n" );
+   }
+}
+
+static float entity_bh_centroid( void *user, u32 item_index, int axis ){
+   world_instance *world = user;
+
+   u32 id    = world->entity_list[ item_index ],
+       type  = mdl_entity_id_type( id ),
+       index = mdl_entity_id_id( id );
+
+   if( type == k_ent_gate ){
+      ent_gate *gate = mdl_arritm( &world->ent_gate, index );
+      return gate->to_world[3][axis];
+   }
+   else if( type == k_ent_objective ){
+      ent_objective *objective = mdl_arritm( &world->ent_objective, index );
+      return objective->transform.co[axis];
+   }
+   else if( type == k_ent_volume ){
+      ent_volume *volume = mdl_arritm( &world->ent_volume, index );
+      return volume->transform.co[axis];
+   }
+   else if( type == k_ent_challenge ){
+      ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
+      return challenge->transform.co[axis];
+   }
+   else {
+      vg_fatal_error( "Programming error\n" );
+      return INFINITY;
+   }
+}
+
+static void entity_bh_swap( void *user, u32 ia, u32 ib ){
+   world_instance *world = user;
+
+   u32 a = world->entity_list[ ia ],
+       b = world->entity_list[ ib ];
+
+   world->entity_list[ ia ] = b;
+   world->entity_list[ ib ] = a;
+}
+
+static void entity_bh_debug( void *user, u32 item_index ){
+   world_instance *world = user;
+
+   u32 id    = world->entity_list[ item_index ],
+       type  = mdl_entity_id_type( id ),
+       index = mdl_entity_id_id( id );
+
+   if( type == k_ent_gate ){
+      ent_gate *gate = mdl_arritm( &world->ent_gate, index );
+      boxf box = {{ -gate->dimensions[0], -gate->dimensions[1], -0.1f },
+                  {  gate->dimensions[0],  gate->dimensions[1],  0.1f }};
+      vg_line_boxf_transformed( gate->to_world, box, 0xf000ff00 );
+   }
+   else if( type == k_ent_objective ){
+      ent_objective *objective = mdl_arritm( &world->ent_objective, index );
+      boxf box;
+      box_init_inf( box );
+
+      for( u32 i=0; i<objective->submesh_count; i++ ){
+         mdl_submesh *sm = mdl_arritm( &world->meta.submeshs,
+                                       objective->submesh_start+i );
+         box_concat( box, sm->bbx );
+      }
+
+      m4x3f transform;
+      mdl_transform_m4x3( &objective->transform, transform );
+      vg_line_boxf_transformed( transform, box, 0xf000ff00 );
+   }
+   else if( type == k_ent_volume ){
+      ent_volume *volume = mdl_arritm( &world->ent_volume, index );
+      vg_line_boxf_transformed( volume->to_world,
+                                (boxf){{-1.0f,-1.0f,-1.0f},{ 1.0f, 1.0f, 1.0f}},
+                                0xf000ff00 );
+   }
+   else if( type == k_ent_challenge ){
+      ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
+
+      boxf box = {{-1.2f*0.5f,-0.72f*0.5f,-0.01f*0.5f},
+                  { 1.2f*0.5f, 0.72f*0.5f, 0.01f*0.5f}};
+      m4x3f transform;
+      mdl_transform_m4x3( &challenge->transform, transform );
+      vg_line_boxf_transformed( transform, box, 0xf0ff0000 );
+   }
+   else{
+      vg_fatal_error( "Programming error\n" );
+   }
+}
+
+static void update_ach_models(void){
+   world_instance *hub = &world_static.instances[k_world_purpose_hub];
+   if( hub->status != k_world_status_loaded ) return;
+
+   for( u32 i=0; i<mdl_arrcount( &hub->ent_prop ); i ++ ){
+      ent_prop *prop = mdl_arritm( &hub->ent_prop, i );
+      if( prop->flags & 0x2 ){
+         if( MDL_CONST_PSTREQ( &hub->meta, prop->pstr_alias, "MARC" ) )
+            if( skaterift.achievements & 0x1 )
+               prop->flags &= ~0x1;
+         if( MDL_CONST_PSTREQ( &hub->meta, prop->pstr_alias, "ALBERT" ) )
+            if( skaterift.achievements & 0x2 )
+               prop->flags &= ~0x1;
+         if( MDL_CONST_PSTREQ( &hub->meta, prop->pstr_alias, "JANET" ) )
+            if( skaterift.achievements & 0x4 )
+               prop->flags &= ~0x1;
+         if( MDL_CONST_PSTREQ( &hub->meta, prop->pstr_alias, "BERNADETTA" ) )
+            if( skaterift.achievements & 0x8 )
+               prop->flags &= ~0x1;
+      }
+   }
+}
+
+static void entity_bh_closest( void *user, u32 item_index, v3f point,
+                                  v3f closest ){
+   world_instance *world = user;
+
+   u32 id    = world->entity_list[ item_index ],
+       type  = mdl_entity_id_type( id ),
+       index = mdl_entity_id_id( id );
+
+   if( type == k_ent_gate ){
+      ent_gate *gate = mdl_arritm( &world->ent_gate, index );
+      v3_copy( gate->to_world[3], closest );
+   }
+   else if( type == k_ent_objective ){
+      ent_objective *challenge = mdl_arritm( &world->ent_objective, index );
+      v3_copy( challenge->transform.co, closest );
+   }
+   else if( type == k_ent_volume ){
+      ent_volume *volume = mdl_arritm( &world->ent_volume, index );
+      v3_copy( volume->to_world[3], closest );
+   }
+   else if( type == k_ent_challenge ){
+      ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
+      v3_copy( challenge->transform.co, closest );
+   }
+   else{
+      vg_fatal_error( "Programming error\n" );
+   }
+}
+
+static void world_entity_start( world_instance *world, vg_msg *sav ){
+   vg_info( "Start instance %p\n", world );
+
+   world->probabilities[ k_probability_curve_constant ] = 1.0f;
+   for( u32 i=0; i<mdl_arrcount(&world->ent_audio); i++ ){
+      ent_audio *audio = mdl_arritm(&world->ent_audio,i);
+      if( audio->flags & AUDIO_FLAG_AUTO_START ){
+         ent_call call;
+         call.data = NULL;
+         call.function = k_ent_function_trigger;
+         call.id = mdl_entity_id( k_ent_audio, i );
+         entity_call( world, &call );
+      }
+   }
+
+   /* read savedata 
+    * ----------------------------------------------------------------------- */
+
+   for( u32 i=0; i<mdl_arrcount(&world->ent_challenge); i++ ){
+      ent_challenge *challenge = mdl_arritm( &world->ent_challenge, i );
+      const char *alias = mdl_pstr( &world->meta, challenge->pstr_alias );
+
+      if( vg_msg_getkvu32( sav, alias, 0 ) ){
+         ent_call call;
+         call.data = NULL;
+         call.function = 0;
+         call.id = mdl_entity_id( k_ent_challenge, i );
+         entity_call( world, &call );
+      }
+   }
+
+   vg_msg routes_block = *sav;
+   if( vg_msg_seekframe( &routes_block, "routes" ) ){
+      for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
+         ent_route *route = mdl_arritm( &world->ent_route, i );
+
+         vg_msg route_info = routes_block;
+         if( vg_msg_seekframe( &route_info, 
+                               mdl_pstr(&world->meta,route->pstr_name) ) ){
+            route->flags |= vg_msg_getkvu32( &route_info, "flags", 0 );
+            route->best_laptime =
+               vg_msg_getkvf64( &route_info, "best_laptime", 0.0 );
+
+            f32 sections[ route->checkpoints_count ];
+            vg_msg_cmd cmd;
+            if( vg_msg_getkvcmd( &route_info, "sections", &cmd ) ){
+               vg_msg_cast( cmd.value, cmd.code, sections,
+                            k_vg_msg_f32 |
+                            vg_msg_count_bits(route->checkpoints_count) );
+            }
+            else{
+               for( u32 j=0; j<route->checkpoints_count; j ++ )
+                  sections[j] = 0.0f;
+            }
+
+            for( u32 j=0; j<route->checkpoints_count; j ++ ){
+               ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint,
+                     route->checkpoints_start + j );
+
+               cp->best_time = sections[j];
+            }
+
+            /* LEGACY: check if steam achievements can give us a medal */
+            if( steam_ready && steam_stats_ready ){
+               for( u32 j=0; j<vg_list_size(track_infos); j ++ ){
+                  struct track_info *inf = &track_infos[j];
+                  if( !strcmp(inf->name,
+                              mdl_pstr(&world->meta,route->pstr_name))){
+                     
+                     steamapi_bool set = 0;
+                     if( SteamAPI_ISteamUserStats_GetAchievement( 
+                              hSteamUserStats, inf->achievement_id, &set ) )
+                     {
+                        if( set ){
+                           route->flags |= k_ent_route_flag_achieve_silver;
+                        }
+                     }
+                  }
+               }
+            }
+         }
+      }
+   }
+
+   ent_region_re_eval( world );
+}
+
+static void world_entity_serialize( world_instance *world, vg_msg *sav ){
+   for( u32 i=0; i<mdl_arrcount(&world->ent_challenge); i++ ){
+      ent_challenge *challenge = mdl_arritm(&world->ent_challenge,i);
+
+      const char *alias = mdl_pstr(&world->meta,challenge->pstr_alias);
+      vg_msg_wkvu32( sav, alias, challenge->status );
+   }
+   
+   if( mdl_arrcount(&world->ent_route) ){
+      vg_msg_frame( sav, "routes" );
+      for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
+         ent_route *route = mdl_arritm( &world->ent_route, i );
+         
+         vg_msg_frame( sav, mdl_pstr( &world->meta, route->pstr_name ) );
+         {
+            vg_msg_wkvu32( sav, "flags", route->flags );
+            vg_msg_wkvf64( sav, "best_laptime", route->best_laptime );
+
+            f32 sections[ route->checkpoints_count ];
+
+            for( u32 j=0; j<route->checkpoints_count; j ++ ){
+               ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint,
+                     route->checkpoints_start + j );
+
+               sections[j] = cp->best_time;
+            }
+
+            vg_msg_wkvnum( sav, "sections", k_vg_msg_f32, 
+                           route->checkpoints_count, sections );
+         }
+         vg_msg_end_frame( sav );
+      }
+      vg_msg_end_frame( sav );
+   }
+}
+
 #endif /* WORLD_ENTITY_C */