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( ent_gate *gate ){
 118    world_routes_fracture( world_current_instance(), gate,
 119                           localplayer.rb.co, localplayer.rb.v );
 120
 121    localplayer.gate_waiting = gate;
 122    world_routes_activate_entry_gate( world_current_instance(), gate );
 123
 124    struct player_cam_controller *cc = &localplayer.cam_control;
 125    m4x3_mulv( gate->transport, cc->tpv_lpf, cc->tpv_lpf );
 126    m3x3_mulv( gate->transport, cc->cam_velocity_smooth,
 127                                cc->cam_velocity_smooth );
 128    m3x3_copy( localplayer.basis, localplayer.basis_gate );
 129
 130    v4f q;
 131    m3x3_q( gate->transport, q );
 132    q_mul( q, localplayer.qbasis, localplayer.qbasis );
 133    q_normalize( localplayer.qbasis );
 134    q_m3x3( localplayer.qbasis, localplayer.basis );
 135    m3x3_transpose( localplayer.basis, localplayer.invbasis );
 136
 137    m4x3_mulv( gate->transport, localplayer.cam.pos, localplayer.cam.pos );
 138
 139    if( gate->flags & k_ent_gate_nonlocal )
 140       world_set_active_instance( gate->target );
 141
 142    audio_lock();
 143    audio_oneshot( &audio_gate_pass, 1.0f, 0.0f );
 144    audio_unlock();
 145
 146    replay_clear( &skaterift.replay );
 147 }
 148
 149 static void player_apply_transport_to_cam( m4x3f transport ){
 150    /* FIXME: Applies to skaterift.cam directly! */
 151
 152    /* Pre-emptively edit the camera matrices so that the motion vectors
 153     * are correct */
 154    m4x3f transport_i;
 155    m4x4f transport_4;
 156    m4x3_invert_affine( transport, transport_i );
 157    m4x3_expand( transport_i, transport_4 );
 158    m4x4_mul( skaterift.cam.mtx.pv, transport_4, skaterift.cam.mtx.pv );
 159    m4x4_mul( skaterift.cam.mtx.v,  transport_4, skaterift.cam.mtx.v );
 160
 161    /* we want the regular transform here no the inversion */
 162    m4x3_expand( transport, transport_4 );
 163    m4x4_mul( world_gates.cam.mtx.pv, transport_4, world_gates.cam.mtx.pv );
 164    m4x4_mul( world_gates.cam.mtx.v,  transport_4, world_gates.cam.mtx.v );
 165 }
 166
 167 static void player__im_gui(void){
 168    if( !k_player_debug_info ) return;
 169
 170    ui_rect box = {
 171       vg.window_x - 300,
 172       0,
 173       300,
 174       vg.window_y
 175    };
 176
 177    ui_fill( box, (ui_colour(k_ui_bg)&0x00ffffff)|0x50000000 );
 178
 179    g_player_debugger[0] = box[0];
 180    g_player_debugger[1] = 0;
 181    g_player_debugger[2] = 300;
 182    g_player_debugger[3] = 32;
 183
 184    player__debugtext( 2, "instance #%u", world_static.active_instance );
 185
 186    char buf_hub[96],
 187         buf_client[96];
 188    if( world_static.addon_client )
 189       addon_alias_uid( &world_static.addon_client->alias, buf_client );
 190    else
 191       strcpy( buf_client, "none" );
 192
 193    if( world_static.addon_hub )
 194       addon_alias_uid( &world_static.addon_hub->alias, buf_hub );
 195    else
 196       strcpy( buf_hub, "none" );
 197
 198    player__debugtext( 1, "hub uid: %s", buf_hub );
 199    player__debugtext( 1, "client uid: %s", buf_client );
 200    player__debugtext( 2, "director" );
 201    player__debugtext( 1, "activity: %s",
 202                      (const char *[]){ [k_skaterift_menu]      = "menu",
 203                                        [k_skaterift_replay]    = "replay",
 204                                        [k_skaterift_ent_focus] = "ent_focus",
 205                                        [k_skaterift_default]   = "default",
 206                                        [k_skaterift_respawning]= "respawning",
 207                      } [skaterift.activity] );
 208    player__debugtext( 1, "time_rate: %.4f", skaterift.time_rate );
 209
 210    player__debugtext( 2, "player" );
 211    player__debugtext( 1, "angles: " PRINTF_v3f( localplayer.cam.angles ) );
 212    player__debugtext( 1, "basis:  " PRINTF_v4f( localplayer.qbasis ) );
 213
 214    if( player_subsystems[ localplayer.subsystem ]->im_gui )
 215       player_subsystems[ localplayer.subsystem ]->im_gui();
 216
 217    skaterift_replay_debug_info();
 218 }
 219
 220
 221 static void player__setpos( v3f pos ){
 222    v3_copy( pos, localplayer.rb.co );
 223    v3_zero( localplayer.rb.v );
 224    rb_update_transform( &localplayer.rb );
 225 }
 226
 227 static void player__spawn( ent_spawn *rp ){
 228    replay_clear( &skaterift.replay );
 229    player__setpos( rp->transform.co );
 230    v3_zero( localplayer.rb.w );
 231    q_identity( localplayer.rb.q );
 232    rb_update_transform( &localplayer.rb );
 233
 234    q_identity( localplayer.qbasis );
 235    m3x3_identity( localplayer.basis );
 236    m3x3_identity( localplayer.invbasis );
 237
 238    localplayer.subsystem = k_player_subsystem_walk;
 239    localplayer.immobile = 0;
 240    localplayer.gate_waiting = NULL;
 241    world_static.last_use = 0.0;
 242    world_static.focused_entity = 0;
 243    world_static.challenge_target = NULL;
 244    world_static.challenge_timer = 0.0f;
 245    world_entity_unfocus();
 246
 247    if( player_subsystems[ localplayer.subsystem ]->reset )
 248       player_subsystems[ localplayer.subsystem ]->reset( rp );
 249 }
 250
 251
 252 static void player__kill(void){
 253 }
 254
 255 static void player__begin_holdout(void){
 256    memcpy( &localplayer.holdout_pose, &localplayer.pose,
 257             sizeof(localplayer.pose) );
 258    localplayer.holdout_time = 1.0f;
 259 }
 260
 261 /* implementation */
 262 #include "player_common.c"
 263 #include "player_walk.c"
 264 #include "player_skate.c"
 265 #include "player_dead.c"
 266 #include "player_drive.c"
 267 #include "player_render.c"
 268 #include "player_ragdoll.c"
 269 #include "player_replay.c"
 270
 271 #endif /* PLAYER_C */