X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_skate.c;h=986be2d92f3fc27b6941b30521cd85eb7e847463;hb=53b534974303043efaf1d887711fcd349f6a2885;hp=a89783c7e15ef669355b154114b2ea6aa7a0ebcd;hpb=510bec78dcd9d91dd57d8995b573b1fff5256821;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_skate.c b/player_skate.c
index a89783c..986be2d 100644
--- a/player_skate.c
+++ b/player_skate.c
@@ -9,9 +9,7 @@
 #include "addon.h"
 
 static void player__skate_bind(void){
-   struct player_avatar *av = localplayer.playeravatar;
-   struct skeleton *sk = &av->sk;
-
+   struct skeleton *sk = &localplayer.skeleton;
    rb_update_transform( &localplayer.rb );
 
    struct { struct skeleton_anim **anim; const char *name; }
@@ -119,7 +117,7 @@ static int skate_grind_scansq( v3f pos, v3f dir, float r,
        support_max;
 
    v3f support_axis;
-   v3_cross( plane, localplayer.basis[1], support_axis );
+   v3_cross( plane, (v3f){0,1,0}, support_axis );
    v3_normalize( support_axis );
    
    bh_iter it;
@@ -156,9 +154,9 @@ static int skate_grind_scansq( v3f pos, v3f dir, float r,
             v3_cross( va, vb, normal );
 
             sample->normal[0] = v3_dot( support_axis, normal );
-            sample->normal[1] = v3_dot( localplayer.basis[1], normal );
+            sample->normal[1] = normal[1];
             sample->co[0]     = v3_dot( support_axis, d );
-            sample->co[1]     = v3_dot( localplayer.basis[1], d );
+            sample->co[1]     = d[1];
 
             v3_copy( normal, sample->normal3 ); /* normalize later
                                                    if we want to us it */
@@ -227,7 +225,7 @@ too_many_samples:
          v3_copy( sj->normal3, n1 );
          v3_cross( n0, n1, dir );
 
-         if( v3_length2( dir ) <= 0.001f )
+         if( v3_length2( dir ) <= 0.000001f )
             continue;
 
          v3_normalize( dir );
@@ -236,8 +234,8 @@ too_many_samples:
          v3_muls( dir, vg_signf(v3_dot(dir,plane)), dir );
          v3_add( average_direction, dir, average_direction );
 
-         float yi = v3_dot( localplayer.basis[1], si->normal3 ),
-               yj = v3_dot( localplayer.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 );
@@ -289,18 +287,14 @@ static int create_jumps_to_hit_target( jump_info *jumps,
 
    v3f v0;
    v3_sub( target, localplayer.rb.co, v0 );
-   m3x3_mulv( localplayer.invbasis, v0, v0 );
 
    v3f ax;
    v3_copy( v0, ax );
    ax[1] = 0.0f;
    v3_normalize( ax );
 
-   v3f v_local;
-   m3x3_mulv( localplayer.invbasis, localplayer.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 +313,6 @@ static int create_jumps_to_hit_target( jump_info *jumps,
 
          v3_muls( ax, cosf( a0 ) * m, inf->v );
          inf->v[1] += sinf( a0 ) * m;
-         m3x3_mulv( localplayer.basis, inf->v, inf->v );
          inf->land_dist = d[0] / (cosf(a0)*m);
          inf->gravity = gravity;
 
@@ -332,7 +325,6 @@ static int create_jumps_to_hit_target( jump_info *jumps,
 
          v3_muls( ax, cosf( a1 ) * m, inf->v );
          inf->v[1] += sinf( a1 ) * m;
-         m3x3_mulv( localplayer.basis, inf->v, inf->v );
          inf->land_dist = d[0] / (cosf(a1)*m);
          inf->gravity = gravity;
 
@@ -360,7 +352,7 @@ static void player__approximate_best_trajectory(void){
    v3_normalize( axis );
 
    /* at high slopes, Y component is low */
-   float upness      = v3_dot( localplayer.rb.to_world[1], localplayer.basis[1] ),
+   float upness      = localplayer.rb.to_world[1][1],
          angle_begin = -(1.0f-fabsf( upness )),
          angle_end   =   1.0f;
 
@@ -410,17 +402,14 @@ static void player__approximate_best_trajectory(void){
       inf->gravity = gravity;
       v3_copy( launch_v, inf->v );
 
-      m3x3f basis;
-      m3x3_copy( localplayer.basis, basis );
-
       for( int i=1; i<=50; i++ ){
          float t = (float)i * k_trace_delta;
 
          v3_muls( launch_v, t, co1 );
-         v3_muladds( co1, basis[1], -0.5f * gravity * t*t, co1 );
+         co1[1] += -0.5f * gravity * t*t;
          v3_add( launch_co, co1, co1 );
 
-         float launch_vy = v3_dot( launch_v,basis[1] );
+         float launch_vy = launch_v[1];
 
          int search_for_grind = 1;
          if( grind_located ) search_for_grind = 0;
@@ -441,7 +430,7 @@ static void player__approximate_best_trajectory(void){
 
                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] );
                }
 
@@ -460,14 +449,12 @@ static void player__approximate_best_trajectory(void){
          if( search_for_grind ){
             v3f ve;
             v3_copy( launch_v, ve );
-            v3_muladds( ve, basis[1], -gravity * t, ve );
+            ve[1] += -gravity * t;
 
             if( skate_grind_scansq( closest, ve, 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 = { ve[0], ve[2] },
+                   v1 = { grind.dir[0], grind.dir[2] };
 
                v2_normalize( v0 );
                v2_normalize( v1 );
@@ -496,11 +483,9 @@ static void player__approximate_best_trajectory(void){
                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->flags & k_ent_gate_nonlocal ){
+               if( gate->flags & k_ent_gate_nonlocal )
                   trace_world = &world_static.instances[ gate->target ];
-               }
             }
          }
 
@@ -526,7 +511,7 @@ static void player__approximate_best_trajectory(void){
 
             v3f ve;
             v3_copy( launch_v, ve );
-            v3_muladds( ve, localplayer.basis[1], -gravity * t, ve );
+            ve[1] += -gravity * t;
 
             inf->score = -v3_dot( ve, inf->n );
             inf->land_dist = t + k_trace_delta * t1;
@@ -573,13 +558,10 @@ static void player__approximate_best_trajectory(void){
 
          v3_copy( jump->v, launch_v );
          v3_copy( localplayer.rb.co, launch_co );
-
-         m3x3f basis;
-         m3x3_copy( localplayer.basis, basis );
          
          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 */
@@ -590,7 +572,7 @@ static void player__approximate_best_trajectory(void){
             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;
@@ -611,8 +593,7 @@ static void player__approximate_best_trajectory(void){
          /* determine score */
          v3f ve;
          v3_copy( jump->v, ve );
-         v3_muladds( ve, localplayer.basis[1], 
-                     -jump->gravity*jump->land_dist, ve );
+         ve[1] += -jump->gravity*jump->land_dist;
          jump->score = -v3_dot( ve, grind.n ) * 0.9f;
 
          player_skate.possible_jumps[ player_skate.possible_jump_count ++ ] = 
@@ -683,9 +664,8 @@ invalidated_grind:;
          v3_zero( state->flip_axis );
       }
    }
-   else{
-      v3_copy( localplayer.basis[1], state->land_normal );
-   }
+   else
+      v3_copy( (v3f){0,1,0}, state->land_normal );
 }
 
 /*
@@ -735,7 +715,7 @@ static void skate_apply_trick_model(void){
       if( v3_length2( state->trick_vel ) < 0.0001f )
          return;
 
-      int carry_on = player_skate_trick_input();
+      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) */
@@ -749,31 +729,36 @@ static void skate_apply_trick_model(void){
       }
 
       float interval = 1.0f / min_rate,
-            current  = floorf( 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( state->trick_euler, state->trick_vel, k_rb_delta,
                   state->trick_euler );
 
-      if( !carry_on && (state->trick_time + k_rb_delta >= next_end) ){
+      if( !carry_on && (state->trick_time + k_rb_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 );
-      }
 
-      state->trick_time += k_rb_delta;
+         audio_lock();
+         audio_oneshot_3d( &audio_flips[vg_randu32(&vg.rand)%4], 
+               localplayer.rb.co, 40.0f, 1.0f );
+         audio_unlock();
+      }
+      else 
+         state->trick_time += k_rb_delta / interval;
    }
    else{
       if( (v3_length2(state->trick_vel) >= 0.0001f ) &&
           state->trick_time > 0.2f)
       {
          player__skate_kill_audio();
-         player__dead_transition();
+         player__dead_transition( k_player_die_type_feet );
       }
 
       state->trick_euler[0] = roundf( state->trick_euler[0] );
@@ -819,6 +804,8 @@ static void skate_apply_steering_model(void){
    float rate = 26.0f,
          top  = 1.0f;
 
+   f32 skid_target = 0.0f;
+
    if( state->activity <= k_skate_activity_air_to_grind ){
       rate = 6.0f * fabsf(steer);
       top  = 1.5f;
@@ -848,12 +835,35 @@ static void skate_apply_steering_model(void){
          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_down(k_srbind_skid) && (fabsf(state->skid)<0.01f) ){
+               state->skid = vg_signf( steer ) * 0.01f;
+            }
+
+            if( button_press(k_srbind_skid) ){
+               skid_target = vg_signf( state->skid );
+            }
+         }
+         else {
+            if( fabsf(skid) > 0.1f ){
+               skid_target = skid;
+            }
+         }
+      }
+
       if( grab < 0.5f ){
          top *= 1.0f+v3_length( state->throw_v )*k_mmthrow_steer;
       }
    }
 
+   vg_slewf( &state->skid, skid_target, k_rb_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,
@@ -887,14 +897,19 @@ static void skate_apply_friction_model(void){
    state->slip = slip;
    state->reverse = -vg_signf(vel[2]);
 
+   f32 lat = k_friction_lat;
+
+   if( fabsf(axis_state(k_sraxis_skid)) > 0.1f ){
+      lat = k_friction_lat * 2.0f;
+   }
+
    vel[0] += vg_cfrictf( vel[0], k_friction_lat * k_rb_delta );
    vel[2] += vg_cfrictf( vel[2], k_friction_resistance * k_rb_delta );
 
    /* Pushing additive force */
 
-   if( !button_press( k_srbind_jump ) ){
-      if( button_press( k_srbind_push ) || (vg.time-state->start_push<0.75) )
-      {
+   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;
 
@@ -945,7 +960,7 @@ static void skate_apply_jump_model(void){
       v3f jumpdir;
       
       /* Launch more up if alignment is up else improve velocity */
-      float aup = v3_dot( localplayer.basis[1], localplayer.rb.to_world[1] ),
+      float aup = localplayer.rb.to_world[1][1],
             mod = 0.5f,
             dir = mod + fabsf(aup)*(1.0f-mod);
 
@@ -972,6 +987,7 @@ static void skate_apply_jump_model(void){
          q_mulv( qtilt, jumpdir, jumpdir );
       }
       state->surface_cooldown = 10;
+      state->trick_input_collect = 0.0f;
       
       float force = k_jump_force*state->jump_charge;
       v3_muladds( localplayer.rb.v, jumpdir, force, localplayer.rb.v );
@@ -1055,9 +1071,7 @@ static void skate_apply_cog_model(void){
 
    /* Apply forces & intergrate */
    v3_muladds( state->cog_v, F, -rb, state->cog_v );
-   v3_muladds( state->cog_v, localplayer.basis[1], -9.8f * k_rb_delta,
-               state->cog_v );
-
+   state->cog_v[1] += -9.8f * k_rb_delta;
    v3_muladds( state->cog, state->cog_v, k_rb_delta, state->cog );
 }
 
@@ -1117,12 +1131,23 @@ static void player__skate_pre_update(void){
       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 ){
-      enum trick_type trick = k_trick_type_none;
-      if( (trick = player_skate_trick_input()) ){
-         if( (vg.time - state->jump_time) < 0.1f ){
+      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 );
-            state->trick_time = 0.0f;
 
             if( trick == k_trick_type_kickflip ){
                state->trick_vel[0] = 3.0f;
@@ -1503,7 +1528,7 @@ static void skate_adjust_up_direction(void){
    }
    else{
       v3f avg;
-      v3_add( localplayer.rb.to_world[1], localplayer.basis[1], avg );
+      v3_add( localplayer.rb.to_world[1], (v3f){0,1,0}, avg );
       v3_normalize( avg );
 
       v3_lerp( state->up_dir, avg,
@@ -1562,7 +1587,6 @@ static void skate_grind_decay( struct grind_info *inf, float strength ){
 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;
@@ -2050,13 +2074,11 @@ static void player__skate_update(void){
 
    if( world->water.enabled ){
       if( localplayer.rb.co[1]+0.25f < world->water.height ){
-#if 0
          player__networked_sfx( k_player_subsystem_walk, 32, 
                                 k_player_walk_soundeffect_splash,
                                 localplayer.rb.co, 1.0f );
-#endif
          player__skate_kill_audio();
-         player__dead_transition();
+         player__dead_transition( k_player_die_type_generic );
          return;
       }
    }
@@ -2108,9 +2130,7 @@ static void player__skate_update(void){
          }
       }
       min_dist -= 0.2f;
-      float vy = v3_dot( localplayer.basis[1], localplayer.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;
    }
    state->slap = vg_lerpf( state->slap, slap, 10.0f*k_rb_delta );
@@ -2311,9 +2331,7 @@ begin_collision:;
    }
 
    rb_update_transform( &localplayer.rb );
-   v3_muladds( localplayer.rb.v, localplayer.basis[1],
-               -state->gravity_bias * player_skate.substep_delta, 
-               localplayer.rb.v );
+   localplayer.rb.v[1] += -state->gravity_bias * player_skate.substep_delta;
 
    player_skate.substep -= player_skate.substep_delta;
 
@@ -2335,7 +2353,7 @@ begin_collision:;
       rb_update_transform( &localplayer.rb );
 
       player__skate_kill_audio();
-      player__dead_transition();
+      player__dead_transition( k_player_die_type_head );
       return;
    }
 
@@ -2418,7 +2436,7 @@ begin_collision:;
    }
 
    /* 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];
@@ -2503,7 +2521,7 @@ begin_collision:;
    if( nforce > 4.0f ){
       if( nforce > 17.6f ){
          v3_muladds( localplayer.rb.v, normal_total, -1.0f, localplayer.rb.v );
-         player__dead_transition();
+         player__dead_transition( k_player_die_type_feet );
          player__skate_kill_audio();
          return;
       }
@@ -2598,6 +2616,27 @@ begin_collision:;
    } 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 );
+      }
+   }
 }
 
 static void player__skate_im_gui(void){
@@ -2637,7 +2676,8 @@ static void player__skate_im_gui(void){
                            state->trick_vel[0],
                            state->trick_vel[1],
                            state->trick_vel[2] );
-   player__debugtext( 1, "tricke: %.2f %.2f %.2f", 
+   player__debugtext( 1, "tricke: %.2fs %.2f %.2f %.2f", 
+                           state->trick_time,
                            state->trick_euler[0],
                            state->trick_euler[1],
                            state->trick_euler[2] );
@@ -2667,7 +2707,7 @@ static void player__skate_animate(void){
 
    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 );
 
    animator->wobble[0] = vg_lerpf( animator->wobble[0], kicks*kicks*sign, 
@@ -2687,7 +2727,6 @@ static void player__skate_animate(void){
 
    v3f cam_offset;
    v3_mul( animator->offset, (v3f){1.0f,0.3f,1.0f}, cam_offset );
-   v3_copy( cam_offset, localplayer.cam_control.tpv_offset_extra );
 
    /* localized vectors */
    m4x3_mulv( localplayer.rb.to_local, state->cog, animator->local_cog );
@@ -2701,24 +2740,34 @@ static void player__skate_animate(void){
    {
       float desired = 0.0f;
       if( state->activity == k_skate_activity_ground )
-         desired = vg_clampf( fabsf( state->slip ), 0.0f, 1.0f );
+         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);
+
+      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 = state->activity <= k_skate_activity_air_to_grind;
 
    float dirz = state->reverse > 0.0f? 0.0f: 1.0f,
-         dirx = state->slip < 0.0f?    0.0f: 1.0f,
-         fly  = iair?                    1.0f: 0.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->x      = vg_lerpf( animator->x,      dirx,  0.6f*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 );
 
@@ -2744,6 +2793,7 @@ static void player__skate_animate(void){
 
    animator->grind_balance = vg_lerpf( animator->grind_balance, grind_frame, 
                                 5.0f*vg.time_delta );
+   animator->activity = state->activity;
 
    /* pushing */
    animator->push_time = vg.time - state->start_push;
@@ -2812,10 +2862,14 @@ static void player__skate_animate(void){
    animator->subslap = vg_lerpf( animator->subslap, slapm, 
                                  vg.time_delta*10.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
+
+   animator->trick_foot = vg_exp_impulse( state->trick_time, 5.0f );
 
    /* grab */
    v2f grab_input;
@@ -2828,10 +2882,14 @@ static void player__skate_animate(void){
    animator->grabbing = state->grabbing;
 
    /* steer */
-   joystick_state( k_srjoystick_steer, animator->steer );
+   v2f steer;
+   joystick_state( k_srjoystick_steer, steer );
+   animator->airdir = vg_lerpf( animator->airdir, 
+                                -steer[0], 2.4f*vg.time_delta );
 
-   animator->airdir = vg_lerpf( animator->airdir, -animator->steer[0],
-                                2.4f*vg.time_delta );
+   animator->steer[0] = steer[0];
+   animator->steer[1] = vg_lerpf( animator->steer[1], 
+                                  steer[0], 4.0f*vg.time_delta );
       
 
    /* flip angle */
@@ -2900,11 +2958,11 @@ static void player__skate_animate(void){
    }
    else q_identity( animator->qfixuptotal );
    rb_extrapolate( &localplayer.rb, animator->root_co, animator->root_q );
+   v3_copy( localplayer.rb.v, animator->root_v );
 }
                         
 static void player__skate_pose( void *_animator, player_pose *pose ){
-   struct player_avatar *av = localplayer.playeravatar;
-   struct skeleton *sk = &av->sk;
+   struct skeleton *sk = &localplayer.skeleton;
    struct player_skate_animator *animator = _animator;
 
    pose->type = k_player_pose_type_ik;
@@ -2947,8 +3005,28 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
       skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
 
       /* sliding */
-      skeleton_sample_anim( sk, player_skate.anim_slide, animator->x * 0.5f, 
-                            bpose );
+      f32 slide_frame = animator->x * 0.25f + 0.25f;
+      skeleton_sample_anim( sk, player_skate.anim_slide, slide_frame, bpose );
+
+      mdl_keyframe mirrored[32];
+      for( u32 i=1; i<sk->bone_count; i ++ ){
+
+         mdl_keyframe *dest = &mirrored[i-1];
+         u8 mapping = localplayer.skeleton_mirror[i];
+
+         if( mapping ) *dest = bpose[mapping-1]; /* R */
+         else          *dest = bpose[i-1];       /* L */
+
+         dest->co[2] *= -1.0f;
+         dest->q[0] *= -1.0f;
+         dest->q[1] *= -1.0f;
+      }
+      skeleton_lerp_pose( sk, bpose, mirrored, animator->z, bpose );
+
+
+
+
+
       skeleton_lerp_pose( sk, apose, bpose, animator->slide, apose );
 
       if( animator->reverse > 0.0f ){
@@ -2986,14 +3064,14 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
    skeleton_lerp_pose( sk, ground_pose, air_pose, animator->fly, 
                        pose->keyframes );
 
-   mdl_keyframe *kf_board    = &pose->keyframes[av->id_board-1],
-                *kf_foot_l   = &pose->keyframes[av->id_ik_foot_l-1],
-                *kf_foot_r   = &pose->keyframes[av->id_ik_foot_r-1],
-                *kf_knee_l   = &pose->keyframes[av->id_ik_knee_l-1],
-                *kf_knee_r   = &pose->keyframes[av->id_ik_knee_r-1],
-                *kf_hip      = &pose->keyframes[av->id_hip-1],
-                *kf_wheels[] = { &pose->keyframes[av->id_wheel_r-1],
-                                 &pose->keyframes[av->id_wheel_l-1] };
+   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] };
 
 
    mdl_keyframe grind_pose[32];
@@ -3009,11 +3087,11 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
    float add_grab_mod = 1.0f - animator->fly;
 
    /* 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 };
+   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,
@@ -3028,11 +3106,11 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
 
    /* angle 'correction' */
    v3f origin;
-   v3_add( av->sk.bones[av->id_hip].co, kf_hip->co, origin );
+   v3_add( sk->bones[localplayer.id_hip].co, kf_hip->co, origin );
 
    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, av->sk.bones[apply_to[i]].co,
+      keyframe_rotate_around( kf, origin, sk->bones[apply_to[i]].co,
                               animator->qfixuptotal );
    }
 
@@ -3059,15 +3137,18 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
    kf_board->co[1]  += animator->slap * animator->subslap;
    kf_hip->co[1] += animator->slap * 0.25f;
 
+   /* 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.2f;
+      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.1f;
-      kf_foot_r->co[0] -= animator->trick_foot * 0.15f;
+      kf_foot_l->co[0] += animator->trick_foot * 0.2f;
       kf_foot_l->co[1] -= animator->trick_foot * 0.18f;
-      kf_foot_r->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;
@@ -3094,14 +3175,14 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
       q_normalize( kf_wheels[i]->q );
    }
 
-#if 0
    {
       mdl_keyframe
-         *kf_head    = &pose->keyframes[av->id_head-1],
-         *kf_elbow_l = &pose->keyframes[av->id_ik_elbow_l-1],
-         *kf_elbow_r = &pose->keyframes[av->id_ik_elbow_r-1],
-         *kf_hand_l  = &pose->keyframes[av->id_ik_hand_l-1],
-         *kf_hand_r  = &pose->keyframes[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(animator->grind, fabsf(animator->weight)) * 0.3f;
@@ -3111,31 +3192,131 @@ static void player__skate_pose( void *_animator, player_pose *pose ){
 
       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 );
+
+
+      /* hand placement */
+
+      u32 hand_id = animator->z < 0.5f? 
+                    localplayer.id_ik_hand_l: localplayer.id_ik_hand_r;
+
+      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 );
+
+      v3_muladds( sample_co, mmdl[1], 0.3f, sample_co );
+      vg_line_point( sample_co, 0.04f, 0xff0000ff );
+
+      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;
+      }
+
+      /* 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 );
+      }
+   }
+}
+
+static void player__skate_effects( void *_animator, m4x3f *final_mtx,
+                                   struct player_board *board,
+                                   struct player_effects_data *effect_data ){
+
+   struct skeleton *sk = &localplayer.skeleton;
+   struct player_skate_animator *animator = _animator;
+
+   if( animator->grind > 0.5f ){
+      v3f vp0, vp1, vpc;
+      if( board ){
+         v3_copy((v3f){0.0f,0.02f, board->truck_positions[0][2]}, vp1 );
+         v3_copy((v3f){0.0f,0.02f, board->truck_positions[1][2]}, vp0 );
+      }
+      else{
+         v3_zero( vp0 );
+         v3_zero( vp1 );
+      }
+
+      v3f *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 );
+
+      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 );
+      }
    }
-#endif
 }
 
 static void player__skate_post_animate(void){
-   struct player_avatar *av = localplayer.playeravatar;
    struct player_skate_state *state = &player_skate.state;
-
    localplayer.cam_velocity_influence = 1.0f;
 
    v3f head = { 0.0f, 1.8f, 0.0f };
-   m4x3_mulv( localplayer.final_mtx[ av->id_head ], 
+   m4x3_mulv( localplayer.final_mtx[ localplayer.id_head ], 
               head, state->head_position );
    m4x3_mulv( localplayer.rb.to_local, 
               state->head_position, state->head_position );
@@ -3189,21 +3370,6 @@ static void player__skate_clear_mechanics(void){
    v3_zero( player_skate.weight_distribution );
 }
 
-static void player__skate_reset( ent_spawn *rp ){
-   struct player_skate_state *state = &player_skate.state;
-   v3_zero( localplayer.rb.v );
-   v4_copy( rp->transform.q, localplayer.rb.q );
-
-   state->activity = k_skate_activity_air;
-   state->activity_prev = k_skate_activity_air;
-
-   player__skate_clear_mechanics();
-   player__skate_reset_animator();
-
-   v3_zero( state->head_position );
-   state->head_position[1] = 1.8f;
-}
-
 #include "network_compression.h"
 
 static void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
@@ -3215,7 +3381,7 @@ static void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
    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, -1.0f, 1.0f, &animator->z );
+   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 */
@@ -3253,22 +3419,28 @@ static void player__skate_animator_exchange( bitpack_ctx *ctx, void *data ){
 
    bitpack_qf32( ctx, 16,  0.0f, 120.0f, &animator->push_time );
    bitpack_qf32( ctx, 16,  0.0f, 120.0f, &animator->jump_time );
+   bitpack_qv3f( ctx, 16, -100.0f, 100.0f, animator->root_v );
+   bitpack_bytes( ctx, 1, &animator->activity );
 }
 
 static void player__skate_sfx_oneshot( u8 id, v3f pos, f32 volume ){
    audio_lock();
 
    if( id == k_player_skate_soundeffect_jump ){
-      audio_oneshot_3d( &audio_jumps[vg_randu32()%2], pos, 40.0f, volume );
+      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()%4], pos, 40.0f, volume );
+      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()%3], pos, 40.0f, volume );
+      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()%2+3], pos, 40.0f, volume );
+      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 );