player.c

   1 #ifndef PLAYER_C
   2 #define PLAYER_C
   3
   4 #include "player.h"
   5 #include "camera.h"
   6 #include "player_model.h"
   7 #include "input.h"
   8 #include "world.h"
   9 #include "audio.h"
  10 #include "player_replay.h"
  11 #include "network.h"
  12
  13 static int localplayer_cmd_respawn( int argc, const char *argv[] ){
  14    ent_spawn *rp = NULL, *r;
  15    world_instance *world = localplayer.viewable_world;
  16
  17    if( argc == 1 ){
  18       rp = world_find_spawn_by_name( world, argv[0] );
  19    }
  20    else if( argc == 0 ){
  21       rp = world_find_closest_spawn( world, localplayer.rb.co );
  22    }
  23
  24    if( !rp )
  25       return 0;
  26
  27    player__spawn( rp );
  28    return 1;
  29 }
  30
  31 static void player_init(void){
  32    for( u32 i=0; i<vg_list_size(player_subsystems); i++ ){
  33       struct player_subsystem_interface *sys = player_subsystems[i];
  34
  35       if( sys->system_register ) sys->system_register();
  36    }
  37
  38    vg_console_reg_cmd( "respawn", localplayer_cmd_respawn, NULL );
  39    VG_VAR_F32( k_cam_damp );
  40    VG_VAR_F32( k_cam_spring );
  41    VG_VAR_F32( k_cam_punch );
  42    VG_VAR_F32( k_cam_shake_strength );
  43    VG_VAR_F32( k_cam_shake_trackspeed );
  44    VG_VAR_I32( k_player_debug_info, flags=VG_VAR_PERSISTENT );
  45
  46    vg_console_reg_var( "cinema", &k_cinema, k_var_dtype_f32, 0 );
  47    vg_console_reg_var( "cinema_fixed", &k_cinema_fixed, k_var_dtype_i32, 0 );
  48    vg_console_reg_var( "invert_y", &k_invert_y,
  49                         k_var_dtype_i32, VG_VAR_PERSISTENT );
  50 }
  51
  52 static void player__debugtext( int size, const char *fmt, ... ){
  53         char buffer[ 1024 ];
  54
  55    va_list args;
  56    va_start( args, fmt );
  57    vsnprintf( buffer, 1024, fmt, args );
  58    va_end( args );
  59
  60    ui_text( g_player_debugger, buffer, size, k_ui_align_left, 0 );
  61    g_player_debugger[1] += size*16;
  62 }
  63
  64 /*
  65  * Appearence
  66  */
  67 static void player__use_avatar( struct player_avatar *av ){
  68    localplayer.playeravatar = av;
  69    player_setup_ragdoll_from_avatar( &localplayer.ragdoll, av );
  70 }
  71
  72 static void player__use_model( u16 reg_id ){
  73    addon_cache_unwatch( k_addon_type_player,
  74                         localplayer.playermodel_view_slot );
  75    localplayer.playermodel_view_slot =
  76       addon_cache_create_viewer( k_addon_type_player, reg_id );
  77 }
  78
  79 static void player__bind(void){
  80    for( u32 i=0; i<vg_list_size(player_subsystems); i++ ){
  81       struct player_subsystem_interface *sys = player_subsystems[i];
  82
  83       if( sys->bind ) sys->bind();
  84    }
  85 }
  86
  87 /*
  88  * Gameloop events
  89  * ----------------------------------------------------------------------------
  90  */
  91
  92 static void player__pre_update(void){
  93    if( button_down( k_srbind_camera ) && !localplayer.immobile ){
  94       if( localplayer.cam_control.camera_mode == k_cam_firstperson )
  95          localplayer.cam_control.camera_mode = k_cam_thirdperson;
  96       else
  97          localplayer.cam_control.camera_mode = k_cam_firstperson;
  98    }
  99
 100    if( player_subsystems[ localplayer.subsystem ]->pre_update )
 101       player_subsystems[ localplayer.subsystem ]->pre_update();
 102 }
 103
 104 static void player__update(void){
 105    if( player_subsystems[ localplayer.subsystem ]->update )
 106       player_subsystems[ localplayer.subsystem ]->update();
 107 }
 108
 109 static void player__post_update(void){
 110    if( player_subsystems[ localplayer.subsystem ]->post_update )
 111       player_subsystems[ localplayer.subsystem ]->post_update();
 112 }
 113
 114 /*
 115  * Applies gate transport to a player_interface
 116  */
 117 static void player__pass_gate( u32 id ){
 118    world_instance *world = world_current_instance();
 119
 120    /* update boundary hash (network animation) */
 121    u16 index = mdl_entity_id_id(id) & ~NETMSG_BOUNDARY_MASK;
 122    localplayer.boundary_hash ^= NETMSG_GATE_BOUNDARY_BIT;
 123    localplayer.boundary_hash &= ~NETMSG_BOUNDARY_MASK;
 124    localplayer.boundary_hash |= index;
 125
 126    ent_gate *gate = mdl_arritm( &world->ent_gate, mdl_entity_id_id(id) );
 127    world_routes_fracture( world, gate, localplayer.rb.co, localplayer.rb.v );
 128
 129    localplayer.gate_waiting = gate;
 130    world_routes_activate_entry_gate( world_current_instance(), gate );
 131
 132    struct player_cam_controller *cc = &localplayer.cam_control;
 133    m4x3_mulv( gate->transport, cc->tpv_lpf, cc->tpv_lpf );
 134    m3x3_mulv( gate->transport, cc->cam_velocity_smooth,
 135                                cc->cam_velocity_smooth );
 136    m3x3_copy( localplayer.basis, localplayer.basis_gate );
 137
 138    v4f q;
 139    m3x3_q( gate->transport, q );
 140    q_mul( q, localplayer.qbasis, localplayer.qbasis );
 141    q_normalize( localplayer.qbasis );
 142    q_m3x3( localplayer.qbasis, localplayer.basis );
 143    m3x3_transpose( localplayer.basis, localplayer.invbasis );
 144
 145    m4x3_mulv( gate->transport, localplayer.cam.pos, localplayer.cam.pos );
 146
 147    if( gate->flags & k_ent_gate_nonlocal )
 148       world_set_active_instance( gate->target );
 149
 150    audio_lock();
 151    audio_oneshot( &audio_gate_pass, 1.0f, 0.0f );
 152    audio_unlock();
 153
 154    replay_clear( &skaterift.replay );
 155 }
 156
 157 static void player_apply_transport_to_cam( m4x3f transport ){
 158    /* FIXME: Applies to skaterift.cam directly! */
 159
 160    /* Pre-emptively edit the camera matrices so that the motion vectors
 161     * are correct */
 162    m4x3f transport_i;
 163    m4x4f transport_4;
 164    m4x3_invert_affine( transport, transport_i );
 165    m4x3_expand( transport_i, transport_4 );
 166    m4x4_mul( skaterift.cam.mtx.pv, transport_4, skaterift.cam.mtx.pv );
 167    m4x4_mul( skaterift.cam.mtx.v,  transport_4, skaterift.cam.mtx.v );
 168
 169    /* we want the regular transform here no the inversion */
 170    m4x3_expand( transport, transport_4 );
 171    m4x4_mul( world_gates.cam.mtx.pv, transport_4, world_gates.cam.mtx.pv );
 172    m4x4_mul( world_gates.cam.mtx.v,  transport_4, world_gates.cam.mtx.v );
 173 }
 174
 175 static void player__im_gui(void){
 176    if( !k_player_debug_info ) return;
 177
 178    ui_rect box = {
 179       vg.window_x - 300,
 180       0,
 181       300,
 182       vg.window_y
 183    };
 184
 185    ui_fill( box, (ui_colour(k_ui_bg)&0x00ffffff)|0x50000000 );
 186
 187    g_player_debugger[0] = box[0];
 188    g_player_debugger[1] = 0;
 189    g_player_debugger[2] = 300;
 190    g_player_debugger[3] = 32;
 191
 192    player__debugtext( 2, "instance #%u", world_static.active_instance );
 193
 194    char buf_hub[96],
 195         buf_client[96];
 196    if( world_static.addon_client )
 197       addon_alias_uid( &world_static.addon_client->alias, buf_client );
 198    else
 199       strcpy( buf_client, "none" );
 200
 201    if( world_static.addon_hub )
 202       addon_alias_uid( &world_static.addon_hub->alias, buf_hub );
 203    else
 204       strcpy( buf_hub, "none" );
 205
 206    player__debugtext( 1, "hub uid: %s", buf_hub );
 207    player__debugtext( 1, "client uid: %s", buf_client );
 208    player__debugtext( 2, "director" );
 209    player__debugtext( 1, "activity: %s",
 210                      (const char *[]){ [k_skaterift_menu]      = "menu",
 211                                        [k_skaterift_replay]    = "replay",
 212                                        [k_skaterift_ent_focus] = "ent_focus",
 213                                        [k_skaterift_default]   = "default",
 214                                        [k_skaterift_respawning]= "respawning",
 215                      } [skaterift.activity] );
 216    player__debugtext( 1, "time_rate: %.4f", skaterift.time_rate );
 217
 218    player__debugtext( 2, "player" );
 219    player__debugtext( 1, "angles: " PRINTF_v3f( localplayer.cam.angles ) );
 220    player__debugtext( 1, "basis:  " PRINTF_v4f( localplayer.qbasis ) );
 221
 222    if( player_subsystems[ localplayer.subsystem ]->im_gui )
 223       player_subsystems[ localplayer.subsystem ]->im_gui();
 224
 225    skaterift_replay_debug_info();
 226 }
 227
 228
 229 static void player__setpos( v3f pos ){
 230    v3_copy( pos, localplayer.rb.co );
 231    v3_zero( localplayer.rb.v );
 232    rb_update_transform( &localplayer.rb );
 233 }
 234
 235 static void player__spawn( ent_spawn *rp ){
 236    replay_clear( &skaterift.replay );
 237    player__setpos( rp->transform.co );
 238    v3_zero( localplayer.rb.w );
 239    q_identity( localplayer.rb.q );
 240    rb_update_transform( &localplayer.rb );
 241
 242    q_identity( localplayer.qbasis );
 243    m3x3_identity( localplayer.basis );
 244    m3x3_identity( localplayer.invbasis );
 245
 246    localplayer.subsystem = k_player_subsystem_walk;
 247    localplayer.immobile = 0;
 248    localplayer.gate_waiting = NULL;
 249    world_static.last_use = 0.0;
 250    world_static.focused_entity = 0;
 251    world_static.challenge_target = NULL;
 252    world_static.challenge_timer = 0.0f;
 253    world_entity_unfocus();
 254
 255    if( player_subsystems[ localplayer.subsystem ]->reset )
 256       player_subsystems[ localplayer.subsystem ]->reset( rp );
 257
 258    localplayer.boundary_hash ^= NETMSG_BOUNDARY_BIT;
 259 }
 260
 261
 262 static void player__kill(void){
 263 }
 264
 265 static void player__begin_holdout(void){
 266    memcpy( &localplayer.holdout_pose, &localplayer.pose,
 267             sizeof(localplayer.pose) );
 268    localplayer.holdout_time = 1.0f;
 269 }
 270
 271 /* implementation */
 272 #include "player_common.c"
 273 #include "player_walk.c"
 274 #include "player_skate.c"
 275 #include "player_dead.c"
 276 #include "player_drive.c"
 277 #include "player_render.c"
 278 #include "player_ragdoll.c"
 279 #include "player_replay.c"
 280
 281 #endif /* PLAYER_C */