X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world_entity.c;h=cdc76f1ae23d96d5bde4957843f86ea791e7ba7a;hb=HEAD;hp=a12e071ade86fdf4a749ea840e1f61edcc434ed7;hpb=874c9d7e6ee2d826f9eb34518e8163283439c38e;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/world_entity.c b/world_entity.c
index a12e071..cdc76f1 100644
--- a/world_entity.c
+++ b/world_entity.c
@@ -1,6 +1,5 @@
-#ifndef WORLD_ENTITY_C
-#define WORLD_ENTITY_C
-
+#include "vg/vg_steam.h"
+#include "vg/vg_steam_user_stats.h"
 #include "model.h"
 #include "entity.h"
 #include "world.h"
@@ -11,26 +10,81 @@
 #include "ent_challenge.h"
 #include "ent_skateshop.h"
 #include "ent_route.h"
+#include "ent_traffic.h"
+#include "ent_glider.h"
+#include "ent_region.h"
+#include "ent_npc.h"
+#include "input.h"
+#include "player_walk.h"
+
+bh_system bh_system_entity_list = 
+{
+   .expand_bound = entity_bh_expand_bound,
+   .item_centroid = entity_bh_centroid,
+   .item_closest = entity_bh_closest,
+   .item_swap = entity_bh_swap,
+   .item_debug = entity_bh_debug,
+   .cast_ray = NULL
+};
+
+void world_entity_set_focus( u32 entity_id )
+{
+   if( world_static.focused_entity )
+   {
+      vg_warn( "Entity %u#%u tried to take focus from %u#%u\n",
+                  mdl_entity_id_type( entity_id ),
+                  mdl_entity_id_id( entity_id ),
+                  mdl_entity_id_type( world_static.focused_entity ),
+                  mdl_entity_id_id( world_static.focused_entity ) );
+      return;
+   }
+
+   world_static.focused_entity = entity_id;
+}
 
-static void world_entity_focus( u32 entity_id ){
+void world_entity_focus_modal(void)
+{
    localplayer.immobile = 1;
    menu.disable_open = 1;
+   srinput.state = k_input_state_resume;
 
    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;
 }
 
-static void world_entity_unfocus(void){
+void world_entity_exit_modal(void)
+{
+   if( skaterift.activity != k_skaterift_ent_focus )
+   {
+      vg_warn( "Entity %u#%u tried to exit modal when we weren't in one\n",
+                  mdl_entity_id_type( world_static.focused_entity ),
+                  mdl_entity_id_id( world_static.focused_entity ) );
+      return;
+   }
+
    localplayer.immobile = 0;
-   skaterift.activity = k_skaterift_default;
    menu.disable_open = 0;
    srinput.state = k_input_state_resume;
+   skaterift.activity = k_skaterift_default;
 }
 
-static void world_entity_focus_camera( world_instance *world, u32 uid ){
+void world_entity_clear_focus(void)
+{
+   if( skaterift.activity == k_skaterift_ent_focus )
+   {
+      vg_warn( "Entity %u#%u tried to clear focus before exiting modal\n",
+                  mdl_entity_id_type( world_static.focused_entity ),
+                  mdl_entity_id_id( world_static.focused_entity ) );
+      return;
+   }
+
+   world_static.focused_entity = 0;
+}
+
+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 );
@@ -42,7 +96,7 @@ static void world_entity_focus_camera( world_instance *world, u32 uid ){
       world_static.focus_cam.fov = cam->fov;
    }
    else {
-      camera_copy( &localplayer.cam, &world_static.focus_cam );
+      vg_camera_copy( &localplayer.cam, &world_static.focus_cam );
 
       /* TODO ? */
       world_static.focus_cam.nearz = localplayer.cam.nearz;
@@ -51,7 +105,8 @@ static void world_entity_focus_camera( world_instance *world, u32 uid ){
 }
 
 /* logic preupdate */
-static void world_entity_focus_preupdate(void){
+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 )
@@ -60,48 +115,61 @@ static void world_entity_focus_preupdate(void){
    vg_slewf( &world_static.focus_strength, active, 
              vg.time_frame_delta * (1.0f/0.5f) );
 
+   if( world_static.focused_entity == 0 )
+      return;
+
    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 );
+   static void (*table[])( ent_focus_context *ctx ) =
+   {
+      [ k_ent_skateshop ] = ent_skateshop_preupdate,
+      [ k_ent_challenge ] = ent_challenge_preupdate,
+      [ k_ent_route ] = ent_route_preupdate,
+      [ k_ent_npc ] = ent_npc_preupdate,
+   };
+
+   if( (type > vg_list_size(table)) || (table[type] == NULL) )
+   {
+      vg_fatal_error( "No pre-update method set for entity (%u#%u)\n",
+                      type, index );
    }
+
+   table[type]( &(ent_focus_context){
+                  .world = world,
+                  .index = index,
+                  .active = active } );
 }
 
 /* additional renderings like text etc.. */
-static void world_entity_focus_render(void){
-   if( skaterift.activity != k_skaterift_ent_focus )
+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 );
-   world_instance *world = world_current_instance();
 
    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_challenge ){}
+   else if( type == k_ent_route ){}
+   else if( type == k_ent_miniworld ){}
+   else if( type == k_ent_npc ){}
    else {
       vg_fatal_error( "Programming error\n" );
    }
 }
 
-static void world_gen_entities_init( world_instance *world ){
+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 );
@@ -115,14 +183,8 @@ static void world_gen_entities_init( world_instance *world ){
       light->angle_sin_cos[1] = cosf( light->angle * 0.5f );
    }
 
-   /* gates */
-   for( u32 j=0; j<mdl_arrcount(&world->ent_gate); j ++ ){
-      ent_gate *gate = mdl_arritm( &world->ent_gate, j );
-
-      if( !(gate->flags & k_ent_gate_nonlocal_DELETED) ) {
-         gate_transform_update( gate );
-      }
-   }
+   vg_async_call( world_link_gates_async, world, 0 );
+   vg_async_stall();
 
    /* water */
    for( u32 j=0; j<mdl_arrcount(&world->ent_water); j++ ){
@@ -190,7 +252,9 @@ static void world_gen_entities_init( world_instance *world ){
       { k_ent_gate, &world->ent_gate },
       { k_ent_objective, &world->ent_objective },
       { k_ent_volume, &world->ent_volume },
-      { k_ent_challenge, &world->ent_challenge }
+      { k_ent_challenge, &world->ent_challenge },
+      { k_ent_glider, &world->ent_glider },
+      { k_ent_npc, &world->ent_npc }
    };
 
    for( u32 i=0; i<vg_list_size(indexables); i++ )
@@ -211,9 +275,21 @@ static void world_gen_entities_init( world_instance *world ){
 
    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];
+   }
 }
 
-static
 ent_spawn *world_find_closest_spawn( world_instance *world, v3f position )
 {
    ent_spawn *rp = NULL, *r;
@@ -242,7 +318,6 @@ ent_spawn *world_find_closest_spawn( world_instance *world, v3f position )
    return rp;
 }
 
-static
 ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name )
 {
    ent_spawn *rp = NULL, *r;
@@ -260,48 +335,77 @@ ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name )
    return rp;
 }
 
-static void ent_volume_call( world_instance *world, ent_call *call )
+void world_default_spawn_pos( world_instance *world, v3f pos )
+{
+   ent_spawn *rp = world_find_spawn_by_name( world, "start" );
+   if( !rp ) rp = world_find_closest_spawn( world, (v3f){0,0,0} );
+   if( rp )
+      v3_copy( rp->transform.co, pos );
+   else
+   {
+      vg_error( "There are no valid spawns in the world\n" );
+      v3_zero( pos );
+   }
+}
+
+entity_call_result 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 );
-   if( !volume->target ) return;
 
-   if( call->function == k_ent_function_trigger ){
+   if( !volume->target ) 
+      return k_entity_call_result_OK;
+
+   if( call->function == k_ent_function_trigger )
+   {
       call->id = volume->target;
 
-      if( volume->flags & k_ent_volume_flag_particles ){
+      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;
-         co[2] = vg_randf64()*2.0f-1.0f;
+         co[0] = vg_randf64(&vg.rand)*2.0f-1.0f;
+         co[1] = vg_randf64(&vg.rand)*2.0f-1.0f;
+         co[2] = vg_randf64(&vg.rand)*2.0f-1.0f;
          m4x3_mulv( volume->to_world, co, co );
 
          call->function = k_ent_function_particle_spawn;
          call->data = co;
          entity_call( world, call );
       }
-      else{
+      else
+      {
          call->function = volume->trigger.event;
          entity_call( world, call );
       }
+
+      return k_entity_call_result_OK;
    }
-   else if( call->function == k_ent_function_trigger_leave ){
+   else if( call->function == k_ent_function_trigger_leave )
+   {
       call->id = volume->target;
 
-      if( volume->flags & k_ent_volume_flag_particles ){
-         assert(0);
+      if( volume->flags & k_ent_volume_flag_particles )
+      {
+         vg_warn( "Invalid condition; calling leave on particle volume.\n" );
       }
-      else{
+      else
+      {
          call->function = volume->trigger.event_leave;
          entity_call( world, call );
       }
+
+      return k_entity_call_result_OK;
    }
+
+   return k_entity_call_result_unhandled;
 }
 
-static void ent_audio_call( world_instance *world, ent_call *call ){
-   if( world->status == k_world_status_unloading ){
+entity_call_result 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;
+      return k_entity_call_result_invalid;
    }
 
    u8 world_id = (world - world_static.instances) + 1;
@@ -310,16 +414,18 @@ static void ent_audio_call( world_instance *world, ent_call *call ){
 
    v3f sound_co;
 
-   if( call->function == k_ent_function_particle_spawn ){
+   if( call->function == k_ent_function_particle_spawn )
+   {
       v3_copy( call->data, sound_co );
    }
-   else if( call->function == k_ent_function_trigger ){
+   else if( call->function == k_ent_function_trigger )
+   {
       v3_copy( audio->transform.co, sound_co );
    }
    else
-      vg_fatal_error( "ent_audio_call (invalid function id)" );
+      return k_entity_call_result_unhandled;
 
-   float chance = vg_randf64()*100.0f,
+   float chance = vg_randf64(&vg.rand)*100.0f,
          bar = 0.0f;
 
    for( u32 i=0; i<audio->clip_count; i++ ){
@@ -330,20 +436,24 @@ static void ent_audio_call( world_instance *world, ent_call *call ){
             p   = clip->probability * mod;
 
       bar += p;
-      if( chance < bar ){
+      if( chance < bar )
+      {
          audio_lock();
 
-         if( audio->behaviour == k_channel_behaviour_unlimited ){
+         if( audio->behaviour == k_channel_behaviour_unlimited )
+         {
             audio_oneshot_3d( &clip->_.clip, sound_co,
                               audio->transform.s[0],
                               audio->volume );
          }
-         else if( audio->behaviour == k_channel_behaviour_discard_if_full ){
+         else if( audio->behaviour == k_channel_behaviour_discard_if_full )
+         {
             audio_channel *ch = 
                audio_get_group_idle_channel( audio->group, 
                                              audio->max_channels );
 
-            if( ch ){
+            if( ch )
+            {
                audio_channel_init( ch, &clip->_.clip, audio->flags );
                audio_channel_group( ch, audio->group );
                audio_channel_world( ch, world_id );
@@ -352,7 +462,8 @@ static void ent_audio_call( world_instance *world, ent_call *call ){
                ch = audio_relinquish_channel( ch );
             }
          }
-         else if( audio->behaviour == k_channel_behaviour_crossfade_if_full){
+         else if( audio->behaviour == k_channel_behaviour_crossfade_if_full)
+         {
             audio_channel *ch =
                audio_get_group_idle_channel( audio->group,
                                              audio->max_channels );
@@ -365,7 +476,7 @@ static void ent_audio_call( world_instance *world, ent_call *call ){
                if( existing ){
                   if( existing->source == &clip->_.clip ){
                      audio_unlock();
-                     return;
+                     return k_entity_call_result_OK;
                   }
                  
                   existing->group = 0;
@@ -375,7 +486,8 @@ static void ent_audio_call( world_instance *world, ent_call *call ){
                ch = audio_get_first_idle_channel();
             }
 
-            if( ch ){
+            if( ch )
+            {
                audio_channel_init( ch, &clip->_.clip, audio->flags );
                audio_channel_group( ch, audio->group );
                audio_channel_world( ch, world_id );
@@ -385,18 +497,24 @@ static void ent_audio_call( world_instance *world, ent_call *call ){
          }
 
          audio_unlock();
-         return;
+         return k_entity_call_result_OK;
       }
    }
+   return k_entity_call_result_OK;
 }
 
 
-static void ent_ccmd_call( world_instance *world, ent_call *call ){
-   if( call->function == k_ent_function_trigger ){
+entity_call_result 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) );
+      vg_execute_console_input( mdl_pstr(&world->meta, ccmd->pstr_command), 0 );
+      return k_entity_call_result_OK;
    }
+   else
+      return k_entity_call_result_unhandled;
 }
 
 /*
@@ -404,8 +522,8 @@ static void ent_ccmd_call( world_instance *world, ent_call *call ){
  * ----------------------------------------------------------------------------
  */
 
-static void 
-entity_bh_expand_bound( void *user, boxf bound, u32 item_index ){
+void entity_bh_expand_bound( void *user, boxf bound, u32 item_index )
+{
    world_instance *world = user;
 
    u32 id    = world->entity_list[ item_index ],
@@ -452,12 +570,25 @@ entity_bh_expand_bound( void *user, boxf bound, u32 item_index ){
       mdl_transform_m4x3( &challenge->transform, transform );
       m4x3_expand_aabb_aabb( transform, bound, box );
    }
+   else if( type == k_ent_glider ){
+      ent_glider *glider = mdl_arritm( &world->ent_glider, index );
+      m4x3f transform;
+      mdl_transform_m4x3( &glider->transform, transform );
+      m4x3_expand_aabb_aabb( transform, bound,
+                            (boxf){{-1.0f,-1.0f,-1.0f},{ 1.0f, 1.0f, 1.0f}} );
+   }
+   else if( type == k_ent_npc )
+   {
+      ent_npc *npc = mdl_arritm( &world->ent_npc, index );
+      box_addpt( bound, npc->transform.co );
+   }
    else{
       vg_fatal_error( "Programming error\n" );
    }
 }
 
-static float entity_bh_centroid( void *user, u32 item_index, int axis ){
+float entity_bh_centroid( void *user, u32 item_index, int axis )
+{
    world_instance *world = user;
 
    u32 id    = world->entity_list[ item_index ],
@@ -476,17 +607,30 @@ static float entity_bh_centroid( void *user, u32 item_index, int axis ){
       ent_volume *volume = mdl_arritm( &world->ent_volume, index );
       return volume->transform.co[axis];
    }
-   else if( type == k_ent_challenge ){
+   else if( type == k_ent_challenge )
+   {
       ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index );
       return challenge->transform.co[axis];
    }
-   else {
+   else if( type == k_ent_glider )
+   {
+      ent_glider *glider = mdl_arritm( &world->ent_glider, index );
+      return glider->transform.co[axis];
+   }
+   else if( type == k_ent_npc )
+   {
+      ent_npc *npc = mdl_arritm( &world->ent_npc, index );
+      return npc->transform.co[axis];
+   }
+   else 
+   {
       vg_fatal_error( "Programming error\n" );
       return INFINITY;
    }
 }
 
-static void entity_bh_swap( void *user, u32 ia, u32 ib ){
+void entity_bh_swap( void *user, u32 ia, u32 ib )
+{
    world_instance *world = user;
 
    u32 a = world->entity_list[ ia ],
@@ -496,7 +640,7 @@ static void entity_bh_swap( void *user, u32 ia, u32 ib ){
    world->entity_list[ ib ] = a;
 }
 
-static void entity_bh_debug( void *user, u32 item_index ){
+void entity_bh_debug( void *user, u32 item_index ){
    world_instance *world = user;
 
    u32 id    = world->entity_list[ item_index ],
@@ -544,8 +688,32 @@ static void entity_bh_debug( void *user, u32 item_index ){
    }
 }
 
-static void entity_bh_closest( void *user, u32 item_index, v3f point,
-                                  v3f closest ){
+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;
+      }
+   }
+}
+
+void entity_bh_closest( void *user, u32 item_index, v3f point, v3f closest )
+{
    world_instance *world = user;
 
    u32 id    = world->entity_list[ item_index ],
@@ -573,13 +741,16 @@ static void entity_bh_closest( void *user, u32 item_index, v3f point,
    }
 }
 
-static void world_entity_start( world_instance *world, vg_msg *sav ){
+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++ ){
+   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 ){
+      if( audio->flags & AUDIO_FLAG_AUTO_START )
+      {
          ent_call call;
          call.data = NULL;
          call.function = k_ent_function_trigger;
@@ -595,7 +766,10 @@ static void world_entity_start( world_instance *world, vg_msg *sav ){
       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 ) ){
+      u32 result;
+      vg_msg_getkvintg( sav, alias, k_vg_msg_u32, &result, NULL );
+
+      if( result ){
          ent_call call;
          call.data = NULL;
          call.function = 0;
@@ -603,45 +777,102 @@ static void world_entity_start( world_instance *world, vg_msg *sav ){
          entity_call( world, &call );
       }
    }
-}
 
-/* 
- * used for relinking multi-world data. ran anytime the world setup changes
- */
-static void world_entity_relink( world_instance *world ){
-   vg_info( "entity_relink(%d)\n", world - world_static.instances );
-   for( u32 i=0; i<mdl_arrcount(&world->ent_miniworld); i++ ){
-      ent_miniworld *miniworld = mdl_arritm( &world->ent_miniworld, i );
-      miniworld->purpose = k_world_purpose_invalid;
-
-      const char *uid = mdl_pstr( &world->meta, miniworld->pstr_world );
-      addon_alias q;
-      addon_uid_to_alias( uid, &q );
-
-      u32 addon_id = addon_match( &q );
-      if( addon_id != 0xffffffff ){
-         addon_reg *reg = get_addon_from_index( k_addon_type_world, addon_id );
-         
-         for( int j=0; j<k_world_max; j ++ ){
-            world_instance *other = &world_static.instances[j];
-            if( other == world ) continue;
-            if( (other->status == k_world_status_loaded) && 
-                (world_static.instance_addons[j] == reg) ){
-               miniworld->purpose = j;
-               break;
+   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) ) ){
+
+            u32 flags;
+            vg_msg_getkvintg( &route_info, "flags", k_vg_msg_u32,    
+                              &flags, NULL );
+            route->flags |= flags;
+
+            vg_msg_getkvintg( &route_info, "best_laptime", k_vg_msg_f64,
+                              &route->best_laptime, NULL );
+
+            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 ){
+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 );
+      vg_msg_wkvnum( sav, alias, k_vg_msg_u32, 1, &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_wkvnum( sav, "flags", k_vg_msg_u32, 1, &route->flags );
+            vg_msg_wkvnum( sav, "best_laptime", 
+                           k_vg_msg_f64, 1, &route->best_laptime );
+
+            f32 sections[ route->checkpoints_count ];
 
-#endif /* WORLD_ENTITY_C */
+            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 );
+   }
+}