6 #include "player_model.h"
10 #include "player_replay.h"
12 VG_STATIC
int localplayer_cmd_respawn( int argc
, const char *argv
[] )
14 ent_spawn
*rp
= NULL
, *r
;
15 world_instance
*world
= localplayer
.viewable_world
;
18 rp
= world_find_spawn_by_name( world
, argv
[0] );
21 rp
= world_find_closest_spawn( world
, localplayer
.rb
.co
);
27 player__spawn( &localplayer
, rp
);
31 VG_STATIC
void player_init(void)
33 for( u32 i
=0; i
<vg_list_size(_player_system_register
); i
++ ){
34 if( _player_system_register
[i
] )
35 _player_system_register
[i
]();
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
);
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
);
53 void player__debugtext( int size
, const char *fmt
, ... )
58 va_start( args
, fmt
);
59 vsnprintf( buffer
, 1024, fmt
, args
);
62 ui_text( g_player_debugger
, buffer
, size
, k_ui_align_left
, 0 );
63 g_player_debugger
[1] += size
*16;
70 void player__create( player_instance
*inst
)
72 static int only_once
= 0;
73 assert( only_once
== 0 );
76 v3_zero( inst
->rb
.co
);
77 v3_zero( inst
->rb
.w
);
78 v3_zero( inst
->rb
.v
);
79 q_identity( inst
->rb
.q
);
80 m4x3_identity( inst
->rb
.to_world
);
81 m4x3_identity( inst
->rb
.to_local
);
88 void player__use_avatar( player_instance
*player
, struct player_avatar
*av
)
90 player
->playeravatar
= av
;
91 player_setup_ragdoll_from_avatar( &player
->ragdoll
, av
);
95 void player__use_model( player_instance
*player
, u16 reg_id
){
96 addon_cache_unwatch( k_addon_type_player
, player
->playermodel_view_slot
);
97 player
->playermodel_view_slot
=
98 addon_cache_create_viewer( k_addon_type_player
, reg_id
);
102 void player__bind( player_instance
*player
)
104 for( u32 i
=0; i
<vg_list_size(_player_bind
); i
++ ){
105 if( _player_bind
[i
] )
106 _player_bind
[i
]( player
);
112 * ----------------------------------------------------------------------------
116 void player__pre_update( player_instance
*player
){
117 if( button_down( k_srbind_camera
) && !player
->immobile
){
118 if( player
->cam_control
.camera_mode
== k_cam_firstperson
)
119 player
->cam_control
.camera_mode
= k_cam_thirdperson
;
121 player
->cam_control
.camera_mode
= k_cam_firstperson
;
124 if( _player_pre_update
[ player
->subsystem
] )
125 _player_pre_update
[ player
->subsystem
]( player
);
129 void player__update( player_instance
*player
){
130 if( _player_update
[ player
->subsystem
] )
131 _player_update
[ player
->subsystem
]( player
);
135 void player__post_update( player_instance
*player
){
136 if( _player_post_update
[ player
->subsystem
] )
137 _player_post_update
[ player
->subsystem
]( player
);
141 * Applies gate transport to a player_interface
144 void player__pass_gate( player_instance
*player
, ent_gate
*gate
)
146 world_routes_fracture( world_current_instance(), gate
,
147 player
->rb
.co
, player
->rb
.v
);
149 player
->gate_waiting
= gate
;
150 world_routes_activate_entry_gate( world_current_instance(), gate
);
152 struct player_cam_controller
*cc
= &player
->cam_control
;
153 m4x3_mulv( gate
->transport
, cc
->tpv_lpf
, cc
->tpv_lpf
);
154 m3x3_mulv( gate
->transport
, cc
->cam_velocity_smooth
,
155 cc
->cam_velocity_smooth
);
156 m3x3_copy( player
->basis
, player
->basis_gate
);
159 m3x3_q( gate
->transport
, q
);
160 q_mul( q
, player
->qbasis
, player
->qbasis
);
161 q_normalize( player
->qbasis
);
162 q_m3x3( player
->qbasis
, player
->basis
);
163 m3x3_transpose( player
->basis
, player
->invbasis
);
165 m4x3_mulv( gate
->transport
, player
->cam
.pos
, player
->cam
.pos
);
167 if( gate
->flags
& k_ent_gate_nonlocal
)
168 world_set_active_instance( gate
->target
);
171 audio_oneshot( &audio_gate_pass
, 1.0f
, 0.0f
);
174 replay_clear( &skaterift
.replay
);
177 VG_STATIC
void player_apply_transport_to_cam( m4x3f transport
)
179 /* FIXME: Applies to skaterift.cam directly! */
181 /* Pre-emptively edit the camera matrices so that the motion vectors
185 m4x3_invert_affine( transport
, transport_i
);
186 m4x3_expand( transport_i
, transport_4
);
187 m4x4_mul( skaterift
.cam
.mtx
.pv
, transport_4
, skaterift
.cam
.mtx
.pv
);
188 m4x4_mul( skaterift
.cam
.mtx
.v
, transport_4
, skaterift
.cam
.mtx
.v
);
190 /* we want the regular transform here no the inversion */
191 m4x3_expand( transport
, transport_4
);
192 m4x4_mul( world_gates
.cam
.mtx
.pv
, transport_4
, world_gates
.cam
.mtx
.pv
);
193 m4x4_mul( world_gates
.cam
.mtx
.v
, transport_4
, world_gates
.cam
.mtx
.v
);
196 __attribute__ ((deprecated
))
197 VG_STATIC
void gate_rotate_angles( ent_gate
*gate
, v3f angles
, v3f d
)
199 v3_copy( angles
, d
);
202 v3f fwd_dir
= { cosf(angles
[0]),
205 m3x3_mulv( gate
->transport
, fwd_dir
, fwd_dir
);
207 v3_copy( angles
, d
);
208 d
[0] = atan2f( fwd_dir
[2], fwd_dir
[0] );
211 PLAYER_API
void player__im_gui( player_instance
*player
){
212 if( !k_player_debug_info
) return;
221 ui_fill( box
, (ui_colour(k_ui_bg
)&0x00ffffff)|0x50000000 );
223 g_player_debugger
[0] = box
[0];
224 g_player_debugger
[1] = 0;
225 g_player_debugger
[2] = 300;
226 g_player_debugger
[3] = 32;
228 player__debugtext( 2, "instance #%u", world_static
.active_instance
);
232 if( world_static
.addon_client
)
233 addon_alias_uid( &world_static
.addon_client
->alias
, buf_client
);
235 strcpy( buf_client
, "none" );
237 if( world_static
.addon_hub
)
238 addon_alias_uid( &world_static
.addon_hub
->alias
, buf_hub
);
240 strcpy( buf_hub
, "none" );
242 player__debugtext( 1, "hub uid: %s", buf_hub
);
243 player__debugtext( 1, "client uid: %s", buf_client
);
244 player__debugtext( 2, "director" );
245 player__debugtext( 1, "activity: %s",
246 (const char *[]){ [k_skaterift_menu
] = "menu",
247 [k_skaterift_replay
] = "replay",
248 [k_skaterift_ent_focus
] = "ent_focus",
249 [k_skaterift_default
] = "default",
250 [k_skaterift_respawning
]= "respawning",
251 } [skaterift
.activity
] );
252 player__debugtext( 1, "time_rate: %.4f", skaterift
.time_rate
);
254 player__debugtext( 2, "player_instance[%p]", player
);
255 player__debugtext( 1, "angles: " PRINTF_v3f( player
->cam
.angles
) );
256 player__debugtext( 1, "basis: " PRINTF_v4f( player
->qbasis
) );
258 if( _player_im_gui
[ player
->subsystem
] )
259 _player_im_gui
[ player
->subsystem
]( player
);
261 skaterift_replay_debug_info();
265 PLAYER_API
void player__setpos( player_instance
*player
, v3f pos
){
266 v3_copy( pos
, player
->rb
.co
);
267 v3_zero( player
->rb
.v
);
268 rb_update_transform( &player
->rb
);
271 PLAYER_API
void player__spawn( player_instance
*player
, ent_spawn
*rp
){
272 replay_clear( &skaterift
.replay
);
273 player__setpos( player
, rp
->transform
.co
);
274 v3_zero( player
->rb
.w
);
275 q_identity( player
->rb
.q
);
276 rb_update_transform( &player
->rb
);
278 q_identity( player
->qbasis
);
279 m3x3_identity( player
->basis
);
280 m3x3_identity( player
->invbasis
);
282 player
->subsystem
= k_player_subsystem_walk
;
283 player
->immobile
= 0;
284 player
->gate_waiting
= NULL
;
285 world_static
.last_use
= 0.0;
286 world_static
.focused_entity
= 0;
287 world_static
.challenge_target
= NULL
;
288 world_static
.challenge_timer
= 0.0f
;
289 world_entity_unfocus();
291 if( _player_reset
[ player
->subsystem
] )
292 _player_reset
[ player
->subsystem
]( player
, rp
);
296 PLAYER_API
void player__kill( player_instance
*player
){
300 PLAYER_API
void player__begin_holdout( player_instance
*player
){
301 memcpy( &player
->holdout_pose
, &player
->pose
, sizeof(player
->pose
) );
302 player
->holdout_time
= 1.0f
;
306 #include "player_common.c"
307 #include "player_walk.c"
308 #include "player_skate.c"
309 #include "player_dead.c"
310 #include "player_drive.c"
311 #include "player_render.c"
312 #include "player_ragdoll.c"
313 #include "player_replay.c"
315 #endif /* PLAYER_C */