run to skate animation

diff --git a/models_src/ch_new.mdl b/models_src/ch_new.mdl
index 0faad3735f33490f47d1509ad704e7ba3d0943c0..b50b895de16a5238fb39ac5db39351d5d50690fe 100644 (file)
Binary files a/models_src/ch_new.mdl and b/models_src/ch_new.mdl differ

diff --git a/player_skate.c b/player_skate.c
index bee2a0ca214a0a65f50e21e1f17a6d52c4b26150..4d40667658aed7856cd16ac67920350b66dfc51a 100644 (file)
--- a/player_skate.c
+++ b/player_skate.c
@@ -413,6 +413,13 @@ void player__approximate_best_trajectory( player_instance *player )
             p->score = -v3_dot( ve, p->n );
             p->land_dist = t + k_trace_delta * t1;
 
+            u32 vert_index = world.scene_geo->arrindices[ idx*3 ];
+            struct world_material *mat = world_tri_index_material( vert_index );
+            
+            /* Bias prediction towords ramps */
+            if( !(mat->info.flags & k_material_flag_skate_surface) )
+               p->score *= 10.0f;
+
             break;
          }
 
@@ -641,49 +648,55 @@ VG_STATIC void skate_apply_steering_model( player_instance *player )
    struct player_skate *s = &player->_skate;
 
    /* Steering */
-   float input = player->input_js1h->axis.value,
-         grab  = player->input_grab->axis.value,
-         steer = input * (1.0f-(s->state.jump_charge+grab)*0.4f),
-         steer_scaled = vg_signf(steer) * powf(steer,2.0f) * k_steer_ground;
+   float steer = player->input_js1h->axis.value,
+         grab  = player->input_grab->axis.value;
+
+   steer = vg_signf( steer ) * steer*steer * k_steer_ground;
 
    v3f steer_axis;
-   v3_muls( player->rb.to_world[1], -vg_signf( steer_scaled ), steer_axis );
+   v3_muls( player->rb.to_world[1], -vg_signf( steer ), steer_axis );
 
    float rate = 26.0f,
          top  = 1.0f;
 
    if( s->state.activity == k_skate_activity_air )
    {
-      rate = 6.0f * fabsf(steer_scaled);
+      rate = 6.0f * fabsf(steer);
       top  = 1.5f;
    }
-   else if( s->state.activity == k_skate_activity_grind_5050 )
+   else
    {
-      rate = 0.0f;
-      top  = 0.0f;
-   }
+      /* rotate slower when grabbing on ground */
+      steer *= (1.0f-(s->state.jump_charge+grab)*0.4f);
 
-   else if( s->state.activity >= k_skate_activity_grind_any )
-   {
-      rate *= fabsf(steer_scaled);
+      if( s->state.activity == k_skate_activity_grind_5050 )
+      {
+         rate = 0.0f;
+         top  = 0.0f;
+      }
 
-      float a = 0.8f * -steer_scaled * k_rb_delta;
+      else if( s->state.activity >= k_skate_activity_grind_any )
+      {
+         rate *= fabsf(steer);
 
-      v4f q;
-      q_axis_angle( q, player->rb.to_world[1], a );
-      q_mulv( q, s->grind_vec, s->grind_vec );
+         float a = 0.8f * -steer * k_rb_delta;
 
-      v3_normalize( s->grind_vec );
-   }
+         v4f q;
+         q_axis_angle( q, player->rb.to_world[1], a );
+         q_mulv( q, s->grind_vec, s->grind_vec );
 
-   else if( s->state.manual_direction )
-   {
-      rate = 35.0f;
-      top  = 1.5f;
+         v3_normalize( s->grind_vec );
+      }
+
+      else if( s->state.manual_direction )
+      {
+         rate = 35.0f;
+         top  = 1.5f;
+      }
    }
 
    float current  = v3_dot( player->rb.to_world[1], player->rb.w ),
-         addspeed = (steer_scaled * -top) - current,
+         addspeed = (steer * -top) - current,
          maxaccel = rate * k_rb_delta,
          accel    = vg_clampf( addspeed, -maxaccel, maxaccel );
 

diff --git a/player_walk.c b/player_walk.c
index d5f4aa0c28df9d57a1200ff762b6723f3f5c5bcb..4dd56e391fff9439690cc72f7ab9538cfbe9e645 100644 (file)
--- a/player_walk.c
+++ b/player_walk.c
@@ -15,7 +15,8 @@ VG_STATIC void player_walk_drop_in_vector( player_instance *player, v3f vec )
 }
 
 VG_STATIC void player_walk_generic_to_skate( player_instance *player,
-                                             enum skate_activity init )
+                                             enum skate_activity init,
+                                             float yaw )
 {
    player->subsystem = k_player_subsystem_skate;
 
@@ -28,7 +29,7 @@ VG_STATIC void player_walk_generic_to_skate( player_instance *player,
    xy_speed[1] = 0.0f;
 
    if( v3_length2( xy_speed ) < 0.1f * 0.1f )
-      q_mulv( player->rb.q, (v3f){0.0f,0.0f,-1.6f}, v );
+      q_mulv( player->rb.q, (v3f){0.0f,0.0f,1.6f}, v );
    else
       v3_copy( player->rb.v, v );
 
@@ -49,7 +50,7 @@ VG_STATIC void player_walk_generic_to_skate( player_instance *player,
    player__skate_reset_animator( player );
    player__skate_clear_mechanics( player );
    rb_update_transform( &player->rb );
-   v3_copy( (v3f){0.0f,0.0f,0.0f}, s->state.trick_euler );
+   v3_copy( (v3f){yaw,0.0f,0.0f}, s->state.trick_euler );
 
    if( init == k_skate_activity_air )
       player__approximate_best_trajectory( player );
@@ -256,10 +257,16 @@ VG_STATIC void player__walk_pre_update( player_instance *player )
          {
             player_walk_drop_in_to_skate( player );
          }
+         else if( w->state.outro_type == k_walk_outro_jump_to_air )
+         {
+            player_walk_generic_to_skate( player, k_skate_activity_air, 0.0f );
+         }
          else
          {
-            player_walk_generic_to_skate( player, k_skate_activity_air );
+            player_walk_generic_to_skate( player, 
+                                          k_skate_activity_ground, 1.0f );
          }
+
          return;
       }
    }
@@ -279,7 +286,20 @@ VG_STATIC void player__walk_pre_update( player_instance *player )
                        av->sk.bones[ av->id_ik_foot_r ].co, 
                        w->state.drop_in_foot_anchor );
          }
-         return;
+         else
+         {
+            w->state.outro_type = k_walk_outro_regular;
+            w->state.outro_anim = w->anim_intro;
+            w->state.outro_start_time = vg.time;
+            w->state.activity = k_walk_activity_lockedmove;
+
+            v3f xy_speed;
+            v3_copy( player->rb.v, xy_speed );
+            xy_speed[1] = 0.0f;
+
+            if( v3_length2( xy_speed ) < 0.1f * 0.1f )
+               q_mulv( player->rb.q, (v3f){0.0f,0.0f,1.6f}, player->rb.v );
+         }
       }
       else
       {
@@ -371,7 +391,9 @@ VG_STATIC void player__walk_update( player_instance *player )
    len = rb_manifold_apply_filtered( manifold, len );
 
    v3f surface_avg = { 0.0f, 0.0f, 0.0f };
-   w->state.activity = k_walk_activity_air;
+
+   if( w->state.activity != k_walk_activity_lockedmove )
+      w->state.activity = k_walk_activity_air;
 
    for( int i=0; i<len; i++ )
    {
@@ -380,7 +402,9 @@ VG_STATIC void player__walk_update( player_instance *player )
 
       if( player_walk_normal_standable( ct->n ) )
       {
-         w->state.activity = k_walk_activity_ground;
+         if( w->state.activity != k_walk_activity_lockedmove )
+            w->state.activity = k_walk_activity_ground;
+
          v3_add( surface_avg, ct->n, surface_avg );
       }
 
@@ -392,7 +416,7 @@ VG_STATIC void player__walk_update( player_instance *player )
     */
    float accel_speed = 0.0f, nominal_speed = 0.0f;
    v3f movedir;
-   v3_muls( right_dir,   walk[0], movedir );
+   v3_muls( right_dir,  walk[0], movedir );
    v3_muladds( movedir, forward_dir, walk[1], movedir );
 
    if( w->state.activity == k_walk_activity_ground )
@@ -775,7 +799,8 @@ VG_STATIC void player__walk_im_gui( player_instance *player )
                            (const char *[]){ "k_walk_activity_air",
                                              "k_walk_activity_ground",
                                              "k_walk_activity_sleep",
-                                             "k_walk_activity_immobile" }
+                                             "k_walk_activity_immobile",
+                                             "k_walk_activity_lockedmove" }
                                              [w->state.activity] );
 
    if( w->state.outro_anim )
@@ -799,6 +824,7 @@ VG_STATIC void player__walk_bind( player_instance *player )
    w->anim_jump         = skeleton_get_anim( sk, "jump+y" );
    w->anim_jump_to_air  = skeleton_get_anim( sk, "jump_to_air" );
    w->anim_drop_in      = skeleton_get_anim( sk, "drop_in" );
+   w->anim_intro        = skeleton_get_anim( sk, "into_skate" );
 }
 
 VG_STATIC void player__walk_transition( player_instance *player, v3f angles )

diff --git a/player_walk.h b/player_walk.h
index bc1fb59f13fd042b83b668c49cd271d20ece431f..beb87d25e476cab9f0595fd2e75f4e1d92234761 100644 (file)
--- a/player_walk.h
+++ b/player_walk.h
@@ -23,7 +23,8 @@ struct player_walk
          k_walk_activity_air,
          k_walk_activity_ground,
          k_walk_activity_sleep,
-         k_walk_activity_immobile
+         k_walk_activity_immobile,
+         k_walk_activity_lockedmove
       }
       activity;
 
@@ -31,7 +32,8 @@ struct player_walk
       {
          k_walk_outro_none,
          k_walk_outro_jump_to_air,
-         k_walk_outro_drop_in
+         k_walk_outro_drop_in,
+         k_walk_outro_regular
       }
       outro_type;
 
@@ -43,7 +45,7 @@ struct player_walk
 
    enum mdl_surface_prop surface;
    struct skeleton_anim *anim_walk, *anim_run, *anim_idle, *anim_jump,
-                        *anim_jump_to_air, *anim_drop_in;
+                        *anim_jump_to_air, *anim_drop_in, *anim_intro;
 
    float blend_fly,
          blend_run,

diff --git a/skaterift.c b/skaterift.c
index 201453080afa0f45f5953f3ddbda63fa4d91da61..fa10ecb3e87736da6b1ad1e0f954247b420e2927 100644 (file)
--- a/skaterift.c
+++ b/skaterift.c
@@ -424,9 +424,11 @@ VG_STATIC void render_scene(void)
    int player_transparent = 1,
        player_draw        = 1;
 
+#if 0
    if( (localplayer.subsystem == k_player_subsystem_dead) ||
        (localplayer.camera_mode == k_cam_thirdperson) )
       player_transparent = 0;
+#endif
                
    if( !player_transparent && player_draw )
       player__render( &main_camera, &localplayer );