X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_skate.c;h=7014c778afcdba4d3d0b49e465923e9f2b64d994;hb=1a194c3888293733939b2dd944251ae1b6c398ce;hp=72c20966bb051fa8ea919d33871001aa78e45e52;hpb=23897aeb79caa65b4c19de6c2f20f05bf3d86114;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_skate.c b/player_skate.c
index 72c2096..7014c77 100644
--- a/player_skate.c
+++ b/player_skate.c
@@ -1,16 +1,46 @@
-#ifndef PLAYER_SKATE_C
-#define PLAYER_SKATE_C
-
+#include "player_skate.h"
 #include "player.h"
 #include "audio.h"
 #include "vg/vg_perlin.h"
+#include "vg/vg_lines.h"
 #include "menu.h"
 #include "ent_skateshop.h"
 #include "addon.h"
+#include "input.h"
+#include "ent_tornado.h"
+
+#include "vg/vg_rigidbody.h"
+#include "scene_rigidbody.h"
+#include "player_glide.h"
+#include "player_dead.h"
+#include "player_walk.h"
 
-static void player__skate_bind(void){
+struct player_skate player_skate;
+struct player_subsystem_interface player_subsystem_skate = 
+{
+   .system_register = player__skate_register,
+   .bind = player__skate_bind,
+   .pre_update = player__skate_pre_update,
+   .update = player__skate_update,
+   .post_update = player__skate_post_update,
+   .im_gui = player__skate_im_gui,
+   .animate = player__skate_animate,
+   .pose = player__skate_pose,
+   .effects = player__skate_effects,
+   .post_animate = player__skate_post_animate,
+   .network_animator_exchange = player__skate_animator_exchange,
+   .sfx_oneshot = player__skate_sfx_oneshot,
+   .sfx_comp = player__skate_comp_audio,
+   .sfx_kill = player__skate_kill_audio,
+
+   .animator_data = &player_skate.animator,
+   .animator_size = sizeof(player_skate.animator),
+   .name = "Skate"
+};
+
+void player__skate_bind(void){
    struct skeleton *sk = &localplayer.skeleton;
-   rb_update_transform( &localplayer.rb );
+   rb_update_matrices( &localplayer.rb );
 
    struct { struct skeleton_anim **anim; const char *name; }
    bindings[] = {
@@ -25,14 +55,14 @@ static void player__skate_bind(void){
       { &player_skate.anim_ollie,        "ollie" },
       { &player_skate.anim_ollie_reverse,"ollie_reverse" },
       { &player_skate.anim_grabs,        "grabs" },
-      { &player_skate.anim_handplant,    "handplant" }
+      { &player_skate.anim_handplant,    "handplant" },
    };
 
    for( u32 i=0; i<vg_list_size(bindings); i++ )
       *bindings[i].anim = skeleton_get_anim( sk, bindings[i].name );
 }
 
-static void player__skate_kill_audio(void){
+void player__skate_kill_audio(void){
    audio_lock();
    if( player_skate.aud_main ){
       player_skate.aud_main = 
@@ -59,11 +89,11 @@ static void player__skate_kill_audio(void){
  * Does collision detection on a sphere vs world, and applies some smoothing
  * filters to the manifold afterwards
  */
-static int skate_collide_smooth( m4x3f mtx, rb_sphere *sphere, rb_ct *man ){
+static int skate_collide_smooth( m4x3f mtx, f32 r, rb_ct *man ){
    world_instance *world = world_current_instance();
 
    int len = 0;
-   len = rb_sphere__scene( mtx, sphere, NULL, &world->rb_geo.inf.scene, man,
+   len = rb_sphere__scene( mtx, r, NULL, world->geo_bh, man,
                            k_material_flag_walking );
 
    for( int i=0; i<len; i++ ){
@@ -336,10 +366,11 @@ static int create_jumps_to_hit_target( jump_info *jumps,
    return valid_count;
 }
 
-static void player__approximate_best_trajectory(void){
+void player__approximate_best_trajectory(void)
+{
    world_instance *world0 = world_current_instance();
 
-   float k_trace_delta = k_rb_delta * 10.0f;
+   float k_trace_delta = vg.time_fixed_delta * 10.0f;
    struct player_skate_state *state = &player_skate.state;
 
    state->air_start = vg.time;
@@ -403,18 +434,29 @@ static void player__approximate_best_trajectory(void){
       inf->gravity = gravity;
       v3_copy( launch_v, inf->v );
 
+      /* initial conditions */
+      v3f v;
+      v3_copy( launch_v, v );
+      v3_copy( launch_co, co1 );
+
       for( int i=1; i<=50; i++ ){
-         float t = (float)i * k_trace_delta;
+         f32 t = (f32)i * k_trace_delta;
 
-         v3_muls( launch_v, t, co1 );
-         co1[1] += -0.5f * gravity * t*t;
-         v3_add( launch_co, co1, co1 );
+         /* integrate forces */
+         v3f a;
+         ent_tornado_forces( co1, v, a );
+         a[1] -= gravity;
 
-         float launch_vy = launch_v[1];
+         /* position */
+         v3_muladds( co1, v, k_trace_delta, co1 );
+         v3_muladds( co1, a, 0.5f*k_trace_delta*k_trace_delta, co1 );
+
+         /* velocity */
+         v3_muladds( v, a, k_trace_delta, v );
 
          int search_for_grind = 1;
          if( grind_located ) search_for_grind = 0;
-         if( launch_vy - gravity*t > 0.0f ) search_for_grind = 0;
+         if( v[1] > 0.0f ) search_for_grind = 0;
 
          /* REFACTOR */
 
@@ -448,13 +490,9 @@ static void player__approximate_best_trajectory(void){
          }
 
          if( search_for_grind ){
-            v3f ve;
-            v3_copy( launch_v, ve );
-            ve[1] += -gravity * t;
-
-            if( skate_grind_scansq( closest, ve, 0.5f, &grind ) ){
+            if( skate_grind_scansq( closest, v, 0.5f, &grind ) ){
                /* check alignment */
-               v2f v0 = { ve[0], ve[2] },
+               v2f v0 = { v[0], v[2] },
                    v1 = { grind.dir[0], grind.dir[2] };
 
                v2_normalize( v0 );
@@ -467,7 +505,7 @@ static void player__approximate_best_trajectory(void){
                   a_min = cosf( VG_PIf * 0.05f );
 
                /* check speed */
-               if( (fabsf(v3_dot( ve, grind.dir ))>=k_grind_axel_min_vel) &&
+               if( (fabsf(v3_dot( v, grind.dir ))>=k_grind_axel_min_vel) &&
                    (a >= a_min) && 
                    (fabsf(grind.dir[1]) < 0.70710678118654752f))
                {
@@ -509,12 +547,7 @@ static void player__approximate_best_trajectory(void){
                world_tri_index_surface( trace_world, tri[0] );
 
             inf->type = k_prediction_land;
-
-            v3f ve;
-            v3_copy( launch_v, ve );
-            ve[1] += -gravity * t;
-
-            inf->score = -v3_dot( ve, inf->n );
+            inf->score = -v3_dot( v, inf->n );
             inf->land_dist = t + k_trace_delta * t1;
 
             /* Bias prediction towords ramps */
@@ -707,10 +740,10 @@ static void skate_apply_trick_model(void){
    v3_add( Fd, Fs, F );
    v3_mul( strength, F, F );
 
-   v3_muladds( state->trick_residualv, F, k_rb_delta, 
+   v3_muladds( state->trick_residualv, F, vg.time_fixed_delta, 
                state->trick_residualv );
    v3_muladds( state->trick_residuald, state->trick_residualv,
-               k_rb_delta, state->trick_residuald );
+               vg.time_fixed_delta, state->trick_residuald );
 
    if( state->activity <= k_skate_activity_air_to_grind ){
       if( v3_length2( state->trick_vel ) < 0.0001f )
@@ -735,10 +768,10 @@ static void skate_apply_trick_model(void){
 
 
       /* integrate trick velocities */
-      v3_muladds( state->trick_euler, state->trick_vel, k_rb_delta,
+      v3_muladds( state->trick_euler, state->trick_vel, vg.time_fixed_delta,
                   state->trick_euler );
 
-      if( !carry_on && (state->trick_time + k_rb_delta/interval >= next_end) ){
+      if( !carry_on && (state->trick_time + vg.time_fixed_delta/interval >= next_end) ){
          state->trick_time = 0.0f;
          state->trick_euler[0] = roundf( state->trick_euler[0] );
          state->trick_euler[1] = roundf( state->trick_euler[1] );
@@ -752,13 +785,13 @@ static void skate_apply_trick_model(void){
          audio_unlock();
       }
       else 
-         state->trick_time += k_rb_delta / interval;
+         state->trick_time += vg.time_fixed_delta / interval;
    }
    else{
       if( (v3_length2(state->trick_vel) >= 0.0001f ) &&
           state->trick_time > 0.2f)
       {
-         player__skate_kill_audio();
+         vg_info( "player fell off due to lack of skill\n" );
          player__dead_transition( k_player_die_type_feet );
       }
 
@@ -784,7 +817,7 @@ static void skate_apply_grab_model(void){
    else
       v2_zero( state->grab_mouse_delta );
 
-   state->grabbing = vg_lerpf( state->grabbing, grabt, 8.4f*k_rb_delta );
+   state->grabbing = vg_lerpf( state->grabbing, grabt, 8.4f*vg.time_fixed_delta );
 }
 
 static void skate_apply_steering_model(void){
@@ -823,7 +856,7 @@ static void skate_apply_steering_model(void){
       else if( state->activity >= k_skate_activity_grind_any ){
          rate *= fabsf(steer);
 
-         float a = 0.8f * -steer * k_rb_delta;
+         float a = 0.8f * -steer * vg.time_fixed_delta;
 
          v4f q;
          q_axis_angle( q, localplayer.rb.to_world[1], a );
@@ -862,13 +895,13 @@ static void skate_apply_steering_model(void){
       }
    }
 
-   vg_slewf( &state->skid, skid_target, k_rb_delta*(1.0f/0.1f) );
+   vg_slewf( &state->skid, skid_target, vg.time_fixed_delta*(1.0f/0.1f) );
    steer = vg_lerpf( steer, state->skid*k_steer_ground*0.5f, 
                      fabsf(state->skid*0.8f) );
 
    float current  = v3_dot( localplayer.rb.to_world[1], localplayer.rb.w ),
          addspeed = (steer * -top) - current,
-         maxaccel = rate * k_rb_delta,
+         maxaccel = rate * vg.time_fixed_delta,
          accel    = vg_clampf( addspeed, -maxaccel, maxaccel );
 
    v3_muladds( localplayer.rb.w, localplayer.rb.to_world[1], 
@@ -902,11 +935,21 @@ static void skate_apply_friction_model(void){
    f32 lat = k_friction_lat;
 
    if( fabsf(axis_state(k_sraxis_skid)) > 0.1f ){
-      lat = k_friction_lat * 2.0f;
+      if( (player_skate.surface == k_surface_prop_snow) ||
+          (player_skate.surface == k_surface_prop_sand) ){
+         lat *= 8.0f;
+      }
+      else
+         lat *= 1.5f;
    }
 
-   vel[0] += vg_cfrictf( vel[0], k_friction_lat * k_rb_delta );
-   vel[2] += vg_cfrictf( vel[2], k_friction_resistance * k_rb_delta );
+   if( player_skate.surface == k_surface_prop_snow )
+      lat *= 0.5f;
+   else if( player_skate.surface == k_surface_prop_sand )
+      lat *= 0.6f;
+
+   vel[0] += vg_cfrictf( vel[0], lat * vg.time_fixed_delta );
+   vel[2] += vg_cfrictf( vel[2], k_friction_resistance * vg.time_fixed_delta );
 
    /* Pushing additive force */
 
@@ -946,13 +989,13 @@ static void skate_apply_jump_model(void){
    }
 
    if( state->charging_jump ){
-      state->jump_charge += k_rb_delta * k_jump_charge_speed;
+      state->jump_charge += vg.time_fixed_delta * k_jump_charge_speed;
 
       if( !charging_jump_prev )
          state->jump_dir = state->reverse>0.0f? 1: 0;
    }
    else{
-      state->jump_charge -= k_jump_charge_speed * k_rb_delta;
+      state->jump_charge -= k_jump_charge_speed * vg.time_fixed_delta;
    }
 
    state->jump_charge = vg_clampf( state->jump_charge, 0.0f, 1.0f );
@@ -1076,7 +1119,7 @@ static void skate_apply_pump_model(void){
       v3_normalize( dir );
 
       float max = v3_dot( dir, state->throw_v ),
-            amt = vg_minf( k_mmdecay * k_rb_delta, max );
+            amt = vg_minf( k_mmdecay * vg.time_fixed_delta, max );
       v3_muladds( state->throw_v, dir, -amt, state->throw_v );
    }
 }
@@ -1097,29 +1140,29 @@ static void skate_apply_cog_model(void){
    v3_sub( localplayer.rb.v, state->cog_v, rv );
 
    v3f F;
-   v3_muls( ideal_diff, -k_cog_spring * k_rb_rate, F );
-   v3_muladds( F, rv,   -k_cog_damp * k_rb_rate, F );
+   v3_muls( ideal_diff, -k_cog_spring * 60.0f, F );
+   v3_muladds( F, rv,   -k_cog_damp * 60.0f, F );
 
    float ra = k_cog_mass_ratio,
          rb = 1.0f-k_cog_mass_ratio;
 
    /* Apply forces & intergrate */
    v3_muladds( state->cog_v, F, -rb, state->cog_v );
-   state->cog_v[1] += -9.8f * k_rb_delta;
-   v3_muladds( state->cog, state->cog_v, k_rb_delta, state->cog );
+   state->cog_v[1] += -9.8f * vg.time_fixed_delta;
+   v3_muladds( state->cog, state->cog_v, vg.time_fixed_delta, state->cog );
 }
 
 static void skate_integrate(void){
    struct player_skate_state *state = &player_skate.state;
 
-   float rate_x = 1.0f - (k_rb_delta * 3.0f),
+   float rate_x = 1.0f - (vg.time_fixed_delta * 3.0f),
          rate_z = rate_x,
          rate_y = 1.0f;
 
    if( state->activity >= k_skate_activity_grind_any ){
-      rate_x = 1.0f-(16.0f*k_rb_delta);
-      rate_y = 1.0f-(10.0f*k_rb_delta);
-      rate_z = 1.0f-(40.0f*k_rb_delta);
+      rate_x = 1.0f-(16.0f*vg.time_fixed_delta);
+      rate_y = 1.0f-(10.0f*vg.time_fixed_delta);
+      rate_z = 1.0f-(40.0f*vg.time_fixed_delta);
    }
 
    float wx = v3_dot( localplayer.rb.w, localplayer.rb.to_world[0] ) * rate_x,
@@ -1132,8 +1175,8 @@ static void skate_integrate(void){
    v3_muladds( localplayer.rb.w, localplayer.rb.to_world[2], wz, 
                localplayer.rb.w );
 
-   state->flip_time += state->flip_rate * k_rb_delta;
-   rb_update_transform( &localplayer.rb );
+   state->flip_time += state->flip_rate * vg.time_fixed_delta;
+   rb_update_matrices( &localplayer.rb );
 }
 
 static enum trick_type player_skate_trick_input(void){
@@ -1143,15 +1186,17 @@ static enum trick_type player_skate_trick_input(void){
           (button_press( k_srbind_trick2 )     );
 }
 
-static void player__skate_pre_update(void){
+void player__skate_pre_update(void){
    struct player_skate_state *state = &player_skate.state;
 
    if( state->activity == k_skate_activity_handplant ){
       state->handplant_t += vg.time_delta;
       mdl_keyframe hpose[32];
 
+      struct skeleton_anim *anim = player_skate.anim_handplant;
+
       int end = !skeleton_sample_anim_clamped( 
-               &localplayer.skeleton, player_skate.anim_handplant,
+               &localplayer.skeleton, anim,
                state->handplant_t, hpose );
 
       if( state->reverse < 0.0f )
@@ -1185,6 +1230,7 @@ static void player__skate_pre_update(void){
 
       m3x3_mulv( transfer, state->air_init_v, localplayer.rb.v );
       m3x3_mulv( transfer, state->store_cog_v, state->cog_v );
+
       m4x3_mulv( transfer, state->store_cog, state->cog );
       v3_muladds( state->cog, localplayer.rb.to_world[1], 
                   -state->handplant_t*0.5f, state->cog );
@@ -1193,7 +1239,7 @@ static void player__skate_pre_update(void){
       m3x3_q( transfer, qtransfer );
       q_mul( qtransfer, state->store_smoothed, state->smoothed_rotation );
       q_normalize( state->smoothed_rotation );
-      rb_update_transform( &localplayer.rb );
+      rb_update_matrices( &localplayer.rb );
 
       if( end ){
          state->activity = k_skate_activity_air;
@@ -1201,9 +1247,15 @@ static void player__skate_pre_update(void){
       else return;
    }
 
-   if( button_down( k_srbind_use ) ){
+   if( button_down(k_srbind_use) && (v3_length2(state->trick_vel) < 0.01f) ){
       localplayer.subsystem = k_player_subsystem_walk;
 
+      if( (state->activity <= k_skate_activity_air_to_grind) &&
+           localplayer.have_glider ){
+         player_glide_transition();
+         return;
+      }
+
       v3f angles;
       v3_copy( localplayer.cam.angles, localplayer.angles );
       localplayer.angles[2] = 0.0f;
@@ -1213,10 +1265,13 @@ static void player__skate_pre_update(void){
       v3_add( newpos, (v3f){0.0f,-1.0f,0.0f}, newpos );
       v3_sub( localplayer.rb.co, newpos, offset );
       v3_copy( newpos, localplayer.rb.co );
+      v3_muladds( localplayer.rb.co, localplayer.rb.to_world[1], -0.1f,
+                  localplayer.rb.co );
 
       player__begin_holdout( offset );
-      player__skate_kill_audio();
-      player__walk_transition();
+      player__walk_transition( state->activity <= k_skate_activity_air_to_grind?
+                               0: 1, state->trick_euler[0] );
+
       return;
    }
 
@@ -1256,44 +1311,26 @@ static void player__skate_pre_update(void){
       state->trick_type = k_trick_type_none;
 }
 
-static void player__skate_post_update(void){
-   struct player_skate_state *state = &player_skate.state;
-
-   for( int i=0; i<player_skate.possible_jump_count; i++ ){
-      jump_info *jump = &player_skate.possible_jumps[i];
-
-      if( jump->log_length == 0 ){
-         vg_fatal_error( "assert: jump->log_length == 0\n" );
-      }
-      
-      for( int j=0; j<jump->log_length - 1; j ++ ){
-         float brightness = jump->score*jump->score*jump->score;
-         v3f p1;
-         v3_lerp( jump->log[j], jump->log[j+1], brightness, p1 );
-         vg_line( jump->log[j], p1, jump->colour );
-      }
-
-      vg_line_cross( jump->log[jump->log_length-1], jump->colour, 0.25f );
-
-      v3f p1;
-      v3_add( jump->log[jump->log_length-1], jump->n, p1 );
-      vg_line( jump->log[jump->log_length-1], p1, 0xffffffff );
-
-      vg_line_point( jump->apex, 0.02f, 0xffffffff );
-   }
-
+void player__skate_comp_audio( void *_animator ){
+   struct player_skate_animator *animator = _animator;
    audio_lock();
 
-   float air   = state->activity <= k_skate_activity_air_to_grind? 1.0f: 0.0f,
-         speed = v3_length( localplayer.rb.v ),
-         attn  = vg_minf( 1.0f, speed*0.1f ),
-         slide = vg_clampf( fabsf(state->slip), 0.0f, 1.0f );
+   f32 air   = ((animator->activity <= k_skate_activity_air_to_grind) ||
+                (animator->activity == k_skate_activity_handplant))? 1.0f: 0.0f,
+       speed = v3_length( animator->root_v ),
+       attn  = vg_minf( 1.0f, speed*0.1f ),
+       slide = animator->slide;
 
-   if( state->activity >= k_skate_activity_grind_any ){
+   if( animator->activity >= k_skate_activity_grind_any )
       slide = 0.0f;
+
+   f32 gate = skaterift.time_rate;
+
+   if( skaterift.activity == k_skaterift_replay ){
+      gate = vg_minf( 1.0f, fabsf(player_replay.track_velocity) );
    }
 
-   f32 gate        = skaterift.time_rate,
+   f32
        vol_main    = sqrtf( (1.0f-air)*attn*(1.0f-slide) * 0.4f ) * gate,
        vol_air     = sqrtf(       air *attn * 0.5f )              * gate,
        vol_slide   = sqrtf( (1.0f-air)*attn*slide * 0.25f )       * gate;
@@ -1318,8 +1355,8 @@ static void player__skate_post_update(void){
    float sidechain_amt = 0.0f,
          hz            = vg_maxf( speed * 2.0f, 2.0f );
 
-   if( (player_skate.surface == k_surface_prop_tiles) &&
-       (state->activity < k_skate_activity_grind_any) )
+   if( (animator->surface == k_surface_prop_tiles) &&
+       (animator->activity < k_skate_activity_grind_any) )
       sidechain_amt = 1.0f;
    else
       sidechain_amt = 0.0f;
@@ -1334,29 +1371,33 @@ static void player__skate_post_update(void){
    else{
       int sample_type = k_skate_sample_concrete;
 
-      if( state->activity == k_skate_activity_grind_5050 ){
-         if( player_skate.surface == k_surface_prop_metal )
+      if( animator->activity == k_skate_activity_grind_5050 ){
+         if( animator->surface == k_surface_prop_metal )
             sample_type = k_skate_sample_metal_scrape_generic;
          else
             sample_type = k_skate_sample_concrete_scrape_metal;
       }
-      else if( (state->activity == k_skate_activity_grind_back50) ||
-               (state->activity == k_skate_activity_grind_front50) )
+      else if( (animator->activity == k_skate_activity_grind_back50) ||
+               (animator->activity == k_skate_activity_grind_front50) )
       {
-         if( player_skate.surface == k_surface_prop_metal ){
+         if( animator->surface == k_surface_prop_metal ){
             sample_type = k_skate_sample_metal_scrape_generic;
          }
          else{
+#if 0
             float a = v3_dot( localplayer.rb.to_world[2], 
                               player_skate.grind_dir );
             if( fabsf(a) > 0.70710678118654752f )
                sample_type = k_skate_sample_concrete_scrape_wood;
             else 
                sample_type = k_skate_sample_concrete_scrape_metal;
+#endif
+
+            sample_type = k_skate_sample_concrete_scrape_wood;
          }
       }
-      else if( state->activity == k_skate_activity_grind_boardslide ){
-         if( player_skate.surface == k_surface_prop_metal )
+      else if( animator->activity == k_skate_activity_grind_boardslide ){
+         if( animator->surface == k_surface_prop_metal )
             sample_type = k_skate_sample_metal_scrape_generic;
          else
             sample_type = k_skate_sample_concrete_scrape_wood;
@@ -1385,7 +1426,7 @@ static void player__skate_post_update(void){
    if( player_skate.aud_main ){
       player_skate.aud_main->colour = 0x00103efe;
       audio_channel_set_spacial( player_skate.aud_main, 
-                                 localplayer.rb.co, 40.0f );
+                                 animator->root_co, 40.0f );
       //audio_channel_slope_volume( player_skate.aud_main, 0.05f, vol_main );
       audio_channel_edit_volume( player_skate.aud_main, vol_main, 1 );
       audio_channel_sidechain_lfo( player_skate.aud_main, 0, sidechain_amt );
@@ -1397,7 +1438,7 @@ static void player__skate_post_update(void){
    if( player_skate.aud_slide ){
       player_skate.aud_slide->colour = 0x00103efe;
       audio_channel_set_spacial( player_skate.aud_slide, 
-                                 localplayer.rb.co, 40.0f );
+                                 animator->root_co, 40.0f );
       //audio_channel_slope_volume( player_skate.aud_slide, 0.05f, vol_slide );
       audio_channel_edit_volume( player_skate.aud_slide, vol_slide, 1 );
       audio_channel_sidechain_lfo( player_skate.aud_slide, 0, sidechain_amt );
@@ -1406,7 +1447,7 @@ static void player__skate_post_update(void){
    if( player_skate.aud_air ){
       player_skate.aud_air->colour = 0x00103efe;
       audio_channel_set_spacial( player_skate.aud_air, 
-                                 localplayer.rb.co, 40.0f );
+                                 animator->root_co, 40.0f );
       //audio_channel_slope_volume( player_skate.aud_air, 0.05f, vol_air );
       audio_channel_edit_volume( player_skate.aud_air, vol_air, 1 );
    }
@@ -1414,6 +1455,33 @@ static void player__skate_post_update(void){
    audio_unlock();
 }
 
+void player__skate_post_update(void){
+   struct player_skate_state *state = &player_skate.state;
+
+   for( int i=0; i<player_skate.possible_jump_count; i++ ){
+      jump_info *jump = &player_skate.possible_jumps[i];
+
+      if( jump->log_length == 0 ){
+         vg_fatal_error( "assert: jump->log_length == 0\n" );
+      }
+      
+      for( int j=0; j<jump->log_length - 1; j ++ ){
+         float brightness = jump->score*jump->score*jump->score;
+         v3f p1;
+         v3_lerp( jump->log[j], jump->log[j+1], brightness, p1 );
+         vg_line( jump->log[j], p1, jump->colour );
+      }
+
+      vg_line_cross( jump->log[jump->log_length-1], jump->colour, 0.25f );
+
+      v3f p1;
+      v3_add( jump->log[jump->log_length-1], jump->n, p1 );
+      vg_line( jump->log[jump->log_length-1], p1, 0xffffffff );
+
+      vg_line_point( jump->apex, 0.02f, 0xffffffff );
+   }
+}
+
 /*
  * truck alignment model at ra(local)
  * returns 1 if valid surface:
@@ -1656,7 +1724,7 @@ static void skate_grind_friction( struct grind_info *inf, float strength ){
          dir      = vg_signf( v3_dot( localplayer.rb.v, inf->dir ) ),
          F        = a * -dir * k_grind_max_friction;
 
-   v3_muladds( localplayer.rb.v, inf->dir, F*k_rb_delta*strength, 
+   v3_muladds( localplayer.rb.v, inf->dir, F*vg.time_fixed_delta*strength, 
                localplayer.rb.v );
 }
 
@@ -1668,7 +1736,7 @@ static void skate_grind_decay( struct grind_info *inf, float strength ){
    v3f v_grind;
    m3x3_mulv( mtx_inv, localplayer.rb.v, v_grind );
 
-   float decay = 1.0f - ( k_rb_delta * k_grind_decayxy * strength );
+   float decay = 1.0f - ( vg.time_fixed_delta * k_grind_decayxy * strength );
    v3_mul( v_grind, (v3f){ 1.0f, decay, decay }, v_grind );
    m3x3_mulv( mtx, v_grind, localplayer.rb.v );
 }
@@ -1688,7 +1756,7 @@ static void skate_grind_truck_apply( float sign, struct grind_info *inf,
    v3_sub( inf->co, wsp, delta );
 
    /* spring force */
-   v3_muladds( localplayer.rb.v, delta, k_spring_force*strength*k_rb_delta, 
+   v3_muladds( localplayer.rb.v, delta, k_spring_force*strength*vg.time_fixed_delta, 
                localplayer.rb.v );
 
    skate_grind_decay( inf, strength );
@@ -1728,12 +1796,12 @@ static void skate_grind_truck_apply( float sign, struct grind_info *inf,
    rb_effect_spring_target_vector( &localplayer.rb, up, target_up,
                                     k_grind_spring, 
                                     k_grind_dampener,
-                                    k_rb_delta );
+                                    vg.time_fixed_delta );
 
    rb_effect_spring_target_vector( &localplayer.rb, fwd, target_fwd,
                                     k_grind_spring*strength, 
                                     k_grind_dampener*strength,
-                                    k_rb_delta );
+                                    vg.time_fixed_delta );
 
    vg_line_arrow( localplayer.rb.co, target_up, 1.0f, VG__GREEN );
    vg_line_arrow( localplayer.rb.co, fwd, 0.8f, VG__RED );
@@ -1791,7 +1859,7 @@ static void skate_5050_apply( struct grind_info *inf_front,
    rb_effect_spring_target_vector( &localplayer.rb, up, target_up,
                                     k_grind_spring, 
                                     k_grind_dampener,
-                                    k_rb_delta );
+                                    vg.time_fixed_delta );
    vg_line_arrow( localplayer.rb.co, up, 1.0f, VG__GREEN );
    vg_line_arrow( localplayer.rb.co, target_up, 1.0f, VG__GREEN );
 
@@ -1809,7 +1877,7 @@ static void skate_5050_apply( struct grind_info *inf_front,
    rb_effect_spring_target_vector( &localplayer.rb, fwd_nplane, dir_nplane,
                                     1000.0f,
                                     k_grind_dampener,
-                                    k_rb_delta );
+                                    vg.time_fixed_delta );
    vg_line_arrow( localplayer.rb.co, fwd_nplane, 0.8f, VG__RED );
    vg_line_arrow( localplayer.rb.co, dir_nplane, 0.8f, VG__RED );
 
@@ -1824,7 +1892,7 @@ static void skate_5050_apply( struct grind_info *inf_front,
    v3_sub( inf_back->co,  pos_back, delta_back );
    v3_add( delta_front, delta_back, delta_total );
 
-   v3_muladds( localplayer.rb.v, delta_total, 50.0f * k_rb_delta, 
+   v3_muladds( localplayer.rb.v, delta_total, 50.0f * vg.time_fixed_delta, 
                localplayer.rb.v );
 
    /* Fake contact */
@@ -1953,12 +2021,12 @@ static void skate_boardslide_apply( struct grind_info *inf ){
    rb_effect_spring_target_vector( &localplayer.rb, localplayer.rb.to_world[0],
                                     dir, 
                                     k_grind_spring, k_grind_dampener,
-                                    k_rb_delta );
+                                    vg.time_fixed_delta );
 
    rb_effect_spring_target_vector( &localplayer.rb, localplayer.rb.to_world[2],
                                     perp,
                                     k_grind_spring, k_grind_dampener,
-                                    k_rb_delta );
+                                    vg.time_fixed_delta );
 
    vg_line_arrow( localplayer.rb.co, dir, 0.5f, VG__GREEN );
    vg_line_arrow( localplayer.rb.co, perp, 0.5f, VG__BLUE );
@@ -2157,7 +2225,7 @@ static enum skate_activity skate_availible_grind(void){
    return new_activity;
 }
 
-static void player__skate_update(void){
+void player__skate_update(void){
    struct player_skate_state *state = &player_skate.state;
    world_instance *world = world_current_instance();
 
@@ -2167,10 +2235,10 @@ static void player__skate_update(void){
 
    if( world->water.enabled ){
       if( localplayer.rb.co[1]+0.25f < world->water.height ){
+         vg_info( "player fell off due to being in water\n" );
          player__networked_sfx( k_player_subsystem_walk, 32, 
                                 k_player_walk_soundeffect_splash,
                                 localplayer.rb.co, 1.0f );
-         player__skate_kill_audio();
          player__dead_transition( k_player_die_type_generic );
          return;
       }
@@ -2226,7 +2294,7 @@ static void player__skate_update(void){
       float vy = vg_maxf( 0.0f, localplayer.rb.v[1] );
       slap = vg_clampf( (min_dist/0.5f) + vy, 0.0f, 1.0f )*0.3f;
    }
-   state->slap = vg_lerpf( state->slap, slap, 10.0f*k_rb_delta );
+   state->slap = vg_lerpf( state->slap, slap, 10.0f*vg.time_fixed_delta );
 
    wheels[0].pos[1] = state->slap;
    wheels[1].pos[1] = state->slap;
@@ -2234,7 +2302,7 @@ static void player__skate_update(void){
 
    const int k_wheel_count = 2;
 
-   player_skate.substep = k_rb_delta;
+   player_skate.substep = vg.time_fixed_delta;
    player_skate.substep_delta = player_skate.substep;
    player_skate.limit_count = 0;
 
@@ -2336,6 +2404,11 @@ grinding:;
    skate_apply_trick_model();
    skate_apply_pump_model();
 
+   ent_tornado_debug();
+   v3f a;
+   ent_tornado_forces( localplayer.rb.co, localplayer.rb.v, a );
+   v3_muladds( localplayer.rb.v, a, vg.time_fixed_delta, localplayer.rb.v );
+
 begin_collision:;
 
    /*
@@ -2399,7 +2472,7 @@ begin_collision:;
 
    /* clamp to a fraction of delta, to prevent locking */
    float rate_lock = substep_count;
-   rate_lock *= k_rb_delta * 0.1f;
+   rate_lock *= vg.time_fixed_delta * 0.1f;
    rate_lock *= rate_lock;
 
    max_time = vg_maxf( max_time, rate_lock );
@@ -2424,7 +2497,7 @@ begin_collision:;
       v3_add( localplayer.rb.co, cg_offset, localplayer.rb.co );
    }
 
-   rb_update_transform( &localplayer.rb );
+   rb_update_matrices( &localplayer.rb );
    localplayer.rb.v[1] += -state->gravity_bias * player_skate.substep_delta;
 
    player_skate.substep -= player_skate.substep_delta;
@@ -2444,9 +2517,9 @@ begin_collision:;
                           k_material_flag_walking ) != -1) )
    {
       v3_lerp( start_co, localplayer.rb.co, t, localplayer.rb.co );
-      rb_update_transform( &localplayer.rb );
+      rb_update_matrices( &localplayer.rb );
 
-      player__skate_kill_audio();
+      vg_info( "player fell of due to hitting head\n" );
       player__dead_transition( k_player_die_type_head );
       return;
    }
@@ -2463,12 +2536,10 @@ begin_collision:;
       m4x3f mtx;
       m3x3_identity( mtx );
       m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, mtx[3] );
-      
-      rb_sphere collider = { .radius = wheels[i].radius };
 
       rb_ct *man = &manifold[ manifold_len ];
 
-      int l = skate_collide_smooth( mtx, &collider, man );
+      int l = skate_collide_smooth( mtx, wheels[i].radius, man );
       if( l )
          wheels[i].state = k_collider_state_colliding;
 
@@ -2476,8 +2547,8 @@ begin_collision:;
    }
 
    float grind_radius = k_board_radius * 0.75f;
-   rb_capsule capsule = { .height = (k_board_length+0.2f)*2.0f, 
-                          .radius=grind_radius };
+   rb_capsule capsule = { .h = (k_board_length+0.2f)*2.0f, 
+                          .r = grind_radius };
    m4x3f mtx;
    v3_muls( localplayer.rb.to_world[0],  1.0f, mtx[0] );
    v3_muls( localplayer.rb.to_world[2], -1.0f, mtx[1] );
@@ -2487,7 +2558,7 @@ begin_collision:;
 
    rb_ct *cman = &manifold[manifold_len];
 
-   int l = rb_capsule__scene( mtx, &capsule, NULL, &world->rb_geo.inf.scene,
+   int l = rb_capsule__scene( mtx, &capsule, NULL, world->geo_bh,
                               cman, k_material_flag_walking );
 
    /* weld joints */
@@ -2497,9 +2568,7 @@ begin_collision:;
    l = rb_manifold_apply_filtered( cman, l );
 
    manifold_len += l;
-
-   if( vg_lines.draw )
-      vg_line_capsule( mtx, capsule.radius, capsule.height, VG__WHITE );
+   vg_line_capsule( mtx, capsule.r, capsule.h, VG__WHITE );
 
    /* add limits */
    if( state->activity >= k_skate_activity_grind_any ){
@@ -2560,7 +2629,7 @@ begin_collision:;
           * regular dance; calculate velocity & total mass, apply impulse.
           */
 
-         struct contact *ct = &manifold[i];
+         rb_ct *ct = &manifold[i];
          
          v3f rv, delta;
          v3_sub( ct->co, world_cog, delta ); 
@@ -2599,7 +2668,7 @@ begin_collision:;
    v3f dt;
    rb_depenetrate( manifold, manifold_len, dt );
    v3_add( dt, localplayer.rb.co, localplayer.rb.co );
-   rb_update_transform( &localplayer.rb );
+   rb_update_matrices( &localplayer.rb );
 
    substep_count ++;
 
@@ -2614,9 +2683,9 @@ begin_collision:;
    f32 nforce = v3_length(normal_total);
    if( nforce > 4.0f ){
       if( nforce > 17.6f ){
+         vg_info( "player fell off due to hitting ground too hard\n" );
          v3_muladds( localplayer.rb.v, normal_total, -1.0f, localplayer.rb.v );
          player__dead_transition( k_player_die_type_feet );
-         player__skate_kill_audio();
          return;
       }
 
@@ -2670,7 +2739,9 @@ begin_collision:;
       q_mul( transport_rotation, localplayer.rb.q, localplayer.rb.q );
       q_mul( transport_rotation, state->smoothed_rotation,
                                  state->smoothed_rotation );
-      rb_update_transform( &localplayer.rb );
+      q_normalize( localplayer.rb.q );
+      q_normalize( state->smoothed_rotation );
+      rb_update_matrices( &localplayer.rb );
       player__pass_gate( id );
    }
 
@@ -2733,7 +2804,7 @@ begin_collision:;
    }
 }
 
-static void player__skate_im_gui(void){
+void player__skate_im_gui(void){
    struct player_skate_state *state = &player_skate.state;
    player__debugtext( 1, "V:  %5.2f %5.2f %5.2f",localplayer.rb.v[0],
                                                 localplayer.rb.v[1],
@@ -2778,7 +2849,7 @@ static void player__skate_im_gui(void){
                            state->trick_euler[2] );
 }
 
-static void player__skate_animate(void){
+void player__skate_animate(void){
    struct player_skate_state *state = &player_skate.state;
    struct player_skate_animator *animator = &player_skate.animator;
 
@@ -2889,6 +2960,7 @@ static void player__skate_animate(void){
    animator->grind_balance = vg_lerpf( animator->grind_balance, grind_frame, 
                                 5.0f*vg.time_delta );
    animator->activity = state->activity;
+   animator->surface = player_skate.surface;
 
    /* pushing */
    animator->push_time = vg.time - state->start_push;
@@ -2991,7 +3063,7 @@ static void player__skate_animate(void){
    if( (state->activity <= k_skate_activity_air_to_grind) &&
        (fabsf(state->flip_rate) > 0.01f) ){
       float substep = vg.time_fixed_extrapolate;
-      float t     = state->flip_time+state->flip_rate*substep*k_rb_delta;
+      float t  = state->flip_time+state->flip_rate*substep*vg.time_fixed_delta;
             sign  = vg_signf( t );
 
       t  = 1.0f - vg_minf( 1.0f, fabsf( t * 1.1f ) );
@@ -3066,7 +3138,7 @@ static void player__skate_animate(void){
    animator->handplant_t = state->handplant_t;
 }
                         
-static void player__skate_pose( void *_animator, player_pose *pose ){
+void player__skate_pose( void *_animator, player_pose *pose ){
    struct skeleton *sk = &localplayer.skeleton;
    struct player_skate_animator *animator = _animator;
 
@@ -3205,10 +3277,12 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
    }
 #endif
 
+
    if( animator->activity == k_skate_activity_handplant ){
+      struct skeleton_anim *anim = player_skate.anim_handplant;
+
       mdl_keyframe hpose[32];
-      skeleton_sample_anim_clamped( sk, player_skate.anim_handplant, 
-                                    animator->handplant_t, hpose );
+      skeleton_sample_anim_clamped( sk, anim, animator->handplant_t, hpose );
       if( animator->reverse < 0.0f )
          player_mirror_pose( hpose, hpose );
 
@@ -3234,8 +3308,10 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
       v3_copy( world_view[3], pose->root_co );
 
       f32 t        = animator->handplant_t,
-          frames   = player_skate.anim_handplant->length-1,
-          length   = frames / player_skate.anim_handplant->rate,
+          frames   = anim->length-1,
+          length   = animator->activity == k_skate_activity_handplant?
+                        frames / anim->rate:
+                        999999,
           end_dist = vg_minf( t, length - t )/k_anim_transition,
           blend    = vg_smoothstepf( vg_minf(1,end_dist) );
 
@@ -3243,9 +3319,6 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
    }
 
 
-
-
-
    /* trick rotation */
    v4f qtrick, qyaw, qpitch, qroll;
    q_axis_angle( qyaw,   (v3f){0.0f,1.0f,0.0f}, animator->board_euler[0] );
@@ -3317,7 +3390,7 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
          *kf_hand_r  = &pose->keyframes[localplayer.id_ik_hand_r-1],
          *kf_hip     = &pose->keyframes[localplayer.id_hip-1];
 
-      float warble = perlin1d( vg.time, 2.0f, 2, 300 );
+      float warble = vg_perlin_fract_1d( vg.time, 2.0f, 2, 300 );
             warble *= vg_maxf(animator->grind, fabsf(animator->weight)) * 0.3f;
 
       v4f qrot;
@@ -3388,30 +3461,40 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
 #endif
 }
 
-static void player__skate_effects( void *_animator, m4x3f *final_mtx,
+void player__skate_effects( void *_animator, m4x3f *final_mtx,
                                    struct player_board *board,
                                    struct player_effects_data *effect_data ){
-
    struct skeleton *sk = &localplayer.skeleton;
    struct player_skate_animator *animator = _animator;
 
-   if( animator->grind > 0.5f ){
-      v3f vp0, vp1, vpc;
-      if( board ){
-         v3_copy((v3f){0.0f,0.02f, board->truck_positions[0][2]}, vp1 );
-         v3_copy((v3f){0.0f,0.02f, board->truck_positions[1][2]}, vp0 );
-      }
-      else{
-         v3_zero( vp0 );
-         v3_zero( vp1 );
-      }
+   v3f vp0, vp1, vpc;
+   if( board ){
+      v3_copy((v3f){0.0f,0.02f, board->truck_positions[0][2]}, vp1 );
+      v3_copy((v3f){0.0f,0.02f, board->truck_positions[1][2]}, vp0 );
+   }
+   else{
+      v3_zero( vp0 );
+      v3_zero( vp1 );
+   }
 
-      v3f *board_mtx = final_mtx[ localplayer.id_board ];
-      m4x3_mulv( board_mtx, vp0, vp0 );
-      m4x3_mulv( board_mtx, vp1, vp1 );
-      v3_add( vp0, vp1, vpc );
-      v3_muls( vpc, 0.5f, vpc );
+   v3f *board_mtx = final_mtx[ localplayer.id_board ];
+   m4x3_mulv( board_mtx, vp0, vp0 );
+   m4x3_mulv( board_mtx, vp1, vp1 );
+   v3_add( vp0, vp1, vpc );
+   v3_muls( vpc, 0.5f, vpc );
 
+   if( animator->surface == k_surface_prop_sand ){
+      if( (animator->slide>0.4f) && (v3_length2(animator->root_v)>4.0f*4.0f) ){
+         v3f v, co;
+         v3_muls( animator->root_v, 0.5f, v );
+         v3_lerp( vp0, vp1, vg_randf64(&vg.rand), co );
+
+         effect_data->sand.colour = 0xff8ec4e6;
+         effect_spark_apply( &effect_data->sand, co, v, vg.time_delta * 8.0 );
+      }
+   }
+
+   if( animator->grind > 0.5f ){
       int back = 0, front = 0, mid = 0;
 
       if( animator->activity == k_skate_activity_grind_5050 ){
@@ -3445,9 +3528,10 @@ static void player__skate_effects( void *_animator, m4x3f *final_mtx,
    }
 }
 
-static void player__skate_post_animate(void){
+void player__skate_post_animate(void){
    struct player_skate_state *state = &player_skate.state;
    localplayer.cam_velocity_influence = 1.0f;
+   localplayer.cam_dist = 1.8f;
 
    v3f head = { 0.0f, 1.8f, 0.0f };
    m4x3_mulv( localplayer.final_mtx[ localplayer.id_head ], 
@@ -3456,7 +3540,7 @@ static void player__skate_post_animate(void){
               state->head_position, state->head_position );
 }
 
-static void player__skate_reset_animator(void){
+void player__skate_reset_animator(void){
    struct player_skate_state *state = &player_skate.state;
 
    memset( &player_skate.animator, 0, sizeof(player_skate.animator) );
@@ -3467,7 +3551,8 @@ static void player__skate_reset_animator(void){
       player_skate.animator.fly = 0.0f;
 }
 
-static void player__skate_clear_mechanics(void){
+void player__skate_clear_mechanics(void)
+{
    struct player_skate_state *state = &player_skate.state;
    state->jump_charge    = 0.0f;
    state->charging_jump  = 0;
@@ -3502,11 +3587,14 @@ static void player__skate_clear_mechanics(void){
    v3_copy( localplayer.rb.to_world[1], player_skate.surface_picture );
    v3_copy( localplayer.rb.co, state->prev_pos );
    v3_zero( player_skate.weight_distribution );
+
+   v3f head = { 0.0f, 1.8f, 0.0f };
+   m4x3_mulv( localplayer.rb.to_world, head, state->head_position );
 }
 
 #include "network_compression.h"
 
-static void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
+void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
    struct player_skate_animator *animator = data;
    
    bitpack_qv3f( ctx, 24, -1024.0f, 1024.0f, animator->root_co );
@@ -3553,11 +3641,12 @@ static void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
 
    bitpack_qf32( ctx, 16,  0.0f, 120.0f, &animator->push_time );
    bitpack_qf32( ctx, 16,  0.0f, 120.0f, &animator->jump_time );
+   bitpack_qf32( ctx, 16,  0.0f, 4.0f, &animator->handplant_t );
    bitpack_qv3f( ctx, 16, -100.0f, 100.0f, animator->root_v );
    bitpack_bytes( ctx, 1, &animator->activity );
 }
 
-static void player__skate_sfx_oneshot( u8 id, v3f pos, f32 volume ){
+void player__skate_sfx_oneshot( u8 id, v3f pos, f32 volume ){
    audio_lock();
 
    if( id == k_player_skate_soundeffect_jump ){
@@ -3585,5 +3674,3 @@ static void player__skate_sfx_oneshot( u8 id, v3f pos, f32 volume ){
 
    audio_unlock();
 }
-
-#endif /* PLAYER_SKATE_C */