X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world_entity.c;h=e75cb29cebfdb2c09519b33e1c212c35845ffb95;hb=refs%2Fheads%2Fmenu2;hp=ec7c2fe13426a5cbc0d773ef7711080bee0b0e80;hpb=fdfd087053eb596f1e9123951af8acee94d8cd99;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/world_entity.c b/world_entity.c
index ec7c2fe..e75cb29 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"
@@ -12,38 +11,90 @@
 #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 "ent_camera.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;
+   }
 
-static void world_entity_focus( u32 entity_id ){
+   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;
-   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;
+}
+
+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;
 }
 
-static void world_entity_focus_camera( world_instance *world, u32 uid ){
-   if( mdl_entity_id_type( uid ) == k_ent_camera ){
+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;
+      ent_camera_unpack( cam, &world_static.focus_cam );
    }
-   else {
-      camera_copy( &localplayer.cam, &world_static.focus_cam );
+   else 
+   {
+      vg_camera_copy( &localplayer.cam, &world_static.focus_cam );
 
       /* TODO ? */
       world_static.focus_cam.nearz = localplayer.cam.nearz;
@@ -52,7 +103,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 )
@@ -61,30 +113,40 @@ 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){
+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 );
+      skateshop_render_nonfocused( world, &g_render.cam );
       return;
    }
 
@@ -98,12 +160,14 @@ static void world_entity_focus_render(void){
    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 );
@@ -117,16 +181,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) ) {
-         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; j<mdl_arrcount(&world->ent_water); j++ ){
@@ -194,7 +250,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++ )
@@ -230,7 +288,6 @@ static void world_gen_entities_init( world_instance *world ){
    }
 }
 
-static
 ent_spawn *world_find_closest_spawn( world_instance *world, v3f position )
 {
    ent_spawn *rp = NULL, *r;
@@ -259,7 +316,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;
@@ -277,15 +333,33 @@ 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(&vg.rand)*2.0f-1.0f;
          co[1] = vg_randf64(&vg.rand)*2.0f-1.0f;
@@ -296,28 +370,40 @@ static void ent_volume_call( world_instance *world, ent_call *call ){
          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;
@@ -326,14 +412,16 @@ 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
-      return;
+      return k_entity_call_result_unhandled;
 
    float chance = vg_randf64(&vg.rand)*100.0f,
          bar = 0.0f;
@@ -346,20 +434,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 );
@@ -368,7 +460,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 );
@@ -381,7 +474,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;
@@ -391,7 +484,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 );
@@ -401,18 +495,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;
 }
 
 /*
@@ -420,8 +520,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 ],
@@ -468,12 +568,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 ],
@@ -492,17 +605,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 ],
@@ -512,7 +638,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 ],
@@ -560,7 +686,8 @@ static void entity_bh_debug( void *user, u32 item_index ){
    }
 }
 
-static void update_ach_models(void){
+void update_ach_models(void)
+{
    world_instance *hub = &world_static.instances[k_world_purpose_hub];
    if( hub->status != k_world_status_loaded ) return;
 
@@ -583,8 +710,8 @@ static void update_ach_models(void){
    }
 }
 
-static void entity_bh_closest( void *user, u32 item_index, v3f point,
-                                  v3f closest ){
+void entity_bh_closest( void *user, u32 item_index, v3f point, v3f closest )
+{
    world_instance *world = user;
 
    u32 id    = world->entity_list[ item_index ],
@@ -612,13 +739,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;
@@ -634,7 +764,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;
@@ -651,9 +784,14 @@ static void world_entity_start( world_instance *world, vg_msg *sav ){
          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 );
+
+            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;
@@ -699,12 +837,13 @@ static void world_entity_start( world_instance *world, vg_msg *sav ){
    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) ){
@@ -714,8 +853,9 @@ static void world_entity_serialize( world_instance *world, vg_msg *sav ){
          
          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 );
+            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 ];
 
@@ -734,5 +874,3 @@ static void world_entity_serialize( world_instance *world, vg_msg *sav ){
       vg_msg_end_frame( sav );
    }
 }
-
-#endif /* WORLD_ENTITY_C */