X-Git-Url: https://harrygodden.com/git/?a=blobdiff_plain;f=player_physics.h;h=6afc1b2c43b0f3e1cf560e83ca1baceb9836a05b;hb=0124cd309a7db70cdd74b5661f2df8b862ca2f2f;hp=a2aabff741f946f4ddd37d1471bde817f60e78a3;hpb=02e138a27fd43ed09bc1869691a8a3a4224d0132;p=carveJwlIkooP6JGAAIwe30JlM.git

diff --git a/player_physics.h b/player_physics.h
index a2aabff..6afc1b2 100644
--- a/player_physics.h
+++ b/player_physics.h
@@ -356,14 +356,11 @@ VG_STATIC void player_physics_control(void)
    phys->slip = slip;
    phys->reverse = -vg_signf(vel[2]);
 
-   float substep = VG_TIMESTEP_FIXED * 0.2f;
+   float substep = VG_TIMESTEP_FIXED;
    float fwd_resistance = k_friction_resistance;
 
-   for( int i=0; i<5; i++ )
-   {
-      vel[2] = stable_force( vel[2],vg_signf(vel[2]) * -fwd_resistance*substep);
-      vel[0] = stable_force( vel[0],vg_signf(vel[0]) * -k_friction_lat*substep);
-   }
+   vel[2] = stable_force( vel[2],vg_signf(vel[2]) * -fwd_resistance*substep);
+   vel[0] = stable_force( vel[0],vg_signf(vel[0]) * -k_friction_lat*substep);
    
    if( player.input_jump->button.value )
    {
@@ -406,6 +403,59 @@ VG_STATIC void player_physics_control(void)
          steer_scaled = vg_signf(steer) * powf(steer,2.0f) * k_steer_ground;
 
    phys->iY -= steer_scaled * VG_TIMESTEP_FIXED;
+   
+
+   /*
+    * EXPERIMENTAL
+    * ===============================================
+    */
+#if 0
+   v3f cog_ideal, diff;
+
+   v3_muladds( phys->rb.co, phys->rb.up, 1.0f-grab, cog_ideal );
+   v3_sub( cog_ideal, phys->cog, diff );
+
+   /* temp */
+   if( v3_length2( diff ) > 20.0f*20.0f )
+      v3_copy( cog_ideal, phys->cog );
+   else
+   {
+      float rate_lat  = k_cog_spring_lat * VG_TIMESTEP_FIXED,
+            rate_vert = k_cog_spring_vert * VG_TIMESTEP_FIXED,
+            vert_amt  = v3_dot( diff, phys->rb.up );
+
+      /* Split into vert/lat springs */
+      v3f diff_vert, diff_lat;
+      v3_muladds( diff, phys->rb.up, -vert_amt, diff_lat );
+      v3_muls( phys->rb.up, vert_amt, diff_vert );
+
+
+      if( diff[1] > 0.0f )
+         rate_vert *= k_cog_boost_multiplier;
+
+      float ap_a =        k_cog_mass_ratio,
+            ap_b = -(1.0f-k_cog_mass_ratio);
+
+      v3_muladds( phys->cog_v, diff_lat,  rate_lat  * ap_a,  phys->cog_v );
+      v3_muladds( phys->cog_v, diff_vert, rate_vert * ap_a,  phys->cog_v );
+
+      //v3_muladds( phys->rb.v,  diff_lat,  rate_lat  * ap_b,  phys->rb.v );
+      v3_muladds( phys->rb.v,  diff_vert, rate_vert * ap_b,  phys->rb.v );
+
+      /* dampen */
+      v3_muls( phys->cog_v, 1.0f-(VG_TIMESTEP_FIXED*k_cog_damp), phys->cog_v );
+
+      /* integrate */
+      v3_muladds( phys->cog, phys->cog_v, VG_TIMESTEP_FIXED, phys->cog );
+   }
+
+
+   /*
+    * EXPERIMENTAL
+    * ===============================================
+    */
+#endif
+
 
    if( !phys->jump_charge && phys->jump > 0.2f )
    {
@@ -577,7 +627,7 @@ VG_STATIC void player_physics_control_air(void)
 #endif
 }
 
-VG_STATIC void player_walk_update_collision(void)
+VG_STATIC void player_walk_collider_configuration(void)
 {
    struct player_phys *phys = &player.phys;
    float h0 = 0.3f,
@@ -597,6 +647,32 @@ VG_STATIC void player_walk_update_collision(void)
    rb_update_bounds( rbb );
 }
 
+VG_STATIC void player_regular_collider_configuration(void)
+{
+   struct player_phys *phys = &player.phys;
+   
+   /* Standard ground configuration */
+   rigidbody *rbf = &player.collide_front,
+             *rbb = &player.collide_back;
+
+   m3x3_copy( phys->rb.to_world, player.collide_front.to_world );
+   m3x3_copy( phys->rb.to_world, player.collide_back.to_world );
+   
+   player.air_blend = vg_lerpf( player.air_blend, phys->in_air, 0.1f );
+   float h = player.air_blend*0.0f;
+
+   m4x3_mulv( phys->rb.to_world, (v3f){0.0f,h,-k_board_length}, rbf->co );
+   v3_copy( rbf->co, rbf->to_world[3] );
+   m4x3_mulv( phys->rb.to_world, (v3f){0.0f,h, k_board_length}, rbb->co );
+   v3_copy( rbb->co, rbb->to_world[3] );
+
+   m4x3_invert_affine( rbf->to_world, rbf->to_local );
+   m4x3_invert_affine( rbb->to_world, rbb->to_local );
+
+   rb_update_bounds( rbf );
+   rb_update_bounds( rbb );
+}
+
 VG_STATIC void player_integrate(void);
 
 VG_STATIC int player_walk_surface_standable( v3f n )
@@ -632,10 +708,7 @@ VG_STATIC void player_walk_stepdown(void)
    }
 }
 
-/*
- * Entire Walking physics model
- * TODO: sleep when under certain velotiy
- */
+VG_STATIC int player_update_collision_manifold( rb_ct *manifold );
 VG_STATIC void player_walk_physics(void)
 {
    struct player_phys *phys = &player.phys;
@@ -665,9 +738,7 @@ VG_STATIC void player_walk_physics(void)
 
    if( phys->in_air )
    {
-      player_walk_update_collision();
-      rb_debug( rbf, 0xff0000ff );
-      rb_debug( rbb, 0xff0000ff );
+      player_walk_collider_configuration();
 
       /* allow player to accelerate a bit */
       v3f walk_3d;
@@ -683,9 +754,7 @@ VG_STATIC void player_walk_physics(void)
       v3_muladds( phys->rb.v, forward_dir, walk[1] * vel_diff, phys->rb.v );
 
 
-      len = 0;
-      len += rb_sphere_scene( rbf, &world.rb_geo, manifold+len );
-      len += rb_sphere_scene( rbb, &world.rb_geo, manifold+len );
+      len = player_update_collision_manifold( manifold );
       rb_presolve_contacts( manifold, len );
 
       for( int i=0; i<len; i++ )
@@ -741,39 +810,37 @@ VG_STATIC void player_walk_physics(void)
 
       v2_muls( walk, k_walkspeed * VG_TIMESTEP_FIXED, walk );
 
-      v3f walk_apply;
-      v3_zero( walk_apply );
-
       /* Do XY translation */
+      v3f walk_apply, walk_measured;
+      v3_zero( walk_apply );
       v3_muladds( walk_apply, right_dir,   walk[0], walk_apply );
       v3_muladds( walk_apply, forward_dir, walk[1], walk_apply );
       v3_add( walk_apply, phys->rb.co, phys->rb.co );
-      v3_divs( walk_apply, VG_TIMESTEP_FIXED, phys->rb.v );
 
       /* Directly resolve collisions */
-      player_walk_update_collision();
-      rb_debug( rbf, 0xffffff00 );
-      rb_debug( rbb, 0xffffff00 );
-
-      len = 0;
-      len += rb_sphere_scene( rbf, &world.rb_geo, manifold+len );
-      len += rb_sphere_scene( rbb, &world.rb_geo, manifold+len );
+      player_walk_collider_configuration();
+      len = player_update_collision_manifold( manifold );
 
       v3f dt;
       v3_zero( dt );
-      for( int j=0; j<3; j++ )
+      for( int j=0; j<8; j++ )
       {
          for( int i=0; i<len; i++ )
          {
             struct contact *ct = &manifold[i];
 
-            float p   = vg_maxf( 0.0f, ct->p - 0.00f ),
-                  cur = vg_clampf( v3_dot( ct->n, dt ), 0.0f, p );
-            v3_muladds( dt, ct->n, (p - cur) * 0.333333333f, dt );
+            float resolved_amt = v3_dot( ct->n, dt ),
+                  remaining    = (ct->p-k_penetration_slop) - resolved_amt,
+                  apply        = vg_maxf( remaining, 0.0f ) * 0.3f;
+
+            v3_muladds( dt, ct->n, apply, dt );
          }
       }
       v3_add( dt, phys->rb.co, phys->rb.co );
 
+      v3_add( dt, walk_apply, walk_measured );
+      v3_divs( walk_measured, VG_TIMESTEP_FIXED, phys->rb.v );
+
       if( len )
       {
          struct world_material *surface_mat = world_contact_material(manifold);
@@ -800,58 +867,6 @@ VG_STATIC void player_walk_physics(void)
       /* otherwise... */
       if( phys->in_air )
          player_walk_stepdown();
-      
-#if 0
-      /* if we've put us in the air, step down slowly */
-      phys->in_air = 1;
-      float max_dist = 0.3f,
-            start_y = phys->rb.co[1];
-
-      v3f pa, pb;
-      v3_copy( phys->rb.co, pa );
-      v3_muladds( pa, (v3f){0.0f,1.0f,0.0f}, -max_dist, pb );
-
-
-      for( int j=0; j<8; j++ )
-      {
-         for( int i=0; i<len; i++ )
-         {
-            struct contact *ct = &manifold[i];
-            if( v3_dot( ct->n, (v3f){0.0f,1.0f,0.0f} ) > 0.5f )
-            {
-               phys->in_air = 0;
-               if( j == 0 )
-                  return;
-
-               v3f dt;
-               v3_zero( dt );
-               for( int j=0; j<3; j++ )
-               {
-                  for( int i=0; i<len; i++ )
-                  {
-                     struct contact *ct = &manifold[i];
-
-                     float p   = vg_maxf( 0.0f, ct->p - 0.0025f ),
-                           cur = vg_clampf( v3_dot( ct->n, dt ), 0.0f, p );
-                     v3_muladds( dt, ct->n, (p - cur) * 0.333333333f, dt );
-                  }
-               }
-               v3_add( dt, phys->rb.co, phys->rb.co );
-               return;
-            }
-         }
-
-         phys->rb.co[1] -= max_dist * 0.125f;
-
-         player_walk_update_collision();
-         len = 0;
-         len += rb_sphere_scene( rbf, &world.rb_geo, manifold+len );
-         len += rb_sphere_scene( rbb, &world.rb_geo, manifold+len );
-      }
-      
-      /* Transitioning into air mode */
-      phys->rb.co[1] = start_y;
-#endif
    }
 }
 
@@ -895,13 +910,17 @@ VG_STATIC int player_update_grind_collision( rb_ct *contact )
                                                                 c0, c1, k_r );
 
    
+#if 0
    vg_line( p0, p1, 0xff0000ff );
+#endif
 
    if( closest_edge )
    {
+#if 0
       vg_line_cross( c0, 0xff000000, 0.1f );
       vg_line_cross( c1, 0xff000000, 0.1f );
       vg_line( c0, c1, 0xff000000 );
+#endif
 
       v3f delta;
       v3_sub( c1, c0, delta );
@@ -939,32 +958,18 @@ VG_STATIC int player_update_collision_manifold( rb_ct *manifold )
 {
    struct player_phys *phys = &player.phys;
 
-   phys->rise = vg_lerpf( phys->rise, phys->in_air? -0.25f: 0.0f, 
-                          VG_TIMESTEP_FIXED );
-
    rigidbody *rbf = &player.collide_front,
              *rbb = &player.collide_back;
 
-   m3x3_copy( phys->rb.to_world, player.collide_front.to_world );
-   m3x3_copy( phys->rb.to_world, player.collide_back.to_world );
-   
-   player.air_blend = vg_lerpf( player.air_blend, phys->in_air, 0.1f );
-   float h = player.air_blend*0.0f;
-
-   m4x3_mulv( phys->rb.to_world, (v3f){0.0f,h,-k_board_length}, rbf->co );
-   v3_copy( rbf->co, rbf->to_world[3] );
-   m4x3_mulv( phys->rb.to_world, (v3f){0.0f,h, k_board_length}, rbb->co );
-   v3_copy( rbb->co, rbb->to_world[3] );
-
-   m4x3_invert_affine( rbf->to_world, rbf->to_local );
-   m4x3_invert_affine( rbb->to_world, rbb->to_local );
-
-   rb_update_bounds( rbf );
-   rb_update_bounds( rbb );
-
    rb_debug( rbf, 0xff00ffff );
    rb_debug( rbb, 0xffffff00 );
 
+
+#if 0
+   phys->rise = vg_lerpf( phys->rise, phys->in_air? -0.25f: 0.0f, 
+                          VG_TIMESTEP_FIXED );
+#endif
+
    int len_f = 0,
        len_b = 0; 
 
@@ -996,28 +1001,6 @@ VG_STATIC int player_update_collision_manifold( rb_ct *manifold )
       len_b = 1;
    else
       len_b = new_len_b;
-#if 0
-   /* 
-    * Preprocess collision points, and create a surface picture.
-    * we want contacts that are within our 'capsule's internal line to be 
-    * clamped so that they face the line and do not oppose, to stop the
-    * player hanging up on stuff
-    */
-   for( int i=0; i<len; i++ )
-   {
-      v3f dfront, dback;
-      v3_sub( manifold[i].co, rbf->co, dfront );
-      v3_sub( manifold[i].co, rbb->co, dback );
-
-      if( (v3_dot( dfront, phys->rb.forward ) < -0.02f) &&
-          (v3_dot( dback,  phys->rb.forward ) > 0.02f))
-      {
-         float p = v3_dot( manifold[i].n, phys->rb.forward );
-         v3_muladds( manifold[i].n, phys->rb.forward, -p, manifold[i].n );
-         v3_normalize( manifold[i].n );
-      }
-   }
-#endif
 
    return len_f + len_b;
 }
@@ -1030,7 +1013,108 @@ VG_STATIC void player_adhere_ground( rb_ct *manifold, int len )
    v3f surface_avg;
    v3_zero( surface_avg );
 
-   if( len == 0 )
+   /*
+    *
+    * EXPERIMENTAL
+    * ================================================================
+    */
+   if( phys->in_air )
+      player.normal_pressure = 0.0f;
+   else
+      player.normal_pressure = v3_dot( phys->rb.up, phys->rb.v );
+
+   v3f p0_0, p0_1,
+       p1_0, p1_1,
+       n0, n1;
+   float t0, t1;
+
+   float mod      = 0.7f * player.input_grab->axis.value + 0.3f,
+         spring_k = mod * k_spring_force,
+         damp_K   = mod * k_spring_dampener,
+         disp_k   = 0.4f;
+
+   v3_copy( player.collide_front.co, p0_0 );
+   v3_copy( player.collide_back.co,  p1_0 );
+
+   v3_muladds( p0_0, phys->rb.up, -disp_k, p0_1 );
+   v3_muladds( p1_0, phys->rb.up, -disp_k, p1_1 );
+
+   int cast0 = spherecast_world( p0_0, p0_1, 0.2f, &t0, n0 ),
+       cast1 = spherecast_world( p1_0, p1_1, 0.2f, &t1, n1 );
+
+   v3f animp0, animp1;
+
+   m4x3f temp;
+   m3x3_copy( phys->rb.to_world, temp );
+   if( cast0 != -1 )
+   {
+      v3_lerp( p0_0, p0_1, t0, temp[3] );
+      v3_copy( temp[3], animp0 );
+      debug_sphere( temp, 0.2f, VG__PINK );
+      
+      v3f F, delta;
+      v3_sub( p0_0, phys->rb.co, delta );
+      
+      float displacement = vg_clampf( 1.0f-t0, 0.0f, 1.0f ),
+            damp         = vg_maxf( 0.0f, v3_dot( phys->rb.up, phys->rb.v ) );
+      v3_muls( phys->rb.up, displacement*spring_k*k_rb_delta -
+                            damp*damp_K*k_rb_delta, F );
+
+      v3_muladds( phys->rb.v, F, 1.0f, phys->rb.v );
+      
+      /* Angular velocity */
+      v3f wa;
+      v3_cross( delta, F, wa );
+      v3_muladds( phys->rb.w, wa, k_spring_angular, phys->rb.w );
+   }
+   else
+      v3_copy( p0_1, animp0 );
+
+   if( cast1 != -1 )
+   {
+      v3_lerp( p1_0, p1_1, t1, temp[3] );
+      v3_copy( temp[3], animp1 );
+      debug_sphere( temp, 0.2f, VG__PINK );
+
+      v3f F, delta;
+      v3_sub( p1_0, phys->rb.co, delta );
+      
+      float displacement = vg_clampf( 1.0f-t1, 0.0f, 1.0f ),
+            damp         = vg_maxf( 0.0f, v3_dot( phys->rb.up, phys->rb.v ) );
+      v3_muls( phys->rb.up, displacement*spring_k*k_rb_delta -
+                            damp*damp_K*k_rb_delta, F );
+
+      v3_muladds( phys->rb.v, F, 1.0f, phys->rb.v );
+      
+      /* Angular velocity */
+      v3f wa;
+      v3_cross( delta, F, wa );
+      v3_muladds( phys->rb.w, wa, k_spring_angular, phys->rb.w );
+   }
+   else
+      v3_copy( p1_1, animp1 );
+
+   v3f animavg, animdelta;
+   v3_add( animp0, animp1, animavg );
+   v3_muls( animavg, 0.5f, animavg );
+
+   v3_sub( animp1, animp0, animdelta );
+   v3_normalize( animdelta );
+
+   m4x3_mulv( phys->rb.to_local, animavg, player.board_offset );
+
+   float dx = -v3_dot( animdelta, phys->rb.forward ),
+         dy =  v3_dot( animdelta, phys->rb.up );
+
+   float angle = -atan2f( dy, dx );
+   q_axis_angle( player.board_rotation, (v3f){ 1.0f, 0.0f, 0.0f }, angle );
+
+   /*
+    * ================================================================
+    * EXPERIMENTAL
+    */
+
+   if( len == 0 && !((cast0 !=-1)&&(cast1!=-1)) )
    {
       phys->lift_frames ++;
 
@@ -1066,11 +1150,13 @@ VG_STATIC void player_adhere_ground( rb_ct *manifold, int len )
          float angle = v3_dot( phys->rb.up, projected );
          v3_cross( phys->rb.up, projected, axis );
 
+#if 0
          v3f p0, p1;
          v3_add( phys->rb.co, projected, p0 );
          v3_add( phys->rb.co, phys->rb.up, p1 );
          vg_line( phys->rb.co, p0, 0xff00ff00 );
          vg_line( phys->rb.co, p1, 0xff000fff );
+#endif
 
          if( fabsf(angle) < 0.999f )
          {
@@ -1090,7 +1176,106 @@ VG_STATIC void player_collision_response( rb_ct *manifold, int len )
 {
    struct player_phys *phys = &player.phys;
 
-   for( int j=0; j<5; j++ )
+   /*
+    * EXPERIMENTAL
+    * ===============================================
+    */
+
+#if 0
+   player.normal_pressure = v3_dot( phys->rb.up, phys->rb.v );
+
+   {
+      float ideal   = 1.0f-player.input_grab->axis.value,
+            diff    = phys->spring - ideal,
+            Fspring = -k_cog_spring_lat * diff,
+            Fdamp   = -k_cog_damp       * phys->springv,
+            F       = (Fspring + Fdamp) * k_rb_delta;
+
+      phys->springv += F;
+      phys->spring  += phys->springv * k_rb_delta;
+
+      if( phys->springv > 0.0f )
+         v3_muladds( phys->rb.v, phys->rb.up, F*k_cog_spring_vert, phys->rb.v );
+
+      if( phys->in_air )
+         player.normal_pressure = 0.0f;
+      else
+         player.normal_pressure = v3_dot( phys->rb.up, phys->rb.v );
+   }
+#endif
+
+   if( player.input_grab->axis.value > 0.5f )
+   {
+      if( !phys->in_air )
+      {
+         /* Throw */
+         v3_muls( phys->rb.up, k_mmthrow_scale, phys->throw_v );
+      }
+   }
+   else
+   {
+      /* Collect */
+      float doty = v3_dot( phys->rb.up, phys->throw_v );
+      
+      v3f Fl, Fv;
+      v3_muladds( phys->throw_v, phys->rb.up, -doty, Fl );
+
+      if( !phys->in_air )
+      {
+         v3_muladds( phys->rb.v,    Fl,  k_mmcollect_lat, phys->rb.v );
+         v3_muladds( phys->throw_v, Fl, -k_mmcollect_lat, phys->throw_v );
+      }
+
+      v3_muls( phys->rb.up, -doty, Fv );
+      v3_muladds( phys->rb.v,    Fv, k_mmcollect_vert, phys->rb.v );
+      v3_muladds( phys->throw_v, Fv, k_mmcollect_vert, phys->throw_v );
+
+      v3_copy( Fl, player.debug_mmcollect_lat );
+      v3_copy( Fv, player.debug_mmcollect_vert );
+   }
+
+   /* Decay */
+   if( v3_length2( phys->throw_v ) > 0.0001f )
+   {
+      v3f dir;
+      v3_copy( phys->throw_v, dir );
+      v3_normalize( dir );
+
+      float max = v3_dot( dir, phys->throw_v ),
+            amt = vg_minf( k_mmdecay * k_rb_delta, max );
+
+      v3_muladds( phys->throw_v, dir, -amt, phys->throw_v );
+   }
+
+
+   /* TODO: RElocate */
+   {
+
+   v3f ideal_cog, ideal_diff;
+   v3_muladds( phys->rb.co, phys->rb.up, 
+               1.0f-player.input_grab->axis.value, ideal_cog );
+   v3_sub( ideal_cog, phys->cog, ideal_diff );
+
+   /* Apply velocities */
+   v3f rv;
+   v3_sub( phys->rb.v, phys->cog_v, rv );
+
+   v3f F;
+   v3_muls( ideal_diff, -k_cog_spring * k_rb_rate, F );
+   v3_muladds( F, rv,   -k_cog_damp * k_rb_rate, F );
+
+   float ra = k_cog_mass_ratio,
+         rb = 1.0f-k_cog_mass_ratio;
+
+   v3_muladds( phys->cog_v, F, -rb, phys->cog_v );
+   }
+
+   /*
+    * EXPERIMENTAL
+    * ===============================================
+    */
+
+   for( int j=0; j<10; j++ )
    {
       for( int i=0; i<len; i++ )
       {
@@ -1136,6 +1321,10 @@ VG_STATIC void player_collision_response( rb_ct *manifold, int len )
          v3_muladds( phys->rb.w, phys->rb.right, wx, phys->rb.w );
       }
    }
+   
+   /* early integrate this */
+   phys->cog_v[1] += -9.8f * k_rb_delta;
+   v3_muladds( phys->cog, phys->cog_v, k_rb_delta, phys->cog );
 }
 
 VG_STATIC void player_save_frame(void)
@@ -1152,6 +1341,10 @@ VG_STATIC void player_restore_frame(void)
 VG_STATIC void player_integrate(void)
 {
    struct player_phys *phys = &player.phys;
+   v3_sub( phys->rb.v, phys->v_last, phys->a );
+   v3_muls( phys->a, 1.0f/VG_TIMESTEP_FIXED, phys->a );
+   v3_copy( phys->rb.v, phys->v_last );
+
    apply_gravity( phys->rb.v, VG_TIMESTEP_FIXED );
    v3_muladds( phys->rb.co, phys->rb.v, VG_TIMESTEP_FIXED, phys->rb.co );
 }
@@ -1181,6 +1374,8 @@ VG_STATIC void player_do_motion(void)
    if( phys->on_board )
    {
       rb_ct manifold[72];
+      
+      player_regular_collider_configuration();
       int len = player_update_collision_manifold( manifold );
       int grind_col = player_update_grind_collision( &manifold[len] );
 
@@ -1297,6 +1492,8 @@ VG_STATIC void player_do_motion(void)
       if( gate_intersect( gate, phys->rb.co, prevco ) )
       {
          m4x3_mulv( gate->transport, phys->rb.co, phys->rb.co );
+         m4x3_mulv( gate->transport, phys->cog, phys->cog );
+         m3x3_mulv( gate->transport, phys->cog_v, phys->cog_v );
          m3x3_mulv( gate->transport, phys->rb.v, phys->rb.v );
          m3x3_mulv( gate->transport, phys->vl, phys->vl );
          m3x3_mulv( gate->transport, phys->v_last, phys->v_last );
@@ -1366,6 +1563,12 @@ VG_STATIC void player_freecam(void)
    v3_add( move_vel, player.camera_pos, player.camera_pos );
 }
 
+VG_STATIC int kill_player( int argc, char const *argv[] )
+{
+   player_kill();
+   return 0;
+}
+
 VG_STATIC int reset_player( int argc, char const *argv[] )
 {
    struct player_phys *phys = &player.phys;
@@ -1428,10 +1631,12 @@ VG_STATIC int reset_player( int argc, char const *argv[] )
 
    v3f delta = {1.0f,0.0f,0.0f};
    m3x3_mulv( the_long_way, delta, delta );
-
-   player.angles[0] = atan2f( delta[0], -delta[2] ); 
-   player.angles[1] = -asinf( delta[1] );
-
+   
+   if( !freecam )
+   {
+      player.angles[0] = atan2f( delta[0], -delta[2] ); 
+      player.angles[1] = -asinf( delta[1] );
+   }
 
    v4_copy( rp->q, phys->rb.q );
    v3_copy( rp->co, phys->rb.co );
@@ -1447,8 +1652,64 @@ VG_STATIC int reset_player( int argc, char const *argv[] )
    player.mdl.shoes[1] = 1;
    
    rb_update_transform( &phys->rb );
+   
+   v3_add( phys->rb.up, phys->rb.co, phys->cog );
+   v3_zero( phys->cog_v );
+
    player_save_frame();
    return 1;
 }
 
+VG_STATIC void reset_player_poll( int argc, char const *argv[] )
+{
+   if( argc == 1 )
+   {
+      for( int i=0; i<world.spawn_count; i++ )
+      {
+         struct respawn_point *r = &world.spawns[i];
+
+         console_suggest_score_text( r->name, argv[argc-1], 0 );
+      }
+   }
+}
+
+VG_STATIC void player_physics_gui(void)
+{
+   return;
+
+	vg_uictx.cursor[0] = 0;
+	vg_uictx.cursor[1] = vg.window_y - 128;
+	vg_uictx.cursor[3] = 14;
+	ui_fill_x();
+
+   char buf[128];
+
+   snprintf( buf, 127, "v: %6.3f %6.3f %6.3f\n", player.phys.rb.v[0],
+                                                 player.phys.rb.v[1],
+                                                 player.phys.rb.v[2] );
+
+   ui_text( vg_uictx.cursor, buf, 1, 0 );
+	vg_uictx.cursor[1] += 14;
+
+
+   snprintf( buf, 127, "a: %6.3f %6.3f %6.3f (%6.3f)\n", player.phys.a[0],
+                                                     player.phys.a[1],
+                                                     player.phys.a[2],
+                                                     v3_length(player.phys.a));
+   ui_text( vg_uictx.cursor, buf, 1, 0 );
+	vg_uictx.cursor[1] += 14;
+
+   float normal_acceleration = v3_dot( player.phys.a, player.phys.rb.up );
+   snprintf( buf, 127, "Normal acceleration: %6.3f\n", normal_acceleration );
+
+   ui_text( vg_uictx.cursor, buf, 1, 0 );
+	vg_uictx.cursor[1] += 14;
+
+   snprintf( buf, 127, "Normal Pressure: %6.3f\n", player.normal_pressure );
+   ui_text( vg_uictx.cursor, buf, 1, 0 );
+	vg_uictx.cursor[1] += 14;
+
+
+}
+
 #endif /* PLAYER_PHYSICS_H */