X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=world_routes.c;h=c4b339385bc9794df093d1789f76d93b321c9382;hb=b440efbe5785d114d08bb3f5ec0e09cad943006d;hp=5f6d283a50dc0183621be8ef968c1fba4d56b13b;hpb=00653e446d6b1310fa89d3aace70800f9fef4122;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/world_routes.c b/world_routes.c
index 5f6d283..c4b3393 100644
--- a/world_routes.c
+++ b/world_routes.c
@@ -1,16 +1,16 @@
+#pragma once
+
 /*
- * Copyright (C) 2021-2023 Mt.ZERO Software, Harry Godden - All Rights Reserved
+ * Copyright (C) 2021-2024 Mt.ZERO Software - All Rights Reserved
+ *
+ * World routes
  */
 
-#ifndef ROUTES_C
-#define ROUTES_C
-
 #include <time.h>
 #include "entity.h"
 #include "world_routes.h"
 #include "world_gate.h"
 #include "world_load.h"
-#include "highscores.h"
 #include "network.h"
 
 #include "font.h"
@@ -21,8 +21,10 @@
 
 #include "shaders/scene_route.h"
 #include "shaders/routeui.h"
+#include "ent_region.h"
+#include "scene_rigidbody.h"
 
-static void world_routes_clear( world_instance *world )
+void world_routes_clear( world_instance *world )
 {
    for( u32 i=0; i<mdl_arrcount( &world->ent_route ); i++ ){
       ent_route *route = mdl_arritm( &world->ent_route, i );
@@ -39,15 +41,17 @@ static void world_routes_clear( world_instance *world )
    world_static.last_use = 0.0;
 }
 
-static void world_routes_time_lap( world_instance *world, ent_route *route )
-{
+static void world_routes_time_lap( world_instance *world, ent_route *route ){
    vg_info( "------- time lap %s -------\n", 
             mdl_pstr(&world->meta,route->pstr_name) );
 
    double start_time = 0.0;
    u32 last_version=0;
+   f64 last_time = 0.0;
+   ent_checkpoint *last_cp = NULL;
 
-   u32 valid_count=0;
+   u32 valid_sections=0;
+   int clean = !localplayer.rewinded_since_last_gate;
 
    for( u32 i=0; i<route->checkpoints_count; i++ ){
       u32 cpid  = (i+route->active_checkpoint) % route->checkpoints_count;
@@ -64,29 +68,52 @@ static void world_routes_time_lap( world_instance *world, ent_route *route )
       if( i == 0 )
          start_time = rg->timing_time;
       else{
-         if( last_version+1 == rg->timing_version ) valid_count ++;
-         else valid_count = 0;
+         if( last_version+1 == rg->timing_version ) valid_sections ++;
+         else valid_sections = 0;
       }
 
+      vg_info( "%u %f [%s]\n", rg->timing_version, rg->timing_time,
+            i? ((rg->flags & k_ent_gate_clean_pass)? "CLEAN": "     "):
+                " N/A ");
+
+      if( !(rg->flags & k_ent_gate_clean_pass) )
+         clean = 0;
+
       last_version = rg->timing_version;
-      vg_info( "%u %f\n", rg->timing_version, rg->timing_time );
+      last_time = rg->timing_time;
+      last_cp = cp;
    }
 
    if( world_static.current_run_version == last_version+1 ){
-      valid_count ++;
+      valid_sections ++;
 
       if( route->checkpoints_count == 1 ){
          route->timing_base = world_static.time;
       }
+
+      f32 section = world_static.time - last_time;
+      if( (section < last_cp->best_time) || (last_cp->best_time == 0.0f) ){
+         last_cp->best_time = section;
+      }
    }
-   else valid_count = 0;
+   else valid_sections = 0;
 
-   vg_info( "%u %f\n", world_static.current_run_version, world_static.time );
+   vg_info( "%u %f [%s]\n", 
+            world_static.current_run_version, world_static.time,
+           !localplayer.rewinded_since_last_gate? "CLEAN": "     " );
 
-   if( valid_count==route->checkpoints_count ){
+   if( valid_sections==route->checkpoints_count ){
       f64 lap_time = world_static.time - start_time;
-      //world_routes_local_set_record( world, route, lap_time );
 
+      if( (route->best_laptime == 0.0) || (lap_time < route->best_laptime) ){
+         route->best_laptime = lap_time;
+      }
+
+      route->flags |= k_ent_route_flag_achieve_silver;
+      if( clean ) route->flags |= k_ent_route_flag_achieve_gold;
+      ent_region_re_eval( world );
+
+      /* for steam achievements. */
       if( route->anon.official_track_id != 0xffffffff ){
          struct track_info *ti = &track_infos[ route->anon.official_track_id ];
          if( ti->achievement_id ){
@@ -105,17 +132,19 @@ static void world_routes_time_lap( world_instance *world, ent_route *route )
                                lap_time );
    }
 
-   route->valid_checkpoints = valid_count+1;
+   route->valid_checkpoints = valid_sections+1;
 
-   vg_info( "valid: %u\n", valid_count );
+   vg_info( "valid sections: %u\n", valid_sections );
    vg_info( "----------------------------\n" );
+
+   route->ui_residual = 1.0f;
+   route->ui_residual_block_w = route->ui_first_block_width;
 }
 
 /*
  * When going through a gate this is called for bookkeeping purposes
  */
-static void world_routes_activate_entry_gate( world_instance *world, 
-                                                 ent_gate *rg )
+void world_routes_activate_entry_gate( world_instance *world, ent_gate *rg )
 {
    world_static.last_use = world_static.time;
    ent_gate *dest = mdl_arritm( &world->ent_gate, rg->target );
@@ -148,6 +177,13 @@ static void world_routes_activate_entry_gate( world_instance *world,
    dest->timing_version = world_static.current_run_version;
    dest->timing_time = world_static.time;
 
+   if( localplayer.rewinded_since_last_gate ){
+      localplayer.rewinded_since_last_gate = 0;
+      dest->flags &= ~k_ent_gate_clean_pass;
+   }
+   else
+      dest->flags |= k_ent_gate_clean_pass;
+
    world_static.current_run_version ++;
 }
 
@@ -279,8 +315,8 @@ void world_routes_place_curve( world_instance *world, ent_route *route,
             v3_muladds( ha.pos, up, 0.06f+gap, va.co );
             v3_muladds( hb.pos, up, 0.06f+gap, vb.co );
 
-            scene_vert_pack_norm( &va, up );
-            scene_vert_pack_norm( &vb, up );
+            scene_vert_pack_norm( &va, up, 0.0f );
+            scene_vert_pack_norm( &vb, up, 0.0f );
 
             float t1 = (travel_length / total_length) * patch_count;
             va.uv[0] = t1;
@@ -440,19 +476,18 @@ static void world_routes_gen_meshes( world_instance *world, u32 route_id,
    scene_copy_slice( sc, &route->sm );
 }
 
-static 
 struct world_surface *world_tri_index_surface( world_instance *world, 
                                                  u32 index );
 
 /* 
  * Create the strips of colour that run through the world along course paths
  */
-static void world_gen_routes_generate( u32 instance_id ){
+void world_gen_routes_generate( u32 instance_id )
+{
    world_instance *world = &world_static.instances[ instance_id ];
    vg_info( "Generating route meshes\n" );
    vg_async_stall();
 
-   vg_rand_seed( 2000 );
    vg_async_item *call_scene = scene_alloc_async( &world->scene_lines, 
                                                   &world->mesh_route_lines,
                                                   200000, 300000 );
@@ -505,7 +540,8 @@ static void world_gen_routes_generate( u32 instance_id ){
 }
 
 /* load all routes from model header */
-static void world_gen_routes_ent_init( world_instance *world ){
+void world_gen_routes_ent_init( world_instance *world )
+{
    vg_info( "Initializing routes\n" );
 
    for( u32 i=0; i<mdl_arrcount(&world->ent_gate); i++ ){
@@ -519,6 +555,14 @@ static void world_gen_routes_ent_init( world_instance *world ){
       ent_route *route = mdl_arritm(&world->ent_route,i);
       mdl_transform_m4x3( &route->anon.transform, route->board_transform );
 
+      route->flags = 0x00;
+      route->best_laptime = 0.0;
+      route->ui_stopper = 0.0f;
+      route->ui_residual = 0.0f;
+      
+      if( mdl_arrcount(&world->ent_region) )
+         route->flags |= k_ent_route_flag_out_of_zone;
+
       route->anon.official_track_id = 0xffffffff;
       for( u32 j=0; j<vg_list_size(track_infos); j ++ ){
          if( !strcmp(track_infos[j].name, 
@@ -541,7 +585,7 @@ static void world_gen_routes_ent_init( world_instance *world ){
          }
 
          if( (gate->flags & k_ent_gate_linked) &
-            !(gate->flags & k_ent_gate_nonlocal_DELETED) ){
+            !(gate->flags & k_ent_gate_nonlocal) ){
             gate = mdl_arritm(&world->ent_gate, gate->target );
 
             for( u32 k=0; k<4; k++ ){
@@ -562,12 +606,18 @@ static void world_gen_routes_ent_init( world_instance *world ){
       ent_gate *gate = mdl_arritm( &world->ent_gate, i );
    }
 
+   for( u32 i=0; i<mdl_arrcount(&world->ent_checkpoint); i++ ){
+      ent_checkpoint *cp = mdl_arritm( &world->ent_checkpoint, i );
+      cp->best_time = 0.0;
+   }
+
    world_routes_clear( world );
 }
 
-static void world_routes_recv_scoreboard( world_instance *world, 
-                                          vg_msg *body, u32 route_id,
-                                          enum request_status status ){
+void world_routes_recv_scoreboard( world_instance *world, 
+                                   vg_msg *body, u32 route_id,
+                                   enum request_status status )
+{
    if( route_id >= mdl_arrcount( &world->ent_route ) ){
       vg_error( "Scoreboard route_id out of range (%u)\n", route_id );
       return;
@@ -597,16 +647,15 @@ static void world_routes_recv_scoreboard( world_instance *world,
  * -----------------------------------------------------------------------------
  */
 
-static void world_routes_init(void){
+void world_routes_init(void)
+{
    world_static.current_run_version = 200;
    world_static.time = 300.0;
    world_static.last_use = 0.0;
-
-   shader_scene_route_register();
-   shader_routeui_register();
 }
 
-static void world_routes_update( world_instance *world ){
+void world_routes_update( world_instance *world )
+{
    world_static.time += vg.time_delta;
 
    for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
@@ -619,37 +668,43 @@ static void world_routes_update( world_instance *world ){
 
    for( u32 i=0; i<world_render.text_particle_count; i++ ){
       struct text_particle *particle = &world_render.text_particles[i];
-      rb_object_debug( &particle->obj, VG__RED );
+      //rb_object_debug( &particle->obj, VG__RED );
    }
 }
 
-static void world_routes_fixedupdate( world_instance *world ){
+void world_routes_fixedupdate( world_instance *world )
+{
    rb_solver_reset();
 
+   rigidbody _null = {0};
+   _null.inv_mass = 0.0f;
+   m3x3_zero( _null.iI );
+
    for( u32 i=0; i<world_render.text_particle_count; i++ ){
       struct text_particle *particle = &world_render.text_particles[i];
 
       if( rb_global_has_space() ){
          rb_ct *buf = rb_global_buffer();
 
-         int l = rb_sphere__scene( particle->obj.rb.to_world,
-                                   &particle->obj.inf.sphere,
-                                   NULL, &world->rb_geo.inf.scene, buf,
+         int l = rb_sphere__scene( particle->rb.to_world,
+                                   particle->radius,
+                                   NULL, world->geo_bh, buf,
                                    k_material_flag_ghosts );
 
          for( int j=0; j<l; j++ ){
-            buf[j].rba = &particle->obj.rb;
-            buf[j].rbb = &world->rb_geo.rb;
+            buf[j].rba = &particle->rb;
+            buf[j].rbb = &_null;
          }
 
          rb_contact_count += l;
       }
    }
 
-   rb_presolve_contacts( rb_contact_buffer, rb_contact_count );
+   rb_presolve_contacts( rb_contact_buffer, 
+                         vg.time_fixed_delta, rb_contact_count );
 
    for( int i=0; i<rb_contact_count; i++ ){
-      rb_contact_restitution( rb_contact_buffer+i, vg_randf64() );
+      rb_contact_restitution( rb_contact_buffer+i, vg_randf64(&vg.rand) );
    }
 
    for( int i=0; i<6; i++ ){
@@ -658,24 +713,25 @@ static void world_routes_fixedupdate( world_instance *world ){
 
    for( u32 i=0; i<world_render.text_particle_count; i++ ){
       struct text_particle *particle = &world_render.text_particles[i];
-      rb_iter( &particle->obj.rb );
+      rb_iter( &particle->rb );
    }
 
    for( u32 i=0; i<world_render.text_particle_count; i++ ){
       struct text_particle *particle = &world_render.text_particles[i];
-      rb_update_transform( &particle->obj.rb );
+      rb_update_matrices( &particle->rb );
    }
 }
 
-static void bind_terrain_noise(void);
-static void world_bind_light_array( world_instance *world,
-                                       GLuint shader, GLuint location, 
-                                       int slot );
-static void world_bind_light_index( world_instance *world,
-                                       GLuint shader, GLuint location, 
-                                       int slot );
+void bind_terrain_noise(void);
+void world_bind_light_array( world_instance *world,
+                             GLuint shader, GLuint location, 
+                             int slot );
+void world_bind_light_index( world_instance *world,
+                             GLuint shader, GLuint location, 
+                             int slot );
 
-static void world_routes_update_timer_texts( world_instance *world ){
+void world_routes_update_timer_texts( world_instance *world )
+{
    world_render.timer_text_count = 0;
 
    for( u32 i=0; i<mdl_arrcount(&world->ent_route); i++ ){
@@ -708,7 +764,11 @@ static void world_routes_update_timer_texts( world_instance *world ){
          text->gate = gate;
          text->route = route;
 
-         if( route->valid_checkpoints >= route->checkpoints_count ){
+         vg_str str;
+         vg_strnull( &str, text->text, sizeof(text->text) );
+
+         if( route->valid_checkpoints >= route->checkpoints_count )
+         {
             double lap_time = world_static.time - route->timing_base,
                    time_centiseconds = lap_time * 100.0;
 
@@ -722,30 +782,32 @@ static void world_routes_update_timer_texts( world_instance *world ){
             seconds     %= 60;
             minutes     %= 60;
 
-            if( minutes > 9 ) minutes = 9;
+            if( minutes > 9 ) 
+               minutes = 9;
             
-            int j=0;
-            if( minutes ){
-               highscore_intr( text->text, minutes, 1, ' ' ); j++;
-               text->text[j++] = ':';
+            if( minutes )
+            {
+               vg_strcati32r( &str, minutes, 1, ' ' );
+               vg_strcatch( &str, ':' );
             }
             
-            if( seconds >= 10 || minutes ){
-               highscore_intr( text->text+j, seconds, 2, '0' ); j+=2;
+            if( seconds >= 10 || minutes )
+            {
+               vg_strcati32r( &str, seconds, 2, '0' );
             }
-            else{
-               highscore_intr( text->text+j, seconds, 1, '0' ); j++;
+            else
+            {
+               vg_strcati32r( &str, seconds, 1, '0' );
             }
 
-            text->text[j++] = '.';
-            highscore_intr( text->text+j, centiseconds, 1, '0' ); j++;
-            text->text[j] = '\0';
+            vg_strcatch( &str, '.' );
+            vg_strcati32r( &str, centiseconds, 1, '0' );
          }
-         else{
-            highscore_intr( text->text, route->valid_checkpoints, 1, ' ' );
-            text->text[1] = '/';
-            highscore_intr( text->text+2, route->checkpoints_count+1, 1, ' ' );
-            text->text[3] = '\0';
+         else
+         {
+            vg_strcati32r( &str, route->valid_checkpoints, 1, ' ' );
+            vg_strcatch( &str, '/' );
+            vg_strcati32r( &str, route->checkpoints_count + 1, 1, ' ' );
          }
    
          gui_font3d.font = &gui.font;
@@ -777,8 +839,8 @@ static void world_routes_update_timer_texts( world_instance *world ){
    }
 }
 
-static void world_routes_fracture( world_instance *world, ent_gate *gate,
-                                      v3f imp_co, v3f imp_v )
+void world_routes_fracture( world_instance *world, ent_gate *gate,
+                            v3f imp_co, v3f imp_v )
 {
    world_render.text_particle_count = 0;
    
@@ -825,26 +887,24 @@ static void world_routes_fracture( world_instance *world, ent_gate *gate,
             v3_add( offset, origin, world_co );
             m4x3_mulv( transform, world_co, world_co );
 
-            float r = vg_maxf( s[0]*glyph->size[0], s[1]*glyph->size[1] )*0.5f;
 
             m3x3_identity( particle->mlocal );
             m3x3_scale( particle->mlocal, s );
             origin[2] *= s[2];
             v3_muls( origin, -1.0f, particle->mlocal[3] );
 
-            v3_copy( world_co, particle->obj.rb.co );
-            v3_muls( imp_v, 1.0f+vg_randf64(), particle->obj.rb.v );
-            particle->obj.rb.v[1] += 2.0f;
+            v3_copy( world_co, particle->rb.co );
+            v3_muls( imp_v, 1.0f+vg_randf64(&vg.rand), particle->rb.v );
+            particle->rb.v[1] += 2.0f;
 
-            v4_copy( q, particle->obj.rb.q );
-            particle->obj.rb.w[0] = vg_randf64()*2.0f-1.0f;
-            particle->obj.rb.w[1] = vg_randf64()*2.0f-1.0f;
-            particle->obj.rb.w[2] = vg_randf64()*2.0f-1.0f;
+            v4_copy( q, particle->rb.q );
+            particle->rb.w[0] = vg_randf64(&vg.rand)*2.0f-1.0f;
+            particle->rb.w[1] = vg_randf64(&vg.rand)*2.0f-1.0f;
+            particle->rb.w[2] = vg_randf64(&vg.rand)*2.0f-1.0f;
 
-            particle->obj.type = k_rb_shape_sphere;
-            particle->obj.inf.sphere.radius = r*0.6f;
-
-            rb_init_object( &particle->obj );
+            f32 r = vg_maxf( s[0]*glyph->size[0], s[1]*glyph->size[1] )*0.5f;
+            particle->radius = r*0.6f;
+            rb_setbody_sphere( &particle->rb, particle->radius, 1.0f, 1.0f );
          }
          offset[0] += glyph->size[0];
       }
@@ -855,7 +915,10 @@ static void render_gate_markers( m4x3f world_mmdl, int run_id, ent_gate *gate ){
    for( u32 j=0; j<4; j++ ){
       if( gate->routes[j] == run_id ){
          m4x3f mmdl;
-         ent_gate_get_mdl_mtx( gate, mmdl );
+         m4x3_copy( gate->to_world, mmdl );
+         m3x3_scale( mmdl, (v3f){ gate->dimensions[0], 
+                                  gate->dimensions[1], 1.0f } );
+
          m4x3_mul( world_mmdl, mmdl, mmdl );
          shader_model_gate_uMdl( mmdl );
          mdl_draw_submesh( &world_gates.sm_marker[j] );
@@ -864,11 +927,11 @@ static void render_gate_markers( m4x3f world_mmdl, int run_id, ent_gate *gate ){
    }
 }
 
-static void render_world_routes( world_instance *world, 
-                                 world_instance *host_world,
-                                 m4x3f mmdl, camera *cam, 
-                                 int viewing_from_gate, int viewing_from_hub ){
-
+void render_world_routes( world_instance *world, 
+                          world_instance *host_world,
+                          m4x3f mmdl, vg_camera *cam, 
+                          int viewing_from_gate, int viewing_from_hub )
+{
    shader_scene_route_use();
    shader_scene_route_uTexGarbage(0);
    world_link_lighting_ub( host_world, _shader_scene_route.id );
@@ -953,7 +1016,7 @@ static void render_world_routes( world_instance *world,
 
          v4f q;
          m4x3f model;
-         rb_extrapolate( &particle->obj.rb, model[3], q );
+         rb_extrapolate( &particle->rb, model[3], q );
          q_m3x3( q, model );
 
          m4x3_mul( model, particle->mlocal, particle->mdl );
@@ -994,7 +1057,7 @@ static void render_world_routes( world_instance *world,
 
          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) )
+            if( !(gate->flags & k_ent_gate_nonlocal) )
                render_gate_markers( mmdl, i, gate );
          }
       }
@@ -1024,5 +1087,3 @@ static void render_world_routes( world_instance *world,
    glEnable( GL_CULL_FACE );
    glDrawBuffers( 2, (GLenum[]){ GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1 } );
 }
-
-#endif /* ROUTES_C */