X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;ds=sidebyside;f=world_entity.c;h=88e0e7e1a240815bc38bde6606efa077f919d09d;hb=81099ee81c1a09ead474333101408b7b8a4a94fc;hp=d3c6a8c011b00fc6dc3af5182c66ca33a690bcd3;hpb=844527ec68c063d78d4993bd8e4053f9ddc47b78;p=carveJwlIkooP6JGAAIwe30JlM.git diff --git a/world_entity.c b/world_entity.c index d3c6a8c..88e0e7e 100644 --- a/world_entity.c +++ b/world_entity.c @@ -1,12 +1,174 @@ -#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" #include "world_load.h" +#include "save.h" +#include "vg/vg_msg.h" +#include "menu.h" +#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; +} + +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; + skaterift.activity = k_skaterift_ent_focus; +} + +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; + menu.disable_open = 0; + srinput.state = k_input_state_resume; + skaterift.activity = k_skaterift_default; +} + +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 ); + + 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 { + vg_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 */ +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 ); + } + else if( type == k_ent_npc ) + { + ent_npc *npc = mdl_arritm( &world->ent_npc, index ); + ent_npc_preupdate( npc, active ); + } +} + +/* additional renderings like text etc.. */ +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; + } -VG_STATIC void world_gen_entities_init( world_instance *world ){ + 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 if( type == k_ent_npc ){} + else { + vg_fatal_error( "Programming error\n" ); + } +} + +void world_gen_entities_init( world_instance *world ) +{ /* lights */ for( u32 j=0; jent_light); j ++ ){ ent_light *light = mdl_arritm( &world->ent_light, j ); @@ -20,15 +182,8 @@ VG_STATIC void world_gen_entities_init( world_instance *world ){ light->angle_sin_cos[1] = cosf( light->angle * 0.5f ); } - /* gates */ - for( u32 j=0; jent_gate); j ++ ){ - ent_gate *gate = mdl_arritm( &world->ent_gate, j ); - - if( !(gate->flags & k_ent_gate_nonlocal) ) { - gate_transform_update( gate ); - } - } - vg_async_call( world_link_nonlocal_async, world, 0 ); + vg_async_call( world_link_gates_async, world, 0 ); + vg_async_stall(); /* water */ for( u32 j=0; jent_water); j++ ){ @@ -94,8 +249,11 @@ VG_STATIC void world_gen_entities_init( world_instance *world ){ } 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 }, - { k_ent_volume, &world->ent_volume } + { k_ent_glider, &world->ent_glider }, + { k_ent_npc, &world->ent_npc } }; for( u32 i=0; ientity_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; ient_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 ent_spawn *world_find_closest_spawn( world_instance *world, v3f position ) { ent_spawn *rp = NULL, *r; @@ -147,7 +317,6 @@ ent_spawn *world_find_closest_spawn( world_instance *world, v3f position ) return rp; } -VG_STATIC ent_spawn *world_find_spawn_by_name( world_instance *world, const char *name ) { ent_spawn *rp = NULL, *r; @@ -165,7 +334,20 @@ 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 ) +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 ); + } +} + +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 ); @@ -176,9 +358,9 @@ VG_STATIC void ent_volume_call( world_instance *world, ent_call *call ) 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; @@ -190,9 +372,21 @@ VG_STATIC void ent_volume_call( world_instance *world, ent_call *call ) 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 ){ + vg_warn( "Invalid condition; calling leave on particle volume.\n" ); + } + else{ + call->function = volume->trigger.event_leave; + entity_call( world, call ); + } + } } -VG_STATIC void ent_audio_call( world_instance *world, ent_call *call ){ +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; @@ -211,9 +405,9 @@ 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, + float chance = vg_randf64(&vg.rand)*100.0f, bar = 0.0f; for( u32 i=0; iclip_count; i++ ){ @@ -224,20 +418,24 @@ VG_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 ); @@ -246,7 +444,8 @@ VG_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 ); @@ -269,7 +468,8 @@ VG_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 ); @@ -285,11 +485,13 @@ VG_STATIC void ent_audio_call( world_instance *world, ent_call *call ){ } -VG_STATIC void ent_ccmd_call( world_instance *world, ent_call *call ){ +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) ); + vg_execute_console_input( mdl_pstr(&world->meta, ccmd->pstr_command), + 0 ); } } @@ -298,8 +500,8 @@ VG_STATIC void ent_ccmd_call( world_instance *world, ent_call *call ){ * ---------------------------------------------------------------------------- */ -VG_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 ], @@ -313,8 +515,8 @@ entity_bh_expand_bound( void *user, boxf bound, u32 item_index ){ m4x3_expand_aabb_aabb( gate->to_world, bound, box ); } - else if( type == k_ent_challenge ){ - ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index ); + 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 */ @@ -322,14 +524,14 @@ entity_bh_expand_bound( void *user, boxf bound, u32 item_index ){ boxf box; box_init_inf( box ); - for( u32 i=0; isubmesh_count; i++ ){ + for( u32 i=0; isubmesh_count; i++ ){ mdl_submesh *sm = mdl_arritm( &world->meta.submeshs, - challenge->submesh_start+i ); + objective->submesh_start+i ); box_concat( box, sm->bbx ); } m4x3f transform; - mdl_transform_m4x3( &challenge->transform, transform ); + mdl_transform_m4x3( &objective->transform, transform ); m4x3_expand_aabb_aabb( transform, bound, box ); } else if( type == k_ent_volume ){ @@ -337,9 +539,34 @@ entity_bh_expand_bound( void *user, boxf bound, u32 item_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 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" ); + } } -VG_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 ], @@ -350,21 +577,38 @@ VG_STATIC float entity_bh_centroid( void *user, u32 item_index, int axis ){ ent_gate *gate = mdl_arritm( &world->ent_gate, index ); return gate->to_world[3][axis]; } - else if( type == k_ent_challenge ){ - ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index ); - return challenge->transform.co[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 { + else if( type == k_ent_challenge ) + { + ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index ); + return challenge->transform.co[axis]; + } + 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; } } -VG_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 ], @@ -374,7 +618,7 @@ VG_STATIC void entity_bh_swap( void *user, u32 ia, u32 ib ){ world->entity_list[ ib ] = a; } -VG_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 ], @@ -387,19 +631,19 @@ VG_STATIC void entity_bh_debug( void *user, u32 item_index ){ { gate->dimensions[0], gate->dimensions[1], 0.1f }}; vg_line_boxf_transformed( gate->to_world, box, 0xf000ff00 ); } - else if( type == k_ent_challenge ){ - ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index ); + 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; isubmesh_count; i++ ){ + for( u32 i=0; isubmesh_count; i++ ){ mdl_submesh *sm = mdl_arritm( &world->meta.submeshs, - challenge->submesh_start+i ); + objective->submesh_start+i ); box_concat( box, sm->bbx ); } m4x3f transform; - mdl_transform_m4x3( &challenge->transform, transform ); + mdl_transform_m4x3( &objective->transform, transform ); vg_line_boxf_transformed( transform, box, 0xf000ff00 ); } else if( type == k_ent_volume ){ @@ -408,13 +652,46 @@ VG_STATIC void entity_bh_debug( void *user, u32 item_index ){ (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" ); } } -VG_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; ient_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 ], @@ -425,17 +702,154 @@ VG_STATIC void entity_bh_closest( void *user, u32 item_index, v3f point, ent_gate *gate = mdl_arritm( &world->ent_gate, index ); v3_copy( gate->to_world[3], closest ); } - else if( type == k_ent_challenge ){ - ent_challenge *challenge = mdl_arritm( &world->ent_challenge, index ); + 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" ); } } -#endif /* WORLD_ENTITY_C */ +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; ient_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; ient_challenge); i++ ){ + ent_challenge *challenge = mdl_arritm( &world->ent_challenge, i ); + const char *alias = mdl_pstr( &world->meta, challenge->pstr_alias ); + + u32 result; + vg_msg_getkvintg( sav, alias, k_vg_msg_u32, &result ); + + if( result ){ + 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; ient_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 ); + route->flags |= flags; + + vg_msg_getkvintg( &route_info, "best_laptime", k_vg_msg_f64, + &route->best_laptime ); + + 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; jcheckpoints_count; j ++ ) + sections[j] = 0.0f; + } + + for( u32 j=0; jcheckpoints_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; jname, + 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 ); +} + +void world_entity_serialize( world_instance *world, vg_msg *sav ) +{ + for( u32 i=0; ient_challenge); i++ ){ + ent_challenge *challenge = mdl_arritm(&world->ent_challenge,i); + + const char *alias = mdl_pstr(&world->meta,challenge->pstr_alias); + 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; ient_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 ]; + + for( u32 j=0; jcheckpoints_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 ); + } +}