dead

diff --git a/player.c b/player.c
index 85cf9166f25ff00b2690e56add842c5917291827..5c9f8cfe21d441e0766fae3ad9f1e22bd4eeb591 100644 (file)
--- a/player.c
+++ b/player.c
@@ -42,6 +42,9 @@ void player__create( player_instance *inst )
    inst->input_use  = vg_create_named_input( "use",     k_input_type_button );
    inst->input_reset= vg_create_named_input( "reset",   k_input_type_button );
    inst->input_camera=vg_create_named_input( "camera",  k_input_type_button );
+   inst->input_trick0=vg_create_named_input( "trick0",  k_input_type_button );
+   inst->input_trick1=vg_create_named_input( "trick1",  k_input_type_button );
+   inst->input_trick2=vg_create_named_input( "trick2",  k_input_type_button );
 
    const char *default_cfg[] = 
    {
@@ -61,6 +64,12 @@ void player__create( player_instance *inst )
       "bind jump space",
       "bind jump gp-a",
 
+      "bind trick0 mouse1",
+      "bind trick0 gp-a",
+      "bind trick1 mouse2",
+      "bind trick1 gp-b",
+      "bind trick2 gp-x",     /* keyboard: m0 + m1 */
+
       "bind push gp-b",
       "bind push w",
 
@@ -292,6 +301,8 @@ PLAYER_API void player__spawn( player_instance *player,
    q_identity( player->rb.q );
    rb_update_transform( &player->rb );
 
+   player->subsystem = k_player_subsystem_walk;
+
    if( _player_reset[ player->subsystem ] )
       _player_reset[ player->subsystem ]( player, rp );
 }

diff --git a/player.h b/player.h
index 137a1ad056896fb33289b2f24a4aa2f408847bf4..50929831ef0c81d93c79f8f94d11342500ec4f5f 100644 (file)
--- a/player.h
+++ b/player.h
@@ -6,7 +6,7 @@
 #include "player_common.h"
 #include "player_walk.h"
 #include "player_skate.h"
-//#include "player_dead.h"
+#include "player_dead.h"
 
 struct player_instance
 {
@@ -59,6 +59,9 @@ struct player_instance
                         *input_js2v,
                         *input_jump,
                         *input_push,
+                        *input_trick0,
+                        *input_trick1,
+                        *input_trick2,
                         *input_walk,
                         *input_walkh,
                         *input_walkv,
@@ -95,7 +98,7 @@ struct player_instance
 
    struct player_skate  _skate;
    struct player_walk   _walk;
-   //struct player_dead   _dead;
+   struct player_dead   _dead;
 };
 
 /*
@@ -132,7 +135,7 @@ void( *_player_update[])( player_instance *player ) =
 {
    player__walk_update,
    player__skate_update,
-   NULL
+   player__dead_update,
 };
 
 VG_STATIC 
@@ -156,7 +159,7 @@ void( *_player_animate[])( player_instance *player, player_animation *dest ) =
 {
    player__walk_animate,
    player__skate_animate,
-   NULL
+   player__dead_animate
 };
 
 VG_STATIC
@@ -164,7 +167,7 @@ void( *_player_post_animate[])( player_instance *player ) =
 {
    player__walk_post_animate,
    player__skate_post_animate,
-   NULL
+   player__dead_post_animate
 };
 
 /* implementation */
@@ -173,7 +176,7 @@ void( *_player_post_animate[])( player_instance *player ) =
 #include "player_common.c"
 #include "player_walk.c"
 #include "player_skate.c"
-//#include "player_dead.c"
+#include "player_dead.c"
 
 #endif /* PLAYER_H */
 

diff --git a/player_common.c b/player_common.c
index 017aa148a02fe1ca43cd3925d9812d8015111c90..3ce7c9cdc7d6143aaf52c77a8f6dc49e81ba0abf 100644 (file)
--- a/player_common.c
+++ b/player_common.c
@@ -99,9 +99,14 @@ VG_STATIC void player__cam_iterate( player_instance *player )
          player->cam_velocity_constant,
          vg.frame_delta * 8.0f );
 
+   enum camera_mode target_mode = player->camera_mode;
+
+   if( player->subsystem == k_player_subsystem_dead )
+      target_mode = k_cam_thirdperson;
+
    player->camera_type_blend = 
       vg_lerpf( player->camera_type_blend, 
-                (player->camera_mode == k_cam_firstperson)? 1.0f: 0.0f,
+                (target_mode == k_cam_firstperson)? 1.0f: 0.0f,
                 5.0f * vg.frame_delta );
 
    v3_lerp( player->fpv_viewpoint_smooth, player->fpv_viewpoint,

diff --git a/player_dead.c b/player_dead.c
new file mode 100644 (file)
index 0000000..f040adb
--- /dev/null
+++ b/player_dead.c
@@ -0,0 +1,63 @@
+#ifndef PLAYER_DEAD_C
+#define PLAYER_DEAD_C
+
+#include "player.h"
+
+VG_STATIC void player__dead_update      ( player_instance *player )
+{
+   player_ragdoll_iter( &player->ragdoll );
+}
+
+VG_STATIC void player__dead_animate     ( player_instance *player, 
+                                          player_animation *anim )
+{
+   v3_zero( anim->root_co );
+   q_identity( anim->root_q );
+   
+   for( int i=0; i<vg_list_size( anim->pose ); i ++ )
+   {
+      v3_zero( anim->pose[i].co );
+      v3_fill( anim->pose[i].s, 1.0f );
+      q_identity( anim->pose[i].q );
+   }
+}
+
+VG_STATIC void player__dead_post_animate( player_instance *player )
+{
+   struct player_avatar *av = player->playeravatar;
+   struct player_dead   *d  = &player->_dead;
+
+   copy_ragdoll_pose_to_avatar( &player->ragdoll, player->playeravatar );
+   player->cam_velocity_influence = 1.0f;
+
+   struct ragdoll_part *part = &player->ragdoll.parts[ av->id_hip-1 ];
+
+   v3_lerp( d->co_lpf, part->rb.co, vg.frame_delta*4.0f, d->co_lpf );
+   v3_lerp( d->v_lpf,  part->rb.v,  vg.frame_delta*4.0f, d->v_lpf );
+   v3_lerp( d->w_lpf,  part->rb.w,  vg.frame_delta*4.0f, d->w_lpf );
+   
+   v3_copy( d->co_lpf, player->rb.co );
+   v3_copy( d->v_lpf, player->rb.v );
+   v3_copy( d->w_lpf, player->rb.w );
+}
+
+VG_STATIC void player__dead_im_gui      ( player_instance *player )
+{
+
+}
+
+VG_STATIC void player__dead_transition  ( player_instance *player )
+{
+   player->subsystem = k_player_subsystem_dead;
+   copy_avatar_pose_to_ragdoll( player->playeravatar, &player->ragdoll, 
+                                player->rb.v );
+
+   struct player_avatar *av = player->playeravatar;
+   struct ragdoll_part *part = &player->ragdoll.parts[ av->id_hip-1 ];
+   struct player_dead   *d  = &player->_dead;
+   v3_copy( part->rb.co, d->co_lpf );
+   v3_copy( part->rb.v,  d->v_lpf );
+   v3_copy( part->rb.w,  d->w_lpf );
+}
+
+#endif /* PLAYER_DEAD_C */

diff --git a/player_dead.h b/player_dead.h
new file mode 100644 (file)
index 0000000..4a10e98
--- /dev/null
+++ b/player_dead.h
@@ -0,0 +1,19 @@
+#ifndef PLAYER_DEAD_H
+#define PLAYER_DEAD_H
+
+#include "player_api.h"
+
+struct player_dead
+{
+   v3f co_lpf, v_lpf, w_lpf;
+};
+
+VG_STATIC void player__dead_update      ( player_instance *player );
+VG_STATIC void player__dead_animate     ( player_instance *player, 
+                                          player_animation *anim );
+
+VG_STATIC void player__dead_post_animate( player_instance *player );
+VG_STATIC void player__dead_im_gui      ( player_instance *player );
+VG_STATIC void player__dead_transition  ( player_instance *player );
+
+#endif /* PLAYER_DEAD_H */

diff --git a/player_skate.c b/player_skate.c
index 788bf0bff2adc7d54c0c3648bb5d13c507b69058..be356676872b52024c1c0002979749b6304f73c1 100644 (file)
--- a/player_skate.c
+++ b/player_skate.c
@@ -712,6 +712,7 @@ 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;
@@ -734,7 +735,7 @@ VG_STATIC void skate_apply_trick_model( player_instance *player )
       if( v3_length2( s->state.trick_vel ) < 0.0001f )
          return;
 
-      int carry_on = player->input_jump->button.value;
+      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) */
@@ -771,9 +772,18 @@ VG_STATIC void skate_apply_trick_model( player_instance *player )
    }
    else
    {
-      if( s->state.lift_frames == 0 )
+      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 );
    }
 }
 
@@ -909,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,
@@ -919,11 +928,6 @@ 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;
-
-      v3_zero( s->state.trick_vel );
-      s->state.trick_vel[0] = 3.0f;
-      s->state.trick_vel[2] = 6.0f;
-      s->state.trick_time = 0.0f;
       s->state.lift_frames ++;
 
       /* FIXME audio events */
@@ -1041,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 );
@@ -1119,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;
@@ -1132,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 )
@@ -1525,7 +1565,7 @@ VG_STATIC void player__skate_animate( player_instance *player,
 
       q_mul( qpitch, qroll, qtrick );
       q_mul( qyaw, qtrick, qtrick );
-      q_mul( qtrick, kf_board->q, kf_board->q );
+      q_mul( kf_board->q, qtrick, kf_board->q );
       q_normalize( kf_board->q );
    }
 
@@ -1611,6 +1651,8 @@ VG_STATIC void player__skate_clear_mechanics( player_instance *player )
    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_reset( player_instance *player,