basic replayable replays
[carveJwlIkooP6JGAAIwe30JlM.git] / player_skate.c
index a796b7c67ee721c2ecfdb528f4bddf78691480f3..1ef19a1b6af6d67bdbddc6ebcc634f118d683803 100644 (file)
@@ -476,7 +476,7 @@ void player__approximate_best_trajectory( player_instance *player )
                float a = v2_dot( v0, v1 );
 
                float a_min = cosf( VG_PIf * 0.185f );
-               if( s->grind_cooldown )
+               if( s->state.grind_cooldown )
                   a_min = cosf( VG_PIf * 0.05f );
 
                /* check speed */
@@ -722,15 +722,15 @@ VG_STATIC void skate_apply_trick_model( player_instance *player )
    v3f Fd, Fs, F;
    v3f strength = { 3.7f, 3.6f, 8.0f };
 
-   v3_muls( s->board_trick_residualv, -4.0f , Fd );
-   v3_muls( s->board_trick_residuald, -10.0f, Fs );
+   v3_muls( s->state.board_trick_residualv, -4.0f , Fd );
+   v3_muls( s->state.board_trick_residuald, -10.0f, Fs );
    v3_add( Fd, Fs, F );
    v3_mul( strength, F, F );
 
-   v3_muladds( s->board_trick_residualv, F, k_rb_delta, 
-               s->board_trick_residualv );
-   v3_muladds( s->board_trick_residuald, s->board_trick_residualv,
-               k_rb_delta, s->board_trick_residuald );
+   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 );
 
    if( s->state.activity <= k_skate_activity_air_to_grind ){
       if( v3_length2( s->state.trick_vel ) < 0.0001f )
@@ -763,7 +763,7 @@ VG_STATIC void skate_apply_trick_model( player_instance *player )
          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->board_trick_residualv );
+         v3_copy( s->state.trick_vel, s->state.board_trick_residualv );
          v3_zero( s->state.trick_vel );
       }
 
@@ -961,7 +961,7 @@ VG_STATIC void skate_apply_jump_model( player_instance *player )
          v3_normalize( jumpdir );
       }else{
          v3_copy( s->state.up_dir, jumpdir );
-         s->grind_cooldown = 30;
+         s->state.grind_cooldown = 30;
          s->state.activity = k_skate_activity_ground;
 
          v2f steer;
@@ -974,7 +974,7 @@ VG_STATIC void skate_apply_jump_model( player_instance *player )
          q_axis_angle( qtilt, s->grind_dir, tilt );
          q_mulv( qtilt, jumpdir, jumpdir );
       }
-      s->surface_cooldown = 10;
+      s->state.surface_cooldown = 10;
       
       float force = k_jump_force*s->state.jump_charge;
       v3_muladds( player->rb.v, jumpdir, force, player->rb.v );
@@ -1195,7 +1195,7 @@ VG_STATIC void player__skate_post_update( player_instance *player )
       slide = 0.0f;
    }
 
-   f32 gate        = 1.0f-menu.factive,
+   f32 gate        = skaterift.time_rate,
        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;
@@ -1962,13 +1962,13 @@ VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
 
-   if( s->grind_cooldown > 100 ){
+   if( s->state.grind_cooldown > 100 ){
       vg_fatal_error( "wth!\n" );
    }
 
    /* debounces this state manager a little bit */
-   if( s->grind_cooldown ){
-      s->grind_cooldown --;
+   if( s->state.grind_cooldown ){
+      s->state.grind_cooldown --;
       return k_skate_activity_undefined;
    }
 
@@ -2058,8 +2058,8 @@ VG_STATIC enum skate_activity skate_availible_grind( player_instance *player )
 
    if(      new_activity == k_skate_activity_undefined ){
       if( s->state.activity >= k_skate_activity_grind_any ){
-         s->grind_cooldown = 15;
-         s->surface_cooldown = 10;
+         s->state.grind_cooldown = 15;
+         s->state.surface_cooldown = 10;
       }
    }
    else if( new_activity == k_skate_activity_grind_boardslide ){
@@ -2203,8 +2203,8 @@ VG_STATIC void player__skate_update( player_instance *player )
       m3x3_mulv( player->rb.to_local, axel, s->truckv0[i] );
    }
 
-   if( s->surface_cooldown ){
-      s->surface_cooldown --;
+   if( s->state.surface_cooldown ){
+      s->state.surface_cooldown --;
       contact_count = 0;
    }
 
@@ -2537,7 +2537,7 @@ begin_collision:;
       }
 
       f32 amt = k_cam_punch;
-      if( player->camera_mode == k_cam_firstperson ){
+      if( player->cam_control.camera_mode == k_cam_firstperson ){
          amt *= 0.25f;
       }
 
@@ -2586,8 +2586,6 @@ begin_collision:;
       q_mul( transport_rotation, s->state.smoothed_rotation,
                                  s->state.smoothed_rotation );
       rb_update_transform( &player->rb );
-
-      s->state_gate_storage = s->state;
       player__pass_gate( player, gate );
    }
 
@@ -2675,6 +2673,7 @@ 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;
 
@@ -2703,19 +2702,22 @@ VG_STATIC void player__skate_animate( player_instance *player,
          kicks     = (vg_randf64()-0.5f)*2.0f*kickspeed,
          sign      = vg_signf( kicks );
 
-   s->wobble[0] = vg_lerpf( s->wobble[0], kicks*kicks*sign, 6.0f*vg.time_delta);
-   s->wobble[1] = vg_lerpf( s->wobble[1], s->wobble[0],     2.4f*vg.time_delta);
+   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);
 
    offset[0] *= 0.26f;
-   offset[0] += s->wobble[1]*3.0f;
+   offset[0] += state->wobble[1]*3.0f;
 
    offset[1] *= -0.3f;
    offset[2] *= 0.01f;
 
-   offset[0]=vg_clampf(offset[0],-0.8f,0.8f)*(1.0f-fabsf(s->blend_slide)*0.9f);
+   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);
 
-   v3_muls( offset, 0.3f, player->tpv_offset_extra );
+   v3_muls( offset, 0.3f, player->cam_control.tpv_offset_extra );
 
    /* 
     * Animation blending
@@ -2728,7 +2730,8 @@ VG_STATIC void player__skate_animate( player_instance *player,
       if( s->state.activity == k_skate_activity_ground )
          desired = vg_clampf( fabsf( s->state.slip ), 0.0f, 1.0f );
 
-      s->blend_slide = vg_lerpf( s->blend_slide, desired, 2.4f*vg.time_delta);
+      state->blend_slide = 
+         vg_lerpf( state->blend_slide, desired, 2.4f*vg.time_delta);
    }
    
    /* movement information */
@@ -2743,10 +2746,14 @@ VG_STATIC void player__skate_animate( player_instance *player,
       if( s->state.activity >= k_skate_activity_grind_any )
          wdist = 0.0f;
 
-      s->blend_z     = vg_lerpf( s->blend_z,      dirz,  2.4f*vg.time_delta );
-      s->blend_x     = vg_lerpf( s->blend_x,      dirx,  0.6f*vg.time_delta );
-      s->blend_fly   = vg_lerpf( s->blend_fly,    fly,   3.4f*vg.time_delta );
-      s->blend_weight= vg_lerpf( s->blend_weight, wdist, 9.0f*vg.time_delta );
+      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 );
    }
 
    mdl_keyframe apose[32], bpose[32];
@@ -2754,10 +2761,11 @@ VG_STATIC void player__skate_animate( player_instance *player,
    {
       /* 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 );
-      s->blend_stand = vg_lerpf( s->blend_stand, stand, 6.0f*vg.time_delta );
+      state->blend_stand = 
+         vg_lerpf( state->blend_stand, stand, 6.0f*vg.time_delta );
 
       /* stand/crouch */
-      float dir_frame   = s->blend_z * (15.0f/30.0f),
+      float dir_frame   = state->blend_z * (15.0f/30.0f),
             stand_blend = offset[1]*-2.0f;
 
       v2f steer;
@@ -2770,7 +2778,7 @@ VG_STATIC void player__skate_animate( player_instance *player,
          f32 slide_dir = vg_signf(v3_dot(player->rb.v,player->rb.to_world[0]));
          s->state.delayed_slip_dir = slide_dir;
       }
-      lean1 = s->blend_slide * s->state.delayed_slip_dir;
+      lean1 = state->blend_slide * s->state.delayed_slip_dir;
 
       if( fabsf(lean1)>fabsf(lean2) ) lean = lean1;
       else                            lean = lean2;
@@ -2790,13 +2798,13 @@ VG_STATIC void player__skate_animate( player_instance *player,
       skeleton_lerp_pose( sk, apose, bpose, stand_blend, apose );
 
       /* sliding */
-      float slide_frame = s->blend_x * (15.0f/30.0f);
+      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, s->blend_slide, apose );
+      skeleton_lerp_pose( sk, apose, bpose, state->blend_slide, apose );
 
       /* pushing */
       double push_time = vg.time - s->state.start_push;
-      s->blend_push = vg_lerpf( s->blend_push,
+      state->blend_push = vg_lerpf( state->blend_push,
                                (vg.time - s->state.cur_push) < 0.125,
                                6.0f*vg.time_delta );
 
@@ -2805,16 +2813,17 @@ VG_STATIC void player__skate_animate( player_instance *player,
       else
          skeleton_sample_anim( sk, s->anim_push_reverse, push_time, bpose );
 
-      skeleton_lerp_pose( sk, apose, bpose, s->blend_push, apose );
+      skeleton_lerp_pose( sk, apose, bpose, state->blend_push, apose );
 
       /* trick setup */
       float jump_start_frame = 14.0f/30.0f;
 
       float charge = s->state.jump_charge;
-      s->blend_jump = vg_lerpf( s->blend_jump, charge, 8.4f*vg.time_delta );
+      state->blend_jump = 
+         vg_lerpf( state->blend_jump, charge, 8.4f*vg.time_delta );
 
       float setup_frame = charge * jump_start_frame,
-            setup_blend = vg_minf( s->blend_jump, 1.0f );
+            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) )
@@ -2835,9 +2844,10 @@ VG_STATIC void player__skate_animate( player_instance *player,
 
       float target = -steer[1];
 
-      s->blend_airdir = vg_lerpf( s->blend_airdir, target, 2.4f*vg.time_delta );
+      state->blend_airdir = 
+         vg_lerpf( state->blend_airdir, target, 2.4f*vg.time_delta );
       
-      float air_frame = (s->blend_airdir*0.5f+0.5f) * (15.0f/30.0f);
+      float air_frame = (state->blend_airdir*0.5f+0.5f) * (15.0f/30.0f);
       skeleton_sample_anim( sk, s->anim_air, air_frame, apose );
 
       static v2f grab_choice;
@@ -2860,7 +2870,8 @@ VG_STATIC void player__skate_animate( player_instance *player,
       skeleton_lerp_pose( sk, apose, bpose, s->state.grabbing, air_pose );
    }
 
-   skeleton_lerp_pose( sk, ground_pose, air_pose, s->blend_fly, dest->pose );
+   skeleton_lerp_pose( sk, ground_pose, air_pose, 
+                        state->blend_fly, dest->pose );
 
 
    mdl_keyframe *kf_board    = &dest->pose[av->id_board-1],
@@ -2884,19 +2895,22 @@ VG_STATIC void player__skate_animate( player_instance *player,
       }
 
       float grind=s->state.activity >= k_skate_activity_grind_any? 1.0f: 0.0f;
-      s->blend_grind = vg_lerpf( s->blend_grind,  grind, 5.0f*vg.time_delta );
-      s->blend_grind_balance=vg_lerpf( s->blend_grind_balance, 
-                                       grind_frame, 5.0f*vg.time_delta );
+      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 = s->blend_grind_balance * (15.0f/30.0f);
+      grind_frame = state->blend_grind_balance * (15.0f/30.0f);
 
       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, s->blend_jump, grind_pose );
+      skeleton_lerp_pose( sk, apose, bpose, state->blend_jump, grind_pose );
    }
-   skeleton_lerp_pose( sk, dest->pose, grind_pose, s->blend_grind, dest->pose );
+   skeleton_lerp_pose( sk, dest->pose, grind_pose, 
+                       state->blend_grind, dest->pose );
 
-   float add_grab_mod = 1.0f - s->blend_fly;
+   float add_grab_mod = 1.0f - state->blend_fly;
 
    /* additive effects */
    {
@@ -2940,7 +2954,7 @@ VG_STATIC void player__skate_animate( player_instance *player,
          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-s->blend_fly;
+               yaw_counter_rotate *= 1.0f-state->blend_fly;
 
          v3f ndir;
          m3x3_mulv( player->rb.to_local, s->state.up_dir, ndir );
@@ -2985,7 +2999,7 @@ VG_STATIC void player__skate_animate( player_instance *player,
       v4f qtrickr, qyawr, qpitchr, qrollr;
       v3f eulerr;
 
-      v3_muls( s->board_trick_residuald, VG_TAUf, eulerr );
+      v3_muls( state->board_trick_residuald, VG_TAUf, eulerr );
 
       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] );
@@ -3024,46 +3038,46 @@ VG_STATIC void player__skate_animate( player_instance *player,
       
       if( board ){
          /* foot weight distribution */
-         if( s->blend_weight > 0.0f ){
+         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*s->blend_weight );
+                         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*s->blend_weight );
+                         -0.5f*state->blend_weight );
          }
       }
 
       float slapm = vg_maxf( 1.0f-v3_length2( s->state.trick_vel ), 0.0f );
-      s->subslap = vg_lerpf( s->subslap, slapm, vg.time_delta*10.0f );
+      state->subslap = vg_lerpf( state->subslap, slapm, vg.time_delta*10.0f );
 
       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 * s->subslap;
+      kf_board->co[1] += s->state.slap * state->subslap;
       kf_hip->co[1] += s->state.slap * 0.25f;
 
 
       f32 l = ((s->state.activity < k_skate_activity_ground) &&
                 v3_length2(s->state.trick_vel) > 0.1f )? 1: 0;
-      s->blend_trick_foot = vg_lerpf( s->blend_trick_foot, l,  
-                                      8.4f*vg.time_delta );
+      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] += s->blend_trick_foot * 0.2f;
+         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] += s->blend_trick_foot * 0.1f;
-         kf_foot_r->co[0] -= s->blend_trick_foot * 0.15f;
+         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] += s->blend_trick_foot * 0.2f;
-         kf_foot_r->co[0] -= s->blend_trick_foot * 0.15f;
+         kf_foot_l->co[0] += state->blend_trick_foot * 0.2f;
+         kf_foot_r->co[0] -= state->blend_trick_foot * 0.15f;
       }
 
 
@@ -3095,7 +3109,8 @@ VG_STATIC void player__skate_animate( player_instance *player,
                 *kf_hand_r  = &dest->pose[av->id_ik_hand_r-1];
 
       float warble = perlin1d( vg.time, 2.0f, 2, 300 );
-            warble *= vg_maxf(s->blend_grind,fabsf(s->blend_weight)) * 0.3f;
+            warble *= vg_maxf(state->blend_grind,
+                              fabsf(state->blend_weight)) * 0.3f;
 
       v4f qrot;
       q_axis_angle( qrot, (v3f){0.8f,0.7f,0.6f}, warble );
@@ -3170,30 +3185,30 @@ VG_STATIC void player__skate_post_animate( player_instance *player )
                                    s->state.head_position );
 }
 
-VG_STATIC void player__skate_reset_animator( player_instance *player )
-{
+VG_STATIC void player__skate_reset_animator( player_instance *player ){
    struct player_skate *s = &player->_skate;
+   struct player_skate_state *state = &s->state;
 
    if( s->state.activity <= k_skate_activity_air_to_grind )
-      s->blend_fly = 1.0f;
+      state->blend_fly = 1.0f;
    else
-      s->blend_fly = 0.0f;
-
-   s->blend_slide = 0.0f;
-   s->blend_z = 0.0f;
-   s->blend_x = 0.0f;
-   s->blend_grind = 0.0f;
-   s->blend_grind_balance = 0.0f;
-   s->blend_stand = 0.0f;
-   s->blend_push = 0.0f;
-   s->blend_jump = 0.0f;
-   s->blend_airdir = 0.0f;
-   s->blend_weight = 0.0f;
-   s->subslap = 0.0f;
-   v2_zero( s->wobble );
-
-   v3_zero( s->board_trick_residuald );
-   v3_zero( s->board_trick_residualv );
+      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] );
 }
@@ -3227,8 +3242,8 @@ VG_STATIC void player__skate_clear_mechanics( player_instance *player )
    v3_zero( s->state.trick_vel );
    v3_zero( s->state.trick_euler );
    v3_zero( s->state.cog_v );
-   s->grind_cooldown = 0;
-   s->surface_cooldown = 0;
+   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 );
@@ -3253,10 +3268,4 @@ VG_STATIC void player__skate_reset( player_instance *player,
    s->state.head_position[1] = 1.8f;
 }
 
-VG_STATIC void player__skate_restore( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   s->state = s->state_gate_storage;
-}
-
 #endif /* PLAYER_SKATE_C */