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

diff --git a/player_skate.c b/player_skate.c
index 49cd6e7..7014c77 100644
--- a/player_skate.c
+++ b/player_skate.c
@@ -1,44 +1,81 @@
-#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"
 
-VG_STATIC void player__skate_bind( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   struct player_avatar *av = player->playeravatar;
-   struct skeleton *sk = &av->sk;
-
-   rb_update_transform( &player->rb );
-   s->anim_grind           = skeleton_get_anim( sk, "pose_grind" );
-   s->anim_grind_jump      = skeleton_get_anim( sk, "pose_grind_jump" );
-   s->anim_stand           = skeleton_get_anim( sk, "pose_stand" );
-   s->anim_highg           = skeleton_get_anim( sk, "pose_highg" );
-   s->anim_air             = skeleton_get_anim( sk, "pose_air" );
-   s->anim_slide           = skeleton_get_anim( sk, "pose_slide" );
-   s->anim_push            = skeleton_get_anim( sk, "push" );
-   s->anim_push_reverse    = skeleton_get_anim( sk, "push_reverse" );
-   s->anim_ollie           = skeleton_get_anim( sk, "ollie" );
-   s->anim_ollie_reverse   = skeleton_get_anim( sk, "ollie_reverse" );
-   s->anim_grabs           = skeleton_get_anim( sk, "grabs" );
-}
+#include "vg/vg_rigidbody.h"
+#include "scene_rigidbody.h"
+#include "player_glide.h"
+#include "player_dead.h"
+#include "player_walk.h"
 
-VG_STATIC void player__skate_kill_audio( player_instance *player )
+struct player_skate player_skate;
+struct player_subsystem_interface player_subsystem_skate = 
 {
-   struct player_skate *s = &player->_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_matrices( &localplayer.rb );
+
+   struct { struct skeleton_anim **anim; const char *name; }
+   bindings[] = {
+      { &player_skate.anim_grind,        "pose_grind" },
+      { &player_skate.anim_grind_jump,   "pose_grind_jump" },
+      { &player_skate.anim_stand,        "pose_stand" },
+      { &player_skate.anim_highg,        "pose_highg" },
+      { &player_skate.anim_air,          "pose_air" },
+      { &player_skate.anim_slide,        "pose_slide" },
+      { &player_skate.anim_push,         "push" },
+      { &player_skate.anim_push_reverse, "push_reverse" },
+      { &player_skate.anim_ollie,        "ollie" },
+      { &player_skate.anim_ollie_reverse,"ollie_reverse" },
+      { &player_skate.anim_grabs,        "grabs" },
+      { &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 );
+}
+
+void player__skate_kill_audio(void){
    audio_lock();
-   if( s->aud_main )
-      s->aud_main = audio_channel_fadeout( s->aud_main, 0.1f );
-   if( s->aud_air )
-      s->aud_air = audio_channel_fadeout( s->aud_air, 0.1f );
-   if( s->aud_slide )
-      s->aud_slide = audio_channel_fadeout( s->aud_slide, 0.1f );
+   if( player_skate.aud_main ){
+      player_skate.aud_main = 
+         audio_channel_fadeout( player_skate.aud_main, 0.1f );
+   }
+   if( player_skate.aud_air ){
+      player_skate.aud_air = 
+         audio_channel_fadeout( player_skate.aud_air, 0.1f );
+   }
+   if( player_skate.aud_slide ){
+      player_skate.aud_slide = 
+         audio_channel_fadeout( player_skate.aud_slide, 0.1f );
+   }
    audio_unlock();
 }
 
@@ -52,25 +89,21 @@ VG_STATIC void player__skate_kill_audio( player_instance *player )
  * Does collision detection on a sphere vs world, and applies some smoothing
  * filters to the manifold afterwards
  */
-VG_STATIC int skate_collide_smooth( player_instance *player,
-                                    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++ )
-   {
-      man[i].rba = &player->rb;
+   for( int i=0; i<len; i++ ){
+      man[i].rba = &localplayer.rb;
       man[i].rbb = NULL;
    }
 
    rb_manifold_filter_coplanar( man, len, 0.03f );
 
-   if( len > 1 )
-   {
+   if( len > 1 ){
       rb_manifold_filter_backface( man, len );
       rb_manifold_filter_joint_edges( man, len, 0.03f );
       rb_manifold_filter_pairs( man, len, 0.03f );
@@ -89,10 +122,8 @@ struct grind_info
    v3f co, dir, n;
 };
 
-VG_STATIC int skate_grind_scansq( player_instance *player,
-                                  v3f pos, v3f dir, float r,
-                                  struct grind_info *inf )
-{
+static int skate_grind_scansq( v3f pos, v3f dir, float r,
+                                  struct grind_info *inf ){
    world_instance *world = world_current_instance();
 
    v4f plane;
@@ -117,7 +148,7 @@ VG_STATIC int skate_grind_scansq( player_instance *player,
        support_max;
 
    v3f support_axis;
-   v3_cross( plane, player->basis[1], support_axis );
+   v3_cross( plane, (v3f){0,1,0}, support_axis );
    v3_normalize( support_axis );
    
    bh_iter it;
@@ -154,9 +185,9 @@ VG_STATIC int skate_grind_scansq( player_instance *player,
             v3_cross( va, vb, normal );
 
             sample->normal[0] = v3_dot( support_axis, normal );
-            sample->normal[1] = v3_dot( player->basis[1], normal );
+            sample->normal[1] = normal[1];
             sample->co[0]     = v3_dot( support_axis, d );
-            sample->co[1]     = v3_dot( player->basis[1], d );
+            sample->co[1]     = d[1];
 
             v3_copy( normal, sample->normal3 ); /* normalize later
                                                    if we want to us it */
@@ -179,8 +210,7 @@ too_many_samples:
    if( sample_count < 2 )
       return 0;
 
-   v3f 
-       average_direction,
+   v3f average_direction,
        average_normal;
 
    v2f min_co, max_co;
@@ -225,14 +255,18 @@ too_many_samples:
          v3_copy( si->normal3, n0 );
          v3_copy( sj->normal3, n1 );
          v3_cross( n0, n1, dir );
+
+         if( v3_length2( dir ) <= 0.000001f )
+            continue;
+
          v3_normalize( dir );
 
          /* make sure the directions all face a common hemisphere */
          v3_muls( dir, vg_signf(v3_dot(dir,plane)), dir );
          v3_add( average_direction, dir, average_direction );
 
-         float yi = v3_dot( player->basis[1], si->normal3 ),
-               yj = v3_dot( player->basis[1], sj->normal3 );
+         float yi = si->normal3[1],
+               yj = sj->normal3[1];
 
          if( yi > yj ) v3_add( si->normal3, average_normal, average_normal );
          else          v3_add( sj->normal3, average_normal, average_normal );
@@ -269,8 +303,7 @@ too_many_samples:
    return passed_samples;
 }
 
-VG_STATIC void reset_jump_info( jump_info *inf )
-{
+static void reset_jump_info( jump_info *inf ){
    inf->log_length = 0;
    inf->land_dist = 0.0f;
    inf->score = 0.0f;
@@ -278,29 +311,21 @@ VG_STATIC void reset_jump_info( jump_info *inf )
    v3_zero( inf->apex );
 }
 
-VG_STATIC int create_jumps_to_hit_target( player_instance *player,
-                                          jump_info *jumps,
+static int create_jumps_to_hit_target( jump_info *jumps,
                                           v3f target, float max_angle_delta,
-                                          float gravity )
-{
-   struct player_skate *s = &player->_skate;
-
+                                          float gravity ){
    /* calculate the exact 2 solutions to jump onto that grind spot */
 
    v3f v0;
-   v3_sub( target, player->rb.co, v0 );
-   m3x3_mulv( player->invbasis, v0, v0 );
+   v3_sub( target, localplayer.rb.co, v0 );
 
    v3f ax;
    v3_copy( v0, ax );
    ax[1] = 0.0f;
    v3_normalize( ax );
 
-   v3f v_local;
-   m3x3_mulv( player->invbasis, player->rb.v, v_local );
-
-   v2f d = { v3_dot( ax, v0 ),           v0[1] },
-       v = { v3_dot( ax, v_local ), v_local[1] };
+   v2f d = { v3_dot( ax, v0 ),               v0[1] },
+       v = { v3_dot( ax, localplayer.rb.v ), localplayer.rb.v[1] };
 
    float a = atan2f( v[1], v[0] ),
          m = v2_length( v ),
@@ -319,7 +344,6 @@ VG_STATIC int create_jumps_to_hit_target( player_instance *player,
 
          v3_muls( ax, cosf( a0 ) * m, inf->v );
          inf->v[1] += sinf( a0 ) * m;
-         m3x3_mulv( player->basis, inf->v, inf->v );
          inf->land_dist = d[0] / (cosf(a0)*m);
          inf->gravity = gravity;
 
@@ -332,7 +356,6 @@ VG_STATIC int create_jumps_to_hit_target( player_instance *player,
 
          v3_muls( ax, cosf( a1 ) * m, inf->v );
          inf->v[1] += sinf( a1 ) * m;
-         m3x3_mulv( player->basis, inf->v, inf->v );
          inf->land_dist = d[0] / (cosf(a1)*m);
          inf->gravity = gravity;
 
@@ -343,26 +366,25 @@ VG_STATIC int create_jumps_to_hit_target( player_instance *player,
    return valid_count;
 }
 
-VG_STATIC 
-void player__approximate_best_trajectory( player_instance *player )
+void player__approximate_best_trajectory(void)
 {
    world_instance *world0 = world_current_instance();
 
-   struct player_skate *s = &player->_skate;
-   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;
 
-   s->state.air_start = vg.time;
-   v3_copy( player->rb.v, s->state.air_init_v );
-   v3_copy( player->rb.co, s->state.air_init_co );
+   state->air_start = vg.time;
+   v3_copy( localplayer.rb.v, state->air_init_v );
+   v3_copy( localplayer.rb.co, state->air_init_co );
 
-   s->possible_jump_count = 0;
+   player_skate.possible_jump_count = 0;
 
    v3f axis;
-   v3_cross( player->rb.v, player->rb.to_world[1], axis );
+   v3_cross( localplayer.rb.v, localplayer.rb.to_world[1], axis );
    v3_normalize( axis );
 
    /* at high slopes, Y component is low */
-   float upness      = v3_dot( player->rb.to_world[1], player->basis[1] ),
+   float upness      = localplayer.rb.to_world[1][1],
          angle_begin = -(1.0f-fabsf( upness )),
          angle_end   =   1.0f;
 
@@ -374,7 +396,7 @@ void player__approximate_best_trajectory( player_instance *player )
    v3f launch_v_bounds[2];
 
    for( int i=0; i<2; i++ ){
-      v3_copy( player->rb.v, launch_v_bounds[i] );
+      v3_copy( localplayer.rb.v, launch_v_bounds[i] );
       float ang = (float[]){ angle_begin, angle_end }[ i ];
             ang *= 0.15f;
 
@@ -384,12 +406,13 @@ void player__approximate_best_trajectory( player_instance *player )
    }
 
    for( int m=0;m<=30; m++ ){
-      jump_info *inf = &s->possible_jumps[ s->possible_jump_count ++ ];
+      jump_info *inf = 
+         &player_skate.possible_jumps[ player_skate.possible_jump_count ++ ];
       reset_jump_info( inf );
 
       v3f launch_co, launch_v, co0, co1;
-      v3_copy( player->rb.co, launch_co );
-      v3_copy( player->rb.v,  launch_v );
+      v3_copy( localplayer.rb.co, launch_co );
+      v3_copy( localplayer.rb.v,  launch_v );
       v3_copy( launch_co, co0 );
       world_instance *trace_world = world0;
 
@@ -403,7 +426,7 @@ void player__approximate_best_trajectory( player_instance *player )
       float yaw_sketch = 1.0f-fabsf(upness);
 
       float yaw_bias = ((float)(m%3) - 1.0f) * 0.08f * yaw_sketch;
-      q_axis_angle( qbias, player->rb.to_world[1], yaw_bias );
+      q_axis_angle( qbias, localplayer.rb.to_world[1], yaw_bias );
       q_mulv( qbias, launch_v, launch_v );
 
       float gravity_bias = vg_lerpf( 0.85f, 1.4f, vt ),
@@ -411,21 +434,29 @@ void player__approximate_best_trajectory( player_instance *player )
       inf->gravity = gravity;
       v3_copy( launch_v, inf->v );
 
-      m3x3f basis;
-      m3x3_copy( player->basis, basis );
+      /* 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;
+
+         /* integrate forces */
+         v3f a;
+         ent_tornado_forces( co1, v, a );
+         a[1] -= gravity;
 
-         v3_muls( launch_v, t, co1 );
-         v3_muladds( co1, basis[1], -0.5f * gravity * t*t, co1 );
-         v3_add( launch_co, co1, co1 );
+         /* position */
+         v3_muladds( co1, v, k_trace_delta, co1 );
+         v3_muladds( co1, a, 0.5f*k_trace_delta*k_trace_delta, co1 );
 
-         float launch_vy = v3_dot( launch_v,basis[1] );
+         /* 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 */
 
@@ -442,7 +473,7 @@ void player__approximate_best_trajectory( player_instance *player )
 
                for( int j=0; j<2; j++ ){
                   v3_muls( launch_v_bounds[j], t, bound[j] );
-                  v3_muladds( bound[j], basis[1], -0.5f*gravity*t*t, bound[j] );
+                  bound[j][1] += -0.5f*gravity*t*t;
                   v3_add( launch_co, bound[j], bound[j] );
                }
 
@@ -459,16 +490,10 @@ void player__approximate_best_trajectory( player_instance *player )
          }
 
          if( search_for_grind ){
-            v3f ve;
-            v3_copy( launch_v, ve );
-            v3_muladds( ve, basis[1], -gravity * t, ve );
-
-            if( skate_grind_scansq( player, closest, ve, 0.5f, &grind ) ){
+            if( skate_grind_scansq( closest, v, 0.5f, &grind ) ){
                /* check alignment */
-               v2f v0 = { v3_dot( ve, basis[0] ), 
-                          v3_dot( ve, basis[2] ) },
-                   v1 = { v3_dot( grind.dir, basis[0] ), 
-                          v3_dot( grind.dir, basis[2] ) };
+               v2f v0 = { v[0], v[2] },
+                   v1 = { grind.dir[0], grind.dir[2] };
 
                v2_normalize( v0 );
                v2_normalize( v1 );
@@ -476,11 +501,11 @@ void player__approximate_best_trajectory( player_instance *player )
                float a = v2_dot( v0, v1 );
 
                float a_min = cosf( VG_PIf * 0.185f );
-               if( s->state.grind_cooldown )
+               if( state->grind_cooldown )
                   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))
                {
@@ -497,11 +522,9 @@ void player__approximate_best_trajectory( player_instance *player )
                m4x3_mulv( gate->transport, co1, co1 );
                m3x3_mulv( gate->transport, launch_v, launch_v);
                m4x3_mulv( gate->transport, launch_co, launch_co );
-               m3x3_mul( gate->transport, basis, basis );
 
-               if( gate->type == k_gate_type_nonlocel ){
-                  trace_world = &world_static.worlds[ gate->target ];
-               }
+               if( gate->flags & k_ent_gate_nonlocal )
+                  trace_world = &world_static.instances[ gate->target ];
             }
          }
 
@@ -511,7 +534,8 @@ void player__approximate_best_trajectory( player_instance *player )
          float scan_radius = k_board_radius;
                scan_radius *= vg_clampf( t, 0.02f, 1.0f );
 
-         int idx = spherecast_world(trace_world, co0, co1, scan_radius, &t1, n);
+         int idx = spherecast_world( trace_world, co0, co1, scan_radius, &t1, n,
+                                     k_material_flag_walking );
          if( idx != -1 ){
             v3f co;
             v3_lerp( co0, co1, t1, co );
@@ -523,12 +547,7 @@ void player__approximate_best_trajectory( player_instance *player )
                world_tri_index_surface( trace_world, tri[0] );
 
             inf->type = k_prediction_land;
-
-            v3f ve;
-            v3_copy( launch_v, ve );
-            v3_muladds( ve, player->basis[1], -gravity * t, ve );
-
-            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 */
@@ -536,31 +555,30 @@ void player__approximate_best_trajectory( player_instance *player )
                inf->score *= 10.0f;
 
             if( surf->info.flags & k_material_flag_boundary )
-               s->possible_jump_count --;
+               player_skate.possible_jump_count --;
 
             break;
          }
          
          if( i % 3 == 0 )
             v3_copy( co1, inf->log[ inf->log_length ++ ] ); 
-
          v3_copy( co1, co0 );
       }
 
       if( inf->type == k_prediction_unset )
-         s->possible_jump_count --;
+         player_skate.possible_jump_count --;
    }
 
    if( grind_located ){
       jump_info grind_jumps[2];
       
       int valid_count = 
-         create_jumps_to_hit_target( player, grind_jumps, grind.co, 
+         create_jumps_to_hit_target( grind_jumps, grind.co, 
                                      0.175f*VG_PIf, grind_located_gravity );
 
       /* knock out original landing points in the 1m area */
-      for( u32 j=0; j<s->possible_jump_count; j++ ){
-         jump_info *jump = &s->possible_jumps[ j ];
+      for( u32 j=0; j<player_skate.possible_jump_count; j++ ){
+         jump_info *jump = &player_skate.possible_jumps[ j ];
          float dist = v3_dist2( jump->log[jump->log_length-1], grind.co );
          float descale = 1.0f-vg_minf(1.0f,dist);
          jump->score += descale*3.0f;
@@ -573,14 +591,11 @@ void player__approximate_best_trajectory( player_instance *player )
          v3f launch_v, launch_co, co0, co1;
 
          v3_copy( jump->v, launch_v );
-         v3_copy( player->rb.co, launch_co );
-
-         m3x3f basis;
-         m3x3_copy( player->basis, basis );
+         v3_copy( localplayer.rb.co, launch_co );
          
          float t = 0.05f * jump->land_dist;
          v3_muls( launch_v, t, co0 );
-         v3_muladds( co0, basis[1], -0.5f * jump->gravity * t*t, co0 );
+         co0[1] += -0.5f * jump->gravity * t*t;
          v3_add( launch_co, co0, co0 );
 
          /* rough scan to make sure we dont collide with anything */
@@ -591,14 +606,15 @@ void player__approximate_best_trajectory( player_instance *player )
             t *= jump->land_dist;
 
             v3_muls( launch_v, t, co1 );
-            v3_muladds( co1, basis[1], -0.5f * jump->gravity * t*t, co1 );
+            co1[1] += -0.5f * jump->gravity * t*t;
             v3_add( launch_co, co1, co1 );
             
             float t1;
             v3f n;
 
             int idx = spherecast_world( world0, co0,co1,
-                                        k_board_radius*0.1f, &t1, n);
+                                        k_board_radius*0.1f, &t1, n, 
+                                        k_material_flag_walking );
             if( idx != -1 ){
                goto invalidated_grind;
             }
@@ -611,10 +627,11 @@ void player__approximate_best_trajectory( player_instance *player )
          /* determine score */
          v3f ve;
          v3_copy( jump->v, ve );
-         v3_muladds( ve, player->basis[1], -jump->gravity*jump->land_dist, ve );
+         ve[1] += -jump->gravity*jump->land_dist;
          jump->score = -v3_dot( ve, grind.n ) * 0.9f;
 
-         s->possible_jumps[ s->possible_jump_count ++ ] = *jump;
+         player_skate.possible_jumps[ player_skate.possible_jump_count ++ ] = 
+            *jump;
 
          continue;
 invalidated_grind:;
@@ -627,8 +644,8 @@ invalidated_grind:;
 
    jump_info *best = NULL;
 
-   for( int i=0; i<s->possible_jump_count; i ++ ){
-      jump_info *jump = &s->possible_jumps[i];
+   for( int i=0; i<player_skate.possible_jump_count; i ++ ){
+      jump_info *jump = &player_skate.possible_jumps[i];
 
       if( jump->score < score_min )
          best = jump;
@@ -637,8 +654,8 @@ invalidated_grind:;
       score_max = vg_maxf( score_max, jump->score );
    }
 
-   for( int i=0; i<s->possible_jump_count; i ++ ){
-      jump_info *jump = &s->possible_jumps[i];
+   for( int i=0; i<player_skate.possible_jump_count; i ++ ){
+      jump_info *jump = &player_skate.possible_jumps[i];
       float s = jump->score;
 
       s -= score_min;
@@ -657,34 +674,32 @@ invalidated_grind:;
    }
 
    if( best ){
-      v3_copy( best->n, s->state.land_normal );
-      v3_copy( best->v, player->rb.v );
-      s->state.land_dist = best->land_dist;
-
-      s->state.gravity_bias = best->gravity;
+      v3_copy( best->n, state->land_normal );
+      v3_copy( best->v, localplayer.rb.v );
+      state->land_dist = best->land_dist;
+      state->gravity_bias = best->gravity;
 
       if( best->type == k_prediction_grind ){
-         s->state.activity = k_skate_activity_air_to_grind;
+         state->activity = k_skate_activity_air_to_grind;
       }
 
       v2f steer;
       joystick_state( k_srjoystick_steer, steer );
       v2_normalize_clamp( steer );
 
-      if( (fabsf(steer[1]) > 0.5f) && (s->state.land_dist >= 1.5f) ){
-         s->state.flip_rate = (1.0f/s->state.land_dist) * vg_signf(steer[1]) *
-                                 s->state.reverse ;
-         s->state.flip_time = 0.0f;
-         v3_copy( player->rb.to_world[0], s->state.flip_axis );
+      if( (fabsf(steer[1]) > 0.5f) && (state->land_dist >= 1.5f) ){
+         state->flip_rate = (1.0f/state->land_dist) * vg_signf(steer[1]) *
+                                 state->reverse ;
+         state->flip_time = 0.0f;
+         v3_copy( localplayer.rb.to_world[0], state->flip_axis );
       }
       else{
-         s->state.flip_rate = 0.0f;
-         v3_zero( s->state.flip_axis );
+         state->flip_rate = 0.0f;
+         v3_zero( state->flip_axis );
       }
    }
-   else{
-      v3_copy( player->basis[1], s->state.land_normal );
-   }
+   else
+      v3_copy( (v3f){0,1,0}, state->land_normal );
 }
 
 /*
@@ -696,47 +711,45 @@ invalidated_grind:;
 /*
  * Air control, no real physics
  */
-VG_STATIC void skate_apply_air_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_apply_air_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( s->state.activity_prev > k_skate_activity_air_to_grind )
-      player__approximate_best_trajectory( player );
+   if( state->activity_prev > k_skate_activity_air_to_grind )
+      player__approximate_best_trajectory();
 
-   float angle = v3_dot( player->rb.to_world[1], s->state.land_normal );
+   float angle = v3_dot( localplayer.rb.to_world[1], state->land_normal );
    angle = vg_clampf( angle, -1.0f, 1.0f );
    v3f axis; 
-   v3_cross( player->rb.to_world[1], s->state.land_normal, axis );
+   v3_cross( localplayer.rb.to_world[1], state->land_normal, axis );
 
    v4f correction;
    q_axis_angle( correction, axis, 
                   acosf(angle)*2.0f*VG_TIMESTEP_FIXED );
-   q_mul( correction, player->rb.q, player->rb.q );
+   q_mul( correction, localplayer.rb.q, localplayer.rb.q );
 }
 
-VG_STATIC enum trick_type player_skate_trick_input( player_instance *player );
-VG_STATIC void skate_apply_trick_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static enum trick_type player_skate_trick_input(void);
+static void skate_apply_trick_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
    v3f Fd, Fs, F;
    v3f strength = { 3.7f, 3.6f, 8.0f };
 
-   v3_muls( s->state.board_trick_residualv, -4.0f , Fd );
-   v3_muls( s->state.board_trick_residuald, -10.0f, Fs );
+   v3_muls( state->trick_residualv, -4.0f , Fd );
+   v3_muls( state->trick_residuald, -10.0f, Fs );
    v3_add( Fd, Fs, F );
    v3_mul( strength, F, F );
 
-   v3_muladds( s->state.board_trick_residualv, F, k_rb_delta, 
-               s->state.board_trick_residualv );
-   v3_muladds( s->state.board_trick_residuald, s->state.board_trick_residualv,
-               k_rb_delta, s->state.board_trick_residuald );
+   v3_muladds( state->trick_residualv, F, vg.time_fixed_delta, 
+               state->trick_residualv );
+   v3_muladds( state->trick_residuald, state->trick_residualv,
+               vg.time_fixed_delta, state->trick_residuald );
 
-   if( s->state.activity <= k_skate_activity_air_to_grind ){
-      if( v3_length2( s->state.trick_vel ) < 0.0001f )
+   if( state->activity <= k_skate_activity_air_to_grind ){
+      if( v3_length2( state->trick_vel ) < 0.0001f )
          return;
 
-      int carry_on = player_skate_trick_input( player );
+      int carry_on = state->trick_type == player_skate_trick_input();
 
       /* we assume velocities share a common divisor, in which case the 
        * interval is the minimum value (if not zero) */
@@ -744,68 +757,71 @@ VG_STATIC void skate_apply_trick_model( player_instance *player )
       float min_rate = 99999.0f;
 
       for( int i=0; i<3; i++ ){
-         float v = s->state.trick_vel[i];
+         float v = state->trick_vel[i];
          if( (v > 0.0f) && (v < min_rate) )
             min_rate = v;
       }
 
       float interval = 1.0f / min_rate,
-            current  = floorf( s->state.trick_time / interval ),
-            next_end = (current+1.0f) * interval;
+            current  = floorf( state->trick_time ),
+            next_end = current+1.0f;
 
 
       /* integrate trick velocities */
-      v3_muladds( s->state.trick_euler, s->state.trick_vel, k_rb_delta,
-                  s->state.trick_euler );
-
-      if( !carry_on && (s->state.trick_time + k_rb_delta >= next_end) ){
-         s->state.trick_time = 0.0f;
-         s->state.trick_euler[0] = roundf( s->state.trick_euler[0] );
-         s->state.trick_euler[1] = roundf( s->state.trick_euler[1] );
-         s->state.trick_euler[2] = roundf( s->state.trick_euler[2] );
-         v3_copy( s->state.trick_vel, s->state.board_trick_residualv );
-         v3_zero( s->state.trick_vel );
+      v3_muladds( state->trick_euler, state->trick_vel, vg.time_fixed_delta,
+                  state->trick_euler );
+
+      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] );
+         state->trick_euler[2] = roundf( state->trick_euler[2] );
+         v3_copy( state->trick_vel, state->trick_residualv );
+         v3_zero( state->trick_vel );
+
+         audio_lock();
+         audio_oneshot_3d( &audio_flips[vg_randu32(&vg.rand)%4], 
+               localplayer.rb.co, 40.0f, 1.0f );
+         audio_unlock();
       }
-
-      s->state.trick_time += k_rb_delta;
+      else 
+         state->trick_time += vg.time_fixed_delta / interval;
    }
    else{
-      if( (v3_length2(s->state.trick_vel) >= 0.0001f ) &&
-          s->state.trick_time > 0.2f)
+      if( (v3_length2(state->trick_vel) >= 0.0001f ) &&
+          state->trick_time > 0.2f)
       {
-         player__skate_kill_audio( player );
-         player__dead_transition( player );
+         vg_info( "player fell off due to lack of skill\n" );
+         player__dead_transition( k_player_die_type_feet );
       }
 
-      s->state.trick_euler[0] = roundf( s->state.trick_euler[0] );
-      s->state.trick_euler[1] = roundf( s->state.trick_euler[1] );
-      s->state.trick_euler[2] = roundf( s->state.trick_euler[2] );
-      s->state.trick_time = 0.0f;
-      v3_zero( s->state.trick_vel );
+      state->trick_euler[0] = roundf( state->trick_euler[0] );
+      state->trick_euler[1] = roundf( state->trick_euler[1] );
+      state->trick_euler[2] = roundf( state->trick_euler[2] );
+      state->trick_time = 0.0f;
+      v3_zero( state->trick_vel );
    }
 }
 
-VG_STATIC void skate_apply_grab_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_apply_grab_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
    float grabt = axis_state( k_sraxis_grab );
 
    if( grabt > 0.5f ){
-      v2_muladds( s->state.grab_mouse_delta, vg.mouse_delta, 0.02f, 
-                  s->state.grab_mouse_delta );
+      v2_muladds( state->grab_mouse_delta, vg.mouse_delta, 0.02f, 
+                  state->grab_mouse_delta );
 
-      v2_normalize_clamp( s->state.grab_mouse_delta );
+      v2_normalize_clamp( state->grab_mouse_delta );
    }
    else
-      v2_zero( s->state.grab_mouse_delta );
+      v2_zero( state->grab_mouse_delta );
 
-   s->state.grabbing = vg_lerpf( s->state.grabbing, grabt, 8.4f*k_rb_delta );
+   state->grabbing = vg_lerpf( state->grabbing, grabt, 8.4f*vg.time_fixed_delta );
 }
 
-VG_STATIC void skate_apply_steering_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_apply_steering_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
    v2f jsteer;
    joystick_state( k_srjoystick_steer, jsteer );
@@ -817,60 +833,86 @@ VG_STATIC void skate_apply_steering_model( player_instance *player )
    steer = vg_signf( steer ) * steer*steer * k_steer_ground;
 
    v3f steer_axis;
-   v3_muls( player->rb.to_world[1], -vg_signf( steer ), steer_axis );
+   v3_muls( localplayer.rb.to_world[1], -vg_signf( steer ), steer_axis );
 
    float rate = 26.0f,
          top  = 1.0f;
 
-   if( s->state.activity <= k_skate_activity_air_to_grind ){
+   f32 skid_target = 0.0f;
+
+   if( state->activity <= k_skate_activity_air_to_grind ){
       rate = 6.0f * fabsf(steer);
       top  = 1.5f;
    }
    else{
       /* rotate slower when grabbing on ground */
-      steer *= (1.0f-(s->state.jump_charge+grab)*0.4f);
+      steer *= (1.0f-(state->jump_charge+grab)*0.4f);
 
-      if( s->state.activity == k_skate_activity_grind_5050 ){
+      if( state->activity == k_skate_activity_grind_5050 ){
          rate = 0.0f;
          top  = 0.0f;
       }
 
-      else if( s->state.activity >= k_skate_activity_grind_any ){
+      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, player->rb.to_world[1], a );
-         q_mulv( q, s->grind_vec, s->grind_vec );
+         q_axis_angle( q, localplayer.rb.to_world[1], a );
+         q_mulv( q, player_skate.grind_vec, player_skate.grind_vec );
 
-         v3_normalize( s->grind_vec );
+         v3_normalize( player_skate.grind_vec );
       }
 
-      else if( s->state.manual_direction ){
+      else if( state->manual_direction ){
          rate = 35.0f;
          top  = 1.5f;
       }
-      
+      else {
+         f32 skid = axis_state(k_sraxis_skid);
+
+         /* skids on keyboard lock to the first direction pressed */
+         if( vg_input.display_input_method == k_input_method_kbm ){
+            if( button_press(k_srbind_skid) && (fabsf(state->skid)<0.01f) &&
+                (fabsf(steer) > 0.4f) ){
+               state->skid = vg_signf( steer ) * 0.02f;
+            }
+
+            if( button_press(k_srbind_skid) && (fabsf(state->skid)>0.01f) ){
+               skid_target = vg_signf( state->skid );
+            }
+         }
+         else {
+            if( fabsf(skid) > 0.1f ){
+               skid_target = skid;
+            }
+         }
+      }
+
       if( grab < 0.5f ){
-         top *= 1.0f+v3_length( s->state.throw_v )*k_mmthrow_steer;
+         top *= 1.0f+v3_length( state->throw_v )*k_mmthrow_steer;
       }
    }
 
-   float current  = v3_dot( player->rb.to_world[1], player->rb.w ),
+   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( player->rb.w, player->rb.to_world[1], accel, player->rb.w );
+   v3_muladds( localplayer.rb.w, localplayer.rb.to_world[1], 
+               accel, localplayer.rb.w );
 }
 
 /*
  * Computes friction and surface interface model
  */
-VG_STATIC void skate_apply_friction_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_apply_friction_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
    /*
     * Computing localized friction forces for controlling the character
@@ -878,7 +920,7 @@ VG_STATIC void skate_apply_friction_model( player_instance *player )
     */
 
    v3f vel;
-   m3x3_mulv( player->rb.to_local, player->rb.v, vel );
+   m3x3_mulv( localplayer.rb.to_local, localplayer.rb.v, vel );
    float slip = 0.0f;
    
    if( fabsf(vel[2]) > 0.01f )
@@ -887,23 +929,38 @@ VG_STATIC void skate_apply_friction_model( player_instance *player )
    if( fabsf( slip ) > 1.2f )
       slip = vg_signf( slip ) * 1.2f;
 
-   s->state.slip = slip;
-   s->state.reverse = -vg_signf(vel[2]);
+   state->slip = slip;
+   state->reverse = -vg_signf(vel[2]);
+
+   f32 lat = k_friction_lat;
 
-   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( fabsf(axis_state(k_sraxis_skid)) > 0.1f ){
+      if( (player_skate.surface == k_surface_prop_snow) ||
+          (player_skate.surface == k_surface_prop_sand) ){
+         lat *= 8.0f;
+      }
+      else
+         lat *= 1.5f;
+   }
+
+   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 */
 
-   if( !button_press( k_srbind_jump ) ){
-      if( button_press( k_srbind_push ) || (vg.time-s->state.start_push<0.75) )
-      {
-         if( (vg.time - s->state.cur_push) > 0.25 )
-            s->state.start_push = vg.time;
+   if( !button_press( k_srbind_jump ) && (fabsf(state->skid)<0.1f) ){
+      if( button_press( k_srbind_push ) || (vg.time-state->start_push<0.75) ){
+         if( (vg.time - state->cur_push) > 0.25 )
+            state->start_push = vg.time;
 
-         s->state.cur_push = vg.time;
+         state->cur_push = vg.time;
 
-         double push_time = vg.time - s->state.start_push;
+         double push_time = vg.time - state->start_push;
 
          float cycle_time = push_time*k_push_cycle_rate,
                accel      = k_push_accel * (sinf(cycle_time)*0.5f+0.5f),
@@ -912,306 +969,384 @@ VG_STATIC void skate_apply_friction_model( player_instance *player )
                new_vel    = vg_minf( current + amt, k_max_push_speed ),
                delta      = new_vel - vg_minf( current, k_max_push_speed );
 
-         vel[2] += delta * -s->state.reverse;
+         vel[2] += delta * -state->reverse;
       }
    }
 
    /* Send back to velocity */
-   m3x3_mulv( player->rb.to_world, vel, player->rb.v );
+   m3x3_mulv( localplayer.rb.to_world, vel, localplayer.rb.v );
 }
 
-VG_STATIC void skate_apply_jump_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   int charging_jump_prev = s->state.charging_jump;
-   s->state.charging_jump = button_press( k_srbind_jump );
+static void skate_apply_jump_model(void){
+   struct player_skate_state *state = &player_skate.state;
+   int charging_jump_prev = state->charging_jump;
+   state->charging_jump = button_press( k_srbind_jump );
 
    /* Cannot charge this in air */
-   if( s->state.activity <= k_skate_activity_air_to_grind ){
-      s->state.charging_jump = 0;
+   if( state->activity <= k_skate_activity_air_to_grind ){
+      state->charging_jump = 0;
       return;
    }
 
-   if( s->state.charging_jump ){
-      s->state.jump_charge += k_rb_delta * k_jump_charge_speed;
+   if( state->charging_jump ){
+      state->jump_charge += vg.time_fixed_delta * k_jump_charge_speed;
 
       if( !charging_jump_prev )
-         s->state.jump_dir = s->state.reverse>0.0f? 1: 0;
+         state->jump_dir = state->reverse>0.0f? 1: 0;
    }
    else{
-      s->state.jump_charge -= k_jump_charge_speed * k_rb_delta;
+      state->jump_charge -= k_jump_charge_speed * vg.time_fixed_delta;
    }
 
-   s->state.jump_charge = vg_clampf( s->state.jump_charge, 0.0f, 1.0f );
+   state->jump_charge = vg_clampf( state->jump_charge, 0.0f, 1.0f );
 
    /* player let go after charging past 0.2: trigger jump */
-   if( (!s->state.charging_jump) && (s->state.jump_charge > 0.2f) ){
+   if( (!state->charging_jump) && (state->jump_charge > 0.2f) ){
       v3f jumpdir;
       
       /* Launch more up if alignment is up else improve velocity */
-      float aup = v3_dot( player->basis[1], player->rb.to_world[1] ),
+      float aup = localplayer.rb.to_world[1][1],
             mod = 0.5f,
             dir = mod + fabsf(aup)*(1.0f-mod);
 
-      if( s->state.activity == k_skate_activity_ground ){
-         v3_copy( player->rb.v, jumpdir );
+      if( state->activity == k_skate_activity_ground ){
+         v3_copy( localplayer.rb.v, jumpdir );
          v3_normalize( jumpdir );
          v3_muls( jumpdir, 1.0f-dir, jumpdir );
-         v3_muladds( jumpdir, player->rb.to_world[1], dir, jumpdir );
+         v3_muladds( jumpdir, localplayer.rb.to_world[1], dir, jumpdir );
          v3_normalize( jumpdir );
       }else{
-         v3_copy( s->state.up_dir, jumpdir );
-         s->state.grind_cooldown = 30;
-         s->state.activity = k_skate_activity_ground;
+         v3_copy( state->up_dir, jumpdir );
+         state->grind_cooldown = 30;
+         state->activity = k_skate_activity_ground;
 
          v2f steer;
          joystick_state( k_srjoystick_steer, steer );
 
          float tilt  = steer[0] * 0.3f;
-               tilt *= vg_signf(v3_dot( player->rb.v, s->grind_dir ));
+               tilt *= vg_signf(v3_dot( localplayer.rb.v, 
+                                        player_skate.grind_dir ));
 
          v4f qtilt;
-         q_axis_angle( qtilt, s->grind_dir, tilt );
+         q_axis_angle( qtilt, player_skate.grind_dir, tilt );
          q_mulv( qtilt, jumpdir, jumpdir );
       }
-      s->state.surface_cooldown = 10;
+      state->surface_cooldown = 10;
+      state->trick_input_collect = 0.0f;
       
-      float force = k_jump_force*s->state.jump_charge;
-      v3_muladds( player->rb.v, jumpdir, force, player->rb.v );
-      s->state.jump_charge = 0.0f;
-      s->state.jump_time = vg.time;
+      float force = k_jump_force*state->jump_charge;
+      v3_muladds( localplayer.rb.v, jumpdir, force, localplayer.rb.v );
+      state->jump_charge = 0.0f;
+      state->jump_time = vg.time;
+      player__networked_sfx( k_player_subsystem_skate, 32, 
+                             k_player_skate_soundeffect_jump,
+                             localplayer.rb.co, 1.0f );
+   }
+}
 
-      audio_lock();
-      audio_oneshot_3d( &audio_jumps[vg_randu32()%2], player->rb.co,40.0f,1.0f);
-      audio_unlock();
+static void skate_apply_handplant_model(void){
+   struct player_skate_state *state = &player_skate.state;
+   if( localplayer.rb.to_world[1][1] < -0.1f ) return;
+   if( localplayer.rb.to_world[1][1] > 0.6f ) return;
+   if( !( button_press(k_srbind_skid) || (fabsf(state->skid)>0.1f)) ) return;
+
+   v3f lco = { 0.0f, -0.2f, -state->reverse },
+       co, dir;
+   m4x3_mulv( localplayer.rb.to_world, lco, co );
+   v3_muls( localplayer.rb.to_world[2], state->reverse, dir );
+   vg_line_arrow( co, dir, 0.13f, 0xff000000 );
+
+   ray_hit hit = { .dist = 2.0f };
+   if( ray_world( world_current_instance(), co, dir, 
+                  &hit, k_material_flag_ghosts )) {
+      vg_line( co, hit.pos, 0xff000000 );
+      vg_line_point( hit.pos, 0.1f, 0xff000000 );
+
+      if( hit.normal[1] < 0.7f ) return;
+      if( hit.dist < 0.95f ) return;
+
+      state->activity = k_skate_activity_handplant;
+      state->handplant_t = 0.0f;
+      v3_copy( localplayer.rb.co, state->store_co );
+      v3_copy( localplayer.rb.v, state->air_init_v );
+      v4_copy( localplayer.rb.q, state->store_q );
+      v3_copy( state->cog, state->store_cog );
+      v3_copy( state->cog_v, state->store_cog_v );
+      v4_copy( state->smoothed_rotation, state->store_smoothed );
    }
 }
 
-VG_STATIC void skate_apply_pump_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_apply_pump_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( s->state.activity != k_skate_activity_ground ){
-      v3_zero( s->state.throw_v );
+   if( state->activity != k_skate_activity_ground ){
+      v3_zero( state->throw_v );
       return;
    }
 
    /* Throw / collect routine 
     */
    if( axis_state( k_sraxis_grab ) > 0.5f ){
-      if( s->state.activity == k_skate_activity_ground ){
+      if( state->activity == k_skate_activity_ground ){
          /* Throw */
-         v3_muls( player->rb.to_world[1], k_mmthrow_scale, s->state.throw_v );
+         v3_muls( localplayer.rb.to_world[1], k_mmthrow_scale, state->throw_v );
       }
    }
    else{
       /* Collect */
-      float doty = v3_dot( player->rb.to_world[1], s->state.throw_v );
+      float doty = v3_dot( localplayer.rb.to_world[1], state->throw_v );
       
       v3f Fl, Fv;
-      v3_muladds( s->state.throw_v, player->rb.to_world[1], -doty, Fl);
+      v3_muladds( state->throw_v, localplayer.rb.to_world[1], -doty, Fl);
 
-      if( s->state.activity == k_skate_activity_ground ){
-         if( v3_length2(player->rb.v)<(20.0f*20.0f) )
-            v3_muladds( player->rb.v,     Fl,  k_mmcollect_lat, player->rb.v );
-         v3_muladds( s->state.throw_v, Fl, -k_mmcollect_lat, s->state.throw_v );
+      if( state->activity == k_skate_activity_ground ){
+         if( v3_length2(localplayer.rb.v)<(20.0f*20.0f) ){
+            v3_muladds( localplayer.rb.v, Fl, 
+                        k_mmcollect_lat, localplayer.rb.v );
+         }
+         v3_muladds( state->throw_v, Fl, -k_mmcollect_lat, state->throw_v );
       }
 
-      v3_muls( player->rb.to_world[1], -doty, Fv );
-      v3_muladds( player->rb.v,     Fv, k_mmcollect_vert, player->rb.v );
-      v3_muladds( s->state.throw_v, Fv, k_mmcollect_vert, s->state.throw_v );
+      v3_muls( localplayer.rb.to_world[1], -doty, Fv );
+      v3_muladds( localplayer.rb.v,     Fv, k_mmcollect_vert, localplayer.rb.v );
+      v3_muladds( state->throw_v, Fv, k_mmcollect_vert, state->throw_v );
    }
 
    /* Decay */
-   if( v3_length2( s->state.throw_v ) > 0.0001f ){
+   if( v3_length2( state->throw_v ) > 0.0001f ){
       v3f dir;
-      v3_copy( s->state.throw_v, dir );
+      v3_copy( state->throw_v, dir );
       v3_normalize( dir );
 
-      float max = v3_dot( dir, s->state.throw_v ),
-            amt = vg_minf( k_mmdecay * k_rb_delta, max );
-      v3_muladds( s->state.throw_v, dir, -amt, s->state.throw_v );
+      float max = v3_dot( dir, state->throw_v ),
+            amt = vg_minf( k_mmdecay * vg.time_fixed_delta, max );
+      v3_muladds( state->throw_v, dir, -amt, state->throw_v );
    }
 }
 
-VG_STATIC void skate_apply_cog_model( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_apply_cog_model(void){
+   struct player_skate_state *state = &player_skate.state;
 
    v3f ideal_cog, ideal_diff, ideal_dir;
-   v3_copy( s->state.up_dir, ideal_dir );
+   v3_copy( state->up_dir, ideal_dir );
    v3_normalize( ideal_dir );
 
    float grab = axis_state( k_sraxis_grab );
-   v3_muladds( player->rb.co, ideal_dir, 1.0f-grab, ideal_cog );
-   v3_sub( ideal_cog, s->state.cog, ideal_diff );
+   v3_muladds( localplayer.rb.co, ideal_dir, 1.0f-grab, ideal_cog );
+   v3_sub( ideal_cog, state->cog, ideal_diff );
 
    /* Apply velocities */
    v3f rv;
-   v3_sub( player->rb.v, s->state.cog_v, rv );
+   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( s->state.cog_v, F, -rb, s->state.cog_v );
-   v3_muladds( s->state.cog_v, player->basis[1], -9.8f * k_rb_delta,
-               s->state.cog_v );
-
-   v3_muladds( s->state.cog, s->state.cog_v, k_rb_delta, s->state.cog );
+   v3_muladds( state->cog_v, F, -rb, state->cog_v );
+   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;
 
-VG_STATIC void skate_integrate( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-
-   float decay_rate_x = 1.0f - (k_rb_delta * 3.0f),
-         decay_rate_z = decay_rate_x,
-         decay_rate_y = 1.0f;
+   float rate_x = 1.0f - (vg.time_fixed_delta * 3.0f),
+         rate_z = rate_x,
+         rate_y = 1.0f;
 
-   if( s->state.activity >= k_skate_activity_grind_any ){
-#if 0
-      decay_rate = 1.0f-vg_lerpf( 3.0f, 20.0f, s->grind_strength ) * k_rb_delta;
-      decay_rate_y = decay_rate;
-#endif
-      decay_rate_x = 1.0f-(16.0f*k_rb_delta);
-      decay_rate_y = 1.0f-(10.0f*k_rb_delta);
-      decay_rate_z = 1.0f-(40.0f*k_rb_delta);
+   if( state->activity >= k_skate_activity_grind_any ){
+      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( player->rb.w, player->rb.to_world[0] ) * decay_rate_x,
-         wy = v3_dot( player->rb.w, player->rb.to_world[1] ) * decay_rate_y,
-         wz = v3_dot( player->rb.w, player->rb.to_world[2] ) * decay_rate_z;
+   float wx = v3_dot( localplayer.rb.w, localplayer.rb.to_world[0] ) * rate_x,
+         wy = v3_dot( localplayer.rb.w, localplayer.rb.to_world[1] ) * rate_y,
+         wz = v3_dot( localplayer.rb.w, localplayer.rb.to_world[2] ) * rate_z;
 
-   v3_muls(                  player->rb.to_world[0], wx, player->rb.w );
-   v3_muladds( player->rb.w, player->rb.to_world[1], wy, player->rb.w );
-   v3_muladds( player->rb.w, player->rb.to_world[2], wz, player->rb.w );
+   v3_muls(                  localplayer.rb.to_world[0], wx, localplayer.rb.w );
+   v3_muladds( localplayer.rb.w, localplayer.rb.to_world[1], wy, 
+               localplayer.rb.w );
+   v3_muladds( localplayer.rb.w, localplayer.rb.to_world[2], wz, 
+               localplayer.rb.w );
 
-   s->state.flip_time += s->state.flip_rate * k_rb_delta;
-   rb_update_transform( &player->rb );
+   state->flip_time += state->flip_rate * vg.time_fixed_delta;
+   rb_update_matrices( &localplayer.rb );
 }
 
-/*
- * 1 2 or 3
- */
-
-VG_STATIC void skate_copy_holdout( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   struct player_avatar *av = player->playeravatar;
-   struct skeleton *sk = &av->sk;
-   skeleton_copy_pose( sk, s->holdout, player->holdout_pose );
-}
-
-VG_STATIC enum trick_type player_skate_trick_input( player_instance *player )
-{
+static enum trick_type player_skate_trick_input(void){
    return (button_press( k_srbind_trick0 )     ) |
           (button_press( k_srbind_trick1 ) << 1) |
           (button_press( k_srbind_trick2 ) << 1) |
           (button_press( k_srbind_trick2 )     );
 }
 
-VG_STATIC void player__skate_pre_update( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+void player__skate_pre_update(void){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( button_down( k_srbind_use ) ){
-      player->subsystem = k_player_subsystem_walk;
+   if( state->activity == k_skate_activity_handplant ){
+      state->handplant_t += vg.time_delta;
+      mdl_keyframe hpose[32];
 
-      v3f angles;
-      v3_copy( player->cam.angles, angles );
-      angles[2] = 0.0f;
+      struct skeleton_anim *anim = player_skate.anim_handplant;
 
-      skate_copy_holdout( player );
-      player->holdout_time = 0.34f;
-      player__skate_kill_audio( player );
-      player__walk_transition( player, angles );
-      return;
-   }
+      int end = !skeleton_sample_anim_clamped( 
+               &localplayer.skeleton, anim,
+               state->handplant_t, hpose );
 
-   enum trick_type trick = k_trick_type_none;
-   if( (s->state.activity <= k_skate_activity_air_to_grind) && 
-       (trick = player_skate_trick_input( player )) )
-   {
-      if( (vg.time - s->state.jump_time) < 0.1f ){
-         v3_zero( s->state.trick_vel );
-         s->state.trick_time = 0.0f;
+      if( state->reverse < 0.0f )
+         player_mirror_pose( hpose, hpose );
 
-         if( trick == k_trick_type_kickflip ){
-            s->state.trick_vel[0] = 3.0f;
-         }
-         else if( trick == k_trick_type_shuvit ){
-            s->state.trick_vel[2] = 3.0f;
-         }
-         else if( trick == k_trick_type_treflip ){
-            s->state.trick_vel[0] = 2.0f;
-            s->state.trick_vel[2] = 2.0f;
-         }
-         s->state.trick_type = trick;
-      }
-   }
-}
+      mdl_keyframe *kf_world = &hpose[ localplayer.id_world -1 ];
+      m4x3f world, mmdl, world_view;
+      q_m3x3( kf_world->q, world );
+      v3_copy( kf_world->co, world[3] );
 
-VG_STATIC void player__skate_post_update( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+      /* original mtx */
+      q_m3x3( state->store_q, mmdl );
+      v3_copy( state->store_co, mmdl[3] );
+      m4x3_mul( mmdl, world, world_view );
 
-   for( int i=0; i<s->possible_jump_count; i++ ){
-      jump_info *jump = &s->possible_jumps[i];
+      vg_line_arrow( world_view[3], world_view[0], 1.0f, 0xff0000ff );
+      vg_line_arrow( world_view[3], world_view[1], 1.0f, 0xff00ff00 );
+      vg_line_arrow( world_view[3], world_view[2], 1.0f, 0xffff0000 );
 
-      if( jump->log_length == 0 ){
-         vg_fatal_error( "assert: jump->log_length == 0\n" );
+      m4x3f invworld;
+      m4x3_invert_affine( world, invworld );
+      m4x3_mul( mmdl, invworld, world_view );
+
+      v3_copy( world_view[3], localplayer.rb.co );
+      m3x3_q( world_view, localplayer.rb.q );
+
+      /* new * old^-1 = transfer function */
+      m4x3f transfer;
+      m4x3_invert_affine( mmdl, transfer );
+      m4x3_mul( world_view, transfer, transfer );
+
+      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 );
+
+      v4f qtransfer;
+      m3x3_q( transfer, qtransfer );
+      q_mul( qtransfer, state->store_smoothed, state->smoothed_rotation );
+      q_normalize( state->smoothed_rotation );
+      rb_update_matrices( &localplayer.rb );
+
+      if( end ){
+         state->activity = k_skate_activity_air;
       }
-      
-      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 );
+      else return;
+   }
+
+   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;
       }
 
-      vg_line_cross( jump->log[jump->log_length-1], jump->colour, 0.25f );
+      v3f angles;
+      v3_copy( localplayer.cam.angles, localplayer.angles );
+      localplayer.angles[2] = 0.0f;
 
-      v3f p1;
-      v3_add( jump->log[jump->log_length-1], jump->n, p1 );
-      vg_line( jump->log[jump->log_length-1], p1, 0xffffffff );
+      v3f newpos, offset;
+      m4x3_mulv( localplayer.rb.to_world, (v3f){0.0f,1.0f,0.0f}, newpos );
+      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 );
 
-      vg_line_point( jump->apex, 0.02f, 0xffffffff );
+      player__begin_holdout( offset );
+      player__walk_transition( state->activity <= k_skate_activity_air_to_grind?
+                               0: 1, state->trick_euler[0] );
+
+      return;
+   }
+
+   enum trick_type trick = player_skate_trick_input();
+   if( trick )
+      state->trick_input_collect += vg.time_frame_delta;
+   else 
+      state->trick_input_collect = 0.0f;
+
+   if( state->activity <= k_skate_activity_air_to_grind ){
+      if( trick && (state->trick_input_collect < 0.1f) ){
+         if( state->trick_time == 0.0f ){
+            audio_lock();
+            audio_oneshot_3d( &audio_flips[vg_randu32(&vg.rand)%4], 
+                  localplayer.rb.co, 40.0f, 1.0f );
+            audio_unlock();
+         }
+
+         if( state->trick_time < 0.1f ){
+            v3_zero( state->trick_vel );
+
+            if( trick == k_trick_type_kickflip ){
+               state->trick_vel[0] = 3.0f;
+            }
+            else if( trick == k_trick_type_shuvit ){
+               state->trick_vel[2] = 3.0f;
+            }
+            else if( trick == k_trick_type_treflip ){
+               state->trick_vel[0] = 2.0f;
+               state->trick_vel[2] = 2.0f;
+            }
+            state->trick_type = trick;
+         }
+      }
    }
+   else
+      state->trick_type = k_trick_type_none;
+}
 
+void player__skate_comp_audio( void *_animator ){
+   struct player_skate_animator *animator = _animator;
    audio_lock();
 
-   float air   = s->state.activity <= k_skate_activity_air_to_grind? 1.0f: 0.0f,
-         speed = v3_length( player->rb.v ),
-         attn  = vg_minf( 1.0f, speed*0.1f ),
-         slide = vg_clampf( fabsf(s->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( s->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;
 
    const u32 flags = AUDIO_FLAG_SPACIAL_3D|AUDIO_FLAG_LOOP;
 
-   if( !s->aud_air ){
-      s->aud_air = audio_get_first_idle_channel();
-      if( s->aud_air )
-         audio_channel_init( s->aud_air, &audio_board[1], flags );
+   if( !player_skate.aud_air ){
+      player_skate.aud_air = audio_get_first_idle_channel();
+      if( player_skate.aud_air )
+         audio_channel_init( player_skate.aud_air, &audio_board[1], flags );
    }
 
-   if( !s->aud_slide ){
-      s->aud_slide = audio_get_first_idle_channel();
-      if( s->aud_slide ) 
-         audio_channel_init( s->aud_slide, &audio_board[2], flags );
+   if( !player_skate.aud_slide ){
+      player_skate.aud_slide = audio_get_first_idle_channel();
+      if( player_skate.aud_slide ) 
+         audio_channel_init( player_skate.aud_slide, &audio_board[2], flags );
    }
 
 
@@ -1220,8 +1355,8 @@ VG_STATIC void player__skate_post_update( player_instance *player )
    float sidechain_amt = 0.0f,
          hz            = vg_maxf( speed * 2.0f, 2.0f );
 
-   if( (s->surface == k_surface_prop_tiles) &&
-       (s->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;
@@ -1230,34 +1365,39 @@ VG_STATIC void player__skate_post_update( player_instance *player )
    audio_set_lfo_wave( 0, k_lfo_polynomial_bipolar, 
                           vg_lerpf( 250.0f, 80.0f, attn ) );
 
-   if( s->sample_change_cooldown > 0.0f ){
-      s->sample_change_cooldown -= vg.time_frame_delta;
+   if( player_skate.sample_change_cooldown > 0.0f ){
+      player_skate.sample_change_cooldown -= vg.time_frame_delta;
    }
    else{
       int sample_type = k_skate_sample_concrete;
 
-      if( s->state.activity == k_skate_activity_grind_5050 ){
-         if( s->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( (s->state.activity == k_skate_activity_grind_back50) ||
-               (s->state.activity == k_skate_activity_grind_front50) )
+      else if( (animator->activity == k_skate_activity_grind_back50) ||
+               (animator->activity == k_skate_activity_grind_front50) )
       {
-         if( s->surface == k_surface_prop_metal ){
+         if( animator->surface == k_surface_prop_metal ){
             sample_type = k_skate_sample_metal_scrape_generic;
          }
          else{
-            float a = v3_dot( player->rb.to_world[2], s->grind_dir );
+#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( s->state.activity == k_skate_activity_grind_boardslide ){
-         if( s->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;
@@ -1271,44 +1411,77 @@ VG_STATIC void player__skate_post_update( player_instance *player )
          &audio_board[5]
       };
 
-      if( (s->main_sample_type != sample_type) || (!s->aud_main) ){
-         s->aud_main = 
-            audio_channel_crossfade( s->aud_main, relevant_samples[sample_type],
+      if( (player_skate.main_sample_type != sample_type) || 
+          (!player_skate.aud_main) ){
+
+         player_skate.aud_main = 
+            audio_channel_crossfade( player_skate.aud_main, 
+                                     relevant_samples[sample_type],
                                      0.06f, flags );
-         s->sample_change_cooldown = 0.1f;
-         s->main_sample_type = sample_type;
+         player_skate.sample_change_cooldown = 0.1f;
+         player_skate.main_sample_type = sample_type;
       }
    }
 
-   if( s->aud_main ){
-      s->aud_main->colour = 0x00103efe;
-      audio_channel_set_spacial( s->aud_main, player->rb.co, 40.0f );
-      //audio_channel_slope_volume( s->aud_main, 0.05f, vol_main );
-      audio_channel_edit_volume( s->aud_main, vol_main, 1 );
-      audio_channel_sidechain_lfo( s->aud_main, 0, sidechain_amt );
+   if( player_skate.aud_main ){
+      player_skate.aud_main->colour = 0x00103efe;
+      audio_channel_set_spacial( player_skate.aud_main, 
+                                 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 );
 
       float rate = 1.0f + (attn-0.5f)*0.2f;
-      audio_channel_set_sampling_rate( s->aud_main, rate );
+      audio_channel_set_sampling_rate( player_skate.aud_main, rate );
    }
 
-   if( s->aud_slide ){
-      s->aud_slide->colour = 0x00103efe;
-      audio_channel_set_spacial( s->aud_slide, player->rb.co, 40.0f );
-      //audio_channel_slope_volume( s->aud_slide, 0.05f, vol_slide );
-      audio_channel_edit_volume( s->aud_slide, vol_slide, 1 );
-      audio_channel_sidechain_lfo( s->aud_slide, 0, sidechain_amt );
+   if( player_skate.aud_slide ){
+      player_skate.aud_slide->colour = 0x00103efe;
+      audio_channel_set_spacial( player_skate.aud_slide, 
+                                 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 );
    }
 
-   if( s->aud_air ){
-      s->aud_air->colour = 0x00103efe;
-      audio_channel_set_spacial( s->aud_air, player->rb.co, 40.0f );
-      //audio_channel_slope_volume( s->aud_air, 0.05f, vol_air );
-      audio_channel_edit_volume( s->aud_air, vol_air, 1 );
+   if( player_skate.aud_air ){
+      player_skate.aud_air->colour = 0x00103efe;
+      audio_channel_set_spacial( player_skate.aud_air, 
+                                 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 );
    }
 
    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:
@@ -1317,19 +1490,16 @@ VG_STATIC void player__skate_post_update( player_instance *player )
  *
  * returns 0 if no good surface found
  */
-VG_STATIC 
-int skate_compute_surface_alignment( player_instance *player,
-                                     v3f ra, u32 colour,
-                                     v3f surface_normal, v3f axel_dir )
-{
-   struct player_skate *s = &player->_skate;
+static 
+int skate_compute_surface_alignment( v3f ra, u32 colour,
+                                     v3f surface_normal, v3f axel_dir ){
    world_instance *world = world_current_instance();
 
    v3f truck, left, right;
-   m4x3_mulv( player->rb.to_world, ra, truck );
+   m4x3_mulv( localplayer.rb.to_world, ra, truck );
 
-   v3_muladds( truck, player->rb.to_world[0], -k_board_width, left  );
-   v3_muladds( truck, player->rb.to_world[0],  k_board_width, right );
+   v3_muladds( truck, localplayer.rb.to_world[0], -k_board_width, left  );
+   v3_muladds( truck, localplayer.rb.to_world[0],  k_board_width, right );
    vg_line( left, right, colour );
 
    float k_max_truck_flex = VG_PIf * 0.25f;
@@ -1337,31 +1507,29 @@ int skate_compute_surface_alignment( player_instance *player,
    ray_hit ray_l, ray_r;
 
    v3f dir;
-   v3_muls( player->rb.to_world[1], -1.0f, dir );
+   v3_muls( localplayer.rb.to_world[1], -1.0f, dir );
 
    int res_l = 0, res_r = 0;
 
-   for( int i=0; i<8; i++ )
-   {
+   for( int i=0; i<8; i++ ){
       float t = 1.0f - (float)i * (1.0f/8.0f);
-      v3_muladds( truck, player->rb.to_world[0], -k_board_radius*t, left );
-      v3_muladds( left,  player->rb.to_world[1],  k_board_radius,   left );
+      v3_muladds( truck, localplayer.rb.to_world[0], -k_board_radius*t, left );
+      v3_muladds( left,  localplayer.rb.to_world[1],  k_board_radius,   left );
       ray_l.dist = 2.1f * k_board_radius;
 
-      res_l = ray_world( world, left, dir, &ray_l );
+      res_l = ray_world( world, left, dir, &ray_l, k_material_flag_walking );
 
       if( res_l )
          break;
    }
 
-   for( int i=0; i<8; i++ )
-   {
+   for( int i=0; i<8; i++ ){
       float t = 1.0f - (float)i * (1.0f/8.0f);
-      v3_muladds( truck, player->rb.to_world[0],  k_board_radius*t, right );
-      v3_muladds( right, player->rb.to_world[1],  k_board_radius,   right );
+      v3_muladds( truck, localplayer.rb.to_world[0],  k_board_radius*t, right );
+      v3_muladds( right, localplayer.rb.to_world[1],  k_board_radius,   right );
       ray_r.dist = 2.1f * k_board_radius;
 
-      res_r = ray_world( world, right, dir, &ray_r );
+      res_r = ray_world( world, right, dir, &ray_r, k_material_flag_walking );
 
       if( res_r )
          break;
@@ -1370,39 +1538,34 @@ int skate_compute_surface_alignment( player_instance *player,
    v3f v0;
    v3f midpoint;
    v3f tangent_average;
-   v3_muladds( truck, player->rb.to_world[1], -k_board_radius, midpoint );
+   v3_muladds( truck, localplayer.rb.to_world[1], -k_board_radius, midpoint );
    v3_zero( tangent_average );
 
-   if( res_l || res_r )
-   {
+   if( res_l || res_r ){
       v3f p0, p1, t;
       v3_copy( midpoint, p0 );
       v3_copy( midpoint, p1 );
 
-      if( res_l ) 
-      {
+      if( res_l ){
          v3_copy( ray_l.pos, p0 );
-         v3_cross( ray_l.normal, player->rb.to_world[0], t );
+         v3_cross( ray_l.normal, localplayer.rb.to_world[0], t );
          v3_add( t, tangent_average, tangent_average );
       }
-      if( res_r )
-      {
+      if( res_r ){
          v3_copy( ray_r.pos, p1 );
-         v3_cross( ray_r.normal, player->rb.to_world[0], t );
+         v3_cross( ray_r.normal, localplayer.rb.to_world[0], t );
          v3_add( t, tangent_average, tangent_average );
       }
 
       v3_sub( p1, p0, v0 );
       v3_normalize( v0 );
    }
-   else
-   {
+   else{
       /* fallback: use the closes point to the trucks */
       v3f closest;
       int idx = bh_closest_point( world->geo_bh, midpoint, closest, 0.1f );
 
-      if( idx != -1 )
-      {
+      if( idx != -1 ){
          u32 *tri = &world->scene_geo.arrindices[ idx * 3 ];
          v3f verts[3];
 
@@ -1415,16 +1578,16 @@ int skate_compute_surface_alignment( player_instance *player,
          v3_cross( vert0, vert1, n );
          v3_normalize( n );
 
-         if( v3_dot( n, player->rb.to_world[1] ) < 0.3f )
+         if( v3_dot( n, localplayer.rb.to_world[1] ) < 0.3f )
             return 0;
 
-         v3_cross( n, player->rb.to_world[2], v0 );
-         v3_muladds( v0, player->rb.to_world[2],
-                     -v3_dot( player->rb.to_world[2], v0 ), v0 );
+         v3_cross( n, localplayer.rb.to_world[2], v0 );
+         v3_muladds( v0, localplayer.rb.to_world[2],
+                     -v3_dot( localplayer.rb.to_world[2], v0 ), v0 );
          v3_normalize( v0 );
 
          v3f t;
-         v3_cross( n, player->rb.to_world[0], t );
+         v3_cross( n, localplayer.rb.to_world[0], t );
          v3_add( t, tangent_average, tangent_average );
       }
       else
@@ -1443,91 +1606,94 @@ int skate_compute_surface_alignment( player_instance *player,
    return 1;
 }
 
-VG_STATIC void skate_weight_distribute( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   v3_zero( s->weight_distribution );
+static void skate_weight_distribute(void){
+   struct player_skate_state *state = &player_skate.state;
+   v3_zero( player_skate.weight_distribution );
 
-   int reverse_dir = v3_dot( player->rb.to_world[2], player->rb.v ) < 0.0f?1:-1;
+   int reverse_dir = v3_dot( localplayer.rb.to_world[2], 
+                             localplayer.rb.v ) < 0.0f?1:-1;
 
    v2f steer;
    joystick_state( k_srjoystick_steer, steer );
 
-   if( s->state.manual_direction == 0 ){
-      if( (steer[1] > 0.7f) && (s->state.activity == k_skate_activity_ground) &&
-          (s->state.jump_charge <= 0.01f) )
-         s->state.manual_direction = reverse_dir;
+   if( state->manual_direction == 0 ){
+      if( (steer[1] > 0.7f) && (state->activity == k_skate_activity_ground) &&
+          (state->jump_charge <= 0.01f) )
+         state->manual_direction = reverse_dir;
    }
    else{
       if( steer[1] < 0.1f ){
-         s->state.manual_direction = 0;
+         state->manual_direction = 0;
       }
       else{
-         if( reverse_dir != s->state.manual_direction ){
+         if( reverse_dir != state->manual_direction ){
             return;
          }
       }
    }
 
-   if( s->state.manual_direction ){
+   if( state->manual_direction ){
       float amt = vg_minf( steer[1] * 8.0f, 1.0f );
-      s->weight_distribution[2] = k_board_length * amt * 
-                                          (float)s->state.manual_direction;
+      player_skate.weight_distribution[2] = k_board_length * amt * 
+                                          (float)state->manual_direction;
    }
 
-   if( s->state.manual_direction ){
+   if( state->manual_direction ){
       v3f plane_z;
 
-      m3x3_mulv( player->rb.to_world, s->weight_distribution, plane_z );
+      m3x3_mulv( localplayer.rb.to_world, player_skate.weight_distribution, 
+                 plane_z );
       v3_negate( plane_z, plane_z );
 
-      v3_muladds( plane_z, s->surface_picture,
-                  -v3_dot( plane_z, s->surface_picture ), plane_z );
+      v3_muladds( plane_z, player_skate.surface_picture,
+                  -v3_dot( plane_z, player_skate.surface_picture ), plane_z );
       v3_normalize( plane_z );
 
-      v3_muladds( plane_z, s->surface_picture, 0.3f, plane_z );
+      v3_muladds( plane_z, player_skate.surface_picture, 0.3f, plane_z );
       v3_normalize( plane_z );
 
       v3f p1;
-      v3_muladds( player->rb.co, plane_z, 1.5f, p1 );
-      vg_line( player->rb.co, p1, VG__GREEN );
+      v3_muladds( localplayer.rb.co, plane_z, 1.5f, p1 );
+      vg_line( localplayer.rb.co, p1, VG__GREEN );
 
       v3f refdir;
-      v3_muls( player->rb.to_world[2], -(float)s->state.manual_direction,
+      v3_muls( localplayer.rb.to_world[2], -(float)state->manual_direction,
                refdir );
 
-      rb_effect_spring_target_vector( &player->rb, refdir, plane_z,
+      rb_effect_spring_target_vector( &localplayer.rb, refdir, plane_z,
                                        k_manul_spring, k_manul_dampener,
-                                       s->substep_delta );
+                                       player_skate.substep_delta );
    }
 }
 
-VG_STATIC void skate_adjust_up_direction( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_adjust_up_direction(void){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( s->state.activity == k_skate_activity_ground ){
+   if( state->activity == k_skate_activity_ground ){
       v3f target;
-      v3_copy( s->surface_picture, target );
+      v3_copy( player_skate.surface_picture, target );
 
-      target[1] += 2.0f * s->surface_picture[1];
+      target[1] += 2.0f * player_skate.surface_picture[1];
       v3_normalize( target );
 
-      v3_lerp( s->state.up_dir, target,
-               8.0f * s->substep_delta, s->state.up_dir );
+      v3_lerp( state->up_dir, target,
+               8.0f * player_skate.substep_delta, state->up_dir );
    }
-   else if( s->state.activity <= k_skate_activity_air_to_grind ){
-      v3_lerp( s->state.up_dir, player->rb.to_world[1],
-               8.0f * s->substep_delta, s->state.up_dir );
+   else if( state->activity <= k_skate_activity_air_to_grind ){
+      v3_lerp( state->up_dir, localplayer.rb.to_world[1],
+               8.0f * player_skate.substep_delta, state->up_dir );
    }
    else{
-      v3_lerp( s->state.up_dir, player->basis[1],
-               12.0f * s->substep_delta, s->state.up_dir );
+      v3f avg;
+      v3_add( localplayer.rb.to_world[1], (v3f){0,1,0}, avg );
+      v3_normalize( avg );
+
+      v3_lerp( state->up_dir, avg,
+               6.0f * player_skate.substep_delta, state->up_dir );
    }
 }
 
-VG_STATIC int skate_point_visible( v3f origin, v3f target )
-{
+static int skate_point_visible( v3f origin, v3f target ){
    v3f dir;
    v3_sub( target, origin, dir );
    
@@ -1536,71 +1702,65 @@ VG_STATIC int skate_point_visible( v3f origin, v3f target )
    v3_muls( dir, 1.0f/ray.dist, dir );
    ray.dist -= 0.025f;
 
-   if( ray_world( world_current_instance(), origin, dir, &ray ) )
+   if( ray_world( world_current_instance(), origin, dir, &ray, 
+                  k_material_flag_walking ) )
       return 0;
 
    return 1;
 }
 
-VG_STATIC void skate_grind_orient( struct grind_info *inf, m3x3f mtx )
-{
+static void skate_grind_orient( struct grind_info *inf, m3x3f mtx ){
    v3_copy( inf->dir, mtx[0] );
    v3_copy( inf->n, mtx[1] );
    v3_cross( mtx[0], mtx[1], mtx[2] );
 }
 
-VG_STATIC void skate_grind_friction( player_instance *player,
-                                     struct grind_info *inf, float strength )
-{
+static void skate_grind_friction( struct grind_info *inf, float strength ){
    v3f v2;
-   v3_muladds( player->rb.to_world[2], inf->n, 
-               -v3_dot( player->rb.to_world[2], inf->n ), v2 );
+   v3_muladds( localplayer.rb.to_world[2], inf->n, 
+               -v3_dot( localplayer.rb.to_world[2], inf->n ), v2 );
 
    float a        = 1.0f-fabsf( v3_dot( v2, inf->dir ) ),
-         dir      = vg_signf( v3_dot( player->rb.v, inf->dir ) ),
+         dir      = vg_signf( v3_dot( localplayer.rb.v, inf->dir ) ),
          F        = a * -dir * k_grind_max_friction;
 
-   v3_muladds( player->rb.v, inf->dir, F*k_rb_delta*strength, player->rb.v );
+   v3_muladds( localplayer.rb.v, inf->dir, F*vg.time_fixed_delta*strength, 
+               localplayer.rb.v );
 }
 
-VG_STATIC void skate_grind_decay( player_instance *player,
-                                  struct grind_info *inf, float strength )
-{
+static void skate_grind_decay( struct grind_info *inf, float strength ){
    m3x3f mtx, mtx_inv;
    skate_grind_orient( inf, mtx );
    m3x3_transpose( mtx, mtx_inv );
 
    v3f v_grind;
-   m3x3_mulv( mtx_inv, player->rb.v, 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, player->rb.v );
+   m3x3_mulv( mtx, v_grind, localplayer.rb.v );
 }
 
-VG_STATIC void skate_grind_truck_apply( player_instance *player,
-                                        float sign, struct grind_info *inf,
-                                        float strength )
-{
-   struct player_skate *s = &player->_skate;
-
+static void skate_grind_truck_apply( float sign, struct grind_info *inf,
+                                        float strength ){
+   struct player_skate_state *state = &player_skate.state;
    /* REFACTOR */
    v3f ra = { 0.0f, -k_board_radius, sign * k_board_length };
    v3f raw, wsp;
-   m3x3_mulv( player->rb.to_world, ra, raw );
-   v3_add( player->rb.co, raw, wsp );
+   m3x3_mulv( localplayer.rb.to_world, ra, raw );
+   v3_add( localplayer.rb.co, raw, wsp );
 
-   v3_copy( ra, s->weight_distribution );
+   v3_copy( ra, player_skate.weight_distribution );
 
    v3f delta;
    v3_sub( inf->co, wsp, delta );
 
    /* spring force */
-   v3_muladds( player->rb.v, delta, k_spring_force*strength*k_rb_delta, 
-               player->rb.v );
+   v3_muladds( localplayer.rb.v, delta, k_spring_force*strength*vg.time_fixed_delta, 
+               localplayer.rb.v );
 
-   skate_grind_decay( player, inf, strength );
-   skate_grind_friction( player, inf, strength );
+   skate_grind_decay( inf, strength );
+   skate_grind_friction( inf, strength );
 
    /* yeah yeah yeah yeah */
    v3f raw_nplane, axis;
@@ -1612,9 +1772,9 @@ VG_STATIC void skate_grind_truck_apply( player_instance *player,
    m3x3f mtx;
    skate_grind_orient( inf, mtx );
    v3f target_fwd, fwd, up, target_up;
-   m3x3_mulv( mtx, s->grind_vec, target_fwd );
+   m3x3_mulv( mtx, player_skate.grind_vec, target_fwd );
    v3_copy( raw_nplane, fwd );
-   v3_copy( player->rb.to_world[1], up );
+   v3_copy( localplayer.rb.to_world[1], up );
    v3_copy( inf->n, target_up );
 
    v3_muladds( target_fwd, inf->n, -v3_dot(inf->n,target_fwd), target_fwd );
@@ -1626,43 +1786,42 @@ VG_STATIC void skate_grind_truck_apply( player_instance *player,
    v2f steer;
    joystick_state( k_srjoystick_steer, steer );
 
-   float way = steer[1] * vg_signf( v3_dot( raw_nplane, player->rb.v ) );
+   float way = steer[1] * vg_signf( v3_dot( raw_nplane, localplayer.rb.v ) );
 
    v4f q;
    q_axis_angle( q, axis, VG_PIf*0.125f * way );
    q_mulv( q, target_up,  target_up );
    q_mulv( q, target_fwd, target_fwd );
 
-   rb_effect_spring_target_vector( &player->rb, up, target_up,
+   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( &player->rb, fwd, target_fwd,
+   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( player->rb.co, target_up, 1.0f, VG__GREEN );
-   vg_line_arrow( player->rb.co, fwd, 0.8f, VG__RED );
-   vg_line_arrow( player->rb.co, target_fwd, 1.0f, VG__YELOW );
+   vg_line_arrow( localplayer.rb.co, target_up, 1.0f, VG__GREEN );
+   vg_line_arrow( localplayer.rb.co, fwd, 0.8f, VG__RED );
+   vg_line_arrow( localplayer.rb.co, target_fwd, 1.0f, VG__YELOW );
 
-   s->grind_strength = strength;
+   player_skate.grind_strength = strength;
 
    /* Fake contact */
-   struct grind_limit *limit = &s->limits[ s->limit_count ++ ];
-   m4x3_mulv( player->rb.to_local, wsp, limit->ra );
-   m3x3_mulv( player->rb.to_local, inf->n, limit->n );
+   struct grind_limit *limit = 
+      &player_skate.limits[ player_skate.limit_count ++ ];
+   m4x3_mulv( localplayer.rb.to_local, wsp, limit->ra );
+   m3x3_mulv( localplayer.rb.to_local, inf->n, limit->n );
    limit->p = 0.0f;
 
-   v3_copy( inf->dir, s->grind_dir );
+   v3_copy( inf->dir, player_skate.grind_dir );
 }
 
-VG_STATIC void skate_5050_apply( player_instance *player, 
-                                 struct grind_info *inf_front,
-                                 struct grind_info *inf_back )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_5050_apply( struct grind_info *inf_front,
+                                 struct grind_info *inf_back ){
+   struct player_skate_state *state = &player_skate.state;
    struct grind_info inf_avg;
 
    v3_sub( inf_front->co, inf_back->co, inf_avg.dir );
@@ -1670,7 +1829,7 @@ VG_STATIC void skate_5050_apply( player_instance *player,
    v3_normalize( inf_avg.dir );
 
    /* dont ask */
-   v3_muls( inf_avg.dir, vg_signf(v3_dot(inf_avg.dir,player->rb.v)), 
+   v3_muls( inf_avg.dir, vg_signf(v3_dot(inf_avg.dir,localplayer.rb.v)), 
             inf_avg.dir );
 
    v3f axis_front, axis_back, axis;
@@ -1680,33 +1839,33 @@ VG_STATIC void skate_5050_apply( player_instance *player,
    v3_normalize( axis );
 
    v3_cross( axis, inf_avg.dir, inf_avg.n );
-   skate_grind_decay( player, &inf_avg, 1.0f );
+   skate_grind_decay( &inf_avg, 1.0f );
 
    v2f steer;
    joystick_state( k_srjoystick_steer, steer );
 
-   float way = steer[1] *
-                  vg_signf( v3_dot( player->rb.to_world[2], player->rb.v ) );
+   float way = steer[1] * vg_signf( v3_dot( localplayer.rb.to_world[2], 
+                                            localplayer.rb.v ) );
    v4f q;
    v3f up, target_up;
-   v3_copy( player->rb.to_world[1], up );
+   v3_copy( localplayer.rb.to_world[1], up );
    v3_copy( inf_avg.n, target_up );
-   q_axis_angle( q, player->rb.to_world[0], VG_PIf*0.25f * -way );
+   q_axis_angle( q, localplayer.rb.to_world[0], VG_PIf*0.25f * -way );
    q_mulv( q, target_up,  target_up );
 
-   v3_zero( s->weight_distribution );
-   s->weight_distribution[2] = k_board_length * -way;
+   v3_zero( player_skate.weight_distribution );
+   player_skate.weight_distribution[2] = k_board_length * -way;
 
-   rb_effect_spring_target_vector( &player->rb, up, target_up,
+   rb_effect_spring_target_vector( &localplayer.rb, up, target_up,
                                     k_grind_spring, 
                                     k_grind_dampener,
-                                    k_rb_delta );
-   vg_line_arrow( player->rb.co, up, 1.0f, VG__GREEN );
-   vg_line_arrow( player->rb.co, target_up, 1.0f, VG__GREEN );
+                                    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 );
 
    v3f fwd_nplane, dir_nplane;
-   v3_muladds( player->rb.to_world[2], inf_avg.n,
-               -v3_dot( player->rb.to_world[2], inf_avg.n ), fwd_nplane );
+   v3_muladds( localplayer.rb.to_world[2], inf_avg.n,
+               -v3_dot( localplayer.rb.to_world[2], inf_avg.n ), fwd_nplane );
 
    v3f dir;
    v3_muls( inf_avg.dir, v3_dot( fwd_nplane, inf_avg.dir ), dir );
@@ -1715,48 +1874,48 @@ VG_STATIC void skate_5050_apply( player_instance *player,
    v3_normalize( fwd_nplane );
    v3_normalize( dir_nplane );
 
-   rb_effect_spring_target_vector( &player->rb, fwd_nplane, dir_nplane,
+   rb_effect_spring_target_vector( &localplayer.rb, fwd_nplane, dir_nplane,
                                     1000.0f,
                                     k_grind_dampener,
-                                    k_rb_delta );
-   vg_line_arrow( player->rb.co, fwd_nplane, 0.8f, VG__RED );
-   vg_line_arrow( player->rb.co, dir_nplane, 0.8f, VG__RED );
+                                    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 );
 
    v3f pos_front = { 0.0f, -k_board_radius, -1.0f * k_board_length },
        pos_back  = { 0.0f, -k_board_radius,  1.0f * k_board_length },
        delta_front, delta_back, delta_total;
 
-   m4x3_mulv( player->rb.to_world, pos_front, pos_front );
-   m4x3_mulv( player->rb.to_world, pos_back,  pos_back  );
+   m4x3_mulv( localplayer.rb.to_world, pos_front, pos_front );
+   m4x3_mulv( localplayer.rb.to_world, pos_back,  pos_back  );
 
    v3_sub( inf_front->co, pos_front, delta_front );
    v3_sub( inf_back->co,  pos_back, delta_back );
    v3_add( delta_front, delta_back, delta_total );
 
-   v3_muladds( player->rb.v, delta_total, 50.0f * k_rb_delta, player->rb.v );
+   v3_muladds( localplayer.rb.v, delta_total, 50.0f * vg.time_fixed_delta, 
+               localplayer.rb.v );
 
    /* Fake contact */
-   struct grind_limit *limit = &s->limits[ s->limit_count ++ ];
+   struct grind_limit *limit = 
+      &player_skate.limits[ player_skate.limit_count ++ ];
    v3_zero( limit->ra );
-   m3x3_mulv( player->rb.to_local, inf_avg.n, limit->n );
+   m3x3_mulv( localplayer.rb.to_local, inf_avg.n, limit->n );
    limit->p = 0.0f;
 
-   v3_copy( inf_avg.dir, s->grind_dir );
+   v3_copy( inf_avg.dir, player_skate.grind_dir );
 }
 
-VG_STATIC int skate_grind_truck_renew( player_instance *player, float sign,
-                                       struct grind_info *inf )
-{
-   struct player_skate *s = &player->_skate;
+static int skate_grind_truck_renew( f32 sign, struct grind_info *inf ){
+   struct player_skate_state *state = &player_skate.state;
 
    v3f wheel_co = { 0.0f, 0.0f,            sign * k_board_length },
        grind_co = { 0.0f, -k_board_radius, sign * k_board_length };
 
-   m4x3_mulv( player->rb.to_world, wheel_co, wheel_co );
-   m4x3_mulv( player->rb.to_world, grind_co, grind_co );
+   m4x3_mulv( localplayer.rb.to_world, wheel_co, wheel_co );
+   m4x3_mulv( localplayer.rb.to_world, grind_co, grind_co );
 
    /* Exit condition: lost grind tracking */
-   if( !skate_grind_scansq( player, grind_co, player->rb.v, 0.3f, inf ) )
+   if( !skate_grind_scansq( grind_co, localplayer.rb.v, 0.3f, inf ) )
       return 0;
 
    /* Exit condition: cant see grind target directly */
@@ -1764,40 +1923,38 @@ VG_STATIC int skate_grind_truck_renew( player_instance *player, float sign,
       return 0;
 
    /* Exit condition: minimum velocity not reached, but allow a bit of error */
-   float dv   = fabsf(v3_dot( player->rb.v, inf->dir )),
+   float dv   = fabsf(v3_dot( localplayer.rb.v, inf->dir )),
          minv = k_grind_axel_min_vel*0.8f;
 
    if( dv < minv )
       return 0;
 
-   if( fabsf(v3_dot( inf->dir, s->grind_dir )) < k_grind_max_edge_angle )
+   if( fabsf(v3_dot( inf->dir, player_skate.grind_dir )) < k_grind_max_edge_angle )
       return 0;
 
-   v3_copy( inf->dir, s->grind_dir );
+   v3_copy( inf->dir, player_skate.grind_dir );
    return 1;
 }
 
-VG_STATIC int skate_grind_truck_entry( player_instance *player, float sign,
-                                       struct grind_info *inf )
-{
-   struct player_skate *s = &player->_skate;
+static int skate_grind_truck_entry( f32 sign, struct grind_info *inf ){
+   struct player_skate_state *state = &player_skate.state;
 
    /* REFACTOR */
    v3f ra = { 0.0f, -k_board_radius, sign * k_board_length };
 
    v3f raw, wsp;
-   m3x3_mulv( player->rb.to_world, ra, raw );
-   v3_add( player->rb.co, raw, wsp );
+   m3x3_mulv( localplayer.rb.to_world, ra, raw );
+   v3_add( localplayer.rb.co, raw, wsp );
 
-   if( skate_grind_scansq( player, wsp, player->rb.v, 0.3, inf ) )
-   {
-      if( fabsf(v3_dot( player->rb.v, inf->dir )) < k_grind_axel_min_vel )
+   if( skate_grind_scansq( wsp, localplayer.rb.v, 0.3, inf ) ){
+      if( fabsf(v3_dot( localplayer.rb.v, inf->dir )) < k_grind_axel_min_vel )
          return 0;
 
       /* velocity should be at least 60% aligned */
       v3f pv, axis;
       v3_cross( inf->n, inf->dir, axis );
-      v3_muladds( player->rb.v, inf->n, -v3_dot( player->rb.v, inf->n ), pv );
+      v3_muladds( localplayer.rb.v, inf->n, 
+                  -v3_dot( localplayer.rb.v, inf->n ), pv );
       
       if( v3_length2( pv ) < 0.0001f )
          return 0;
@@ -1806,27 +1963,21 @@ VG_STATIC int skate_grind_truck_entry( player_instance *player, float sign,
       if( fabsf(v3_dot( pv, inf->dir )) < k_grind_axel_max_angle )
          return 0;
 
-      if( v3_dot( player->rb.v, inf->n ) > 0.5f )
-         return 0;
-
-#if 0
-      /* check for vertical alignment */
-      if( v3_dot( player->rb.to_world[1], inf->n ) < k_grind_axel_max_vangle )
+      if( v3_dot( localplayer.rb.v, inf->n ) > 0.5f )
          return 0;
-#endif
       
       v3f local_co, local_dir, local_n;
-      m4x3_mulv( player->rb.to_local, inf->co,  local_co );
-      m3x3_mulv( player->rb.to_local, inf->dir, local_dir );
-      m3x3_mulv( player->rb.to_local, inf->n,   local_n );
+      m4x3_mulv( localplayer.rb.to_local, inf->co,  local_co );
+      m3x3_mulv( localplayer.rb.to_local, inf->dir, local_dir );
+      m3x3_mulv( localplayer.rb.to_local, inf->n,   local_n );
 
       v2f delta = { local_co[0], local_co[2] - k_board_length*sign };
 
       float truck_height = -(k_board_radius+0.03f);
 
       v3f rv;
-      v3_cross( player->rb.w, raw, rv );
-      v3_add( player->rb.v, rv, rv );
+      v3_cross( localplayer.rb.w, raw, rv );
+      v3_add( localplayer.rb.v, rv, rv );
 
       if( (local_co[1] >= truck_height) &&
           (v2_length2( delta ) <= k_board_radius*k_board_radius) )
@@ -1838,23 +1989,21 @@ VG_STATIC int skate_grind_truck_entry( player_instance *player, float sign,
    return 0;
 }
 
-VG_STATIC void skate_boardslide_apply( player_instance *player,
-                                       struct grind_info *inf )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_boardslide_apply( struct grind_info *inf ){
+   struct player_skate_state *state = &player_skate.state;
 
    v3f local_co, local_dir, local_n;
-   m4x3_mulv( player->rb.to_local, inf->co, local_co );
-   m3x3_mulv( player->rb.to_local, inf->dir, local_dir );
-   m3x3_mulv( player->rb.to_local, inf->n, local_n );
+   m4x3_mulv( localplayer.rb.to_local, inf->co, local_co );
+   m3x3_mulv( localplayer.rb.to_local, inf->dir, local_dir );
+   m3x3_mulv( localplayer.rb.to_local, inf->n, local_n );
 
    v3f intersection;
    v3_muladds( local_co, local_dir, local_co[0]/-local_dir[0], 
                intersection );
-   v3_copy( intersection, s->weight_distribution );
+   v3_copy( intersection, player_skate.weight_distribution );
 
-   skate_grind_decay( player, inf, 0.0125f );
-   skate_grind_friction( player, inf, 0.25f );
+   skate_grind_decay( inf, 0.0125f );
+   skate_grind_friction( inf, 0.25f );
 
    /* direction alignment */
    v3f dir, perp;
@@ -1862,47 +2011,45 @@ VG_STATIC void skate_boardslide_apply( player_instance *player,
    v3_muls( local_dir, vg_signf(local_dir[0]), dir );
    v3_muls( perp, vg_signf(perp[2]), perp );
 
-   m3x3_mulv( player->rb.to_world, dir, dir );
-   m3x3_mulv( player->rb.to_world, perp, perp );
+   m3x3_mulv( localplayer.rb.to_world, dir, dir );
+   m3x3_mulv( localplayer.rb.to_world, perp, perp );
 
    v4f qbalance;
    q_axis_angle( qbalance, dir, local_co[0]*k_grind_balance );
    q_mulv( qbalance, perp, perp );
 
-   rb_effect_spring_target_vector( &player->rb, player->rb.to_world[0],
+   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( &player->rb, player->rb.to_world[2],
+   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( player->rb.co, dir, 0.5f, VG__GREEN );
-   vg_line_arrow( player->rb.co, perp, 0.5f, VG__BLUE );
+   vg_line_arrow( localplayer.rb.co, dir, 0.5f, VG__GREEN );
+   vg_line_arrow( localplayer.rb.co, perp, 0.5f, VG__BLUE );
 
-   v3_copy( inf->dir, s->grind_dir );
+   v3_copy( inf->dir, player_skate.grind_dir );
 }
 
-VG_STATIC int skate_boardslide_entry( player_instance *player,
-                                      struct grind_info *inf )
-{
-   struct player_skate *s = &player->_skate;
+static int skate_boardslide_entry( struct grind_info *inf ){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( skate_grind_scansq( player, player->rb.co, 
-                           player->rb.to_world[0], k_board_length,
+   if( skate_grind_scansq( localplayer.rb.co, 
+                           localplayer.rb.to_world[0], k_board_length,
                            inf ) )
    {
       v3f local_co, local_dir;
-      m4x3_mulv( player->rb.to_local, inf->co, local_co );
-      m3x3_mulv( player->rb.to_local, inf->dir, local_dir );
+      m4x3_mulv( localplayer.rb.to_local, inf->co, local_co );
+      m3x3_mulv( localplayer.rb.to_local, inf->dir, local_dir );
 
       if( (fabsf(local_co[2]) <= k_board_length) &&   /* within wood area */
           (local_co[1] >= 0.0f) &&                    /* at deck level */
           (fabsf(local_dir[0]) >= 0.25f) )            /* perpendicular to us */
       {
-         if( fabsf(v3_dot( player->rb.v, inf->dir )) < k_grind_axel_min_vel )
+         if( fabsf(v3_dot( localplayer.rb.v, inf->dir )) < k_grind_axel_min_vel )
             return 0;
 
          return 1;
@@ -1912,63 +2059,58 @@ VG_STATIC int skate_boardslide_entry( player_instance *player,
    return 0;
 }
 
-VG_STATIC int skate_boardslide_renew( player_instance *player,
-                                      struct grind_info *inf )
-{
-   struct player_skate *s = &player->_skate;
+static int skate_boardslide_renew( struct grind_info *inf ){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( !skate_grind_scansq( player, player->rb.co, 
-                            player->rb.to_world[0], k_board_length,
+   if( !skate_grind_scansq( localplayer.rb.co, 
+                            localplayer.rb.to_world[0], k_board_length,
                             inf ) )
       return 0;
 
    /* Exit condition: cant see grind target directly */
    v3f vis;
-   v3_muladds( player->rb.co, player->rb.to_world[1], 0.2f, vis );
+   v3_muladds( localplayer.rb.co, localplayer.rb.to_world[1], 0.2f, vis );
    if( !skate_point_visible( vis, inf->co ) )
       return 0;
 
    /* Exit condition: minimum velocity not reached, but allow a bit of error */
-   float dv   = fabsf(v3_dot( player->rb.v, inf->dir )),
+   float dv   = fabsf(v3_dot( localplayer.rb.v, inf->dir )),
          minv = k_grind_axel_min_vel*0.8f;
 
    if( dv < minv )
       return 0;
 
-   if( fabsf(v3_dot( inf->dir, s->grind_dir )) < k_grind_max_edge_angle )
+   if( fabsf(v3_dot( inf->dir, player_skate.grind_dir )) < k_grind_max_edge_angle )
       return 0;
 
    return 1;
 }
 
-VG_STATIC void skate_store_grind_vec( player_instance *player,
-                                      struct grind_info *inf )
-{
-   struct player_skate *s = &player->_skate;
+static void skate_store_grind_vec( struct grind_info *inf ){
+   struct player_skate_state *state = &player_skate.state;
 
    m3x3f mtx;
    skate_grind_orient( inf, mtx );
    m3x3_transpose( mtx, mtx );
 
    v3f raw;
-   v3_sub( inf->co, player->rb.co, raw );
+   v3_sub( inf->co, localplayer.rb.co, raw );
 
-   m3x3_mulv( mtx, raw, s->grind_vec );
-   v3_normalize( s->grind_vec );
-   v3_copy( inf->dir, s->grind_dir );
+   m3x3_mulv( mtx, raw, player_skate.grind_vec );
+   v3_normalize( player_skate.grind_vec );
+   v3_copy( inf->dir, player_skate.grind_dir );
 }
 
-VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+static enum skate_activity skate_availible_grind(void){
+   struct player_skate_state *state = &player_skate.state;
 
-   if( s->state.grind_cooldown > 100 ){
+   if( state->grind_cooldown > 100 ){
       vg_fatal_error( "wth!\n" );
    }
 
    /* debounces this state manager a little bit */
-   if( s->state.grind_cooldown ){
-      s->state.grind_cooldown --;
+   if( state->grind_cooldown ){
+      state->grind_cooldown --;
       return k_skate_activity_undefined;
    }
 
@@ -1986,52 +2128,52 @@ VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
    v2f steer;
    joystick_state( k_srjoystick_steer, steer );
 
-   if( s->state.activity == k_skate_activity_grind_5050 || 
-       s->state.activity == k_skate_activity_grind_back50 ||
-       s->state.activity == k_skate_activity_grind_front50 )
+   if( state->activity == k_skate_activity_grind_5050 || 
+       state->activity == k_skate_activity_grind_back50 ||
+       state->activity == k_skate_activity_grind_front50 )
    {
       float tilt = steer[1];
 
       if( fabsf(tilt) >= 0.25f ){
          v3f raw = {0.0f,0.0f,tilt};
-         m3x3_mulv( player->rb.to_world, raw, raw );
+         m3x3_mulv( localplayer.rb.to_world, raw, raw );
 
-         float way = tilt * vg_signf( v3_dot( raw, player->rb.v ) );
+         float way = tilt * vg_signf( v3_dot( raw, localplayer.rb.v ) );
 
          if( way < 0.0f ) allow_front = 0;
          else allow_back = 0;
       }
    }
 
-   if( s->state.activity == k_skate_activity_grind_boardslide ){
-      res_slide = skate_boardslide_renew( player, &inf_slide );
+   if( state->activity == k_skate_activity_grind_boardslide ){
+      res_slide = skate_boardslide_renew( &inf_slide );
    }
-   else if( s->state.activity == k_skate_activity_grind_back50 ){
-      res_back50  = skate_grind_truck_renew( player,  1.0f, &inf_back50 );
+   else if( state->activity == k_skate_activity_grind_back50 ){
+      res_back50  = skate_grind_truck_renew( 1.0f, &inf_back50 );
 
       if( allow_front )
-         res_front50 = skate_grind_truck_entry( player, -1.0f, &inf_front50 );
+         res_front50 = skate_grind_truck_entry( -1.0f, &inf_front50 );
    }
-   else if( s->state.activity == k_skate_activity_grind_front50 ){
-      res_front50 = skate_grind_truck_renew( player, -1.0f, &inf_front50 );
+   else if( state->activity == k_skate_activity_grind_front50 ){
+      res_front50 = skate_grind_truck_renew( -1.0f, &inf_front50 );
 
       if( allow_back )
-         res_back50  = skate_grind_truck_entry( player,  1.0f, &inf_back50 );
+         res_back50  = skate_grind_truck_entry(  1.0f, &inf_back50 );
    }
-   else if( s->state.activity == k_skate_activity_grind_5050 ){
+   else if( state->activity == k_skate_activity_grind_5050 ){
       if( allow_front )
-         res_front50 = skate_grind_truck_renew( player, -1.0f, &inf_front50 );
+         res_front50 = skate_grind_truck_renew( -1.0f, &inf_front50 );
       if( allow_back )
-         res_back50  = skate_grind_truck_renew( player,  1.0f, &inf_back50 );
+         res_back50  = skate_grind_truck_renew(  1.0f, &inf_back50 );
    }
    else{
-      res_slide   = skate_boardslide_entry( player, &inf_slide );
+      res_slide   = skate_boardslide_entry( &inf_slide );
 
       if( allow_back )
-         res_back50  = skate_grind_truck_entry( player,  1.0f, &inf_back50 );
+         res_back50  = skate_grind_truck_entry(  1.0f, &inf_back50 );
 
       if( allow_front )
-         res_front50 = skate_grind_truck_entry( player, -1.0f, &inf_front50 );
+         res_front50 = skate_grind_truck_entry( -1.0f, &inf_front50 );
 
       if( res_back50 != res_front50 ){
          int wants_to_do_that = fabsf(steer[1]) >= 0.25f;
@@ -2057,48 +2199,53 @@ VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
    , new_activity = table[ res_slide << 2 | res_back50 << 1 | res_front50 ];
 
    if(      new_activity == k_skate_activity_undefined ){
-      if( s->state.activity >= k_skate_activity_grind_any ){
-         s->state.grind_cooldown = 15;
-         s->state.surface_cooldown = 10;
+      if( state->activity >= k_skate_activity_grind_any ){
+         state->grind_cooldown = 15;
+         state->surface_cooldown = 10;
       }
    }
    else if( new_activity == k_skate_activity_grind_boardslide ){
-      skate_boardslide_apply( player, &inf_slide );
+      skate_boardslide_apply( &inf_slide );
    }
    else if( new_activity == k_skate_activity_grind_back50 ){
-      if( s->state.activity != k_skate_activity_grind_back50 )
-         skate_store_grind_vec( player, &inf_back50 );
+      if( state->activity != k_skate_activity_grind_back50 )
+         skate_store_grind_vec( &inf_back50 );
 
-      skate_grind_truck_apply( player,  1.0f, &inf_back50, 1.0f );
+      skate_grind_truck_apply(  1.0f, &inf_back50, 1.0f );
    }
    else if( new_activity == k_skate_activity_grind_front50 ){
-      if( s->state.activity != k_skate_activity_grind_front50 )
-         skate_store_grind_vec( player, &inf_front50 );
+      if( state->activity != k_skate_activity_grind_front50 )
+         skate_store_grind_vec( &inf_front50 );
 
-      skate_grind_truck_apply( player, -1.0f, &inf_front50, 1.0f );
+      skate_grind_truck_apply( -1.0f, &inf_front50, 1.0f );
    }
    else if( new_activity == k_skate_activity_grind_5050 )
-      skate_5050_apply( player, &inf_front50, &inf_back50 );
+      skate_5050_apply( &inf_front50, &inf_back50 );
 
    return new_activity;
 }
 
-VG_STATIC void player__skate_update( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
+void player__skate_update(void){
+   struct player_skate_state *state = &player_skate.state;
    world_instance *world = world_current_instance();
 
+   if( state->activity == k_skate_activity_handplant ){
+      return;
+   }
+
    if( world->water.enabled ){
-      if( player->rb.co[1]+0.25f < world->water.height ){
-         audio_oneshot_3d( &audio_splash, player->rb.co, 40.0f, 1.0f );
-         player__skate_kill_audio( player );
-         player__dead_transition( player );
+      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__dead_transition( k_player_die_type_generic );
          return;
       }
    }
 
-   v3_copy( player->rb.co, s->state.prev_pos );
-   s->state.activity_prev = s->state.activity;
+   v3_copy( localplayer.rb.co, state->prev_pos );
+   state->activity_prev = state->activity;
    v3f normal_total;
    v3_zero( normal_total );
 
@@ -2133,128 +2280,134 @@ VG_STATIC void player__skate_update( player_instance *player )
 
    float slap = 0.0f;
 
-   if( s->state.activity <= k_skate_activity_air_to_grind ){
+   if( state->activity <= k_skate_activity_air_to_grind ){
       float min_dist = 0.6f;
       for( int i=0; i<2; i++ ){
          v3f wpos, closest;
-         m4x3_mulv( player->rb.to_world, wheels[i].pos, wpos );
+         m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, wpos );
 
          if( bh_closest_point( world->geo_bh, wpos, closest, min_dist ) != -1 ){
             min_dist = vg_minf( min_dist, v3_dist( closest, wpos ) );
          }
       }
       min_dist -= 0.2f;
-      float vy = v3_dot( player->basis[1], player->rb.v );
-            vy = vg_maxf( 0.0f, vy );
-
+      float vy = vg_maxf( 0.0f, localplayer.rb.v[1] );
       slap = vg_clampf( (min_dist/0.5f) + vy, 0.0f, 1.0f )*0.3f;
    }
-   s->state.slap = vg_lerpf( s->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] = s->state.slap;
-   wheels[1].pos[1] = s->state.slap;
+   wheels[0].pos[1] = state->slap;
+   wheels[1].pos[1] = state->slap;
 
 
    const int k_wheel_count = 2;
 
-   s->substep = k_rb_delta;
-   s->substep_delta = s->substep;
-   s->limit_count = 0;
+   player_skate.substep = vg.time_fixed_delta;
+   player_skate.substep_delta = player_skate.substep;
+   player_skate.limit_count = 0;
 
    int substep_count = 0;
 
-   v3_zero( s->surface_picture );
+   v3_zero( player_skate.surface_picture );
 
    int prev_contacts[2];
 
    for( int i=0; i<k_wheel_count; i++ ){
       wheels[i].state = k_collider_state_default;
-      prev_contacts[i] = s->wheel_contacts[i];
+      prev_contacts[i] = player_skate.wheel_contacts[i];
    }
 
    /* check if we can enter or continue grind */
-   enum skate_activity grindable_activity = skate_availible_grind( player );
+   enum skate_activity grindable_activity = skate_availible_grind();
    if( grindable_activity != k_skate_activity_undefined ){
-      s->state.activity = grindable_activity;
+      state->activity = grindable_activity;
       goto grinding;
    }
 
    int contact_count = 0;
    for( int i=0; i<2; i++ ){
       v3f normal, axel;
-      v3_copy( player->rb.to_world[0], axel );
+      v3_copy( localplayer.rb.to_world[0], axel );
 
-      if( skate_compute_surface_alignment( player, wheels[i].pos, 
+      if( skate_compute_surface_alignment( wheels[i].pos, 
                                            wheels[i].colour, normal, axel ) )
       {
-         rb_effect_spring_target_vector( &player->rb, player->rb.to_world[0],
+         rb_effect_spring_target_vector( &localplayer.rb, 
+                                          localplayer.rb.to_world[0],
                                           axel,
                                           k_surface_spring, k_surface_dampener,
-                                          s->substep_delta );
+                                          player_skate.substep_delta );
 
-         v3_add( normal, s->surface_picture, s->surface_picture );
+         v3_add( normal, player_skate.surface_picture, 
+                 player_skate.surface_picture );
          contact_count ++;
-         s->wheel_contacts[i] = 1;
+         player_skate.wheel_contacts[i] = 1;
       }
       else{
-         s->wheel_contacts[i] = 0;
+         player_skate.wheel_contacts[i] = 0;
       }
 
-      m3x3_mulv( player->rb.to_local, axel, s->truckv0[i] );
+      m3x3_mulv( localplayer.rb.to_local, axel, player_skate.truckv0[i] );
    }
 
-   if( s->state.surface_cooldown ){
-      s->state.surface_cooldown --;
+   if( state->surface_cooldown ){
+      state->surface_cooldown --;
       contact_count = 0;
    }
 
    if( (prev_contacts[0]+prev_contacts[1] == 1) && (contact_count == 2) ){
-      audio_lock();
       for( int i=0; i<2; i++ ){
          if( !prev_contacts[i] ){
             v3f co;
-            m4x3_mulv( player->rb.to_world, wheels[i].pos, co );
-            audio_oneshot_3d( &audio_taps[vg_randu32()%4], co, 40.0f, 0.75f );
+            m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, co );
+            player__networked_sfx( k_player_subsystem_skate, 32, 
+                                   k_player_skate_soundeffect_tap,
+                                   localplayer.rb.co, 0.75f );
          }
       }
-      audio_unlock();
    }
 
    if( contact_count ){
-      s->state.activity = k_skate_activity_ground;
-      s->state.gravity_bias = k_gravity;
-      v3_normalize( s->surface_picture );
+      state->activity = k_skate_activity_ground;
+      state->gravity_bias = k_gravity;
+      v3_normalize( player_skate.surface_picture );
 
-      skate_apply_friction_model( player );
-      skate_weight_distribute( player );
+      skate_apply_friction_model();
+      skate_weight_distribute();
    }
    else{
-      if( s->state.activity > k_skate_activity_air_to_grind )
-         s->state.activity = k_skate_activity_air;
+      if( state->activity > k_skate_activity_air_to_grind )
+         state->activity = k_skate_activity_air;
 
-      v3_zero( s->weight_distribution );
-      skate_apply_air_model( player );
+      v3_zero( player_skate.weight_distribution );
+      skate_apply_air_model();
    }
 
 grinding:;
 
-   if( s->state.activity == k_skate_activity_grind_back50 )
+   if( state->activity == k_skate_activity_grind_back50 )
       wheels[1].state = k_collider_state_disabled;
-   if( s->state.activity == k_skate_activity_grind_front50 )
+   if( state->activity == k_skate_activity_grind_front50 )
       wheels[0].state = k_collider_state_disabled;
-   if( s->state.activity == k_skate_activity_grind_5050 ){
+   if( state->activity == k_skate_activity_grind_5050 ){
       wheels[0].state = k_collider_state_disabled;
       wheels[1].state = k_collider_state_disabled;
    }
 
    /* all activities */
-   skate_apply_steering_model( player );
-   skate_adjust_up_direction( player );
-   skate_apply_cog_model( player );
-   skate_apply_jump_model( player );
-   skate_apply_grab_model( player );
-   skate_apply_trick_model( player );
-   skate_apply_pump_model( player );
+   skate_apply_steering_model();
+   skate_adjust_up_direction();
+   skate_apply_cog_model();
+   skate_apply_jump_model();
+   skate_apply_handplant_model();
+   skate_apply_grab_model();
+   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:;
 
@@ -2264,35 +2417,36 @@ begin_collision:;
     */
 
    v3f head_wp0, head_wp1, start_co;
-   m4x3_mulv( player->rb.to_world, s->state.head_position, head_wp0 );
-   v3_copy( player->rb.co, start_co );
+   m4x3_mulv( localplayer.rb.to_world, state->head_position, head_wp0 );
+   v3_copy( localplayer.rb.co, start_co );
 
    /* calculate transform one step into future */
    v3f future_co;
    v4f future_q;
-   v3_muladds( player->rb.co, player->rb.v, s->substep, future_co );
+   v3_muladds( localplayer.rb.co, localplayer.rb.v, player_skate.substep, 
+               future_co );
 
-   if( v3_length2( player->rb.w ) > 0.0f ){
+   if( v3_length2( localplayer.rb.w ) > 0.0f ){
       v4f rotation;
       v3f axis;
-      v3_copy( player->rb.w, axis );
+      v3_copy( localplayer.rb.w, axis );
       
       float mag = v3_length( axis );
       v3_divs( axis, mag, axis );
-      q_axis_angle( rotation, axis, mag*s->substep );
-      q_mul( rotation, player->rb.q, future_q );
+      q_axis_angle( rotation, axis, mag*player_skate.substep );
+      q_mul( rotation, localplayer.rb.q, future_q );
       q_normalize( future_q );
    }
    else
-      v4_copy( player->rb.q, future_q );
+      v4_copy( localplayer.rb.q, future_q );
 
    v3f future_cg, current_cg, cg_offset;
-   q_mulv( player->rb.q, s->weight_distribution, current_cg );
-   q_mulv( future_q, s->weight_distribution, future_cg );
+   q_mulv( localplayer.rb.q, player_skate.weight_distribution, current_cg );
+   q_mulv( future_q, player_skate.weight_distribution, future_cg );
    v3_sub( future_cg, current_cg, cg_offset );
 
    /* calculate the minimum time we can move */
-   float max_time = s->substep;
+   float max_time = player_skate.substep;
 
    for( int i=0; i<k_wheel_count; i++ ){
       if( wheels[i].state == k_collider_state_disabled )
@@ -2304,48 +2458,49 @@ begin_collision:;
       v3_add( future, future_co, future );
       v3_add( cg_offset, future, future );
 
-      q_mulv( player->rb.q, wheels[i].pos, current );
-      v3_add( current, player->rb.co, current );
+      q_mulv( localplayer.rb.q, wheels[i].pos, current );
+      v3_add( current, localplayer.rb.co, current );
       
       float t;
       v3f n;
 
       float cast_radius = wheels[i].radius - k_penetration_slop * 2.0f;
-      if( spherecast_world( world, current, future, cast_radius, &t, n ) != -1)
-         max_time = vg_minf( max_time, t * s->substep );
+      if( spherecast_world( world, current, future, cast_radius, &t, n,
+                            k_material_flag_walking ) != -1)
+         max_time = vg_minf( max_time, t * player_skate.substep );
    }
 
    /* 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 );
-   s->substep_delta = max_time;
+   player_skate.substep_delta = max_time;
 
    /* integrate */
-   v3_muladds( player->rb.co, player->rb.v, s->substep_delta, player->rb.co );
-   if( v3_length2( player->rb.w ) > 0.0f ){
+   v3_muladds( localplayer.rb.co, localplayer.rb.v, 
+               player_skate.substep_delta, localplayer.rb.co );
+   if( v3_length2( localplayer.rb.w ) > 0.0f ){
       v4f rotation;
       v3f axis;
-      v3_copy( player->rb.w, axis );
+      v3_copy( localplayer.rb.w, axis );
       
       float mag = v3_length( axis );
       v3_divs( axis, mag, axis );
-      q_axis_angle( rotation, axis, mag*s->substep_delta );
-      q_mul( rotation, player->rb.q, player->rb.q );
-      q_normalize( player->rb.q );
+      q_axis_angle( rotation, axis, mag*player_skate.substep_delta );
+      q_mul( rotation, localplayer.rb.q, localplayer.rb.q );
+      q_normalize( localplayer.rb.q );
 
-      q_mulv( player->rb.q, s->weight_distribution, future_cg );
+      q_mulv( localplayer.rb.q, player_skate.weight_distribution, future_cg );
       v3_sub( current_cg, future_cg, cg_offset );
-      v3_add( player->rb.co, cg_offset, player->rb.co );
+      v3_add( localplayer.rb.co, cg_offset, localplayer.rb.co );
    }
 
-   rb_update_transform( &player->rb );
-   v3_muladds( player->rb.v, player->basis[1],
-               -s->state.gravity_bias * s->substep_delta, player->rb.v );
+   rb_update_matrices( &localplayer.rb );
+   localplayer.rb.v[1] += -state->gravity_bias * player_skate.substep_delta;
 
-   s->substep -= s->substep_delta;
+   player_skate.substep -= player_skate.substep_delta;
 
    rb_ct manifold[128];
    int manifold_len = 0;
@@ -2353,18 +2508,19 @@ begin_collision:;
     * Phase -1: head detection
     * --------------------------------------------------------------------------
     */
-   m4x3_mulv( player->rb.to_world, s->state.head_position, head_wp1 );
+   m4x3_mulv( localplayer.rb.to_world, state->head_position, head_wp1 );
 
    float t;
    v3f n;
    if( (v3_dist2( head_wp0, head_wp1 ) > 0.001f) &&
-       (spherecast_world( world, head_wp0, head_wp1, 0.2f, &t, n ) != -1) )
+       (spherecast_world( world, head_wp0, head_wp1, 0.2f, &t, n,
+                          k_material_flag_walking ) != -1) )
    {
-      v3_lerp( start_co, player->rb.co, t, player->rb.co );
-      rb_update_transform( &player->rb );
+      v3_lerp( start_co, localplayer.rb.co, t, localplayer.rb.co );
+      rb_update_matrices( &localplayer.rb );
 
-      player__skate_kill_audio( player );
-      player__dead_transition( player );
+      vg_info( "player fell of due to hitting head\n" );
+      player__dead_transition( k_player_die_type_head );
       return;
    }
 
@@ -2379,13 +2535,11 @@ begin_collision:;
 
       m4x3f mtx;
       m3x3_identity( mtx );
-      m4x3_mulv( player->rb.to_world, wheels[i].pos, mtx[3] );
-      
-      rb_sphere collider = { .radius = wheels[i].radius };
+      m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, mtx[3] );
 
       rb_ct *man = &manifold[ manifold_len ];
 
-      int l = skate_collide_smooth( player, mtx, &collider, man );
+      int l = skate_collide_smooth( mtx, wheels[i].radius, man );
       if( l )
          wheels[i].state = k_collider_state_colliding;
 
@@ -2393,19 +2547,19 @@ 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( player->rb.to_world[0],  1.0f, mtx[0] );
-   v3_muls( player->rb.to_world[2], -1.0f, mtx[1] );
-   v3_muls( player->rb.to_world[1],  1.0f, mtx[2] );
-   v3_muladds( player->rb.to_world[3], player->rb.to_world[1], 
-               grind_radius + k_board_radius*0.25f+s->state.slap, mtx[3] );
+   v3_muls( localplayer.rb.to_world[0],  1.0f, mtx[0] );
+   v3_muls( localplayer.rb.to_world[2], -1.0f, mtx[1] );
+   v3_muls( localplayer.rb.to_world[1],  1.0f, mtx[2] );
+   v3_muladds( localplayer.rb.to_world[3], localplayer.rb.to_world[1], 
+               grind_radius + k_board_radius*0.25f+state->slap, mtx[3] );
 
    rb_ct *cman = &manifold[manifold_len];
 
-   int l = rb_capsule__scene( mtx, &capsule, NULL, &world->rb_geo.inf.scene,
-                              cman );
+   int l = rb_capsule__scene( mtx, &capsule, NULL, world->geo_bh,
+                              cman, k_material_flag_walking );
 
    /* weld joints */
    for( int i=0; i<l; i ++ )
@@ -2414,17 +2568,15 @@ 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( s->state.activity >= k_skate_activity_grind_any ){
-      for( int i=0; i<s->limit_count; i++ ){
-         struct grind_limit *limit = &s->limits[i];
+   if( state->activity >= k_skate_activity_grind_any ){
+      for( int i=0; i<player_skate.limit_count; i++ ){
+         struct grind_limit *limit = &player_skate.limits[i];
          rb_ct *ct = &manifold[ manifold_len ++ ];
-         m4x3_mulv( player->rb.to_world, limit->ra, ct->co );
-         m3x3_mulv( player->rb.to_world, limit->n, ct->n );
+         m4x3_mulv( localplayer.rb.to_world, limit->ra, ct->co );
+         m3x3_mulv( localplayer.rb.to_world, limit->n, ct->n );
          ct->p = limit->p;
          ct->type = k_contact_type_default;
       }
@@ -2437,16 +2589,17 @@ begin_collision:;
 
 
    v3f world_cog;
-   m4x3_mulv( player->rb.to_world, s->weight_distribution, world_cog );
+   m4x3_mulv( localplayer.rb.to_world, 
+              player_skate.weight_distribution, world_cog );
    vg_line_point( world_cog, 0.02f, VG__BLACK );
 
    for( int i=0; i<manifold_len; i ++ ){
-      rb_prepare_contact( &manifold[i], s->substep_delta );
+      rb_prepare_contact( &manifold[i], player_skate.substep_delta );
       rb_debug_contact( &manifold[i] );
    }
 
    /* yes, we are currently rebuilding mass matrices every frame. too bad! */
-   v3f extent = { k_board_width, 0.1f, k_board_length };
+   v3f extent = { k_board_width*10.0f, 0.1f, k_board_length };
    float ex2 = k_board_interia*extent[0]*extent[0],
          ey2 = k_board_interia*extent[1]*extent[1],
          ez2 = k_board_interia*extent[2]*extent[2];
@@ -2467,8 +2620,8 @@ begin_collision:;
    m3x3_inv( iI, iI );
 
    m3x3f iIw;
-   m3x3_mul( iI, player->rb.to_local, iIw );
-   m3x3_mul( player->rb.to_world, iIw, iIw );
+   m3x3_mul( iI, localplayer.rb.to_local, iIw );
+   m3x3_mul( localplayer.rb.to_world, iIw, iIw );
 
    for( int j=0; j<10; j++ ){
       for( int i=0; i<manifold_len; i++ ){
@@ -2476,12 +2629,12 @@ 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 ); 
-         v3_cross( player->rb.w, delta, rv );
-         v3_add( player->rb.v, rv, rv );
+         v3_cross( localplayer.rb.w, delta, rv );
+         v3_add( localplayer.rb.v, rv, rv );
 
          v3f raCn;
          v3_cross( delta, ct->n, raCn );
@@ -2501,25 +2654,25 @@ begin_collision:;
          v3_muls( ct->n, lambda, impulse );
 
          v3_muladds( normal_total, impulse, inv_mass, normal_total );
-         v3_muladds( player->rb.v, impulse, inv_mass, player->rb.v );
+         v3_muladds( localplayer.rb.v, impulse, inv_mass, localplayer.rb.v );
          v3_cross( delta, impulse, impulse );
          m3x3_mulv( iIw, impulse, impulse );
-         v3_add( impulse, player->rb.w, player->rb.w );
+         v3_add( impulse, localplayer.rb.w, localplayer.rb.w );
 
-         v3_cross( player->rb.w, delta, rv );
-         v3_add( player->rb.v, rv, rv );
+         v3_cross( localplayer.rb.w, delta, rv );
+         v3_add( localplayer.rb.v, rv, rv );
          vn = v3_dot( rv, ct->n );
       }
    }
 
    v3f dt;
    rb_depenetrate( manifold, manifold_len, dt );
-   v3_add( dt, player->rb.co, player->rb.co );
-   rb_update_transform( &player->rb );
+   v3_add( dt, localplayer.rb.co, localplayer.rb.co );
+   rb_update_matrices( &localplayer.rb );
 
    substep_count ++;
 
-   if( s->substep >= 0.0001f )
+   if( player_skate.substep >= 0.0001f )
       goto begin_collision;      /* again! */
 
    /* 
@@ -2530,118 +2683,144 @@ begin_collision:;
    f32 nforce = v3_length(normal_total);
    if( nforce > 4.0f ){
       if( nforce > 17.6f ){
-         v3_muladds( player->rb.v, normal_total, -1.0f, player->rb.v );
-         player__dead_transition(player);
-         player__skate_kill_audio(player);
+         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 );
          return;
       }
 
       f32 amt = k_cam_punch;
-      if( player->cam_control.camera_mode == k_cam_firstperson ){
+      if( localplayer.cam_control.camera_mode == k_cam_firstperson ){
          amt *= 0.25f;
       }
 
-      v3_muladds( player->cam_land_punch_v, normal_total, amt,
-                  player->cam_land_punch_v );
+      v3_muladds( localplayer.cam_land_punch_v, normal_total, amt,
+                  localplayer.cam_land_punch_v );
    }
 
-   s->surface = k_surface_prop_concrete;
+   player_skate.surface = k_surface_prop_concrete;
 
    for( int i=0; i<manifold_len; i++ ){
       rb_ct *ct = &manifold[i];
       struct world_surface *surf = world_contact_surface( world, ct );
 
-      if( surf->info.surface_prop > s->surface )
-         s->surface = surf->info.surface_prop;
+      if( surf->info.surface_prop > player_skate.surface )
+         player_skate.surface = surf->info.surface_prop;
    }
 
    for( int i=0; i<k_wheel_count; i++ ){
       m4x3f mtx;
-      m3x3_copy( player->rb.to_world, mtx );
-      m4x3_mulv( player->rb.to_world, wheels[i].pos, mtx[3] );
+      m3x3_copy( localplayer.rb.to_world, mtx );
+      m4x3_mulv( localplayer.rb.to_world, wheels[i].pos, mtx[3] );
       vg_line_sphere( mtx, wheels[i].radius,
                       (u32[]){ VG__WHITE, VG__BLACK, 
                             wheels[i].colour }[ wheels[i].state ]);
    }
 
-   skate_integrate( player );
-   vg_line_point( s->state.cog, 0.02f, VG__WHITE );
+   skate_integrate();
+   vg_line_point( state->cog, 0.02f, VG__WHITE );
+
+   u32 id = world_intersect_gates( world, localplayer.rb.co, state->prev_pos );
 
-   ent_gate *gate = 
-      world_intersect_gates(world, player->rb.co, s->state.prev_pos );
+   if( id ){
+      ent_gate *gate = mdl_arritm( &world->ent_gate, mdl_entity_id_id(id) );
 
-   if( gate ){
-      m4x3_mulv( gate->transport, player->rb.co, player->rb.co );
-      m3x3_mulv( gate->transport, player->rb.v,  player->rb.v );
-      m4x3_mulv( gate->transport, s->state.cog,   s->state.cog );
-      m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
-      m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
-      m3x3_mulv( gate->transport, s->state.head_position,
-                                  s->state.head_position );
-      m3x3_mulv( gate->transport, s->state.up_dir, s->state.up_dir );
+      m4x3_mulv( gate->transport, localplayer.rb.co, localplayer.rb.co );
+      m3x3_mulv( gate->transport, localplayer.rb.v,  localplayer.rb.v );
+      m4x3_mulv( gate->transport, state->cog,   state->cog );
+      m3x3_mulv( gate->transport, state->cog_v, state->cog_v );
+      m3x3_mulv( gate->transport, state->throw_v, state->throw_v );
+      m3x3_mulv( gate->transport, state->head_position,
+                                  state->head_position );
+      m3x3_mulv( gate->transport, state->up_dir, state->up_dir );
 
       v4f transport_rotation;
       m3x3_q( gate->transport, transport_rotation );
-      q_mul( transport_rotation, player->rb.q, player->rb.q );
-      q_mul( transport_rotation, s->state.smoothed_rotation,
-                                 s->state.smoothed_rotation );
-      rb_update_transform( &player->rb );
-      player__pass_gate( player, gate );
+      q_mul( transport_rotation, localplayer.rb.q, localplayer.rb.q );
+      q_mul( transport_rotation, state->smoothed_rotation,
+                                 state->smoothed_rotation );
+      q_normalize( localplayer.rb.q );
+      q_normalize( state->smoothed_rotation );
+      rb_update_matrices( &localplayer.rb );
+      player__pass_gate( id );
    }
 
    /* FIXME: Rate limit */
    static int stick_frames = 0;
 
-   if( s->state.activity >= k_skate_activity_ground )
+   if( state->activity >= k_skate_activity_ground )
       stick_frames ++;
    else
       stick_frames = 0;
 
-   if( stick_frames >  5 ) stick_frames =  5;
+   if( stick_frames > 5 ) stick_frames =  5;
 
    if( stick_frames == 4 ){
-      audio_lock();
-
-      if( s->state.activity == k_skate_activity_ground ){
-         if( (fabsf(s->state.slip) > 0.75f) ){
-            audio_oneshot_3d( &audio_lands[vg_randu32()%2+3], player->rb.co, 
-                              40.0f, 1.0f );
+      if( state->activity == k_skate_activity_ground ){
+         if( (fabsf(state->slip) > 0.75f) ){
+            player__networked_sfx( k_player_subsystem_skate, 128, 
+                                   k_player_skate_soundeffect_land_bad,
+                                   localplayer.rb.co, 0.6f );
          }
          else{
-            audio_oneshot_3d( &audio_lands[vg_randu32()%3], player->rb.co, 
-                              40.0f, 1.0f );
+            player__networked_sfx( k_player_subsystem_skate, 128, 
+                                   k_player_skate_soundeffect_land_good,
+                                   localplayer.rb.co, 1.0f );
          }
       }
-      else if( s->surface == k_surface_prop_metal ){
-         audio_oneshot_3d( &audio_board[3], player->rb.co, 40.0f, 1.0f );
+      else if( player_skate.surface == k_surface_prop_metal ){
+         player__networked_sfx( k_player_subsystem_skate, 128, 
+                                k_player_skate_soundeffect_grind_metal,
+                                localplayer.rb.co, 1.0f );
       }
       else{
-         audio_oneshot_3d( &audio_board[8], player->rb.co, 40.0f, 1.0f );
+         player__networked_sfx( k_player_subsystem_skate, 128, 
+                                k_player_skate_soundeffect_grind_wood,
+                                localplayer.rb.co, 1.0f );
       }
-
-      audio_unlock();
    } else if( stick_frames == 0 ){
-      
+      /* TODO: EXIT SOUNDS */
+   }
+
+   if( (state->activity_prev < k_skate_activity_grind_any) && 
+       (state->activity >= k_skate_activity_grind_any) ){
+      state->velocity_limit = v3_length( localplayer.rb.v )*1.0f;
+      state->grind_y_start = localplayer.rb.co[1];
+   }
+
+   if( state->activity >= k_skate_activity_grind_any ){
+      f32 dy = localplayer.rb.co[1] - state->grind_y_start;
+      if( dy < 0.0f ){
+         state->velocity_limit += -dy*0.2f;
+      }
+      state->grind_y_start = localplayer.rb.co[1];
+
+
+      f32 speed_end = v3_length( localplayer.rb.v );
+      if( speed_end > state->velocity_limit ){
+         v3_muls( localplayer.rb.v, state->velocity_limit/speed_end, 
+                  localplayer.rb.v );
+      }
    }
 }
 
-VG_STATIC void player__skate_im_gui( player_instance *player ){
-   struct player_skate *s = &player->_skate;
-   player__debugtext( 1, "V:  %5.2f %5.2f %5.2f",player->rb.v[0],
-                                                player->rb.v[1],
-                                                player->rb.v[2] );
-   player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",player->rb.co[0],
-                                                player->rb.co[1],
-                                                player->rb.co[2] );
-   player__debugtext( 1, "W:  %5.2f %5.2f %5.2f",player->rb.w[0],
-                                                player->rb.w[1],
-                                                player->rb.w[2] );
-
-   const char *activity_txt[] = 
-   {
+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],
+                                                localplayer.rb.v[2] );
+   player__debugtext( 1, "CO: %5.2f %5.2f %5.2f",localplayer.rb.co[0],
+                                                localplayer.rb.co[1],
+                                                localplayer.rb.co[2] );
+   player__debugtext( 1, "W:  %5.2f %5.2f %5.2f",localplayer.rb.w[0],
+                                                localplayer.rb.w[1],
+                                                localplayer.rb.w[2] );
+
+   const char *activity_txt[] = {
       "air",
       "air_to_grind",
       "ground",
+      "handplant",
       "undefined (INVALID)",
       "grind_any (INVALID)",
       "grind_boardslide",
@@ -2651,73 +2830,72 @@ VG_STATIC void player__skate_im_gui( player_instance *player ){
       "grind_5050"
    };
 
-   player__debugtext( 1, "activity: %s", activity_txt[s->state.activity] );
+   player__debugtext( 1, "activity: %s", activity_txt[state->activity] );
 #if 0
    player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
-                        s->state.steerx_s, s->state.steery_s,
+                        state->steerx_s, state->steery_s,
                         k_steer_ground, k_steer_air );
 #endif
-   player__debugtext( 1, "flip: %.4f %.4f", s->state.flip_rate, 
-                                             s->state.flip_time );
+   player__debugtext( 1, "flip: %.4f %.4f", state->flip_rate, 
+                                             state->flip_time );
    player__debugtext( 1, "trickv: %.2f %.2f %.2f", 
-                           s->state.trick_vel[0],
-                           s->state.trick_vel[1],
-                           s->state.trick_vel[2] );
-   player__debugtext( 1, "tricke: %.2f %.2f %.2f", 
-                           s->state.trick_euler[0],
-                           s->state.trick_euler[1],
-                           s->state.trick_euler[2] );
+                           state->trick_vel[0],
+                           state->trick_vel[1],
+                           state->trick_vel[2] );
+   player__debugtext( 1, "tricke: %.2fs %.2f %.2f %.2f", 
+                           state->trick_time,
+                           state->trick_euler[0],
+                           state->trick_euler[1],
+                           state->trick_euler[2] );
 }
 
-VG_STATIC void player__skate_animate( player_instance *player,
-                                      player_animation *dest )
-{
-   struct player_skate *s = &player->_skate;
-   struct player_skate_state *state = &player->_skate.state;
-   struct player_avatar *av = player->playeravatar;
-   struct skeleton *sk = &av->sk;
+void player__skate_animate(void){
+   struct player_skate_state *state = &player_skate.state;
+   struct player_skate_animator *animator = &player_skate.animator;
 
    /* Head */
    float kheight = 2.0f,
          kleg = 0.6f;
 
-   v3f offset;
-   v3_zero( offset );
+   v3_zero( animator->offset );
 
    v3f cog_local, cog_ideal;
-   m4x3_mulv( player->rb.to_local, s->state.cog, cog_local );
+   m4x3_mulv( localplayer.rb.to_local, state->cog, cog_local );
 
-   v3_copy( s->state.up_dir, cog_ideal );
+   v3_copy( state->up_dir, cog_ideal );
    v3_normalize( cog_ideal );
-   m3x3_mulv( player->rb.to_local, cog_ideal, cog_ideal );
-
-   v3_sub( cog_ideal, cog_local, offset );
+   m3x3_mulv( localplayer.rb.to_local, cog_ideal, cog_ideal );
 
+   v3_sub( cog_ideal, cog_local, animator->offset );
 
-   v3_muls( offset, 4.0f, offset );
-   offset[1] *= -1.0f;
+   v3_muls( animator->offset, 4.0f, animator->offset );
+   animator->offset[1] *= -1.0f;
 
-   float curspeed  = v3_length( player->rb.v ),
+   float curspeed  = v3_length( localplayer.rb.v ),
          kickspeed = vg_clampf( curspeed*(1.0f/40.0f), 0.0f, 1.0f ),
-         kicks     = (vg_randf64()-0.5f)*2.0f*kickspeed,
+         kicks     = (vg_randf64(&vg.rand)-0.5f)*2.0f*kickspeed,
          sign      = vg_signf( kicks );
 
-   state->wobble[0] = vg_lerpf( state->wobble[0], kicks*kicks*sign, 
-                                6.0f*vg.time_delta);
-   state->wobble[1] = vg_lerpf( state->wobble[1], state->wobble[0],
-                                2.4f*vg.time_delta);
+   animator->wobble[0] = vg_lerpf( animator->wobble[0], kicks*kicks*sign, 
+                                   6.0f*vg.time_delta);
+   animator->wobble[1] = vg_lerpf( animator->wobble[1], animator->wobble[0], 
+                                   2.4f*vg.time_delta);
 
-   offset[0] *= 0.26f;
-   offset[0] += state->wobble[1]*3.0f;
+   animator->offset[0] *= 0.26f;
+   animator->offset[0] += animator->wobble[1]*3.0f;
 
-   offset[1] *= -0.3f;
-   offset[2] *= 0.01f;
+   animator->offset[1] *= -0.3f;
+   animator->offset[2] *= 0.01f;
 
-   offset[0]=vg_clampf(offset[0],-0.8f,0.8f)
-                  *(1.0f-fabsf(state->blend_slide)*0.9f);
-   offset[1]=vg_clampf(offset[1],-0.5f,0.0f);
+   animator->offset[0]=vg_clampf(animator->offset[0],-0.8f,0.8f)*
+                                 (1.0f-fabsf(animator->slide)*0.9f);
+   animator->offset[1]=vg_clampf(animator->offset[1],-0.5f,0.0f);
 
-   v3_muls( offset, 0.3f, player->cam_control.tpv_offset_extra );
+   v3f cam_offset;
+   v3_mul( animator->offset, (v3f){1.0f,0.3f,1.0f}, cam_offset );
+
+   /* localized vectors */
+   m4x3_mulv( localplayer.rb.to_local, state->cog, animator->local_cog );
 
    /* 
     * Animation blending
@@ -2727,545 +2905,772 @@ VG_STATIC void player__skate_animate( player_instance *player,
    /* sliding */
    {
       float desired = 0.0f;
-      if( s->state.activity == k_skate_activity_ground )
-         desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f );
+      if( state->activity == k_skate_activity_ground )
+         desired = vg_clampf( vg_maxf(fabsf( state->slip ),
+                                      fabsf( state->skid ) ), 0.0f, 1.0f );
+
+      animator->slide = vg_lerpf( animator->slide, desired, 2.4f*vg.time_delta);
 
-      state->blend_slide = 
-         vg_lerpf( state->blend_slide, desired, 2.4f*vg.time_delta);
+      f32 dirx = 0.0f;
+      if( fabsf(state->slip) > fabsf(dirx) ) dirx = state->slip;
+      if( fabsf(state->skid) > fabsf(dirx) ) dirx = state->skid;
+      if( fabsf( dirx ) > 0.025f ) dirx = vg_signf( dirx );
+         dirx = vg_signf( state->slip );
+      vg_slewf( &animator->x, dirx, 2.6f*vg.time_delta );
    }
+
+   cam_offset[0] += animator->slide * -animator->x;
+   v3_copy( cam_offset, localplayer.cam_control.tpv_offset_extra );
    
    /* movement information */
-   {
-      int iair = s->state.activity <= k_skate_activity_air_to_grind;
-
-      float dirz = s->state.reverse > 0.0f? 0.0f: 1.0f,
-            dirx = s->state.slip < 0.0f?    0.0f: 1.0f,
-            fly  = iair?                    1.0f: 0.0f,
-            wdist= s->weight_distribution[2] / k_board_length;
-
-      if( s->state.activity >= k_skate_activity_grind_any )
-         wdist = 0.0f;
-
-      state->blend_z = 
-         vg_lerpf( state->blend_z,      dirz,  2.4f*vg.time_delta );
-      state->blend_x = 
-         vg_lerpf( state->blend_x,      dirx,  0.6f*vg.time_delta );
-      state->blend_fly = 
-         vg_lerpf( state->blend_fly,    fly,   3.4f*vg.time_delta );
-      state->blend_weight = 
-         vg_lerpf( state->blend_weight, wdist, 9.0f*vg.time_delta );
+   int iair = state->activity <= k_skate_activity_air_to_grind;
+
+   float dirz = state->reverse > 0.0f? 0.0f: 1.0f,
+         fly  = iair?                  1.0f: 0.0f,
+         wdist= player_skate.weight_distribution[2] / k_board_length;
+
+   if( state->activity >= k_skate_activity_grind_any )
+      wdist = 0.0f;
+
+   animator->z      = vg_lerpf( animator->z,      dirz,  2.4f*vg.time_delta );
+   animator->skid = state->skid;
+   animator->fly    = vg_lerpf( animator->fly,    fly,   3.4f*vg.time_delta );
+   animator->weight = vg_lerpf( animator->weight, wdist, 9.0f*vg.time_delta );
+
+   float stand = 1.0f - vg_clampf( curspeed * 0.03f, 0.0f, 1.0f );
+   animator->stand  = vg_lerpf( animator->stand, stand, 6.0f*vg.time_delta );
+   animator->reverse = state->reverse;
+
+   if( fabsf(state->slip) > 0.3f ){
+      f32 slide_x = v3_dot(localplayer.rb.v, localplayer.rb.to_world[0]);
+      state->delayed_slip_dir = vg_signf(slide_x);
+   }
+
+   /* grinding */
+   f32 grind=state->activity >= k_skate_activity_grind_any? 1.0f: 0.0f;
+   animator->grind = vg_lerpf( animator->grind,  grind, 5.0f*vg.time_delta );
+
+   f32 grind_frame = 0.5f;
+
+   if( state->activity == k_skate_activity_grind_front50 )
+      grind_frame = 0.0f;
+   else if( state->activity == k_skate_activity_grind_back50 )
+      grind_frame = 1.0f;
+
+   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;
+   animator->push = vg_lerpf( animator->push, 
+                              (vg.time - state->cur_push) < 0.125,
+                              6.0f*vg.time_delta );
+
+   /* jumping */
+   animator->jump_charge = state->jump_charge;
+   animator->jump = vg_lerpf( animator->jump, animator->jump_charge, 
+                              8.4f*vg.time_delta );
+
+   /* trick setup */
+   animator->jump_dir = state->jump_dir;
+   f32 jump_start_frame = 14.0f/30.0f;
+   animator->jump_time = animator->jump_charge * jump_start_frame;
+   f32 jump_frame = (vg.time - state->jump_time) + jump_start_frame;
+   if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
+      animator->jump_time = jump_frame;
+
+   /* trick */
+   float jump_t = vg.time-state->jump_time;
+   float k=17.0f;
+   float h = k*jump_t;
+   float extra = h*exp(1.0-h) * (state->jump_dir?1.0f:-1.0f);
+         extra *= state->slap * 4.0f;
+
+   v3_add( state->trick_euler, state->trick_residuald, 
+            animator->board_euler );
+   v3_muls( animator->board_euler, VG_TAUf, animator->board_euler );
+
+   animator->board_euler[0] *= 0.5f;
+   animator->board_euler[1] += extra;
+   animator->trick_type = state->trick_type;
+
+   /* board lean */
+   f32 lean1, lean2 = animator->steer[0] * animator->reverse * -0.36f,
+       lean;
+
+   lean1 = animator->slide * animator->delayed_slip_dir;
+   if( fabsf(lean1)>fabsf(lean2) ) lean = lean1;
+   else                            lean = lean2;
+
+   if( ((int)roundf(animator->board_euler[0]/VG_PIf)) % 2 ) lean = -lean;
+   lean = vg_clampf( lean, -1.0f, 1.0f );
+   animator->board_lean = 
+      vg_lerpf(animator->board_lean, lean, vg.time_delta*18.0f);
+
+   /* feet placement */
+   struct player_board *board = 
+      addon_cache_item_if_loaded( k_addon_type_board,
+                                  localplayer.board_view_slot );
+   if( board ){
+      if( animator->weight > 0.0f ){
+         animator->foot_offset[0] = 
+            board->truck_positions[k_board_truck_back][2]+0.3f;
+      }
+      else{
+         animator->foot_offset[1] = 
+            board->truck_positions[k_board_truck_front][2]-0.3f;
+      }
    }
 
-   mdl_keyframe apose[32], bpose[32];
-   mdl_keyframe ground_pose[32];
-   {
-      /* when the player is moving fast he will crouch down a little bit */
-      float stand = 1.0f - vg_clampf( curspeed * 0.03f, 0.0f, 1.0f );
-      state->blend_stand = 
-         vg_lerpf( state->blend_stand, stand, 6.0f*vg.time_delta );
+   f32 slapm = vg_maxf( 1.0f-v3_length2( state->trick_vel ), 0.0f );
+   animator->slap = state->slap;
+   animator->subslap = vg_lerpf( animator->subslap, slapm, 
+                                 vg.time_delta*10.0f );
 
-      /* stand/crouch */
-      float dir_frame   = state->blend_z * (15.0f/30.0f),
-            stand_blend = offset[1]*-2.0f;
+#if 0
+   f32 l = ((state->activity < k_skate_activity_ground) &&
+             v3_length2(state->trick_vel) > 0.1f )? 1: 0;
+   animator->trick_foot = vg_lerpf( animator->trick_foot, l, 
+                                    8.4f*vg.time_delta );
+#endif
 
-      v2f steer;
-      joystick_state( k_srjoystick_steer, steer );
-      f32 lean1,
-          lean2 = steer[0] * s->state.reverse * -0.36f,
-          lean;
+   animator->trick_foot = vg_exp_impulse( state->trick_time, 5.0f );
 
-      if( fabsf(s->state.slip) > 0.3f ){
-         f32 slide_dir = vg_signf(v3_dot(player->rb.v,player->rb.to_world[0]));
-         s->state.delayed_slip_dir = slide_dir;
-      }
-      lean1 = state->blend_slide * s->state.delayed_slip_dir;
+   /* grab */
+   v2f grab_input;
+   joystick_state( k_srjoystick_grab, grab_input );
+   v2_add( state->grab_mouse_delta, grab_input, grab_input );
 
-      if( fabsf(lean1)>fabsf(lean2) ) lean = lean1;
-      else                            lean = lean2;
+   if( v2_length2( grab_input ) <= 0.001f ) grab_input[0] = -1.0f;
+   else v2_normalize_clamp( grab_input );
+   v2_lerp( animator->grab, grab_input, 2.4f*vg.time_delta, animator->grab );
+   animator->grabbing = state->grabbing;
 
-      if( ((int)roundf(s->state.trick_euler[0])) % 2 ) lean = -lean;
-      lean = vg_clampf( lean, -1.0f, 1.0f );
+   /* steer */
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
+   animator->airdir = vg_lerpf( animator->airdir, 
+                                -steer[0], 2.4f*vg.time_delta );
 
-      player->board_pose.lean = vg_lerpf( player->board_pose.lean, lean,
-                                          vg.time_delta * 18.0f );
+   animator->steer[0] = steer[0];
+   animator->steer[1] = vg_lerpf( animator->steer[1], 
+                                  steer[0], 4.0f*vg.time_delta );
+      
 
-      v3f local_cog;
-      m4x3_mulv( player->rb.to_local, s->state.cog, local_cog );
-      stand_blend = vg_clampf( 1.0f-local_cog[1], 0, 1 );
+   /* flip angle */
+   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*vg.time_fixed_delta;
+            sign  = vg_signf( t );
 
-      skeleton_sample_anim( sk, s->anim_stand, dir_frame, apose );
-      skeleton_sample_anim( sk, s->anim_highg, dir_frame, bpose );
-      skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
+      t  = 1.0f - vg_minf( 1.0f, fabsf( t * 1.1f ) );
+      t  = sign * (1.0f-t*t);
 
-      /* sliding */
-      float slide_frame = state->blend_x * (15.0f/30.0f);
-      skeleton_sample_anim( sk, s->anim_slide, slide_frame, bpose );
-      skeleton_lerp_pose( sk, apose, bpose, state->blend_slide, apose );
-
-      /* pushing */
-      double push_time = vg.time - s->state.start_push;
-      state->blend_push = vg_lerpf( state->blend_push,
-                               (vg.time - s->state.cur_push) < 0.125,
-                               6.0f*vg.time_delta );
-
-      if( s->state.reverse > 0.0f )
-         skeleton_sample_anim( sk, s->anim_push, push_time, bpose );
-      else
-         skeleton_sample_anim( sk, s->anim_push_reverse, push_time, bpose );
+      f32 angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf,
+          distm = state->land_dist * fabsf(state->flip_rate) * 3.0f,
+          blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
+      angle = vg_lerpf( angle, vg_signf(state->flip_rate)*VG_TAUf, blend );
+      q_axis_angle( animator->qflip, state->flip_axis, angle );
+   }
+   else 
+      q_identity( animator->qflip );
+
+   /* counter-rotation */
+   if( v3_length2( state->up_dir ) > 0.001f ){
+      v4_lerp( state->smoothed_rotation, localplayer.rb.q, 
+               2.0f*vg.time_frame_delta,
+               state->smoothed_rotation );
+      q_normalize( state->smoothed_rotation );
+
+      v3f yaw_smooth = {1.0f,0.0f,0.0f};
+      q_mulv( state->smoothed_rotation, yaw_smooth, yaw_smooth );
+      m3x3_mulv( localplayer.rb.to_local, yaw_smooth, yaw_smooth );
+      yaw_smooth[1] = 0.0f;
+      v3_normalize( yaw_smooth );
+
+      f32 yaw_counter_rotate  = yaw_smooth[0];
+          yaw_counter_rotate  = vg_maxf( 0.7f, yaw_counter_rotate );
+          yaw_counter_rotate  = acosf( yaw_counter_rotate );
+          yaw_counter_rotate *= 1.0f-animator->fly;
+
+      v3f ndir;
+      m3x3_mulv( localplayer.rb.to_local, state->up_dir, ndir );
+      v3_normalize( ndir );
+
+      v3f up = { 0.0f, 1.0f, 0.0f };
+      float a = v3_dot( ndir, up );
+      a = acosf( vg_clampf( a, -1.0f, 1.0f ) );
 
-      skeleton_lerp_pose( sk, apose, bpose, state->blend_push, apose );
+      v3f axis;
+      v4f qcounteryaw, qfixup;
+      
+      v3_cross( up, ndir, axis );
+      q_axis_angle( qfixup, axis, a*2.0f );
 
-      /* trick setup */
-      float jump_start_frame = 14.0f/30.0f;
+      v3_cross( (v3f){1.0f,0.0f,0.0f}, yaw_smooth, axis );
+      q_axis_angle( qcounteryaw, axis, yaw_counter_rotate );
 
-      float charge = s->state.jump_charge;
-      state->blend_jump = 
-         vg_lerpf( state->blend_jump, charge, 8.4f*vg.time_delta );
+      q_mul( qcounteryaw, qfixup, animator->qfixuptotal );
+      q_normalize( animator->qfixuptotal );
 
-      float setup_frame = charge * jump_start_frame,
-            setup_blend = vg_minf( state->blend_jump, 1.0f );
-      
-      float jump_frame = (vg.time - s->state.jump_time) + jump_start_frame;
-      if( jump_frame >= jump_start_frame && jump_frame <= (40.0f/30.0f) )
-         setup_frame = jump_frame;
+      v3f p1, p2;
+      m3x3_mulv( localplayer.rb.to_world, up, p1 );
+      m3x3_mulv( localplayer.rb.to_world, ndir, p2 );
 
-      struct skeleton_anim *jump_anim = s->state.jump_dir?
-                                        s->anim_ollie:
-                                        s->anim_ollie_reverse;
+      vg_line_arrow( localplayer.rb.co, p1, 0.5f, VG__PINK );
+      vg_line_arrow( localplayer.rb.co, p2, 0.5f, VG__PINK );
+   }
+   else q_identity( animator->qfixuptotal );
 
-      skeleton_sample_anim_clamped( sk, jump_anim, setup_frame, bpose );
-      skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
+   if( state->activity == k_skate_activity_handplant ){
+      v3_copy( state->store_co, animator->root_co );
+      v4_copy( state->store_q, animator->root_q );
+      v3_zero( animator->root_v );
+   }
+   else {
+      rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
+      v3_copy( localplayer.rb.v, animator->root_v );
    }
-   
-   mdl_keyframe air_pose[32];
-   {
-      v2f steer;
-      joystick_state( k_srjoystick_steer, steer );
 
-      float target = -steer[1];
+   animator->handplant_t = state->handplant_t;
+}
+                        
+void player__skate_pose( void *_animator, player_pose *pose ){
+   struct skeleton *sk = &localplayer.skeleton;
+   struct player_skate_animator *animator = _animator;
 
-      state->blend_airdir = 
-         vg_lerpf( state->blend_airdir, target, 2.4f*vg.time_delta );
-      
-      float air_frame = (state->blend_airdir*0.5f+0.5f) * (15.0f/30.0f);
-      skeleton_sample_anim( sk, s->anim_air, air_frame, apose );
+   pose->type = k_player_pose_type_ik;
+   v3_copy( animator->root_co, pose->root_co );
+   v4_copy( animator->root_q, pose->root_q );
 
-      static v2f grab_choice;
+   /* transform */
+   v3f ext_up,ext_co;
+   q_mulv( pose->root_q, (v3f){0.0f,1.0f,0.0f}, ext_up );
+   v3_copy( pose->root_co, ext_co );
+   v3_muladds( pose->root_co, ext_up, -0.1f, pose->root_co );
 
-      v2f grab_input;
-      joystick_state( k_srjoystick_grab, grab_input );
-      v2_add( s->state.grab_mouse_delta, grab_input, grab_input );
+   /* apply flip rotation at midpoint */
+   q_mul( animator->qflip, pose->root_q, pose->root_q );
+   q_normalize( pose->root_q );
 
-      if( v2_length2( grab_input ) <= 0.001f )
-         grab_input[0] = -1.0f;
-      else
-         v2_normalize_clamp( grab_input );
-      v2_lerp( grab_choice, grab_input, 2.4f*vg.time_delta, grab_choice );
+   v3f rotation_point, rco;
+   v3_muladds( ext_co, ext_up, 0.5f, rotation_point );
+   v3_sub( pose->root_co, rotation_point, rco );
+   
+   q_mulv( animator->qflip, rco, rco );
+   v3_add( rco, rotation_point, pose->root_co );
 
-      float ang = atan2f( grab_choice[0], grab_choice[1] ),
-            ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
-            grab_frame = ang_unit * (15.0f/30.0f);
+   /* ANIMATIONS 
+    * ---------------------------------------------------------------------- */
 
-      skeleton_sample_anim( sk, s->anim_grabs, grab_frame, bpose );
-      skeleton_lerp_pose( sk, apose, bpose, s->state.grabbing, air_pose );
-   }
+   mdl_keyframe apose[32], bpose[32];
+   mdl_keyframe ground_pose[32];
+   {
+      /* stand/crouch */
+      f32 dir_frame   = animator->z * (15.0f/30.0f),
+          stand_blend = animator->offset[1]*-2.0f;
 
-   skeleton_lerp_pose( sk, ground_pose, air_pose, 
-                        state->blend_fly, dest->pose );
+      pose->board.lean = animator->board_lean;
 
+      stand_blend = vg_clampf( 1.0f-animator->local_cog[1], 0, 1 );
 
-   mdl_keyframe *kf_board    = &dest->pose[av->id_board-1],
-                *kf_foot_l   = &dest->pose[av->id_ik_foot_l-1],
-                *kf_foot_r   = &dest->pose[av->id_ik_foot_r-1],
-                *kf_knee_l   = &dest->pose[av->id_ik_knee_l-1],
-                *kf_knee_r   = &dest->pose[av->id_ik_knee_r-1],
-                *kf_hip      = &dest->pose[av->id_hip-1],
-                *kf_wheels[] = { &dest->pose[av->id_wheel_r-1],
-                                 &dest->pose[av->id_wheel_l-1] };
+      skeleton_sample_anim( sk, player_skate.anim_stand, dir_frame, apose );
+      skeleton_sample_anim( sk, player_skate.anim_highg, dir_frame, bpose );
+      skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
 
+      /* sliding */
+      f32 slide_frame = animator->x * 0.25f + 0.25f;
+      skeleton_sample_anim( sk, player_skate.anim_slide, slide_frame, bpose );
 
-   mdl_keyframe grind_pose[32];
-   {
-      float grind_frame = 0.5f;
+      mdl_keyframe mirrored[32];
+      player_mirror_pose( bpose, mirrored );
+      skeleton_lerp_pose( sk, bpose, mirrored, animator->z, bpose );
+      skeleton_lerp_pose( sk, apose, bpose, animator->slide, apose );
 
-      if( s->state.activity == k_skate_activity_grind_front50 ){
-         grind_frame = 0.0f;
-      } else if( s->state.activity == k_skate_activity_grind_back50 ){
-         grind_frame = 1.0f;
+      if( animator->reverse > 0.0f ){
+         skeleton_sample_anim( sk, player_skate.anim_push, animator->push_time, 
+                               bpose );
       }
+      else{
+         skeleton_sample_anim( sk, player_skate.anim_push_reverse, 
+                               animator->push_time, bpose );
+      }
+      skeleton_lerp_pose( sk, apose, bpose, animator->push, apose );
 
-      float grind=s->state.activity >= k_skate_activity_grind_any? 1.0f: 0.0f;
-      state->blend_grind = 
-         vg_lerpf( state->blend_grind,  grind, 5.0f*vg.time_delta );
-      state->blend_grind_balance =
-         vg_lerpf( state->blend_grind_balance, 
-                   grind_frame, 5.0f*vg.time_delta );
-
-      grind_frame = state->blend_grind_balance * (15.0f/30.0f);
+      struct skeleton_anim *jump_anim = animator->jump_dir?
+                                        player_skate.anim_ollie:
+                                        player_skate.anim_ollie_reverse;
 
-      skeleton_sample_anim( sk, s->anim_grind, grind_frame, apose );
-      skeleton_sample_anim( sk, s->anim_grind_jump, grind_frame, bpose );
-      skeleton_lerp_pose( sk, apose, bpose, state->blend_jump, grind_pose );
+      f32 setup_blend = vg_minf( animator->jump, 1.0f );
+      skeleton_sample_anim_clamped( sk, jump_anim, animator->jump_time, bpose );
+      skeleton_lerp_pose( sk, apose, bpose, setup_blend, ground_pose );
    }
-   skeleton_lerp_pose( sk, dest->pose, grind_pose, 
-                       state->blend_grind, dest->pose );
+   
+   mdl_keyframe air_pose[32];
+   {
+      float air_frame = (animator->airdir*0.5f+0.5f) * (15.0f/30.0f);
+      skeleton_sample_anim( sk, player_skate.anim_air, air_frame, apose );
 
-   float add_grab_mod = 1.0f - state->blend_fly;
+      float ang = atan2f( animator->grab[0], animator->grab[1] ),
+            ang_unit = (ang+VG_PIf) * (1.0f/VG_TAUf),
+            grab_frame = ang_unit * (15.0f/30.0f);
 
-   /* additive effects */
-   {
-      u32 apply_to[] = { av->id_hip, 
-                         av->id_ik_hand_l,
-                         av->id_ik_hand_r,
-                         av->id_ik_elbow_l,
-                         av->id_ik_elbow_r };
-
-      float apply_rates[] = { 1.0f,
-                              0.75f,
-                              0.75f,
-                              0.75f,
-                              0.75f };
-
-      for( int i=0; i<vg_list_size(apply_to); i ++ ){
-         dest->pose[apply_to[i]-1].co[0] += offset[0]*add_grab_mod;
-         dest->pose[apply_to[i]-1].co[2] += offset[2]*add_grab_mod;
-      }
-
-      /* angle correction */
-      if( v3_length2( s->state.up_dir ) > 0.001f ){
-
-         if( v4_length(s->state.smoothed_rotation) <= 0.1f ||
-             v4_length(s->state.smoothed_rotation) >= 1.1f ){
-            vg_warn( "FIX THIS! CARROT\n" );
-            v4_copy( player->rb.q, s->state.smoothed_rotation );
-         }
-         v4_lerp( s->state.smoothed_rotation, player->rb.q, 
-                  2.0f*vg.time_frame_delta,
-                  s->state.smoothed_rotation );
-         q_normalize( s->state.smoothed_rotation );
-
-         v3f yaw_ref    = {1.0f,0.0f,0.0f}, 
-             yaw_smooth = {1.0f,0.0f,0.0f};
-         q_mulv( player->rb.q, yaw_ref, yaw_ref );
-         q_mulv( s->state.smoothed_rotation, yaw_smooth, yaw_smooth );
-         m3x3_mulv( player->rb.to_local, yaw_smooth, yaw_smooth );
-         m3x3_mulv( player->rb.to_local, yaw_ref, yaw_ref );
-
-         float yaw_counter_rotate  = v3_dot(yaw_ref,yaw_smooth);
-               yaw_counter_rotate  = vg_clampf(yaw_counter_rotate,-1.0f,1.0f);
-               yaw_counter_rotate  = acosf( yaw_counter_rotate );
-               yaw_counter_rotate *= 1.0f-state->blend_fly;
-
-         v3f ndir;
-         m3x3_mulv( player->rb.to_local, s->state.up_dir, ndir );
-         v3_normalize( ndir );
-
-         v3f up = { 0.0f, 1.0f, 0.0f };
-
-         float a = v3_dot( ndir, up );
-         a = acosf( vg_clampf( a, -1.0f, 1.0f ) );
-
-         v3f axis;
-         v4f qfixup, qcounteryaw, qtotal;
-         
-         v3_cross( up, ndir, axis );
-         q_axis_angle( qfixup, axis, a );
+      skeleton_sample_anim( sk, player_skate.anim_grabs, grab_frame, bpose );
+      skeleton_lerp_pose( sk, apose, bpose, animator->grabbing, air_pose );
+   }
 
-         q_axis_angle( qcounteryaw, (v3f){0.0f,1.0f,0.0f}, yaw_counter_rotate );
-         q_mul( qcounteryaw, qfixup, qtotal );
-         q_normalize( qtotal );
+   skeleton_lerp_pose( sk, ground_pose, air_pose, animator->fly, 
+                       pose->keyframes );
 
-         mdl_keyframe *kf_hip = &dest->pose[av->id_hip-1];
-         v3f origin;
-         v3_add( av->sk.bones[av->id_hip].co, kf_hip->co, origin );
+   mdl_keyframe *kf_board    = &pose->keyframes[localplayer.id_board-1],
+                *kf_foot_l   = &pose->keyframes[localplayer.id_ik_foot_l-1],
+                *kf_foot_r   = &pose->keyframes[localplayer.id_ik_foot_r-1],
+                *kf_knee_l   = &pose->keyframes[localplayer.id_ik_knee_l-1],
+                *kf_knee_r   = &pose->keyframes[localplayer.id_ik_knee_r-1],
+                *kf_hip      = &pose->keyframes[localplayer.id_hip-1],
+                *kf_wheels[] = { &pose->keyframes[localplayer.id_wheel_r-1],
+                                 &pose->keyframes[localplayer.id_wheel_l-1] };
 
-         for( int i=0; i<vg_list_size(apply_to); i ++ ){
-            mdl_keyframe *kf = &dest->pose[apply_to[i]-1];
 
-            keyframe_rotate_around( kf, origin, av->sk.bones[apply_to[i]].co,
-                                    qtotal );
-         }
+   mdl_keyframe grind_pose[32];
+   {
+      f32 frame = animator->grind_balance * 0.5f;
 
-         v3f p1, p2;
-         m3x3_mulv( player->rb.to_world, up, p1 );
-         m3x3_mulv( player->rb.to_world, ndir, p2 );
+      skeleton_sample_anim( sk, player_skate.anim_grind, frame, apose );
+      skeleton_sample_anim( sk, player_skate.anim_grind_jump, frame, bpose );
+      skeleton_lerp_pose( sk, apose, bpose, animator->jump, grind_pose );
+   }
+   skeleton_lerp_pose( sk, pose->keyframes, grind_pose, 
+                       animator->grind, pose->keyframes );
+   float add_grab_mod = 1.0f - animator->fly;
 
-         vg_line_arrow( player->rb.co, p1, 0.25f, VG__PINK );
-         vg_line_arrow( player->rb.co, p2, 0.25f, VG__PINK );
+   /* additive effects */
+   u32 apply_to[] = { localplayer.id_hip, 
+                      localplayer.id_ik_hand_l,
+                      localplayer.id_ik_hand_r,
+                      localplayer.id_ik_elbow_l,
+                      localplayer.id_ik_elbow_r };
 
-      }
+   float apply_rates[] = { 1.0f,
+                           0.75f,
+                           0.75f,
+                           0.75f,
+                           0.75f };
 
-      v4f qtotal;
-      v4f qtrickr, qyawr, qpitchr, qrollr;
-      v3f eulerr;
+   for( int i=0; i<vg_list_size(apply_to); i ++ ){
+      pose->keyframes[apply_to[i]-1].co[0] += animator->offset[0]*add_grab_mod;
+      pose->keyframes[apply_to[i]-1].co[2] += animator->offset[2]*add_grab_mod;
+   }
 
-      v3_muls( state->board_trick_residuald, VG_TAUf, eulerr );
+#if 1
+   /* angle 'correction' */
+   v3f origin;
+   v3_add( sk->bones[localplayer.id_hip].co, kf_hip->co, origin );
 
-      q_axis_angle( qyawr,   (v3f){0.0f,1.0f,0.0f}, eulerr[0] * 0.5f );
-      q_axis_angle( qpitchr, (v3f){1.0f,0.0f,0.0f}, eulerr[1] );
-      q_axis_angle( qrollr,  (v3f){0.0f,0.0f,1.0f}, eulerr[2] );
+   for( int i=0; i<vg_list_size(apply_to); i ++ ){
+      mdl_keyframe *kf = &pose->keyframes[apply_to[i]-1];
+      keyframe_rotate_around( kf, origin, sk->bones[apply_to[i]].co,
+                              animator->qfixuptotal );
+   }
+#endif
 
-      q_mul( qpitchr, qrollr, qtrickr );
-      q_mul( qyawr, qtrickr, qtotal );
-      q_normalize( qtotal );
 
-      q_mul( qtotal, kf_board->q, kf_board->q );
+   if( animator->activity == k_skate_activity_handplant ){
+      struct skeleton_anim *anim = player_skate.anim_handplant;
 
-      /* trick rotation */
-      v4f qtrick, qyaw, qpitch, qroll;
-      v3f euler;
-      v3_muls( s->state.trick_euler, VG_TAUf, euler );
+      mdl_keyframe hpose[32];
+      skeleton_sample_anim_clamped( sk, anim, animator->handplant_t, hpose );
+      if( animator->reverse < 0.0f )
+         player_mirror_pose( hpose, hpose );
 
-      float jump_t = vg.time-s->state.jump_time;
+      mdl_keyframe *kf_world = &hpose[ localplayer.id_world -1 ];
+      m4x3f world, mmdl, world_view;
+      q_m3x3( kf_world->q, world );
+      v3_copy( kf_world->co, world[3] );
 
-      float k=17.0f;
-      float h = k*jump_t;
-      float extra = h*exp(1.0-h) * (s->state.jump_dir?1.0f:-1.0f);
-            extra *= s->state.slap * 4.0f;
+      q_m3x3( pose->root_q, mmdl );
+      v3_copy( pose->root_co, mmdl[3] );
 
-      q_axis_angle( qyaw,   (v3f){0.0f,1.0f,0.0f}, euler[0] * 0.5f );
-      q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, euler[1] + extra );
-      q_axis_angle( qroll,  (v3f){0.0f,0.0f,1.0f}, euler[2] );
+      m4x3_mul( mmdl, world, world_view );
 
-      q_mul( qyaw, qroll, qtrick );
-      q_mul( qpitch, qtrick, qtrick );
-      q_mul( kf_board->q, qtrick, kf_board->q );
-      q_normalize( kf_board->q );
+      vg_line_arrow( world_view[3], world_view[0], 1.0f, 0xff0000ff );
+      vg_line_arrow( world_view[3], world_view[1], 1.0f, 0xff00ff00 );
+      vg_line_arrow( world_view[3], world_view[2], 1.0f, 0xffff0000 );
 
-      struct player_board *board = 
-         addon_cache_item_if_loaded( k_addon_type_board,
-                                     player->board_view_slot );
-      
-      if( board ){
-         /* foot weight distribution */
-         if( state->blend_weight > 0.0f ){
-            kf_foot_l->co[2] = 
-               vg_lerpf( kf_foot_l->co[2], 
-                         board->truck_positions[k_board_truck_back][2]+0.3f, 
-                         0.5f*state->blend_weight );
-         }
-         else{
-            kf_foot_r->co[2] = 
-               vg_lerpf( kf_foot_r->co[2], 
-                         board->truck_positions[k_board_truck_front][2]-0.3f, 
-                         -0.5f*state->blend_weight );
-         }
-      }
+      m4x3f invworld;
+      m4x3_invert_affine( world, invworld );
+      m4x3_mul( mmdl, invworld, world_view );
 
-      float slapm = vg_maxf( 1.0f-v3_length2( s->state.trick_vel ), 0.0f );
-      state->subslap = vg_lerpf( state->subslap, slapm, vg.time_delta*10.0f );
+      m3x3_q( world_view, pose->root_q );
+      v3_copy( world_view[3], pose->root_co );
 
-      kf_foot_l->co[1] += s->state.slap;
-      kf_foot_r->co[1] += s->state.slap;
-      kf_knee_l->co[1] += s->state.slap;
-      kf_knee_r->co[1] += s->state.slap;
-      kf_board->co[1] += s->state.slap * state->subslap;
-      kf_hip->co[1] += s->state.slap * 0.25f;
+      f32 t        = animator->handplant_t,
+          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) );
 
+      skeleton_lerp_pose( sk, pose->keyframes, hpose, blend, pose->keyframes );
+   }
 
-      f32 l = ((s->state.activity < k_skate_activity_ground) &&
-                v3_length2(s->state.trick_vel) > 0.1f )? 1: 0;
-      state->blend_trick_foot = vg_lerpf( state->blend_trick_foot, l,  
-                                          8.4f*vg.time_delta );
 
-      if( s->state.trick_type == k_trick_type_kickflip ){
-         kf_foot_l->co[0] += state->blend_trick_foot * 0.2f;
-      }
-      else if( s->state.trick_type == k_trick_type_shuvit ){
-         kf_foot_l->co[0] += state->blend_trick_foot * 0.1f;
-         kf_foot_r->co[0] -= state->blend_trick_foot * 0.15f;
-      }
-      else if( s->state.trick_type == k_trick_type_treflip ){
-         kf_foot_l->co[0] += state->blend_trick_foot * 0.2f;
-         kf_foot_r->co[0] -= state->blend_trick_foot * 0.15f;
-      }
+   /* trick rotation */
+   v4f qtrick, qyaw, qpitch, qroll;
+   q_axis_angle( qyaw,   (v3f){0.0f,1.0f,0.0f}, animator->board_euler[0] );
+   q_axis_angle( qpitch, (v3f){1.0f,0.0f,0.0f}, animator->board_euler[1] );
+   q_axis_angle( qroll,  (v3f){0.0f,0.0f,1.0f}, animator->board_euler[2] );
 
+   q_mul( qyaw, qroll, qtrick );
+   q_mul( qpitch, qtrick, qtrick );
+   q_mul( kf_board->q, qtrick, kf_board->q );
+   q_normalize( kf_board->q );
 
-      /* 
-       * animation wishlist:
-       *    boardslide/grind jump animations
-       *    when tricking the slap should not appply or less apply
-       *    not animations however DONT target grinds that are vertically down.
-       */
+   kf_foot_l->co[2] = vg_lerpf( kf_foot_l->co[2], animator->foot_offset[0],
+                                 0.5f * animator->weight );
+   kf_foot_r->co[2] = vg_lerpf( kf_foot_r->co[2], animator->foot_offset[1],
+                                -0.5f * animator->weight );
 
-      /* truck rotation */
-      for( int i=0; i<2; i++ ){
-         float a = vg_minf( s->truckv0[i][0], 1.0f );
-         a = -acosf( a ) * vg_signf( s->truckv0[i][1] );
+   kf_foot_l->co[1] += animator->slap;
+   kf_foot_r->co[1] += animator->slap;
+   kf_knee_l->co[1] += animator->slap;
+   kf_knee_r->co[1] += animator->slap;
+   kf_board->co[1]  += animator->slap * animator->subslap;
+   kf_hip->co[1] += animator->slap * 0.25f;
 
-         v4f q;
-         q_axis_angle( q, (v3f){0.0f,0.0f,1.0f}, a );
-         q_mul( q, kf_wheels[i]->q, kf_wheels[i]->q );
-         q_normalize( kf_wheels[i]->q );
-      }
+   /* kickflip and shuvit are in the wrong order for some reason */
+   if( animator->trick_type == k_trick_type_kickflip ){
+      kf_foot_l->co[0] += animator->trick_foot * 0.15f;
+      kf_foot_r->co[0] -= animator->trick_foot * 0.15f;
+      kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
+      kf_foot_r->co[1] -= animator->trick_foot * 0.18f;
    }
+   else if( animator->trick_type == k_trick_type_shuvit ){
+      kf_foot_l->co[0] += animator->trick_foot * 0.2f;
+      kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
+      kf_foot_r->co[0] -= animator->trick_foot * 0.1f;
+      kf_foot_r->co[1] += animator->trick_foot * 0.09f;
+   }
+   else if( animator->trick_type == k_trick_type_treflip ){
+      kf_foot_l->co[0] += animator->trick_foot * 0.2f;
+      kf_foot_r->co[0] -= animator->trick_foot * 0.15f;
+      kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
+      kf_foot_r->co[1] -= animator->trick_foot * 0.18f;
+   }
+
+   /* 
+    * animation wishlist:
+    *    boardslide/grind jump animations
+    *    when tricking the slap should not appply or less apply
+    *    not animations however DONT target grinds that are vertically down.
+    */
 
+   /* truck rotation */
+   for( int i=0; i<2; i++ ){
+      float a = vg_minf( player_skate.truckv0[i][0], 1.0f );
+      a = -acosf( a ) * vg_signf( player_skate.truckv0[i][1] );
+
+      v4f q;
+      q_axis_angle( q, (v3f){0.0f,0.0f,1.0f}, a );
+      q_mul( q, kf_wheels[i]->q, kf_wheels[i]->q );
+      q_normalize( kf_wheels[i]->q );
+   }
+ 
+#if 1
    {
       mdl_keyframe
-                *kf_head    = &dest->pose[av->id_head-1],
-                *kf_elbow_l = &dest->pose[av->id_ik_elbow_l-1],
-                *kf_elbow_r = &dest->pose[av->id_ik_elbow_r-1],
-                *kf_hand_l  = &dest->pose[av->id_ik_hand_l-1],
-                *kf_hand_r  = &dest->pose[av->id_ik_hand_r-1];
+         *kf_head    = &pose->keyframes[localplayer.id_head-1],
+         *kf_elbow_l = &pose->keyframes[localplayer.id_ik_elbow_l-1],
+         *kf_elbow_r = &pose->keyframes[localplayer.id_ik_elbow_r-1],
+         *kf_hand_l  = &pose->keyframes[localplayer.id_ik_hand_l-1],
+         *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 );
-            warble *= vg_maxf(state->blend_grind,
-                              fabsf(state->blend_weight)) * 0.3f;
+      float warble = vg_perlin_fract_1d( vg.time, 2.0f, 2, 300 );
+            warble *= vg_maxf(animator->grind, fabsf(animator->weight)) * 0.3f;
 
       v4f qrot;
       q_axis_angle( qrot, (v3f){0.8f,0.7f,0.6f}, warble );
 
       v3f origin = {0.0f,0.2f,0.0f};
       keyframe_rotate_around( kf_hand_l, origin, 
-                              av->sk.bones[av->id_ik_hand_l].co, qrot );
+                              sk->bones[localplayer.id_ik_hand_l].co, qrot );
       keyframe_rotate_around( kf_hand_r, origin, 
-                              av->sk.bones[av->id_ik_hand_r].co, qrot );
+                              sk->bones[localplayer.id_ik_hand_r].co, qrot );
       keyframe_rotate_around( kf_hip, origin, 
-                              av->sk.bones[av->id_hip].co, qrot );
+                              sk->bones[localplayer.id_hip].co, qrot );
       keyframe_rotate_around( kf_elbow_r, origin, 
-                              av->sk.bones[av->id_ik_elbow_r].co, qrot );
+                              sk->bones[localplayer.id_ik_elbow_r].co, qrot );
       keyframe_rotate_around( kf_elbow_l, origin, 
-                              av->sk.bones[av->id_ik_elbow_l].co, qrot );
+                              sk->bones[localplayer.id_ik_elbow_l].co, qrot );
 
       q_inv( qrot, qrot );
       q_mul( qrot, kf_head->q, kf_head->q );
       q_normalize( kf_head->q );
-   }
 
-   /* transform */
-   rb_extrapolate( &player->rb, dest->root_co, dest->root_q );
 
-   v3f ext_up,ext_co;
-   q_mulv( dest->root_q, (v3f){0.0f,1.0f,0.0f}, ext_up );
-   v3_copy( dest->root_co, ext_co );
-   v3_muladds( dest->root_co, ext_up, -0.1f, dest->root_co );
+      /* hand placement */
 
-   v4f qflip;
-   if( (s->state.activity <= k_skate_activity_air_to_grind) &&
-       (fabsf(s->state.flip_rate) > 0.01f) )
-   {
-      float substep = vg.time_fixed_extrapolate;
-      float t     = s->state.flip_time+s->state.flip_rate*substep*k_rb_delta;
-            sign  = vg_signf( t );
+      u32 hand_id = animator->z < 0.5f? 
+                    localplayer.id_ik_hand_l: localplayer.id_ik_hand_r;
 
-      t  = 1.0f - vg_minf( 1.0f, fabsf( t * 1.1f ) );
-      t  = sign * (1.0f-t*t);
+      v3f sample_co;
+      m4x3f mmdl;
+      q_m3x3( pose->root_q, mmdl );
+      q_mulv( pose->root_q, pose->keyframes[hand_id-1].co, mmdl[3] );
+      v3_add( mmdl[3], pose->root_co, mmdl[3] );
+      m4x3_mulv( mmdl, sk->bones[hand_id].co, sample_co );
 
-      float angle = vg_clampf( t, -1.0f, 1.0f ) * VG_TAUf,
-            distm = s->state.land_dist * fabsf(s->state.flip_rate) * 3.0f,
-            blend = vg_clampf( 1.0f-distm, 0.0f, 1.0f );
+      v3_muladds( sample_co, mmdl[1], 0.3f, sample_co );
+      vg_line_point( sample_co, 0.04f, 0xff0000ff );
 
-      angle = vg_lerpf( angle, vg_signf(s->state.flip_rate) * VG_TAUf, blend );
+      v3f dir;
+      v3_muls( mmdl[1], -1.0f, dir );
+      ray_hit hit = { .dist = 1.5f };
+      if(ray_world( world_current_instance(), sample_co, dir, &hit, 0 )){
+         vg_line_cross( hit.pos, 0xff0000ff, 0.05f );
+         vg_line( sample_co, hit.pos, 0xffffffff );
+
+         f32 amt = vg_maxf( 0.0f, animator->slide-0.5f ) * 
+                   2.0f * fabsf(animator->z*2.0f-1.0f);
+
+         f32 d = (hit.dist - 0.3f) * amt;
+         pose->keyframes[hand_id-1].co[1] -= d;
+         kf_hip->co[1] -= d*0.4f;
+      }
 
-      q_axis_angle( qflip, s->state.flip_axis, angle );
-      q_mul( qflip, dest->root_q, dest->root_q );
-      q_normalize( dest->root_q );
+      /* skid */
+      f32 amt = vg_maxf(0.0f, (animator->slide - 0.5f) * 2.0f);
+      u8 skidders[] = { localplayer.id_ik_foot_l, 
+                        localplayer.id_ik_foot_r,
+                        localplayer.id_board };
+      v4f qskid;
+      q_axis_angle( qskid, (v3f){0,1,0}, -animator->steer[1]*0.2f );
+
+      for( u32 i=0; i<vg_list_size(skidders); i ++ ){
+         mdl_keyframe *kf = &pose->keyframes[ skidders[i]-1 ];
+         keyframe_rotate_around( kf, 
+               (v3f){0,0,0.4f*(animator->z*2.0f-1.0f)*amt}, 
+                                 sk->bones[skidders[i]].co, qskid );
+      }
+   }
+#endif
+}
 
-      v3f rotation_point, rco;
-      v3_muladds( ext_co, ext_up, 0.5f, rotation_point );
-      v3_sub( dest->root_co, rotation_point, rco );
-      
-      q_mulv( qflip, rco, rco );
-      v3_add( rco, rotation_point, dest->root_co );
+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;
+
+   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 );
    }
 
-   skeleton_copy_pose( sk, dest->pose, s->holdout );
-}
+   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 );
 
-VG_STATIC void player__skate_post_animate( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   struct player_avatar *av = player->playeravatar;
+   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 );
 
-   player->cam_velocity_influence = 1.0f;
+         effect_data->sand.colour = 0xff8ec4e6;
+         effect_spark_apply( &effect_data->sand, co, v, vg.time_delta * 8.0 );
+      }
+   }
 
-   v3f head = { 0.0f, 1.8f, 0.0f };
-   m4x3_mulv( av->sk.final_mtx[ av->id_head ], head, s->state.head_position );
-   m4x3_mulv( player->rb.to_local, s->state.head_position, 
-                                   s->state.head_position );
+   if( animator->grind > 0.5f ){
+      int back = 0, front = 0, mid = 0;
+
+      if( animator->activity == k_skate_activity_grind_5050 ){
+         back = 1;
+         front = 1;
+      }
+      else if( animator->activity == k_skate_activity_grind_back50 ){
+         back = 1;
+      }
+      else if( animator->activity == k_skate_activity_grind_front50 ){
+         front = 1;
+      }
+      else if( animator->activity == k_skate_activity_grind_boardslide ){
+         mid = 1;
+      }
+
+      if( back ){
+         effect_spark_apply( &effect_data->spark, vp0,
+                              animator->root_v, vg.time_delta );
+      }
+
+      if( front ){
+         effect_spark_apply( &effect_data->spark, vp1,
+                              animator->root_v, vg.time_delta );
+      }
+
+      if( mid ){
+         effect_spark_apply( &effect_data->spark, vpc,
+                              animator->root_v, vg.time_delta );
+      }
+   }
 }
 
-VG_STATIC void player__skate_reset_animator( player_instance *player ){
-   struct player_skate *s = &player->_skate;
-   struct player_skate_state *state = &s->state;
+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;
 
-   if( s->state.activity <= k_skate_activity_air_to_grind )
-      state->blend_fly = 1.0f;
-   else
-      state->blend_fly = 0.0f;
-
-   state->blend_slide = 0.0f;
-   state->blend_z = 0.0f;
-   state->blend_x = 0.0f;
-   state->blend_grind = 0.0f;
-   state->blend_grind_balance = 0.0f;
-   state->blend_stand = 0.0f;
-   state->blend_push = 0.0f;
-   state->blend_jump = 0.0f;
-   state->blend_airdir = 0.0f;
-   state->blend_weight = 0.0f;
-   state->subslap = 0.0f;
-   v2_zero( state->wobble );
-
-   v3_zero( state->board_trick_residuald );
-   v3_zero( state->board_trick_residualv );
-   v3_zero( s->truckv0[0] );
-   v3_zero( s->truckv0[1] );
+   v3f head = { 0.0f, 1.8f, 0.0f };
+   m4x3_mulv( localplayer.final_mtx[ localplayer.id_head ], 
+              head, state->head_position );
+   m4x3_mulv( localplayer.rb.to_local, 
+              state->head_position, state->head_position );
 }
 
-VG_STATIC void player__skate_clear_mechanics( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   s->state.jump_charge    = 0.0f;
-   s->state.charging_jump  = 0;
-   s->state.jump_dir       = 0;
-   v3_zero( s->state.flip_axis );
-   s->state.flip_time      = 0.0f;
-   s->state.flip_rate      = 0.0f;
-   s->state.reverse        = 0.0f;
-   s->state.slip           = 0.0f;
-   s->state.grabbing       = 0.0f;
-   v2_zero( s->state.grab_mouse_delta );
-   s->state.slap           = 0.0f;
-   s->state.jump_time      = 0.0;
-   s->state.start_push     = 0.0;
-   s->state.cur_push       = 0.0;
-   s->state.air_start      = 0.0;
-
-   v3_zero( s->state.air_init_v );
-   v3_zero( s->state.air_init_co );
-
-   s->state.gravity_bias   = k_gravity;
-   v3_copy( player->rb.co, s->state.prev_pos );
-   v4_copy( player->rb.q, s->state.smoothed_rotation );
-   v3_zero( s->state.throw_v );
-   v3_zero( s->state.trick_vel );
-   v3_zero( s->state.trick_euler );
-   v3_zero( s->state.cog_v );
-   s->state.grind_cooldown = 0;
-   s->state.surface_cooldown = 0;
-   v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
-   v3_copy( player->rb.to_world[1], s->state.up_dir );
-   v3_copy( player->rb.to_world[1], s->surface_picture );
-   v3_zero( s->weight_distribution );
-   v3_copy( player->rb.co, s->state.prev_pos );
+void player__skate_reset_animator(void){
+   struct player_skate_state *state = &player_skate.state;
+
+   memset( &player_skate.animator, 0, sizeof(player_skate.animator) );
+
+   if( state->activity <= k_skate_activity_air_to_grind ) 
+      player_skate.animator.fly = 1.0f;
+   else 
+      player_skate.animator.fly = 0.0f;
 }
 
-VG_STATIC void player__skate_reset( player_instance *player,
-                                    ent_spawn *rp )
+void player__skate_clear_mechanics(void)
 {
-   struct player_skate *s = &player->_skate;
-   v3_zero( player->rb.v );
-   v4_copy( rp->transform.q, player->rb.q );
+   struct player_skate_state *state = &player_skate.state;
+   state->jump_charge    = 0.0f;
+   state->charging_jump  = 0;
+   state->jump_dir       = 0;
+   v3_zero( state->flip_axis );
+   state->flip_time      = 0.0f;
+   state->flip_rate      = 0.0f;
+   state->reverse        = 0.0f;
+   state->slip           = 0.0f;
+   state->grabbing       = 0.0f;
+   v2_zero( state->grab_mouse_delta );
+   state->slap           = 0.0f;
+   state->jump_time      = 0.0;
+   state->start_push     = 0.0;
+   state->cur_push       = 0.0;
+   state->air_start      = 0.0;
+
+   v3_zero( state->air_init_v );
+   v3_zero( state->air_init_co );
+
+   state->gravity_bias   = k_gravity;
+   v3_copy( localplayer.rb.co, state->prev_pos );
+   v4_copy( localplayer.rb.q, state->smoothed_rotation );
+   v3_zero( state->throw_v );
+   v3_zero( state->trick_vel );
+   v3_zero( state->trick_euler );
+   v3_zero( state->cog_v );
+   state->grind_cooldown = 0;
+   state->surface_cooldown = 0;
+   v3_muladds( localplayer.rb.co, localplayer.rb.to_world[1], 1.0f, state->cog );
+   v3_copy( localplayer.rb.to_world[1], state->up_dir );
+   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 );
 
-   s->state.activity = k_skate_activity_air;
-   s->state.activity_prev = k_skate_activity_air;
+   v3f head = { 0.0f, 1.8f, 0.0f };
+   m4x3_mulv( localplayer.rb.to_world, head, state->head_position );
+}
 
-   player__skate_clear_mechanics( player );
-   player__skate_reset_animator( player );
+#include "network_compression.h"
 
-   v3_zero( s->state.head_position );
-   s->state.head_position[1] = 1.8f;
+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 );
+   bitpack_qquat( ctx, animator->root_q );
+
+   bitpack_qv3f( ctx, 8, -1.0f, 1.0f, animator->offset );
+   bitpack_qv3f( ctx, 8, -1.0f, 1.0f, animator->local_cog );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->slide );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->z );
+   bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->x );
+
+   /* these could likely be pressed down into single bits if needed */
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->fly );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->grind );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->stand );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->push );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->jump );        /*??*/
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->jump_charge ); /*??*/
+
+   /* just the sign bit? */
+   bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->reverse );
+   bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->delayed_slip_dir );
+   bitpack_bytes( ctx, 1, &animator->jump_dir );
+   bitpack_bytes( ctx, 1, &animator->trick_type );
+
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->grind_balance );
+   bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->airdir );
+   bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->weight );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->trick_foot );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->slap );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->subslap );
+   bitpack_qf32( ctx, 8,  0.0f, 1.0f, &animator->grabbing );
+
+   /* animator->wobble is ommited */
+
+   bitpack_qv2f( ctx, 8, -1.0f, 1.0f, animator->foot_offset );
+   bitpack_qquat( ctx, animator->qfixuptotal );
+   bitpack_qquat( ctx, animator->qflip );
+
+   bitpack_qv3f( ctx, 16, -100.0f, 100.0f, animator->board_euler );
+   bitpack_qf32( ctx, 8, -1.0f, 1.0f, &animator->board_lean );
+   bitpack_qv2f( ctx, 8, -1.0f, 1.0f, animator->steer );
+   bitpack_qv2f( ctx, 8, -1.0f, 1.0f, animator->grab );
+
+   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 );
 }
 
-#endif /* PLAYER_SKATE_C */
+void player__skate_sfx_oneshot( u8 id, v3f pos, f32 volume ){
+   audio_lock();
+
+   if( id == k_player_skate_soundeffect_jump ){
+      audio_oneshot_3d( &audio_jumps[vg_randu32(&vg.rand)%2], 
+                        pos, 40.0f, volume );
+   }
+   else if( id == k_player_skate_soundeffect_tap ){
+      audio_oneshot_3d( &audio_taps[vg_randu32(&vg.rand)%4], 
+                        pos, 40.0f, volume );
+   }
+   else if( id == k_player_skate_soundeffect_land_good ){
+      audio_oneshot_3d( &audio_lands[vg_randu32(&vg.rand)%3], 
+                        pos, 40.0f, volume );
+   }
+   else if( id == k_player_skate_soundeffect_land_bad ){
+      audio_oneshot_3d( &audio_lands[vg_randu32(&vg.rand)%2+3], 
+                        pos, 40.0f, volume );
+   }
+   else if( id == k_player_skate_soundeffect_grind_metal ){
+      audio_oneshot_3d( &audio_board[3], pos, 40.0f, volume );
+   }
+   else if( id == k_player_skate_soundeffect_grind_wood ){
+      audio_oneshot_3d( &audio_board[8], pos, 40.0f, volume );
+   }
+
+   audio_unlock();
+}