X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_skate.c;h=be356676872b52024c1c0002979749b6304f73c1;hb=c4c762ce6f3bbdcb770bbc42e349aebbc3390d9d;hp=4e354e5e8ed009f448a71754a89bcdc958548d97;hpb=33de52d9660ab86caafdd0ae4abb496dbc072778;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_skate.c b/player_skate.c
index 4e354e5..be35667 100644
--- a/player_skate.c
+++ b/player_skate.c
@@ -263,7 +263,7 @@ VG_STATIC void skate_score_biased_path( v3f co, v3f v, m3x3f vr,
 }
 
 VG_STATIC 
-void player_approximate_best_trajectory( player_instance *player )
+void player__approximate_best_trajectory( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
 
@@ -458,7 +458,7 @@ VG_STATIC void skate_apply_air_model( player_instance *player )
       return;
 
    if( s->state.activity_prev != k_skate_activity_air )
-      player_approximate_best_trajectory( player );
+      player__approximate_best_trajectory( player );
 
    m3x3_mulv( s->state.velocity_bias, player->rb.v, player->rb.v );
    ray_hit hit;
@@ -684,6 +684,12 @@ VG_STATIC void skate_apply_interface_model( player_instance *player,
          s->state.lift_frames = 0;
          v3f projected, axis;
 
+         if( s->state.activity_prev == k_skate_activity_air )
+         {
+            player->cam_land_punch_v += v3_dot( player->rb.v, surface_avg ) *
+                                          k_cam_punch;
+         }
+
          float const DOWNFORCE = -k_downforce*VG_TIMESTEP_FIXED;
          v3_muladds( player->rb.v, player->rb.to_world[1], 
                      DOWNFORCE, player->rb.v );
@@ -706,6 +712,81 @@ VG_STATIC void skate_apply_interface_model( player_instance *player,
    }
 }
 
+VG_STATIC int player_skate_trick_input( player_instance *player );
+VG_STATIC void skate_apply_trick_model( player_instance *player )
+{
+   struct player_skate *s = &player->_skate;
+
+   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_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 );
+
+   if( s->state.activity == k_skate_activity_air )
+   {
+      if( v3_length2( s->state.trick_vel ) < 0.0001f )
+         return;
+
+      int carry_on = player_skate_trick_input( player );
+
+      /* we assume velocities share a common divisor, in which case the 
+       * interval is the minimum value (if not zero) */
+
+      float min_rate = 99999.0f;
+
+      for( int i=0; i<3; i++ )
+      {
+         float v = s->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;
+
+
+      /* 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->board_trick_residualv );
+         v3_zero( s->state.trick_vel );
+      }
+
+      s->state.trick_time += k_rb_delta;
+   }
+   else
+   {
+      if( (s->state.lift_frames == 0) 
+          && (v3_length2(s->state.trick_vel) >= 0.0001f ) &&
+          s->state.trick_time > 0.2f)
+      {
+         player__dead_transition( 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] );
+      s->state.trick_time = 0.0f;
+      v3_zero( s->state.trick_vel );
+   }
+}
+
 VG_STATIC void skate_apply_grab_model( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
@@ -838,7 +919,6 @@ VG_STATIC void skate_apply_jump_model( player_instance *player )
       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;
 
       v2f steer = { player->input_js1h->axis.value,
@@ -848,6 +928,7 @@ VG_STATIC void skate_apply_jump_model( player_instance *player )
       float maxspin = k_steer_air * k_rb_delta * k_spin_boost;
       s->state.steery_s = -steer[0] * maxspin;
       s->state.steerx = s->state.steerx_s;
+      s->state.lift_frames ++;
 
       /* FIXME audio events */
 #if 0
@@ -964,11 +1045,8 @@ VG_STATIC void skate_collision_response( player_instance *player,
          if( fabsf(v3_dot( impulse, player->rb.to_world[2] )) > 10.0f ||
              fabsf(v3_dot( impulse, player->rb.to_world[1] )) > 50.0f )
          {
-            /* FIXME */
-#if 0
-            player_kill();
+            player__dead_transition( player );
             return;
-#endif
          }
 
          v3_add( impulse, player->rb.v, player->rb.v );
@@ -1042,8 +1120,22 @@ VG_STATIC void skate_integrate( player_instance *player )
    rb_update_transform( &player->rb );
 }
 
+/*
+ * 1 2 or 3
+ */
+
+VG_STATIC int player_skate_trick_input( player_instance *player )
+{
+   return (player->input_trick0->button.value) |
+          (player->input_trick1->button.value << 1) |
+          (player->input_trick2->button.value << 1) |
+          (player->input_trick2->button.value);
+}
+
 VG_STATIC void player__skate_pre_update( player_instance *player )
 {
+   struct player_skate *s = &player->_skate;
+
    if( vg_input_button_down( player->input_use ) )
    {
       player->subsystem = k_player_subsystem_walk;
@@ -1055,6 +1147,31 @@ VG_STATIC void player__skate_pre_update( player_instance *player )
       player__walk_transition( player, angles );
       return;
    }
+
+   int trick_id; 
+   if( (s->state.lift_frames > 0) &&
+       (trick_id = 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( trick_id == 1 )
+         {
+            s->state.trick_vel[0] = 3.0f;
+         }
+         else if( trick_id == 2 )
+         {
+            s->state.trick_vel[2] = 3.0f;
+         }
+         else if( trick_id == 3 )
+         {
+            s->state.trick_vel[0] = 2.0f;
+            s->state.trick_vel[2] = 2.0f;
+         }
+      }
+   }
 }
 
 VG_STATIC void player__skate_post_update( player_instance *player )
@@ -1157,6 +1274,7 @@ VG_STATIC void player__skate_update( player_instance *player )
    skate_apply_friction_model( player );
    skate_apply_jump_model( player );
    skate_apply_air_model( player );
+   skate_apply_trick_model( player );
 
    skate_integrate( player );
 
@@ -1168,7 +1286,6 @@ VG_STATIC void player__skate_update( player_instance *player )
 
    vg_line( player->rb.co, s->state.cog, VG__RED );
 
-
    teleport_gate *gate;
    if( (gate = world_intersect_gates( player->rb.co, s->state.prev_pos )) )
    {
@@ -1178,13 +1295,6 @@ VG_STATIC void player__skate_update( player_instance *player )
       m3x3_mulv( gate->transport, s->state.cog_v, s->state.cog_v );
       m3x3_mulv( gate->transport, s->state.throw_v, s->state.throw_v );
 
-      /*camera */
-      m3x3_mulv( gate->transport, s->state.vl, s->state.vl );
-
-#if 0
-      mixedcam_transport( &s->state.cam, gate );
-#endif
-
       v4f transport_rotation;
       m3x3_q( gate->transport, transport_rotation );
       q_mul( transport_rotation, player->rb.q, player->rb.q );
@@ -1210,16 +1320,24 @@ VG_STATIC void player__skate_im_gui( player_instance *player )
                                                 player->rb.w[1],
                                                 player->rb.w[2] );
 
-   player__debugtext( 1, "activity: %s\n",
+   player__debugtext( 1, "activity: %s",
                            (const char *[]){ "k_skate_activity_air",
                                              "k_skate_activity_ground",
                                              "k_skate_activity_grind }" }
                                              [s->state.activity] );
-   player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]\n",
+   player__debugtext( 1, "steer_s: %5.2f %5.2f [%.2f %.2f]",
                         s->state.steerx_s, s->state.steery_s,
                         k_steer_ground, k_steer_air );
-   player__debugtext( 1, "flip: %.4f %.4f\n", s->state.flip_rate, 
+   player__debugtext( 1, "flip: %.4f %.4f", s->state.flip_rate, 
                                              s->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] );
 }
 
 VG_STATIC void player__skate_animate( player_instance *player,
@@ -1239,18 +1357,16 @@ VG_STATIC void player__skate_animate( player_instance *player,
    m4x3_mulv( player->rb.to_local, s->state.cog, offset );
    v3_muls( offset, -4.0f, offset );
 
-   static float speed_wobble = 0.0f, speed_wobble_2 = 0.0f;
-
    float curspeed  = v3_length( player->rb.v ),
          kickspeed = vg_clampf( curspeed*(1.0f/40.0f), 0.0f, 1.0f ),
          kicks     = (vg_randf()-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], speed_wobble,     2.4f*vg.time_delta);
+   s->wobble[1] = vg_lerpf( s->wobble[1], s->wobble[0],     2.4f*vg.time_delta);
 
    offset[0] *= 0.26f;
-   offset[0] += speed_wobble_2*3.0f;
+   offset[0] += s->wobble[1]*3.0f;
 
    offset[1] *= -0.3f;
    offset[2] *= 0.01f;
@@ -1399,20 +1515,58 @@ VG_STATIC void player__skate_animate( player_instance *player,
       v3_add( bo, kf_foot_l->co, kf_foot_l->co );
       v3_add( bo, kf_foot_r->co, kf_foot_r->co );
 
+#if 0
       m3x3f c;
       q_m3x3( s->board_rotation, c );
+#endif
+
+      v4f qtotal;
+
+      v4f qtrickr, qyawr, qpitchr, qrollr;
+      v3f eulerr;
+
+      
+
+      v3_muls( s->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] );
+      q_axis_angle( qrollr,  (v3f){0.0f,0.0f,1.0f}, eulerr[2] );
+
+      q_mul( qpitchr, qrollr, qtrickr );
+      q_mul( qyawr, qtrickr, qtrickr );
+      q_mul( s->board_rotation, qtrickr, qtotal );
+      q_normalize( qtotal );
+
+      q_mul( qtotal, kf_board->q, kf_board->q );
+
 
       v3f d;
       v3_sub( kf_foot_l->co, bo, d );
-      m3x3_mulv( c, d, d );
+      q_mulv( qtotal, d, d );
       v3_add( bo, d, kf_foot_l->co );
       
       v3_sub( kf_foot_r->co, bo, d );
-      m3x3_mulv( c, d, d );
+      q_mulv( qtotal, d, d );
       v3_add( bo, d, kf_foot_r->co );
 
       q_mul( s->board_rotation, kf_board->q, kf_board->q );
       q_normalize( kf_board->q );
+
+
+      /* trick rotation */
+      v4f qtrick, qyaw, qpitch, qroll;
+      v3f euler;
+      v3_muls( s->state.trick_euler, VG_TAUf, euler );
+
+      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] );
+      q_axis_angle( qroll,  (v3f){0.0f,0.0f,1.0f}, euler[2] );
+
+      q_mul( qpitch, qroll, qtrick );
+      q_mul( qyaw, qtrick, qtrick );
+      q_mul( kf_board->q, qtrick, kf_board->q );
+      q_normalize( kf_board->q );
    }
 
    /* transform */
@@ -1449,133 +1603,72 @@ VG_STATIC void player__skate_animate( player_instance *player,
       v3_muladds( player->rb.co, player->rb.to_world[1], 0.5f, rotation_point );
       v3_sub( dest->root_co, rotation_point, rco );
       
-      /* FIXME: q_mul v3 */
-      m3x3f TEMP;
-      q_m3x3( qflip, TEMP );
-      m3x3_mulv( TEMP, rco, rco );
+      q_mulv( qflip, rco, rco );
       v3_add( rco, rotation_point, dest->root_co );
    }
 }
 
-VG_STATIC void skate_camera_firstperson( player_instance *player )
-{
-   struct player_skate *s = &player->_skate;
-   struct player_avatar *av = player->playeravatar;
-
-   /* FIXME: viewpoint entity */
-   v3f vp = {-0.1f,1.8f,0.0f};
-   m4x3_mulv( av->sk.final_mtx[ av->id_head-1 ], vp, player->fpv_pos );
-   v3_zero( player->fpv_angles );
-
-   v3f flat_dir,
-       vel_dir,
-       look_dir;
-
-   v3_copy( player->rb.v, vel_dir );
-   //v3_normalize( vel_dir );
-
-   float tti = s->land_dist;
-   v3f   norm;
-   v3_copy( s->land_normal, norm );
-
-   if( s->state.activity == k_skate_activity_ground )
-   {
-      tti = 0.0f;
-      v3_copy( player->rb.to_world[1], norm );
-   }
-
-   v3_muladds( vel_dir, norm, -v3_dot(vel_dir,norm), flat_dir );
-   //v3_normalize( flat_dir );
-
-   v3_lerp( flat_dir, vel_dir, vg_clampf( tti / 2.0f, 0.4f, 1.0f ), look_dir );
-   v3_lerp( s->state.vl, look_dir, 4.0f*vg.time_delta, s->state.vl );
-   player_vector_angles( player->fpv_angles, s->state.vl, 1.0f, 0.25f );
-}
-
-VG_STATIC void skate_camera_thirdperson( player_instance *player )
+VG_STATIC void player__skate_post_animate( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
    struct player_avatar *av = player->playeravatar;
 
-   v3f origin, dir, target;
-   v3_copy( player->rb.co, origin );
-   v3_add( origin, (v3f){0.0f,1.35f,0.0f}, origin );
-   player_set_follower_subject( player, origin );
+   player->cam_velocity_influence = 1.0f;
 }
 
-VG_STATIC void player__skate_post_animate( player_instance *player )
+VG_STATIC void player__skate_reset_animator( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
-   struct player_avatar *av = player->playeravatar;
-
-   skate_camera_thirdperson( player );
-   skate_camera_firstperson( player );
-   player->cam_angles_override_strength = 0.0f;
-   player->cam_position_override_strength = 0.0f;
-
-
 
+   if( s->state.activity == k_skate_activity_air )
+      s->blend_fly = 1.0f;
+   else
+      s->blend_fly = 0.0f;
 
-   /* FIXME: Organize this. Its int wrong fucking place */
-   v3f vp0 = {0.0f,0.1f, 0.6f},
-       vp1 = {0.0f,0.1f,-0.6f};
-
-   m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp0, TEMP_BOARD_0 );
-   m4x3_mulv( av->sk.final_mtx[ av->id_board ], vp1, TEMP_BOARD_1 );
+   s->blend_slide = 0.0f;
+   s->blend_z = 0.0f;
+   s->blend_x = 0.0f;
+   s->blend_stand = 0.0f;
+   s->blend_push = 0.0f;
+   s->blend_jump = 0.0f;
+   s->blend_airdir = 0.0f;
 }
 
-VG_STATIC void player__skate_reset( player_instance *player,
-                                   struct respawn_point *rp )
+VG_STATIC void player__skate_clear_mechanics( player_instance *player )
 {
    struct player_skate *s = &player->_skate;
-   v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
+   s->state.jump_charge    = 0.0f;
+   s->state.lift_frames    = 0;
+   s->state.flip_rate      = 0.0f;
+   s->state.steery         = 0.0f;
+   s->state.steerx         = 0.0f;
+   s->state.steery_s       = 0.0f;
+   s->state.steerx_s       = 0.0f;
+   s->state.reverse        = 0.0f;
+   s->state.slip           = 0.0f;
+   v3_copy( player->rb.co, s->state.prev_pos );
 
-#if 0
-   mixedcam_reset( player, &s->state.cam );
-#endif
+   m3x3_identity( s->state.velocity_bias );
+   m3x3_identity( s->state.velocity_bias_pstep );
+   v3_zero( s->state.throw_v );
+   v3_zero( s->state.trick_vel );
+   v3_zero( s->state.trick_euler );
 }
 
-VG_STATIC void player__skate_transition( player_instance *player,
-                                         v3f init_velocity,
-                                         enum skate_activity init_acitivity )
+VG_STATIC void player__skate_reset( player_instance *player,
+                                    struct respawn_point *rp )
 {
    struct player_skate *s = &player->_skate;
-   s->state.activity_prev = k_skate_activity_ground;
-   s->state.activity = init_acitivity;
-
-   v3f dir;
-   v3_copy( init_velocity, dir );
-   v3_normalize( dir );
-   
-   vg_info( "init velocity: %f %f %f\n", init_velocity[0],
-                                         init_velocity[1],
-                                         init_velocity[2] );
-
-   q_axis_angle( player->rb.q, (v3f){0.0f,1.0f,0.0f}, 
-                 atan2f( -dir[0], -dir[2] ) );
-
    v3_muladds( player->rb.co, player->rb.to_world[1], 1.0f, s->state.cog );
-   v3_copy( init_velocity, s->state.cog_v );
-   v3_copy( init_velocity, s->state.vl );
-   v3_copy( init_velocity, player->rb.v );
+   v3_zero( player->rb.v );
+   v3_zero( s->state.cog_v );
+   v4_copy( rp->q, player->rb.q );
 
-   rb_update_transform( &player->rb );
+   s->state.activity = k_skate_activity_air;
+   s->state.activity_prev = k_skate_activity_air;
 
-   if( init_acitivity == k_skate_activity_air )
-   {
-      player_approximate_best_trajectory( player );
-      s->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_stand = 0.0f;
-   s->blend_push = 0.0f;
-   s->blend_jump = 0.0f;
-   s->blend_airdir = 0.0f;
+   player__skate_clear_mechanics( player );
+   player__skate_reset_animator( player );
 }
 
 #endif /* PLAYER_SKATE_C */