//----------------------------------------------------------------------------- // // $Logfile:: /Quake 2 Engine/Sin/code/game/player.cpp $ // $Revision:: 422 $ // $Author:: Jimdose $ // $Date:: 2/16/99 8:38p $ // // Copyright (C) 1997 by Ritual Entertainment, Inc. // All rights reserved. // // This source is may not be distributed and/or modified without // expressly written permission by Ritual Entertainment, Inc. // // $Log:: /Quake 2 Engine/Sin/code/game/player.cpp $ // // 422 2/16/99 8:38p Jimdose // moved sin arcade comm stuff to client // // 421 1/29/99 6:14p Jimdose // added 2015 changes // // 420 1/27/99 5:15p Jimdose // Fixed no weapon bug in arcade mode deathmatch // // 419 12/18/98 11:03p Jimdose // removed include of qcommon.h // // 418 12/16/98 5:42p Jimdose // fixed a bunch of respawn issues for Sin Arcade // // 417 12/16/98 12:41a Jimdose // Killed no longer deletes player's weapon in training mode 2 (arcade) // // 416 12/14/98 8:17p Aldie // Took out #if 0 // // 415 12/14/98 8:07p Aldie // Temporarily remove arcade stuff // // 414 12/14/98 6:53p Aldie // Added some stuff for arcade when death occurs // // 413 12/14/98 6:03p Jimdose // made GodCheat allow a value to set it on of off // // 412 11/18/98 3:47a Aldie // Fix for mutants and inventory items showing up in inventory // // 411 11/18/98 3:02a Jimdose // made mutant mode stay across levels // // 410 11/17/98 6:54p Aldie // Don't do spawn particles for training // // 409 11/17/98 3:48a Jimdose // gravpaths no longer pull you during waterjumps // // 408 11/16/98 9:05p Markd // don't do flash blend if hit by MOD_FISTS // // 407 11/16/98 8:29p Jimdose // added CheckWater // // 406 11/16/98 7:45p Markd // made take, only take a certain amount // // 405 11/16/98 4:37a Markd // don't set angles if player is frozen // // 404 11/16/98 12:42a Aldie // spidermine camera // // 403 11/15/98 8:43p Markd // Fixed third person crosshair issues and gravity axis and zooming // // 402 11/15/98 3:55a Markd // fixed weapon visible in vehicles // // 401 11/14/98 7:57p Markd // always reload when pressing use // // 400 11/14/98 2:52a Markd // put in RF_DONTDRAW support on weapons // // 399 11/14/98 2:54a Aldie // Added InitSkin to preserve custom skins in single player // // 398 11/13/98 11:02p Jimdose // made fov persistant across levels and after zooming in and out // // 397 11/13/98 10:42p Aldie // Free inventory of type when a take item is issued by the script // // 396 11/13/98 7:13p Jimdose // health is now set to 1 if it's less than 1 when changing or entering levels // // 395 11/13/98 2:37a Aldie // Fixed pain event to play sound and flash within bounds // // 394 11/11/98 11:12p Aldie // Added custom gibbing // // 393 11/10/98 3:57p Jimdose // fixed bug where player enters vehicle crouched and the view hieght is too // low // // 392 11/09/98 3:31a Markd // PM_trace should check for godmode // // 391 11/09/98 1:43a Markd // put in falling protection for landing on ladder // // 390 11/09/98 12:55a Jimdose // added sv_footsteps cvar so that server admins can turn footsteps off // completely // // 389 11/08/98 10:48p Jimdose // moved earthquake to level struct // // 388 11/08/98 8:29p Aldie // Fix for some console bugs when moving while using them // // 387 11/07/98 10:46p Markd // Fixed music stuff // // 386 11/07/98 10:15p Markd // put in forcemusic support // // 385 11/07/98 10:00p Jimdose // Made spawn and actor commands work with model names // // 384 11/07/98 8:01p Markd // Added in damage_since_pain, fixed some camera stuff // // 383 11/07/98 5:29p Aldie // Drop inventory in coop // // 382 11/07/98 5:27p Aldie // Fixed coop death bug // // 381 11/07/98 4:39p Markd // fixed music stuff // // 380 11/07/98 3:34p Markd // reset music when coming back from action // // 379 11/06/98 10:09p Aldie // Moved has_thought to constructor // // 378 11/06/98 9:38p Aldie // Moved waitforplayer stuff to the think function // // 377 11/06/98 5:17p Jimdose // added missionfailed and missionfailedtime to level vars // when a mission has failed or the player is dead in single player, the game // code immediately shows the loadmenu, preventing them from letting the game // continue running if they exit the menu // // 376 11/05/98 2:06a Markd // changed the way music works a bit, so that action would override anything // else // // 375 10/27/98 9:46p Aldie // Changed training cvar to level.training // // 374 10/27/98 5:10p Aldie // Fixed take "all" for fists and spidermine // // 373 10/26/98 10:32p Aldie // If onladder, don't get affected by gravitypaths // // 372 10/26/98 9:53p Markd // Moved GotKill around, added gibfest sound // // 371 10/26/98 8:12p Aldie // Fixed some weapon bugs with detaching from owner when removing // // 370 10/26/98 5:37p Markd // expanded whatis functionality // // 369 10/26/98 4:30p Aldie // Changed airtime default to 20 // // 368 10/26/98 2:17p Aldie // Added AirClamp // // 367 10/26/98 2:18a Aldie // Added FL_OXYGEN // // 366 10/26/98 12:28a Markd // put in no jc support // // 365 10/25/98 11:55p Jimdose // moved playerfrozen from game to level // // 364 10/25/98 10:15p Aldie // Added training cvar // // 363 10/25/98 1:51a Aldie // Bulletproof the floating inventory code // // 362 10/24/98 6:39p Markd // Added in more dialog based on Blade killing things // // 361 10/24/98 6:21p Aldie // Fixed spidermine error... // // 360 10/24/98 5:44p Markd // Added killent, removent, killclass removeclass and added parameters to // whatis // // 359 10/24/98 3:17p Aldie // Take out gibs for parent mode // // 358 10/24/98 3:14p Aldie // Addec check for silencer, removed blood checks // // 357 10/24/98 2:17p Markd // Put in JC saying blade was dead // // 356 10/24/98 4:05a Markd // fixed zoomed in in a vehicle // // 355 10/24/98 12:42a Markd // changed origins to worldorigins where appropriate // // 354 10/22/98 9:28p Aldie // Added support for deathgib animations // // 353 10/22/98 5:19p Aldie // Fixed crash of using Powerups // // 352 10/22/98 5:04p Markd // Blade will no longer taunt deaths of civilians or inanimate objects // // 351 10/22/98 4:21p Aldie // Fixed spidermine and fov changing // // 350 10/22/98 2:39a Jimdose // player no longer does crouching bob when in water // // 349 10/21/98 10:58p Jimdose // Made TouchStuff not touch the world // // 348 10/21/98 5:28p Aldie // Added a setskin command // // 347 10/21/98 1:45a Aldie // Fixed silencer clearing out, updated gib test function // // 346 10/20/98 10:29p Jimdose // Restore crosshair when respawning in 3rd person // // 345 10/20/98 7:42p Markd // fixed weapons in vehicles // // 344 10/20/98 5:22p Aldie // Added die_gibs flag // // 343 10/19/98 9:53p Jimdose // Added blend for lightvolume // changed slime variables to lightvolume // // 342 10/19/98 5:29p Aldie // Increased air time to 20 // // 341 10/19/98 12:07a Jimdose // made all code use fast checks for inheritance (no text lookups when // possible) // isSubclassOf no longer requires ::_classinfo() // // 340 10/18/98 10:55p Aldie // Added check for useless body removal on bodies that you don't need anything // from // // 339 10/18/98 9:01p Markd // Added ShowWeapon support for vehicles and zooming in on vehicles // // 338 10/18/98 1:31a Aldie // Added some more stuff to whatis command // // 337 10/17/98 12:23a Jimdose // don't load persistant data during deathmatch // // 336 10/16/98 2:27a Jimdose // Added Endlevel // saved godmode and notarget on level change // made cameras work cross level and in savegames // // 335 10/16/98 2:18a Aldie // Took out mutant movement when in single player mutant mode // // 334 10/14/98 10:58p Jimdose // player now archives fov, viewmode, and skin damage // // 333 10/14/98 6:29p Markd // Put in STAT_EXITSIGN // // 332 10/14/98 5:34p Aldie // Mutant stuff // // 331 10/14/98 1:19a Jimdose // Got cross-level persistant info working // // 330 10/12/98 8:54p Aldie // Process player killed events // // 329 10/12/98 8:44p Jimdose // Rewrote init function // started adding persistant functions // // 328 10/12/98 12:59p Markd // Fixed vehicle entering which messed up intro // // 327 10/11/98 9:03p Aldie // Updated Killed to clear mutant status // // 326 10/11/98 7:40p Aldie // Mutate and restore commands for Richard // // 325 10/11/98 5:46p Aldie // Obituaries // // 324 10/11/98 5:33p Aldie // Fix a couple init bugs // // 323 10/11/98 12:02a Aldie // Adrenaline effects // // 322 10/10/98 9:58p Aldie // Fixed mutant mode bug and changed alpha for PODD. // // 321 10/10/98 9:14p Aldie // Death message and fix camera in spidermines // // 320 10/10/98 5:58p Aldie // More quantumdestab fixes // // 319 10/09/98 8:59p Aldie // Moved oxygen to player // // 318 10/09/98 4:54p Markd // Replaced misc script code with ExecuteThread // // 317 10/09/98 2:06a Aldie // Updated DMFLAGS // // 316 10/08/98 7:24p Markd // changed vehicle movetype from noclip to vehicle // // 315 10/07/98 11:57p Jimdose // Added SetDeltaAngles // Moved old_pmove out of client // Moved PlayerFrozen to game // Init isn't called until client enters game // Got rid of MonsterGoal // // 314 10/03/98 1:09p Aldie // Fix a bug with flashcolor // // 313 10/02/98 7:19p Aldie // Added flash color to do blinding flashes // // 312 9/30/98 11:22p Markd // Changed taunts from volume 2 to volume 1 // // 311 9/30/98 11:11p Markd // Limited fov in deathmatch // // 310 9/30/98 5:39p Aldie // Added showinfo command // // 309 9/30/98 3:42p Markd // put in bulletproofing for start thread functions // // 308 9/30/98 1:25p Aldie // Gib on ion destruct // // 307 9/29/98 5:34p Aldie // Moved gravity nodes to it's own function to fix goddam compiler bug // // 306 9/29/98 2:59p Markd // tried reformatting gravpath stuff // // 305 9/29/98 2:12p Aldie // Trying to fix grav release bug // // 304 9/28/98 5:51p Markd // // 303 9/28/98 4:34p Markd // added "player_in_vehicle" variable for scripting // // 302 9/28/98 4:07p Aldie // Added oxygen powerup // // 301 9/27/98 6:28p Aldie // Added water, slime, and lava colors to worldspawn // // 300 9/26/98 4:45p Aldie // Added mutant mode // // 299 9/24/98 1:48a Markd // Made taunts double volume // // 298 9/23/98 10:08p Aldie // Gib on a ION_DESTRUCT // // 297 9/22/98 8:10p Aldie // Initialize some variables causing head bobbing // // 296 9/22/98 5:19p Markd // Put in new consolidated gib function // // 295 9/22/98 3:27p Markd // Took out old variable // // 294 9/22/98 3:21p Markd // put in parentmode lockout for blood and gibs // // 293 9/22/98 2:42p Aldie // Fixed health ticking below 100 when over 100 in prethink // // 292 9/22/98 12:14p Aldie // Added sentientFrozen and exit consoles when you take pain. // // 291 9/21/98 1:34a Aldie // Only do obits in deathmatch // // 290 9/20/98 5:11p Aldie // Fixed a crash with the "give" command // // 289 9/19/98 4:47p Markd // fixed music stuff and added actionincrement to weapons // // 288 9/18/98 10:58p Jimdose // Added spawnactor and actorinfo // // 287 9/17/98 8:02p Jimdose // Removed blending for underwater // // 286 9/17/98 1:48p Markd // Fixed swimmin animations // // 285 9/16/98 8:58p Aldie // Added ability to do a hold down weapon charge // // 284 9/16/98 3:13p Aldie // Initialize poweruptype // // 283 9/14/98 4:15p Markd // zero out velocity when entering vehicles // // 282 9/12/98 12:13a Jimdose // NearestNode was being called even when ai_createnodes was not set // // 281 9/11/98 5:03p Aldie // Initialize draw overlay // // 280 9/11/98 2:49p Aldie // Fixed death message causing crash and added release firing. // // 279 9/10/98 8:53p Markd // put in proper falling and landing animation thresholds. // // 278 9/10/98 12:45p Markd // Added whereami support // // 277 9/09/98 5:06p Markd // Added savefov and restorefov, also added fov change when teleporting // // 276 9/09/98 3:03p Markd // fixed deathmatch camera // // 275 9/07/98 6:21p Markd // cleared out velocity when in vehicle. Also don't use death cam when in // single player // // 274 9/07/98 5:28p Markd // Fixed player kickangles while jumping, fixed prediciton while in the camera // // 273 9/05/98 6:20p Markd // Fixed player bouncing with kick angles // // 272 9/05/98 6:03p Markd // fixed next weapon and previous weapon in helicopter // // 271 9/05/98 12:11p Aldie // Fixed up falling damage flags and init'ed poweruptimer/poweruptype // // 270 9/03/98 4:55p Jimdose // Tweaked kick code // // 269 9/02/98 7:47p Aldie // Added ValidPlayerModels list // // 268 9/02/98 12:54p Markd // put in proper teleportation stuff // // 267 9/02/98 11:57a Markd // Put in walk_fire // // 266 9/02/98 11:40a Markd // really freeze the player when frozen // // 265 9/01/98 7:46p Aldie // Added itemname to inventory stuff // // 264 9/01/98 12:10p Markd // fixed run_firing while crouching // // 263 8/31/98 7:45p Aldie // Updated surface data structure and removed surfinfo field // // 262 8/31/98 7:16p Markd // Fixed player animation naming convention // // 261 8/31/98 5:42p Aldie // Changed powerups timer, added cloak // // 260 8/30/98 7:29p Markd // Put in auto-dead camera where after 10 seconds, player will follow the // endnode1 path // // 259 8/29/98 9:45p Jimdose // Added call info to G_Trace // // 258 8/28/98 8:06p Markd // made crosshair change when targetting // // 257 8/28/98 7:54p Markd // Put in taunttime govenor on taunting // // 256 8/28/98 4:13p Markd // Made taunt into a VoiceSound so that AI would interact // // 255 8/27/98 9:03p Jimdose // Made grav a reference // // 254 8/27/98 7:17p Aldie // Don't draw the weapon when in a console. // // 253 8/27/98 6:23p Jimdose // Fixed bug with player walking in place // // 252 8/27/98 4:50p Markd // Fixed falling damage and detach things when dead // // 251 8/27/98 2:30p Aldie // Added adrenaline and more gravity stuff // // 250 8/26/98 8:47p Aldie // Removed a printf // // 249 8/26/98 8:46p Aldie // Put in velocity limiter for the gravity path nodes // // 248 8/26/98 6:19p Aldie // Fix for spidermine cameras // // 247 8/25/98 8:02p Jimdose // Now get the gravaxis from the starting location // // 246 8/25/98 7:54p Markd // Added third-person crosshair back into the game // // 245 8/25/98 6:18p Aldie // New spidermine and detonator support // // 244 8/25/98 5:50p Markd // Added THIRDPERSON support for client side crosshair // // 243 8/25/98 4:11p Markd // Added taunt support // // 242 8/24/98 6:53p Jimdose // Fixed falling damage on alternate gravity axis // Fixed bug with inverted gravity axis // // 241 8/24/98 5:35p Aldie // Added projectile camera functionality // // 240 8/24/98 3:49p Jimdose // Fixed bug with inverted gravity axis // Made fabric cause no falling damage // // 239 8/24/98 11:32a Markd // Added Start method to threads, repladed all ProcessEvent( // EV_ScriptThread_execute) with thread->Start( -1 ) // // 238 8/22/98 9:57p Markd // Only clear fade if not a cinematic // // 237 8/22/98 9:36p Jimdose // Added support for alternate gravity axis // // 236 8/22/98 1:22a Markd // Added Director.PlayerSpawned call, also made skipthread make sure there is // at least one character // // 235 8/21/98 7:38p Markd // Fixed climbing code // // 234 8/21/98 6:36p Markd // made it so climbing works when climbing down as well // // 233 8/21/98 3:47p Markd // Only exit camera if strafing or movement are above a threshold // // 232 8/21/98 1:05a Jimdose // Got the movement and the model angles working for the alt-gravity stuff // // 231 8/19/98 7:45p Jimdose // Fixed viewhieght during noclip // // 230 8/19/98 4:48p Aldie // Fixed a bug in falling damage // // 229 8/18/98 11:08p Markd // Added new Alias System // // 228 8/18/98 10:02p Jimdose // Changed ClearPathTo to CheckMove // // 227 8/17/98 8:59p Jimdose // Added WhatIs // // 226 8/17/98 7:45p Markd // Added lava and slime // // 225 8/17/98 6:19p Markd // Changed SetCamera to a Player method // Got out of cinematic if in Pain // // 224 8/17/98 4:34p Markd // Put in camera exiting and no-falling-damage // // 223 8/17/98 3:28p Jimdose // Started adding code for varying gravity vectors // // 222 8/17/98 2:56p Aldie // Added weapon use command // // 221 8/15/98 3:00p Markd // Fixed camera/console issues with weapons // // 220 8/14/98 8:14p Aldie // Added generic overlay system // // 219 8/13/98 8:11p Markd // Made sure invulnerability gets reset in Init function // // 218 8/13/98 8:11p Aldie // Don't do pain animation if damage is below threshold // // 217 8/13/98 1:53p Aldie // Fixed initialization of pm // // 216 8/12/98 6:03p Aldie // Added a shield timer // // 215 8/07/98 6:46p Aldie // If you're dead, don't do prediction // // 214 8/07/98 6:00p Aldie // Credit frags to the correct player when falling damage kills someone. // // 213 8/06/98 10:29p Markd // Scaled down debris damage // // 212 8/06/98 7:05p Markd // Added crouch flag to effects // // 211 8/03/98 7:36p Markd // Put in debris damage // // 210 8/03/98 1:15p Aldie // Added QuantumD to give all // // 209 8/02/98 9:00p Markd // Merged code 3.17 // // 208 7/31/98 8:09p Jimdose // Script commands now include flags to indicate cheats and console commands // // 207 7/31/98 4:20p Jimdose // Added GiveHealthCheat // // 206 7/30/98 9:28p Jimdose // Allows the Give cheat if Cheats are enabled // // 205 7/29/98 2:32p Aldie // Changed health to a float // // 204 7/26/98 2:14p Aldie // Force respawns in single player // // 203 7/26/98 1:56p Aldie // Respawn automatically // // 202 7/26/98 12:34p Jimdose // Changed cheat codes // // 201 7/26/98 9:34a Markd // Took out ToggleViewMode while in a vehicle // // 200 7/26/98 4:15a Aldie // Exit console = show stats // // 199 7/26/98 1:18a Aldie // Camera based consoles // // 198 7/26/98 12:50a Markd // only do a reload on use, if not using something else // // 197 7/26/98 12:45a Aldie // Try to fix player death stuck anims // // 196 7/25/98 7:13p Markd // forgot to if_demo the spider mines // // 195 7/25/98 7:04p Markd // Eliminated unused weapons for demo // // 194 7/25/98 5:42p Markd // Fixed player runfire bug // // 193 7/25/98 5:23p Markd // Added GotKill to player // // 192 7/25/98 4:36p Aldie // Fade stuff // // 191 7/24/98 10:04p Aldie // Gibs and fade tweaks // // 190 7/24/98 7:33p Aldie // Changed method for hiding hud // // 189 7/24/98 6:22p Jimdose // Falling damage is now based on surface type (grass, concrete, wood, etc.) // // 188 7/24/98 3:48p Aldie // Fixed splashing sounds and hardcoded models, etc... // // 187 7/23/98 9:56p Aldie // Fixed obits and added hud command. // // 186 7/23/98 7:12p Aldie // Fun with gibs // // 185 7/23/98 6:17p Aldie // Updated damage system and fixed some damage related bugs. Also put tracers // back to the way they were, and added gib event to funcscriptmodels // // 184 7/23/98 1:50p Aldie // give armor in give all // // 183 7/23/98 12:29p Markd // Put in climbing support // // 182 7/22/98 10:21p Markd // Added support for multi-handed weapons and firing // // 181 7/22/98 7:03p Aldie // More MOD messages and remove actors when we clean them out. // // 180 7/22/98 5:28p Markd // FIxed third person camera stuff // // 179 7/21/98 9:04p Markd // Added UpdateMusic and stuff // // 178 7/21/98 1:10p Aldie // Added meansofdeath to obituaries // // 177 7/20/98 6:54p Aldie // Moved cancellation of fades to init function // // 176 7/20/98 5:40p Aldie // Fixed selected item stats. // // 175 7/20/98 12:09p Markd // Added vehicle anim support // // 174 7/19/98 10:18p Aldie // You should not be able to override the death animation. // // 173 7/19/98 7:38p Markd // Made sure to get rid of ENVMAPPED and DLIGHT in Init function // // 172 7/19/98 5:40p Markd // Fixed shields, added takeItem support // // 171 7/19/98 3:42p Markd // Fixed fade out to all players // // 170 7/18/98 7:36p Aldie // Added support for fades // // 169 7/18/98 4:02p Markd // Added vehicle check for snapintial // // 168 7/18/98 3:53p Markd // Put in vehicle code that prevents the player from going into other // animations while in vehicle // // 167 7/17/98 4:01p Markd // Added UseWeapon method and weapons for vehicle // // 166 7/17/98 11:31a Aldie // Added clipammo and some reloading stuff when the player switches weaps // // 165 7/15/98 11:23p Markd // Added FL_SHIELDS support // // 164 7/15/98 9:58p Markd // Clear out environment mapping when respawning // // 163 7/15/98 12:00a Markd // Added location based pain animations // // 162 7/14/98 9:54p Markd // Fixed camera stuff // // 161 7/14/98 5:37a Jimdose // Removed definition of player height (already in q_shared.h) // // 160 7/14/98 5:35a Jimdose // Removed unused variable "bob" // now initializing v_dmg_time. Should fix bug where player's view is screwy // when starting a new map // // 159 7/13/98 5:00p Aldie // Added dead player bodies with gibbing // // 158 7/12/98 9:48p Markd // Fixed weird lerping problem when pausing and unpausing the game and viewing // from a cinematic camera or third person. Turned out that // client->ps.pmove.origin was being overwritten by incoming client movement // commands. So when you have an external camera, the origin is saved and // restored around pmove movement. // // 157 7/12/98 6:34p Markd // Fixed camera stuff so that player automatically warps to camera properly // // 156 7/11/98 8:58p Markd // Added testthread command // // 155 7/11/98 8:22p Jimdose // Players are no longer non-solid when the respawn // // 154 7/10/98 11:18p Jimdose // Removed third-person crosshair // // 153 7/10/98 11:11p Jimdose // Players only swim when the water is deep enough // no longer switch weapons after dropping them when killed // // 152 7/09/98 11:39p Aldie // Don't draw scores when in DM // // 151 7/09/98 10:39p Aldie // Moved bodyparts to game // // 150 7/08/98 3:11p Aldie // First try at spectator mode // // 149 7/07/98 8:06p Aldie // Spectator and dead stuff // // 148 7/07/98 6:08p Aldie // Gibs, drop weaps, water swim // // 147 7/03/98 12:02p Aldie // Made player init on the model specified in client data // // 146 7/01/98 7:02p Aldie // Mission computer and removed some crosshair stuff for zoom // // 145 7/01/98 4:38p Aldie // Moved some stats around // // 144 6/28/98 3:43p Markd // removed precaching from player // // 143 6/27/98 4:25p Aldie // Made a STAT_WEAPONLIST // // 142 6/25/98 8:47p Markd // Added keyed items for Triggers, Rewrote Item class, rewrote every pickup // method // // 141 6/25/98 7:31p Aldie // Changed the armor stats // // 140 6/24/98 1:37p Aldie // Implementation of inventory system and picking stuff up // // 139 6/22/98 2:04p Jimdose // Added vehicles back in // Organized the control code a bit more. May want to make physics into a // class // // 138 6/20/98 6:21p Aldie // Added modelindex for inventory stat // // 137 6/20/98 2:13p Aldie // Inventory system stats // // 136 6/19/98 6:36p Aldie // Put some more inventory managment back in // // 135 6/18/98 9:25p Aldie // Added inventory commands // // 134 6/18/98 3:57p Aldie // Changed the zooming alpha belnd color // // 133 6/17/98 5:41p Aldie // Returned scale of player back to normal // // 132 6/17/98 3:03p Markd // Changed NumArgs back to previous behavior // // 131 6/17/98 2:47p Markd // Inverted roll on player // // 130 6/17/98 10:54a Aldie // Removed the scaling of player's pitch // // 129 6/15/98 10:48p Jimdose // Added AddPathNode // // 128 6/13/98 8:20p Jimdose // Removed optimize path stuff // // 127 6/10/98 7:53p Markd // Made NumArgs behave correctly like argc // // 126 6/10/98 2:10p Aldie // Updated damage function. // // 125 6/08/98 7:12p Markd // put in assertions for ammo_types and armor_types so that the game would not // crash // // 124 6/08/98 7:15p Aldie // Added SpiderMines // // 123 6/08/98 11:34a Aldie // Updated "give all" command // // 122 6/05/98 6:25p Aldie // Added armor stats to player // // 121 6/04/98 4:35p Markd // changed action_level decay // // 120 6/03/98 4:38p Markd // Added gunoffset and gunangle, changed the way weapons work with the camera, // removed weapon parameter from SetCamerablablah // // 119 5/28/98 8:01p Markd // Clamped action_level at 80 // // 118 5/28/98 7:17p Markd // Tweaked music and action_level // // 117 5/28/98 6:01p Markd // moved action_level stuff around // // 116 5/27/98 8:36p Markd // Put in swimming, got rid of some "Give All" weapons // // 115 5/27/98 7:04a Markd // put in primitive action level // // 114 5/27/98 6:32a Markd // cleared out damageskin state in respawn // // 113 5/27/98 5:21a Markd // switched order of giveWeapon's // // 112 5/26/98 7:55p Jimdose // added scripted cameras // // 111 5/26/98 4:45p Aldie // Added take (object) from player // // 110 5/25/98 1:39p Aldie // Added create console user // // 109 5/26/98 4:37a Jimdose // Third person camera works again // Added tracking crosshair // // 108 5/26/98 1:54a Markd // Fixed up a bunch of player sounds // // 107 5/25/98 6:47p Jimdose // Made animateframe, prethink and posthink into functions built into the base // entity class // // 106 5/24/98 8:46p Jimdose // Made a lot of functions more str-friendly. // Got rid of a lot of char * based strings // Cleaned up get spawn arg functions and sound functions // sound functions now use consistant syntax // // 105 5/24/98 4:48p Jimdose // Made char *'s const // // 104 5/24/98 1:04a Jimdose // Added sound events for ai // // 103 5/22/98 12:22p Aldie // Removed unused variable from player struct // // 102 5/22/98 12:17p Aldie // Added gravity paths and updated earthquake effect // // 101 5/20/98 10:22p Aldie // Added earthquake effects // // 100 5/18/98 8:14p Jimdose // Renamed Navigator back to PathManager // // 99 5/16/98 5:00p Markd // Added RF_XFLIP stuff // // 98 5/13/98 4:49p Jimdose // Now use SafePtrs for keeping track of nodes // // 97 5/11/98 3:19p Markd // Changed zoom-in and zoom-out sounds // // 96 5/11/98 2:19p Markd // Fixed randomsound stuff // // 95 5/11/98 11:25a Markd // Added new weapons // // 94 5/09/98 7:44p Markd // Added gunmodel, gunframe and gunindex for other side gun animations // // 93 5/08/98 7:01p Markd // Took out RF_SHELL flags // // 92 5/07/98 11:23p Markd // Added playerframe, playeranim and playerindex to playerstate // // 91 5/07/98 10:46p Aldie // Fixed players exiting consoles. // // 90 5/07/98 10:43p Jimdose // working on cameras and archiving // // 89 5/05/98 2:40p Jimdose // Added support for new camera system. // Rewrote a lot of stuff to allow a clean separation between the camera // control variables in client and the Player entity. This allows a much // easier interface for creating new camera views // // 88 5/03/98 4:46p Jimdose // Added camera view // changed Vector class. Aliased vectors via pointsTo no longer supported. // // 87 5/02/98 4:24p Jimdose // Added FL_BLOOD to player // // 86 5/01/98 6:15p Jimdose // Made Respawn an event so that Trigger_Hurt wouldn't rekill a player after // respawn // // 85 5/01/98 5:55p Aldie // Removed debugging printf's // // 84 4/29/98 5:38p Jimdose // Added death messages // Sniper rifle zooms out before changing weapon // fov no longer a cheat and is persistant across respawns // // 83 4/27/98 6:09p Jimdose // Changed alpha on debug lines // // 82 4/27/98 4:12p Jimdose // Working on path placement // // 81 4/21/98 2:25p Aldie // Added enterconsole and exit console events. // // 80 4/20/98 5:44p Jimdose // working on ai // // 79 4/20/98 2:45p Jimdose // working on ai // // 78 4/18/98 6:10p Aldie // Updated ammo stats. // // 77 4/18/98 4:24p Aldie // Added ammo bar to stats. // // 76 4/18/98 4:06p Jimdose // Working on ai // // 75 4/18/98 3:17p Markd // Changed view weapon naming convention // // 74 4/18/98 3:02p Jimdose // Added ai_createnodes and ai_showpath // working on ai // // 73 4/16/98 6:22p Jimdose // // 72 4/16/98 5:35p Aldie // Change fov of sniperrifle // // 71 4/16/98 3:22p Jimdose // // 70 4/16/98 2:09p Jimdose // Added prevframe support for guns // No longer set SOLID_NOT in destructor (world may have been deleted, so the // gi.link in setSolidType would crash) // // 69 4/09/98 8:44p Jimdose // Added view blend effects // added drowing // // 68 4/09/98 7:44p Aldie // Added blending for sniper zoom. // // 67 4/08/98 5:32p Jimdose // Fixed bug in SpawnEntity // Added key/value pairs to spawn command // // 66 4/08/98 4:46p Jimdose // Made weapon appear in third person view // Secondary Use isn't sent until the weapon is ready // Zoom mode overrides third person view. // // 65 4/07/98 11:55p Jimdose // Changed beams to specify color // // 64 4/07/98 8:05p Jimdose // Made use much more sensitive. Opens too many things at once, but, oh well. // // 63 4/07/98 6:41p Jimdose // Fixed bugs in weapon code // Added checks for being dead in various functions (changing weapons) // working on making use more responsive // // 62 4/07/98 3:48p Aldie // Added zooming crosshair // // 61 4/06/98 8:00p Jimdose // Init resets your gravity to 1.0 // // 60 4/06/98 7:10p Aldie // Added zooming for SniperRifle // // 59 4/05/98 2:57a Jimdose // added respawn_time // made firing anim work temporarily // // 58 4/04/98 6:07p Jimdose // Added events for syncing firing to animation // // 57 4/02/98 4:56p Jimdose // Added pain, obituary and showscores // Fixed bug in Init where persistant data was always being cleared // ammo stats are now kept up to date // Added falling and landing animations // // 56 3/31/98 1:40p Jimdose // Removed footstep stuff (it's in entity now) // jump sound is now played by the model // // 55 3/31/98 12:47p Jimdose // Fixed the gunoffset // // 54 3/30/98 11:39p Markd // Added modelIndex stuff // // 53 3/30/98 9:55p Jimdose // Changed location of .def files // // 52 3/30/98 2:41p Jimdose // Worked on weapons // Fixed footstep. There weren't any 'break's in the switch statement // // 51 3/29/98 9:42p Jimdose // Moved animation stuff to sentient // Changed killed to an event // // 50 3/29/98 5:57p Jimdose // Added SpawnEntity command // // 49 3/28/98 8:55p Jimdose // Added pulse rifle // // 48 3/28/98 6:51p Jimdose // Made the angles in player starts work // // 47 3/28/98 4:35p Jimdose // Added kill command // Added deathmatch starts // You can no longer move your view when you're dead // // 46 3/27/98 10:00p Jimdose // Changed all worldangle references to use setAngles // // 45 3/27/98 6:36p Jimdose // Precached weapon models // Added assault rifle // // 44 3/27/98 5:40p Jimdose // Added third person view mode // respawn now calls FreeInventory so that weapons don't carry over when you // die // // 43 3/26/98 8:25p Jimdose // Added deathmatch // Precache sounds // Added animation control functions // // 42 3/23/98 1:31p Jimdose // Revamped event and command system // // 41 3/18/98 7:22p Jimdose // Added new-style weapons // Fixed bug where orientation and v_angle wasn't being set // // 40 3/04/98 5:13p Aldie // Added support for damage surfaces. // // 39 3/03/98 6:56p Aldie // Removed a printf. // // 38 3/03/98 6:51p Aldie // Added some more footstep sounds. // // 37 3/03/98 6:02p Aldie // First pass at footsteps. // // 36 3/02/98 8:49p Jimdose // Changed the classid parameter of CLASS_DECLARATION to a quoted string so // that you could have a NULL classid. // // 35 3/02/98 5:41p Jimdose // Added commands for testing paths // Changed the trace that use does. // // 34 2/21/98 1:21p Jimdose // Removed A LOT of unused varables and code. Anything from here on out should // be code written specifically for Sin and not converted Quake code. Quake is // not a blueprint. It's only a reference. // // 33 2/19/98 2:35p Jimdose // Added weapons back in // // 32 2/17/98 8:34p Jimdose // Enabled the use key // // 31 2/06/98 5:44p Jimdose // replaced use of think and touch functions with events // move client to Entity // // 30 2/03/98 10:59a Jimdose // Updated to work with Quake 2 engine // Moved initialization to constructor and removed Init function // This will probably be rewritten to be simpler. This first rewrite sucks. // // 28 12/15/97 2:52p Markd // Fixed default weapons // // 27 12/15/97 12:35p Aldie // // 26 12/14/97 8:51p Aldie // Updated impulse 9 to give all weapons. // // 25 12/14/97 8:16p Aldie // Modified give all weapons list. // // 24 12/14/97 5:33p Markd // Made default weapon Shotgun instead of DoubleBarrel // // 23 12/13/97 6:53p Aldie // Added shotgun to give all weapons list // // 22 12/06/97 1:31p Aldie // Fixed give weapon handler so that "give all" is case insensitive. // // 21 12/06/97 12:34p Aldie // Added Tracer Gun to give all weapons list. // // 20 12/05/97 4:08p Aldie // Added event to player for giving weapons. // // 19 11/18/97 5:29p Markd // Added magnum and spear gun to impulse 9, checked for NULL currentWeapon and // updated weapon frames in PlayerPostThink // // 18 11/12/97 5:12p Jimdose // Changed enter and exit vehicle messages to be defined in Player.h // // 17 11/12/97 2:10p Jimdose // Simplified the interface to PathSearch // // 16 11/10/97 8:30p Jimdose // Flags were being subtracted rather than masked off in Jump. // // 15 11/07/97 6:49p Jimdose // Added code for testing path.cpp. Enable by defining TESTPATH // // 14 11/01/97 2:19p Jimdose // looking // // 13 11/01/97 2:12p Jimdose // jump in vehicles // // 12 10/31/97 9:02p Jimdose // Added FL_PRETHINK and FL_POSTTHINK // // 11 10/30/97 11:48p Jimdose // Worked on vehicle code // // 10 10/29/97 12:54p Markd // made viewthing multiple spawnable // // 9 10/29/97 11:51a Markd // Made viewthing always face you when spawned. // // 8 10/28/97 6:54p Markd // Added SPAWN_VIEWTHING message. Also added "return true" to other handled // messages // // 7 10/27/97 3:29p Jimdose // Removed dependency on quakedef.h // // 6 10/22/97 12:24p Jimdose // Disabled warning when player recieves a blocked event. // // 5 10/09/97 4:26p Jimdose // Worked on vehicle code // // 4 10/08/97 9:30p Jimdose // Refined Vehicle movement. // // 3 10/08/97 6:03p Jimdose // Began vehicle support. // // 2 9/26/97 6:47p Jimdose // Added standard Ritual headers // // DESCRIPTION: // Class definition of the player. // #include "g_local.h" #include "entity.h" #include "player.h" #include "worldspawn.h" #include "weapon.h" #include "trigger.h" #include "scriptmaster.h" #include "vehicle.h" #include "path.h" #include "navigate.h" #include "misc.h" #include "q_shared.h" #include "console.h" #include "earthquake.h" #include "gravpath.h" #include "armor.h" #include "inventoryitem.h" #include "gibs.h" #include "spidermine.h" #include "deadbody.h" #include "actor.h" #include const Vector power_color( 0.0, 1.0, 0.0 ); const Vector acolor( 1.0, 1.0, 1.0 ); const Vector bcolor( 1.0, 0.0, 0.0 ); static const char *ammo_types[ NUM_AMMO_TYPES ] = { "Bullet357", "ShotgunClip", "Bullet10mm", "Bullet50mm", "BulletPulse", "BulletSniper", "Rockets", "SpiderMines" }; static const char *armor_types[ NUM_ARMOR_TYPES ] = { "RiotHelmet", "FlakJacket", "FlakPants" }; Event EV_Player_GodCheat( "superfuzz", EV_CHEAT ); Event EV_Player_NoTargetCheat( "wallflower", EV_CHEAT ); Event EV_Player_NoClipCheat( "nocollision", EV_CHEAT ); Event EV_Player_GiveAllCheat( "wuss", EV_CHEAT ); Event EV_Player_EndLevel( "endlevel" ); Event EV_Player_DevGodCheat( "god", EV_CHEAT ); Event EV_Player_DevNoTargetCheat( "notarget", EV_CHEAT ); Event EV_Player_DevNoClipCheat( "noclip", EV_CHEAT ); Event EV_Player_PrevWeapon( "weapprev", EV_CONSOLE ); Event EV_Player_NextWeapon( "weapnext", EV_CONSOLE ); Event EV_Player_PrevItem( "invprev", EV_CONSOLE ); Event EV_Player_NextItem( "invnext", EV_CONSOLE ); Event EV_Player_UseInventoryItem( "invuse", EV_CONSOLE ); Event EV_Player_GiveCheat( "give", EV_CHEAT ); Event EV_Player_Take( "take" ); Event EV_Player_UseItem( "use", EV_CONSOLE ); Event EV_Player_Spectator( "spectator", EV_CONSOLE ); Event EV_Player_GameVersion( "gameversion", EV_CONSOLE ); Event EV_Player_Fov( "fov" ); Event EV_Player_SaveFov( "savefov", EV_CONSOLE ); Event EV_Player_RestoreFov( "restorefov", EV_CONSOLE ); Event EV_Player_ToggleViewMode( "toggleviewmode", EV_CONSOLE ); Event EV_Player_ToggleZoomMode( "togglezoommode", EV_CHEAT ); Event EV_Player_ZoomOut( "zoomout" ); Event EV_Player_Kill( "playerkill", EV_CONSOLE ); Event EV_Player_Dead( "dead" ); Event EV_Player_SpawnEntity( "spawn", EV_CHEAT ); Event EV_Player_SpawnActor( "actor", EV_CHEAT ); Event EV_Player_ShowInfo( "showinfo", EV_CONSOLE ); Event EV_Player_ReadyToFire( "readytofire" ); Event EV_Player_WaitingToFire( "waitingtofire" ); Event EV_Player_AttackDone( "attackdone" ); Event EV_Player_AddPathNode( "addnode", EV_CHEAT ); Event EV_Player_Respawn( "respawn" ); Event EV_Player_ClearFloatingInventory( "clear_flinv" ); Event EV_Player_TestThread( "testthread", EV_CHEAT ); Event EV_Player_PowerupTimer( "poweruptimer" ); Event EV_Player_UpdatePowerupTimer( "updatepoweruptime" ); Event EV_Player_DrawOverlay( "drawoverlay" ); Event EV_Player_HideOverlay( "hideoverlay" ); Event EV_Player_DrawStats( "drawstats" ); Event EV_Player_HideStats( "hidestats" ); Event EV_Player_SetFlashColor( "setflashcolor" ); Event EV_Player_ClearFlashColor( "clearflashcolor" ); Event EV_Player_Mutate( "mutate", EV_CHEAT ); Event EV_Player_Human( "human", EV_CHEAT ); Event EV_Player_Skin( "skin" ); Event EV_Player_WhatIs( "whatis", EV_CHEAT ); Event EV_Player_ActorInfo( "actorinfo", EV_CHEAT ); Event EV_Player_Taunt( "taunt", EV_CONSOLE ); Event EV_Player_KillEnt( "killent", EV_CONSOLE ); Event EV_Player_KillClass( "killclass", EV_CONSOLE ); Event EV_Player_RemoveEnt( "removeent", EV_CONSOLE ); Event EV_Player_RemoveClass( "removeclass", EV_CONSOLE ); #define UPRIGHT_SPEED 320.0f #define CROUCH_SPEED 110.0f #define ACCELERATION 10.0f #define TAUNT_TIME 1.0f /* ============================================================================== PLAYER ============================================================================== */ // deadflag values cvar_t * s_debugmusic; cvar_t * whereami; CLASS_DECLARATION( Sentient, Player, "player" ); ResponseDef Player::Responses[] = { { &EV_ClientMove, ( Response )Player::ClientThink }, { &EV_ClientEndFrame, ( Response )Player::EndFrame }, { &EV_Player_ShowInfo, ( Response )Player::ShowInfo }, { &EV_Vehicle_Enter, ( Response )Player::EnterVehicle }, { &EV_Vehicle_Exit, ( Response )Player::ExitVehicle }, { &EV_Player_EndLevel, ( Response )Player::EndLevel }, { &EV_Player_AddPathNode, ( Response )Player::AddPathNode }, { &EV_Player_PrevWeapon, ( Response )Player::EventPreviousWeapon }, { &EV_Player_NextWeapon, ( Response )Player::EventNextWeapon }, { &EV_Player_PrevItem, ( Response )Player::EventPreviousItem }, { &EV_Player_NextItem, ( Response )Player::EventNextItem }, { &EV_Player_UseItem, ( Response )Player::EventUseItem }, { &EV_Player_UseInventoryItem,( Response )Player::EventUseInventoryItem }, { &EV_Player_GiveCheat, ( Response )Player::GiveCheat }, { &EV_Player_GiveAllCheat, ( Response )Player::GiveAllCheat }, { &EV_Player_Take, ( Response )Player::Take }, { &EV_Player_GodCheat, ( Response )Player::GodCheat }, { &EV_Player_DevGodCheat, ( Response )Player::GodCheat }, { &EV_Player_Spectator, ( Response )Player::Spectator }, { &EV_Player_NoTargetCheat, ( Response )Player::NoTargetCheat }, { &EV_Player_DevNoTargetCheat,( Response )Player::NoTargetCheat }, { &EV_Player_NoClipCheat, ( Response )Player::NoclipCheat }, { &EV_Player_DevNoClipCheat, ( Response )Player::NoclipCheat }, { &EV_Player_GameVersion, ( Response )Player::GameVersion }, { &EV_Player_Fov, ( Response )Player::Fov }, { &EV_Player_SaveFov, ( Response )Player::SaveFov }, { &EV_Player_RestoreFov, ( Response )Player::RestoreFov }, { &EV_Player_ToggleViewMode, ( Response )Player::ToggleViewMode }, { &EV_Player_ToggleZoomMode, ( Response )Player::ToggleZoomMode }, { &EV_Player_ZoomOut, ( Response )Player::ZoomOut }, { &EV_EnterConsole, ( Response )Player::EnterConsole }, { &EV_ExitConsole, ( Response )Player::ExitConsole }, { &EV_KickFromConsole, ( Response )Player::KickConsole }, { &EV_Player_Kill, ( Response )Player::Kill }, { &EV_Player_Dead, ( Response )Player::Dead }, { &EV_Player_SpawnEntity, ( Response )Player::SpawnEntity }, { &EV_Player_SpawnActor, ( Response )Player::SpawnActor }, { &EV_Player_Respawn, ( Response )Player::Respawn }, { &EV_Pain, ( Response )Player::Pain }, { &EV_Killed, ( Response )Player::Killed }, { &EV_Gib, ( Response )Player::GibEvent }, { &EV_GotKill, ( Response )Player::GotKill }, { &EV_Player_ReadyToFire, ( Response )Player::ReadyToFire }, { &EV_Player_WaitingToFire, ( Response )Player::WaitingToFire }, { &EV_Player_AttackDone, ( Response )Player::DoneFiring }, { &EV_Player_TestThread, ( Response )Player::TestThread }, { &EV_Player_ClearFloatingInventory, (Response)Player::ClearFloatingInventory }, { &EV_Player_PowerupTimer, ( Response )Player::SetPowerupTimer }, { &EV_Player_UpdatePowerupTimer, ( Response )Player::UpdatePowerupTimer }, { &EV_Player_WhatIs, ( Response )Player::WhatIs }, { &EV_Player_ActorInfo, ( Response )Player::ActorInfo }, { &EV_Player_Taunt, ( Response )Player::Taunt }, { &EV_Player_KillEnt, ( Response )Player::KillEnt }, { &EV_Player_RemoveEnt, ( Response )Player::RemoveEnt }, { &EV_Player_KillClass, ( Response )Player::KillClass }, { &EV_Player_RemoveClass, ( Response )Player::RemoveClass }, { &EV_Player_DrawOverlay, ( Response )Player::DrawOverlay }, { &EV_Player_HideOverlay, ( Response )Player::HideOverlay }, { &EV_Player_DrawStats, ( Response )Player::DrawStats }, { &EV_Player_HideStats, ( Response )Player::HideStats }, { &EV_Player_SetFlashColor, ( Response )Player::SetFlashColor }, { &EV_Player_ClearFlashColor, ( Response )Player::ClearFlashColor }, { &EV_Player_Mutate, ( Response )Player::Mutate }, { &EV_Player_Human, ( Response )Player::Human }, { &EV_Player_Skin, ( Response )Player::SetSkin }, { NULL, NULL } }; Player::Player() { path = NULL; respawn_time = -1; watchCamera = NULL; thirdpersonCamera = NULL; movieCamera = NULL; spectatorCamera = NULL; damage_blood = 0; damage_alpha = 0; action_level = 0; drawoverlay = false; defaultViewMode = FIRST_PERSON; fov = atof( Info_ValueForKey( client->pers.userinfo, "fov" ) ); if ( fov < 1 ) { fov = 90; } else if ( fov > 160 ) { fov = 160; } savedfov = 0; has_thought = false; s_debugmusic = gi.cvar ("s_debugmusic", "0", 0); whereami = gi.cvar ("whereami", "0", 0); // Remove him from the world until we spawn him unlink(); } void Player::InitSkin ( void ) { // If this is a new level, there will be no custom skin, so go back to the original blade skin. if ( !LoadingSavegame && !deathmatch->value ) { int playernum = edict-g_edicts-1; strcpy( client->pers.skin, "blade_base" ); // combine name, skin and model into a configstring gi.configstring( CS_PLAYERSKINS+playernum, va( "%s\\%s\\%s", client->pers.netname, client->pers.model, client->pers.skin ) ); } } void Player::Init ( void ) { InitClient(); InitPhysics(); InitPowerups(); InitWorldEffects(); InitMusic(); InitPath(); InitView(); InitState(); InitEdict(); InitModel(); InitWeapons(); InitSkin(); // don't call RestoreEnt when respawning on a training level if ( !LoadingServer && ( deathmatch->value || ( level.training && ( respawn_time != -1 ) ) || !PersistantData.RestoreEnt( this ) ) ) { InitInventory(); InitHealth(); } ChooseSpawnPoint(); if ( !LoadingSavegame && ( viewmode == THIRD_PERSON ) && !crosshair ) { cvar_t * chair; chair = gi.cvar("crosshair", "0", 0); crosshair = new Entity; crosshair->setModel( va( "sprites/crosshair%d.spr", (int)chair->value ) ); crosshair->edict->svflags |= SVF_ONLYPARENT; crosshair->edict->owner = this->edict; } if ( !deathmatch->value ) { gi.AddCommandString( "con_clearfade\n" ); } // make sure we put the player back into the world link(); } void Player::WritePersistantData ( SpawnArgGroup &group ) { str text; char t[ 3 ]; int hi; int lo; int i; // encode the damage states into a text string t[ 2 ] = 0; for( i = 0; i < MAX_MODEL_GROUPS; i++ ) { hi = ( edict->s.groups[ i ] >> 4 ) & 0xf; lo = edict->s.groups[ i ] & 0xf; t[ 0 ] = ( char )( 'A' + hi ); t[ 1 ] = ( char )( 'A' + lo ); text += t; } G_SetSpawnArg( "savemodel", savemodel.c_str() ); G_SetSpawnArg( "saveskin", saveskin.c_str() ); G_SetSpawnArg( "damage_groups", text.c_str() ); G_SetFloatArg( "fov", fov ); G_SetIntArg( "defaultViewMode", defaultViewMode ); G_SetIntArg( "flags", flags & ( FL_GODMODE | FL_NOTARGET | FL_SP_MUTANT ) ); Sentient::WritePersistantData( group ); } void Player::RestorePersistantData ( SpawnArgGroup &group ) { #ifndef SIN_DEMO SpiderMine *spidermine; Detonator *detonator; #endif int i; int len; str text; const char *ptr; int hi; int lo; Sentient::RestorePersistantData( group ); group.RestoreArgs( 1 ); // clear the damage states memset( edict->s.groups, 0, sizeof( edict->s.groups ) ); savemodel = G_GetStringArg( "savemodel" ); saveskin = G_GetStringArg( "saveskin" ); text = G_GetStringArg( "damage_groups" ); len = text.length() >> 1; if ( len > MAX_MODEL_GROUPS ) { len = MAX_MODEL_GROUPS; } // decode the damage states from text string ptr = text.c_str(); for( i = 0; i < len; i++ ) { hi = ( *ptr++ - 'A' ) & 0xf; lo = ( *ptr++ - 'A' ) & 0xf; edict->s.groups[ i ] = ( hi << 4 ) + lo; } flags |= G_GetIntArg( "flags" ); fov = G_GetFloatArg( "fov", 90 ); defaultViewMode = ( viewmode_t )G_GetIntArg( "defaultViewMode", FIRST_PERSON ); #ifndef SIN_DEMO spidermine = ( SpiderMine * )FindItem( "SpiderMine" ); detonator = ( Detonator * )FindItem( "Detonator" ); if ( spidermine ) { spidermine->SetDetonator( detonator ); } if ( FindItem( "Silencer" ) ) { flags |= FL_SILENCER; } if ( FindItem( "ScubaGear" ) ) { flags |= FL_OXYGEN; } if ( flags & FL_SP_MUTANT ) { setModel( "manumit_pl.def" ); SetAnim( "idle" ); } #endif if ( defaultViewMode == CAMERA_VIEW ) { defaultViewMode = FIRST_PERSON; } SetViewMode( defaultViewMode ); // prevent the player from starting dead if ( health < 1 ) { health = 1; } } void Player::InitEdict ( void ) { // entity state stuff setSolidType( SOLID_BBOX ); setMoveType( MOVETYPE_WALK ); setSize( Vector( -16, -16, 0 ), Vector( 16, 16, STAND_HEIGHT ) ); edict->clipmask = MASK_PLAYERSOLID; edict->svflags &= ~SVF_DEADMONSTER; edict->svflags &= ~SVF_HIDEOWNER; edict->owner = NULL; // clear entity state values edict->s.effects = 0; edict->s.frame = 0; } void Player::InitMusic ( void ) { // // reset the music // client->ps.current_music_mood = mood_normal; client->ps.fallback_music_mood = mood_normal; ChangeMusic( "normal", "normal", false ); music_forced = false; } void Player::InitClient ( void ) { client_persistant_t saved; client_respawn_t resp; // deathmatch wipes most client data every spawn if ( deathmatch->value || level.training ) { char userinfo[ MAX_INFO_STRING ]; resp = client->resp; memcpy( userinfo, client->pers.userinfo, sizeof( userinfo ) ); G_InitClientPersistant( client ); G_ClientUserinfoChanged( edict, userinfo ); } else { memset( &resp, 0, sizeof( resp ) ); } // clear everything but the persistant data and fov saved = client->pers; memset( client, 0, sizeof( *client ) ); client->pers = saved; client->resp = resp; } void Player::InitState ( void ) { in_console = false; trappedInQuantum = false; floating_owner = NULL; gibbed = false; enemy = NULL; lastEnemyTime = 0; lastTauntTime = 0; takedamage = DAMAGE_AIM; deadflag = DEAD_NO; flags &= ~FL_NO_KNOCKBACK; flags |= ( FL_BLOOD | FL_DIE_GIBS ); if ( parentmode->value ) { flags &= ~FL_BLOOD; flags &= ~FL_DIE_GIBS; } } void Player::InitHealth ( void ) { // Don't do anything if we're loading a server game. // This is either a loadgame or a restart if ( LoadingServer ) { return; } // reset the health values health = 100; max_health = 100; last_damage_time = 0; // clear the damage states memset( edict->s.groups, 0, sizeof( edict->s.groups ) ); } void Player::InitModel ( void ) { str model; // Model stuff edict->s.renderfx |= RF_CUSTOMSKIN; edict->s.skinnum = edict->s.number - 1; // Make sure that the model is allowed model = client->pers.model; if ( !game.ValidPlayerModels.ObjectInList( model ) ) { model = "pl_blade.def"; } setModel( model.c_str() ); TempAnim( "idle", NULL ); showModel(); } void Player::InitPhysics ( void ) { // Physics stuff onladder = false; sentientFrozen = false; oldvelocity = vec_zero; velocity = vec_zero; gravity = 1.0; falling = false; fall_time = 0; fall_value = 0; fallsurface = NULL; mass = 200; xyspeed = 0; } void Player::InitPowerups ( void ) { // powerups poweruptimer = 0; poweruptype = 0; flags &= ~( FL_SHIELDS | FL_ADRENALINE | FL_CLOAK | FL_MUTANT | FL_SILENCER | FL_OXYGEN ); edict->s.renderfx &= ~( RF_DLIGHT | RF_ENVMAPPED ); } void Player::InitWorldEffects ( void ) { // world effects next_drown_time = 0; air_finished = level.time + 20; old_waterlevel = 0; drown_damage = 0; } void Player::InitWeapons ( void ) { // weapon stuff firing = false; firedown = false; firedowntime = 0; gunoffset = Vector( 0, 0, STAND_HEIGHT ); } void Player::InitInventory ( void ) { // Don't do anything if we're loading a server game. // This is either a loadgame or a restart if ( LoadingServer ) { return; } // Give player the default weapon if ( !FindItem( "Magnum" ) ) { giveWeapon( "Magnum" ); } if ( !FindItem( "Fists" ) ) { giveWeapon( "Fists" ); } #ifndef SIN_DEMO if ( !FindItem( "SpiderMine" ) ) { giveWeapon( "SpiderMine" ); } #endif } void Player::InitView ( void ) { // Camera stuff zoom_mode = ZOOMED_OUT; spectator = false; currentCameraTarget = 0; checked_dead_camera = false; SetViewMode( defaultViewMode ); // view stuff kick_angles = vec_zero; kick_origin = vec_zero; v_angle = vec_zero; oldviewangles = vec_zero; v_gunoffset = vec_zero; v_gunangles = vec_zero; viewheight = STAND_EYE_HEIGHT; // blend stuff v_dmg_time = 0; damage_blend = vec_zero; flash_color[0] = flash_color[1] = flash_color[2] = flash_color[3] = 0; // hud hidestats = false; } void Player::ChooseSpawnPoint ( void ) { // set up the player's spawn location SelectSpawnPoint( origin, angles, &gravaxis ); setOrigin( origin + "0 0 17" ); worldorigin.copyTo( edict->s.old_origin ); edict->s.renderfx |= RF_FRAMELERP; KillBox( this ); // set gravity axis SetGravityAxis( gravaxis ); client->ps.pmove.gravity_axis = gravaxis; // setup the orientation setAngles( angles ); v_angle = worldangles; // set the delta angle client->ps.pmove.delta_angles[0] = ANGLE2SHORT( angles.x - client->resp.cmd_angles[0] ); client->ps.pmove.delta_angles[1] = ANGLE2SHORT( angles.y - client->resp.cmd_angles[1] ); client->ps.pmove.delta_angles[2] = ANGLE2SHORT( angles.z - client->resp.cmd_angles[2] ); if ( deathmatch->value || coop->value ) { SpawnTeleportEffect( worldorigin, 124 ); } } void Player::InitPath ( void ) { // pathnode placement stuff nearestNode = NULL; if ( ai_createnodes->value ) { nearestNode = new PathNode; nearestNode->Setup( worldorigin ); } goalNode = nearestNode; lastNode = nearestNode; lastVisible = worldorigin; searchTime = level.time + 0.1; } Player::~Player() { if ( client ) { gi.bprintf( PRINT_HIGH, "%s disconnected\n", client->pers.netname ); } if ( watchCamera && ( ( watchCamera == thirdpersonCamera ) || ( watchCamera == spectatorCamera ) ) ) { delete watchCamera; watchCamera = NULL; thirdpersonCamera = NULL; spectatorCamera = NULL; } if ( crosshair ) { delete crosshair; crosshair = NULL; } if ( path ) { delete path; path = NULL; } edict->s.modelindex = 0; gi.configstring( CS_PLAYERSKINS + entnum - 1, "" ); } void Player::EndLevel ( Event *ev ) { if ( flags & FL_MUTANT ) { Human( NULL ); } InitPowerups(); if ( health > max_health ) { health = max_health; } if ( health < 1 ) { health = 1; } } void Player::Respawn ( Event *ev ) { if ( deathmatch->value || coop->value || level.training ) { assert ( deadflag == DEAD_DEAD ); #ifdef SIN_ARCADE if ( deathmatch->value ) { FreeInventory(); } #else FreeInventory(); #endif if ( !gibbed && !level.training ) { CopyToBodyQueue( edict ); } respawn_time = level.time; Init(); // hold in place briefly client->ps.pmove.pm_time = 50; client->ps.pmove.pm_flags = PMF_TIME_TELEPORT; return; } // force the load game menu to come up level.missionfailed = true; level.missionfailedtime = level.time - FRAMETIME; } void Player::SetDeltaAngles ( void ) { int i; // Use v_angle since we may be in a camera for( i = 0; i < 3; i++ ) { client->ps.pmove.delta_angles[ i ] = ANGLE2SHORT( v_angle[ i ] ); } } void Player::Spectator ( Event *ev ) { hideModel(); setSolidType( SOLID_NOT ); spectator = true; FreeInventory(); // Send over a message that lets the player know they are in spectator mode. gi.WriteByte (svc_layout); gi.WriteString ("jcx jt hstring 0 0 1 \"SPECTATOR MODE\""); gi.unicast (edict, true); client->ps.stats[ STAT_LAYOUTS ] |= DRAW_SPECTATOR; } void Player::Obituary ( Entity *attacker, Entity *inflictor, str location, int meansofdeath ) { const char *message1 = NULL; const char *message2 = ""; int num; if ( !deathmatch->value ) return; // Client killed themself if ( attacker == this ) { switch ( meansofdeath ) { case MOD_FALLING: message1 = "fell down"; break; case MOD_ADRENALINE: message1 = "overdosed on adrenaline"; break; case MOD_ION_DESTRUCT: message1 = "overloaded his gun"; break; default: message1 = "cracked under the pressure"; } if ( message1 ) { gi.bprintf( PRINT_MEDIUM, "%s %s.\n", client->pers.netname, message1 ); } else { gi.bprintf( PRINT_MEDIUM, "%s died.\n", client->pers.netname ); } client->resp.score--; return; } // Killed by another client if ( attacker && attacker->isClient() ) { switch (meansofdeath) { case MOD_FISTS: // FISTS { num = G_Random(6); switch (num) { case 0: message1 = "was knocked out by"; break; case 1: message1 = "was pummelled by"; break; case 2: message1 = "was over come by"; message2 = "'s ninja technique"; break; case 3: message1 = "ate a knuckle sandwich courtesy of"; break; case 4: message1 = "takes"; message2 = "'s beating"; break; case 5: message1 = "liked"; message2 = "'s death touch"; break; default: message1 = "was killed by"; message2 = "'s fists"; break; } } break; case MOD_MUTANTHANDS: message1 = "was shredded by"; break; case MOD_MAGNUM: // Magnum { num = G_Random(5); switch (num) { case 0: message1 = "was capped in the ass by"; break; case 1: message1 = "was gunned down in broad daylight by"; break; case 2: message1 = "eats"; message2 = "'s magnum"; break; case 3: message1 = "was punked by"; break; case 4: message1 = "was jacked by"; break; default: message1 = "was killed by"; message2 = "'s magnum"; break; } break; } case MOD_SHOTGUN: // Shotgun { num = G_Random(5); switch (num) { case 0: message1 = "is a victim of"; message2 = "'s shotgun"; break; case 1: message1 = "was slaughtered by"; break; case 2: message1 = "drowns in a rain of"; message2 = "'s hot lead"; break; case 3: message1 = "finds out why"; message2 = " got an F in gun safety"; break; case 4: message1 = "was shotgunned by"; break; default: message1 = "was killed by"; message2 = "'s shotgun"; break; } break; } case MOD_ASSRIFLE: { num = G_Random(4); switch (num) { case 0: message1 = "was assaulted by"; break; case 1: message1 = "was cut in half by"; break; case 2: message1 = "forgot that"; message2 = " had a bigger gun"; break; case 3: message1 = "was machinegunned down by"; break; default: message1 = "was killed by"; message2 = "'s assault rifle"; break; } } break; case MOD_CHAINGUN: message1 = "was mowed down by"; message2 = "'s chaingun"; break; case MOD_GRENADE: message1 = "was fragged by"; message2 = "'s grenade"; break; case MOD_ROCKET: { num = G_Random(5); switch (num) { case 0: message1 = "was blown up by"; message2 = "'s direct rocket hit"; break; case 1: message1 = "bows down to"; message2 = "'s almighty rocket launcher"; break; case 2: message1 = "was incinerated by"; message2 = "'s rocket"; break; case 3: message1 = "was obliterated by"; message2 = "'s rocket"; break; case 4: message1 = "likes walking into"; message2 = "'s projectiles"; break; default: message1 = "was killed by"; message2 = "'s rocket launcher"; } } break; case MOD_ROCKETSPLASH: { num = G_Random(5); switch (num) { case 0: message1 = "was caught in"; message2 = "'s explosion"; break; case 1: message1 = "was burned to a crisp in"; message2 = "'s blast"; break; case 2: message1 = "is pulling shrapnel out of his ass thanks to"; break; case 3: message1 = "couldn't dodge"; message2 = "'s blast damage"; break; case 4: message1 = "was drenched by"; message2 = "'s splash damage"; break; default: message1 = "was killed by"; message2 = "'s explosion"; } break; } case MOD_SPIDERSPLASH: message1 = "was bitten by"; message2 = "'s spidermine"; break; case MOD_SPEARGUN: message1 = "was stuck by"; message2 = "'s spear"; break; case MOD_PULSE: message1 = "was pulsed by"; break; case MOD_PULSELASER: message1 = "was burned to a crisp by"; message2 = "'s laser"; break; case MOD_ION: case MOD_ION_DESTRUCT: message1 = "Was ionized by"; break; case MOD_QUANTUM: message1 = "Was particlized by"; break; case MOD_SNIPER: { num = G_Random(5); switch (num) { case 0: message1 = "was hollowpointed by"; break; case 1: message1 = "was put to sleep by"; break; case 2: message1 = "was sniped by"; break; case 3: message1 = "never saw it coming from"; break; case 4: message1 = "was killed by a precision shot from"; break; default: message1 = "was killed by"; message2 = "'s sniper rifle"; } break; } default: message1 = "was killed by"; } gi.bprintf( PRINT_MEDIUM, "%s %s %s%s\n", client->pers.netname, message1, attacker->client->pers.netname, message2 ); attacker->client->resp.score++; return; } // Killed by a non-client switch (meansofdeath) { case MOD_FALLING: { // Credit the last person who damaged me with the kill if ( enemy && enemy->isClient() && ( enemy != this ) && level.time < lastEnemyTime ) { attacker = enemy; message1 = "was pushed over the edge by"; message2 = ""; // Give the last enemy a frag enemy->client->resp.score++; } else { message1 = "fell down"; message2 = ""; } break; } } // Killed indirectly by enemy if (message1 && attacker->isClient() ) { gi.bprintf( PRINT_MEDIUM, "%s %s %s%s\n", client->pers.netname, message1, attacker->client->pers.netname, message2 ); } // Killed by world somehow else if (message1) { gi.bprintf( PRINT_MEDIUM, "%s %s\n", client->pers.netname, message1); client->resp.score--; } else { gi.bprintf( PRINT_MEDIUM, "%s died.\n", client->pers.netname ); client->resp.score--; } } void Player::Dead ( Event *ev ) { deadflag = DEAD_DEAD; StopAnimating(); // // drop anything that might be attached to us // if (numchildren && ( level.training != 2 ) ) { Entity * child; int i; // // detach all our children // for ( i=0; i < MAX_MODEL_CHILDREN; i++ ) { if (children[i]) { child = ( Entity * )G_GetEntity( children[ i ] ); child->ProcessEvent( EV_Detach ); } } } if ( !deathmatch->value && !coop->value && !level.training ) { // Fade to white gi.WriteByte( svc_console_command ); gi.WriteString( "fo 0.8 1 1 1" ); gi.unicast( edict, false ); PostEvent( EV_Player_Respawn, 3.0f ); } #ifdef SIN_ARCADE gi.WriteByte( svc_stufftext ); gi.WriteString( "playerdead" ); gi.unicast( edict, true ); #endif } void Player::Killed ( Event *ev ) { Entity *attacker; Entity *inflictor; str location; str prefix; str aname; int meansofdeath; int i; qboolean deathgib=false; str dname; Event *ev1; attacker = ev->GetEntity( 1 ); inflictor = ev->GetEntity( 3 ); location = ev->GetString( 4 ); meansofdeath = ev->GetInteger( 5 ); // Set the enemy to attacker if it is a client, otherwise // some world object killed the player. We don't overwrite // enemy with non-clients, so clients can get credit for // kills they caused (i.e. shooting someone caused them to fall ) if ( attacker->isClient() ) { enemy = attacker; } // get rid of the third person crosshair if we have one if ( crosshair ) { delete crosshair; crosshair = NULL; } Obituary( attacker, inflictor, location, meansofdeath ); StopAnimating(); CancelPendingEvents(); // // determine death animation // if ( DoGib( meansofdeath, inflictor ) ) { deathgib = true; } prefix = AnimPrefixForPlayer(); if ( deathgib ) { str location; location = ev->GetString( 4 ); // Check for location first otherwise randomize if ( location == "torso_upper" ) dname += str( "gibdeath_upper" ); else if ( location == "torso_lower" ) dname += str( "gibdeath_lower" ); else if ( strstr( location.c_str(), "leg" ) ) dname += str( "gibdeath_lower" ); else if ( strstr( location.c_str(), "arm" ) ) dname += str( "gibdeath_upper" ); else if ( strstr( location.c_str(), "head" ) ) dname += str( "gibdeath_upper" ); else if ( G_Random() > 0.5 ) dname += str( "gibdeath_upper" ); else dname += str( "gibdeath_lower" ); } if ( deathgib ) aname = prefix + dname; else aname = prefix + str("death_") + location; i = gi.Anim_Random( edict->s.modelindex, aname.c_str() ); if ( i == -1 ) { aname = prefix + str("death"); } // moved to before the deadflag being set to prevent a definate game crash if ( flags & ( FL_MUTANT|FL_SP_MUTANT ) ) { Human( NULL ); } deadflag = DEAD_DYING; respawn_time = level.time + 1.0; if ( currentWeapon ) { if ( !level.training ) { DropWeapon( currentWeapon ); } else if ( level.training != 2 ) { delete currentWeapon; } } if ( coop->value ) { DropInventoryItems(); } edict->clipmask = MASK_DEADSOLID; edict->svflags |= SVF_DEADMONSTER; ProcessEvent( EV_Player_ZoomOut ); SetViewMode( THIRD_PERSON ); setMoveType( MOVETYPE_NONE ); edict->s.renderfx &= ~RF_DLIGHT; edict->s.renderfx &= ~RF_ENVMAPPED; angles.x = 0; angles.z = 0; setAngles( angles ); if ( deathmatch->value ) { client->showinfo = true; G_DeathmatchScoreboard( this ); } if ( flags & ( FL_MUTANT|FL_SP_MUTANT ) ) { ev1 = new Event( EV_Gib ); ev1->AddInteger( 0 ); ProcessEvent( ev1 ); ProcessEvent( EV_Player_Dead ); } else if ( strstr( aname.c_str(), "gibdeath" ) ) { ev1 = new Event( EV_Gib ); ev1->AddInteger( 1 ); ProcessEvent( ev1 ); } RandomAnimate( aname.c_str(), EV_Player_Dead ); animOverride = true; // // change music // ChangeMusic( "failure", "normal", true ); if ( !deathmatch->value && !level.training && !level.no_jc ) { char name[ 128 ]; int num; num = (int)G_Random( 4 ) + 1; sprintf( name, "global/universal_script.scr::jc_talks_blade_dies%d", num ); ExecuteThread( name, true ); } } void Player::Pain ( Event *ev ) { float damage,delta; Entity *attacker; int meansofdeath; damage = ev->GetFloat( 1 ); attacker = ev->GetEntity( 2 ); meansofdeath = ev->GetInteger( 4 ); if ( viewmode == CAMERA_VIEW ) { if ( level.cinematic ) { return; } else { ExitConsole( NULL ); SetCamera( NULL ); } } // add to our damage time v_dmg_time = level.time + DAMAGE_TIME; if ( attacker->isClient() ) { if ( !deadflag ) { enemy = attacker; lastEnemyTime = level.time + ENEMY_TIME; } } // increase action level of game action_level += damage; // add to the damage inflicted on a player this frame // the total will be turned into screen blends and view angle kicks // at the end of the frame damage_blood += damage; // white flash signifying no damage was taken. if ( ( damage <= 0 ) && ( meansofdeath != MOD_FISTS ) ) { Event *ev1; ProcessEvent( EV_Player_ClearFlashColor ); ev1 = new Event( EV_Player_SetFlashColor ); // Flash the player white ev1->AddFloat( 1 ); ev1->AddFloat( 1 ); ev1->AddFloat( 1 ); ev1->AddFloat( 0.3 ); ProcessEvent( ev1 ); } delta = level.time - last_damage_time; // Don' play more than one pain sound or animation a second if ( delta < 1.0 ) { return; } last_damage_time = level.time; // If damage > 5 then play a pain animation, otherwise play a pain sound if ( !firing && !deadflag && damage > 5) { str prefix; str aname; int index; // // determine pain animation // prefix = AnimPrefixForPlayer(); aname = prefix + str("pain_") + str( ev->GetString( 3 ) ); index = gi.Anim_Random( edict->s.modelindex, aname.c_str() ); if ( index == -1 ) { aname = prefix + str("pain"); } TempAnim( aname.c_str(), NULL ); } else { RandomSound( "snd_pain", 1 ); ProcessEvent( EV_PainSound ); } } void Player::DoUse ( void ) { int i; int num; edict_t *touch[ MAX_EDICTS ]; edict_t *hit; Event *ev; Vector min; Vector max; Vector offset; trace_t trace; Vector start; Vector end; float t; // Pickup inventory if one exists PickupFloatingInventory(); start = worldorigin + Vector( 0, 0, viewheight ); end = start + Vector( orientation[ 0 ] ) * 64.0f; trace = G_Trace( start, vec_zero, vec_zero, end, this, MASK_SOLID, "Player::DoUse" ); t = 64 * trace.fraction - maxs[ 0 ]; if ( t < 0 ) { t = 0; } offset = Vector( orientation[ 0 ] ) * t; min = start + offset + "-16 -16 -16"; max = start + offset + "16 16 16"; num = gi.BoxEdicts( min.vec3(), max.vec3(), touch, MAX_EDICTS, AREA_TRIGGERS ); // be careful, it is possible to have an entity in this // list removed before we get to it (killtriggered) for( i = 0; i < num; i++ ) { hit = touch[ i ]; if ( !hit->inuse ) { continue; } assert( hit->entity ); ev = new Event( EV_Use ); ev->AddEntity( this ); hit->entity->ProcessEvent( ev ); } num = gi.BoxEdicts( min.vec3(), max.vec3(), touch, MAX_EDICTS, AREA_SOLID ); // be careful, it is possible to have an entity in this // list removed before we get to it (killtriggered) for( i = 0; i < num; i++ ) { hit = touch[ i ]; if ( !hit->inuse ) { continue; } assert( hit->entity ); ev = new Event( EV_Use ); ev->AddEntity( this ); hit->entity->ProcessEvent( ev ); } // Force a reload on a weapon if ( currentWeapon ) { currentWeapon->ForceReload(); } } static Entity *pm_passent; // pmove doesn't need to know about passent and contentmask extern "C" trace_t PM_trace ( vec3_t start, vec3_t mins, vec3_t maxs, vec3_t end ) { if ( ( pm_passent->flags & FL_GODMODE ) || ( pm_passent->health > 0 ) ) { return G_Trace( start, mins, maxs, end, pm_passent->edict, MASK_PLAYERSOLID, "PM_trace 1" ); } else { return G_Trace( start, mins, maxs, end, pm_passent->edict, MASK_DEADSOLID, "PM_trace 1" ); } } EXPORT_FROM_DLL void Player::SetViewMode ( viewmode_t mode, Entity * newCamera ) { Camera *c; viewmode = mode; if ( watchCamera && ( ( watchCamera == thirdpersonCamera ) || ( watchCamera == spectatorCamera ) ) ) { delete watchCamera; watchCamera = NULL; thirdpersonCamera = NULL; spectatorCamera = NULL; } if ( crosshair ) { delete crosshair; crosshair = NULL; } switch( viewmode ) { default : case THIRD_PERSON : { Event * ev; Vector pos; c = new Camera; ev = new Event( EV_Camera_MoveToPos ); pos = worldorigin; pos.z = absmax.z; ev->AddVector( pos ); c->ProcessEvent( ev ); ev = new Event( EV_Camera_TurnTo ); ev->AddVector( v_angle ); c->ProcessEvent( ev ); if ( vehicle ) c->FollowEntity( this, 256, MASK_OPAQUE ); else c->FollowEntity( this, 128, MASK_PLAYERSOLID ); watchCamera = c; thirdpersonCamera = c; if ( !deadflag ) { cvar_t * chair; chair = gi.cvar("crosshair", "0", 0); crosshair = new Entity; crosshair->setModel( va( "sprites/crosshair%d.spr", (int)chair->value ) ); crosshair->edict->svflags |= SVF_ONLYPARENT; crosshair->edict->owner = this->edict; } } break; case SPECTATOR : { Event * ev; Vector pos; edict_t *cl_ent; cl_ent = g_edicts + 1 + currentCameraTarget; c = new Camera; ev = new Event( EV_Camera_MoveToPos ); pos = cl_ent->entity->worldorigin; pos.z = cl_ent->entity->absmax.z; ev->AddVector( pos ); c->ProcessEvent( ev ); ev = new Event( EV_Camera_TurnTo ); ev->AddVector( cl_ent->entity->worldangles ); c->ProcessEvent( ev ); c->FollowEntity( cl_ent->entity, 128, MASK_PLAYERSOLID ); watchCamera = c; spectatorCamera = c; } break; case FIRST_PERSON : watchCamera = this; break; case CAMERA_VIEW : watchCamera = newCamera; break; } } EXPORT_FROM_DLL void Player::CheckButtons ( void ) { // Only process buttons if you're not dying if ( deadflag != DEAD_NO ) { return; } if ( new_buttons & BUTTON_USE ) { DoUse(); } if ( ( buttons & BUTTON_ATTACK ) && spectator ) ChangeSpectator(); // Check for button release if ( !( buttons & BUTTON_ATTACK ) ) { if ( firedown ) { Event *event; event = new Event( EV_Sentient_ReleaseAttack ); event->AddFloat( level.time - firedowntime ); ProcessEvent( event ); firedown = false; } } // fire weapon from final position if needed if ( ( buttons & BUTTON_ATTACK ) && WeaponReady() ) { // // raise the action level // if ( currentWeapon ) action_level += currentWeapon->ActionLevelIncrement(); firedown = true; firedowntime = level.time; if ( !vehicle ) { str name; str prefix; prefix = AnimPrefixForPlayer(); // // append the prefix based on which weapon we are holding // prefix += str( AnimPrefixForWeapon() ); if ( ( xyspeed > 20 ) ) { int num; int numframes; if ( ( waterlevel > 2 ) || ( xyspeed > 250 ) ) name = prefix + str("run_fire"); else name = prefix + str("walk_fire"); num = gi.Anim_Random( edict->s.modelindex, name.c_str() ); if ( num != -1 ) { numframes = gi.Anim_NumFrames( edict->s.modelindex, num ); if ( ( last_frame_in_anim + 1 ) == numframes ) edict->s.anim = num; else TempAnim( name.c_str(), NULL ); } else { name = prefix + str("fire"); TempAnim( name.c_str(), NULL ); } } else { name = prefix + str("fire"); TempAnim( name.c_str(), NULL ); } } ProcessEvent( EV_Sentient_Attack ); if ( ai_createnodes->value ) { goalNode = nearestNode; if ( !goalNode ) { if ( ai_debugpath->value ) { gi.dprintf( "New path node\n" ); } nearestNode = new PathNode; nearestNode->Setup( worldorigin ); goalNode = nearestNode; lastNode = nearestNode; } } } } EXPORT_FROM_DLL void Player::TouchStuff ( pmove_t *pm ) { edict_t *other; Event *event; int i; int j; if ( getMoveType() != MOVETYPE_NOCLIP ) { G_TouchTriggers( this ); } // touch other objects for( i = 0; i < pm->numtouch; i++ ) { other = pm->touchents[ i ]; for( j = 0; j < i ; j++ ) { if ( pm->touchents[ j ] == other ) break; } if ( j != i ) { // duplicated continue; } // Don't bother touching the world if ( ( !other->entity ) || ( other->entity == world ) ) { continue; } event = new Event( EV_Touch ); event->AddEntity( this ); other->entity->ProcessEvent( event ); event = new Event( EV_Touch ); event->AddEntity( other->entity ); ProcessEvent( event ); } } EXPORT_FROM_DLL void Player::EnterVehicle ( Event *ev ) { Entity *ent; ent = ev->GetEntity( 1 ); if ( ent && ent->isSubclassOf( Vehicle ) ) { viewheight = STAND_EYE_HEIGHT; levelVars.SetVariable( "player_in_vehicle", 1 ); velocity = vec_zero; vehicle = ( Vehicle * )ent; if ( vehicle->IsDrivable() ) setMoveType( MOVETYPE_VEHICLE ); else setMoveType( MOVETYPE_NOCLIP ); if ( ev->NumArgs() > 1 ) vehicleanim = ev->GetString( 2 ); else vehicleanim = "drive"; } } EXPORT_FROM_DLL void Player::ExitVehicle ( Event *ev ) { levelVars.SetVariable( "player_in_vehicle", 0 ); setMoveType( MOVETYPE_WALK ); vehicle = NULL; } EXPORT_FROM_DLL void Player::GetMoveInfo ( pmove_t *pm ) { if ( !deadflag ) { v_angle[ 0 ] = pm->viewangles[ 0 ]; v_angle[ 1 ] = pm->viewangles[ 1 ]; v_angle[ 2 ] = pm->viewangles[ 2 ]; AnglesToMat( v_angle.vec3(), orientation ); } client->ps.pmove = pm->s; old_pmove = pm->s; setOrigin( Vector( pm->s.origin[ 0 ], pm->s.origin[ 1 ], pm->s.origin[ 2 ] ) * 0.125 ); velocity = Vector( pm->s.velocity[ 0 ], pm->s.velocity[ 1 ], pm->s.velocity[ 2 ] ) * 0.125; if ( ( client->ps.pmove.pm_type == PM_FREEZE ) || ( client->ps.pmove.pm_type == PM_INVEHICLE_ZOOM ) || ( client->ps.pmove.pm_type == PM_INVEHICLE ) ) velocity = vec_zero; setSize( pm->mins, pm->maxs ); gunoffset = Vector( 0, 0, pm->viewheight ); viewheight = pm->viewheight; waterlevel = pm->waterlevel; watertype = pm->watertype; onladder = pm->onladder; if ( pm->groundentity ) { groundentity = pm->groundentity; groundsurface = pm->groundsurface; groundplane = pm->groundplane; groundcontents = pm->groundcontents; groundentity_linkcount = pm->groundentity->linkcount; } else { groundentity = NULL; groundsurface = NULL; groundcontents = 0; } if ( pm->groundsurface ) fallsurface = pm->groundsurface; } EXPORT_FROM_DLL void Player::SetMoveInfo ( pmove_t *pm, usercmd_t *ucmd ) { pm_passent = this; // set up for pmove memset( pm, 0, sizeof( pmove_t ) ); pm->s = client->ps.pmove; pm->s.origin[ 0 ] = worldorigin.x * 8; pm->s.origin[ 1 ] = worldorigin.y * 8; pm->s.origin[ 2 ] = worldorigin.z * 8; pm->s.velocity[ 0 ] = velocity.x * 8; pm->s.velocity[ 1 ] = velocity.y * 8; pm->s.velocity[ 2 ] = velocity.z * 8; if ( !vehicle && memcmp( &old_pmove, &pm->s, sizeof( pm->s ) ) ) { pm->snapinitial = true; } pm->cmd = *ucmd; pm->trace = PM_trace; // adds default parms pm->pointcontents = gi.pointcontents; } EXPORT_FROM_DLL pmtype_t Player::GetMovePlayerMoveType ( void ) { if ( level.playerfrozen || sentientFrozen ) { return PM_FREEZE; } else if ( viewmode == CAMERA_VIEW ) { return PM_LOCKVIEW; } else if ( vehicle ) { if ( zoom_mode == ZOOMED_IN ) { return PM_INVEHICLE_ZOOM; } else { return PM_INVEHICLE; } } else if ( ( getMoveType() == MOVETYPE_NOCLIP ) || ( spectator ) ) { return PM_SPECTATOR; } else if ( deadflag ) { return PM_DEAD; } else if ( zoom_mode == ZOOMED_IN ) { return PM_ZOOM; } else if ( ( viewmode == THIRD_PERSON ) && ( !gravaxis ) ) { return PM_LOCKVIEW; } else { return PM_NORMAL; } } EXPORT_FROM_DLL void Player::ClientMove ( usercmd_t *ucmd ) { pmove_t pm; client->ps.pmove.pm_type = GetMovePlayerMoveType(); if ( ( client->ps.pmove.pm_type == PM_LOCKVIEW ) || ( client->ps.pmove.pm_type == PM_INVEHICLE ) || ( client->ps.pmove.pm_type == PM_INVEHICLE_ZOOM ) || ( client->ps.pmove.pm_type == PM_FREEZE ) || ( client->ps.pmove.pm_type == PM_DEAD ) ) client->ps.pmove.pm_flags |= PMF_NO_PREDICTION; else client->ps.pmove.pm_flags &= ~PMF_NO_PREDICTION; if ( flags & FL_MUTANT ) client->ps.pmove.pm_flags |= PMF_MUTANT; else client->ps.pmove.pm_flags &= ~PMF_MUTANT; if ( flags & FL_ADRENALINE ) client->ps.pmove.pm_flags |= PMF_ADRENALINE; else client->ps.pmove.pm_flags &= ~PMF_ADRENALINE; if ( level.airclamp ) client->ps.pmove.pm_flags &= ~PMF_NOAIRCLAMP; else client->ps.pmove.pm_flags |= PMF_NOAIRCLAMP; edict->s.effects &= ~EF_NOFOOTSTEPS; if ( !sv_footsteps->value ) { edict->s.effects |= EF_NOFOOTSTEPS; } client->ps.pmove.gravity = sv_gravity->value * gravity; SetMoveInfo( &pm, ucmd ); // perform a pmove gi.Pmove( &pm ); if ( !deadflag && !level.playerfrozen ) { if ( waterlevel == 3 && falling) { Event * ev; ev = new Event( EV_Sentient_AnimLoop ); ProcessEvent( ev ); falling = false; } if ( groundentity && !pm.groundentity && ( pm.cmd.upmove >= 10 ) && ( waterlevel <= 1 ) ) { TempAnim( "jump", NULL ); falling = true; } if ( !groundentity && pm.groundentity && ( ( pm.s.velocity[ 2 ] < -1600 ) || falling ) ) { falling = false; if ( waterlevel <= 2 ) { TempAnim( "land", NULL ); } } if ( ( !onladder ) && !pm.groundentity && ( velocity[ 2 ] < -200 ) && ( pm.s.velocity[ 2 ] > -2000 ) ) { if ( !waterlevel ) { TempAnim( "fall", NULL ); falling = true; } } } // save results of pmove GetMoveInfo( &pm ); TouchStuff( &pm ); if ( !level.playerfrozen ) CheckButtons(); if ( whereami->value ) { static Vector last; if ( worldorigin != last ) { last = worldorigin; gi.dprintf("x %8.2f y%8.2f z %8.2f area %2d\n", worldorigin[0], worldorigin[1], worldorigin[2], edict->areanum ); } } } /* ============== ClientThink This will be called once for each client frame, which will usually be a couple times for each server frame. ============== */ EXPORT_FROM_DLL void Player::ClientThink ( Event *ev ) { if ( !has_thought ) { // let any threads waiting on us know they can go ahead Director.PlayerSpawned(); has_thought = true; } new_buttons = current_ucmd->buttons & ~buttons; buttons = current_ucmd->buttons; // set the current gravity axis client->ps.pmove.gravity_axis = gravaxis; // save light level the player is standing on for // monster sighting AI light_level = current_ucmd->lightlevel; if ( level.intermissiontime ) { client->ps.pmove.pm_type = PM_FREEZE; // can exit intermission after five seconds if ( level.time > level.intermissiontime + 5.0 && ( new_buttons & BUTTON_ANY ) ) { level.exitintermission = true; } // Save cmd angles so that we can get delta angle movements next frame client->resp.cmd_angles[ 0 ] = SHORT2ANGLE( current_ucmd->angles[ 0 ] ); client->resp.cmd_angles[ 1 ] = SHORT2ANGLE( current_ucmd->angles[ 1 ] ); client->resp.cmd_angles[ 2 ] = SHORT2ANGLE( current_ucmd->angles[ 2 ] ); return; } if ( current_ucmd->debris ) { float mult; mult = SURFACE_DamageMultiplier( current_ucmd->debris << SURF_START_BIT ); mult *= 2; if ( mult > 0 ) { Damage( world, world, ( int )mult, worldorigin, vec_zero, vec_zero, 0, 0, MOD_DEBRIS, -1, -1, 1.0f ); } } if ( ( client->ps.pmove.pm_flags & PMF_TIME_TELEPORT ) && ( savedfov ) && ( client->ps.pmove.pm_time < 95 ) ) { Event * ev; ev = new Event( EV_Player_RestoreFov ); ProcessEvent( ev ); } if ( !vehicle || !vehicle->Drive( current_ucmd ) ) { short temporigin[ 3 ]; if ( watchCamera != this ) { // // we save off the origin so that camera's origins are not messed up // temporigin[ 0 ] = client->ps.pmove.origin[ 0 ]; temporigin[ 1 ] = client->ps.pmove.origin[ 1 ]; temporigin[ 2 ] = client->ps.pmove.origin[ 2 ]; ClientMove( current_ucmd ); client->ps.pmove.origin[ 0 ] = temporigin[ 0 ]; client->ps.pmove.origin[ 1 ] = temporigin[ 1 ]; client->ps.pmove.origin[ 2 ] = temporigin[ 2 ]; } else { ClientMove( current_ucmd ); } } else { CheckWater(); if ( !level.playerfrozen ) CheckButtons(); } // If we're dying, check for respawn assert( !( deadflag && deadflag != DEAD_DEAD && !animating ) ); if ( ( deadflag == DEAD_DEAD && ( level.time > respawn_time ) ) || ( deadflag && !animating ) ) { if ( ( deathmatch->value ) && ( !checked_dead_camera ) && ( level.time > ( respawn_time + 10 ) ) ) { int num; checked_dead_camera = true; // Find the end node num = G_FindTarget( 0, "endnode1" ); if ( num && thirdpersonCamera ) { Entity * path; Event * event; event = new Event( EV_Camera_NormalAngles ); thirdpersonCamera->ProcessEvent( event ); event = new Event( EV_Camera_Orbit); path = G_GetEntity( num ); event->AddEntity( path ); thirdpersonCamera->ProcessEvent( event ); event = new Event( EV_Camera_JumpCut ); thirdpersonCamera->ProcessEvent( event ); } } // wait for any button just going down if ( new_buttons || ( DM_FLAG( DF_FORCE_RESPAWN ) ) ) { ProcessEvent( EV_Player_Respawn ); } } // // check to see if we want to get out of a cinematic or camera // if ( ( viewmode == CAMERA_VIEW ) && ( ( buttons & BUTTON_ATTACK ) || ( buttons & BUTTON_USE ) || ( abs( current_ucmd->forwardmove ) >= 200 ) || ( abs( current_ucmd->sidemove ) >= 200 ) || ( current_ucmd->upmove > 0 ) ) ) { if ( level.cinematic ) { if ( ( buttons & BUTTON_ATTACK ) || ( buttons & BUTTON_USE ) || ( current_ucmd->upmove > 0 ) ) { if ( world->skipthread.length() > 1 ) { ExecuteThread( world->skipthread ); } } } else { if ( !( buttons & BUTTON_USE ) && !( buttons & BUTTON_ATTACK ) && !( trappedInQuantum ) && !( in_console ) ) { SetCamera( NULL ); } } } // Save cmd angles so that we can get delta angle movements next frame client->resp.cmd_angles[ 0 ] = SHORT2ANGLE( current_ucmd->angles[ 0 ] ); client->resp.cmd_angles[ 1 ] = SHORT2ANGLE( current_ucmd->angles[ 1 ] ); client->resp.cmd_angles[ 2 ] = SHORT2ANGLE( current_ucmd->angles[ 2 ] ); } void Player::EventUseItem ( Event *ev ) { const char *name; name = ev->GetString( 1 ); assert( name ); if ( deadflag ) return; if ( flags & ( FL_MUTANT|FL_SP_MUTANT ) ) return; if ( currentWeapon && !currentWeapon->ChangingWeapons() ) { if ( !Q_stricmp( name, currentWeapon->getClassname() ) ) { Event *event; event = new Event(EV_Weapon_SecondaryUse); event->AddEntity(this); currentWeapon->ProcessEvent(event); return; } } ProcessEvent( EV_Player_ZoomOut ); if ( checkInheritance( &Weapon::ClassInfo, name ) ) useWeapon( name ); } void Player::EventUseInventoryItem ( Event *ev ) { if ( deadflag ) return; if ( !currentItem ) return; if ( flags & ( FL_MUTANT|FL_SP_MUTANT ) ) return; currentItem->ProcessEvent(EV_InventoryItem_Use); } Weapon *Player::useWeapon ( const char *weaponname ) { if ( vehicle && vehicle->HasWeapon() ) return NULL; else return Sentient::useWeapon( weaponname ); } void Player::Take ( Event *ev ) { const char *name; name = ev->GetString( 1 ); assert( name ); if ( deadflag ) { return; } if ( !stricmp( name, "all" ) ) { if ( currentWeapon ) currentWeapon->DetachFromOwner(); SetCurrentWeapon( NULL ); FreeInventoryOfType("Weapon"); giveWeapon( "Fists" ); giveWeapon( "SpiderMine" ); } else if ( checkInheritance( &Weapon::ClassInfo, name ) ) { takeWeapon( name ); } else if ( checkInheritance( &Ammo::ClassInfo, name ) ) { EventTakeAmmo( ev ); } else if ( checkInheritance( &Item::ClassInfo, name ) ) { EventTakeItem( ev ); } else { gi.cprintf( edict, PRINT_HIGH, "Unknown take object : %s\n", name ); } } void Player::GiveCheat ( Event *ev ) { const char *name; name = ev->GetString( 1 ); assert( name ); if ( deadflag ) { return; } if ( checkInheritance( &Weapon::ClassInfo, name ) ) { giveWeapon( name ); } else if ( checkInheritance( &Ammo::ClassInfo, name ) ) { EventGiveAmmo( ev ); } else if ( checkInheritance( &InventoryItem::ClassInfo, name ) ) { if (ev->NumArgs() != 2) { gi.cprintf( edict, PRINT_HIGH, "Usage: give \n"); return; } EventGiveInventoryItem( ev ); } else if ( checkInheritance( &Item::ClassInfo, name ) ) { EventGiveItem( ev ); } } void Player::GiveAllCheat ( Event *ev ) { if ( deadflag ) { return; } #ifdef SIN_DEMO giveWeapon( "Fists" ); giveWeapon( "RocketLauncher" ); giveWeapon( "Magnum" ); giveWeapon( "SniperRifle" ); giveWeapon( "AssaultRifle" ); giveWeapon( "Shotgun" ); #else giveWeapon( "Fists" ); giveWeapon( "RocketLauncher" ); giveWeapon( "Magnum" ); giveWeapon( "SniperRifle" ); giveWeapon( "AssaultRifle" ); giveWeapon( "ChainGun" ); giveWeapon( "PulseRifle" ); giveWeapon( "Shotgun" ); giveWeapon( "SpearGun" ); giveWeapon( "SpiderMine" ); giveWeapon( "MutantHands" ); giveWeapon( "QuantumDestabilizer" ); #endif giveItem( "RiotHelmet", 100); giveItem( "FlakJacket", 100); giveItem( "FlakPants", 100); } void Player::GodCheat ( Event *ev ) { const char *msg; if ( ev->NumArgs() > 0 ) { if ( ev->GetInteger( 1 ) ) { flags |= FL_GODMODE; } else { flags &= ~FL_GODMODE; } } else { flags ^= FL_GODMODE; } if ( ev->GetSource() == EV_FROM_CONSOLE ) { if ( !( flags & FL_GODMODE ) ) { msg = "godmode OFF\n"; } else { msg = "godmode ON\n"; } gi.cprintf( edict, PRINT_HIGH, msg ); } } void Player::Kill ( Event *ev ) { if ( ( level.time - respawn_time ) < 5 ) { return; } flags &= ~FL_GODMODE; health = 0; Damage( this, this, 10, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_PROTECTION, MOD_SUICIDE, -1, -1, 1.0f ); } void Player::NoTargetCheat ( Event *ev ) { const char *msg; flags ^= FL_NOTARGET; if ( !( flags & FL_NOTARGET ) ) { msg = "notarget OFF\n"; } else { msg = "notarget ON\n"; } gi.cprintf( edict, PRINT_HIGH, msg ); } void Player::NoclipCheat ( Event *ev ) { const char *msg; if ( vehicle ) { msg = "Must exit vehicle first\n"; } else if ( getMoveType() == MOVETYPE_NOCLIP ) { setMoveType( MOVETYPE_WALK ); msg = "noclip OFF\n"; } else { setMoveType( MOVETYPE_NOCLIP ); msg = "noclip ON\n"; } gi.cprintf( edict, PRINT_HIGH, msg ); } void Player::SpawnEntity ( Event *ev ) { Entity *ent; const char *name; ClassDef *cls; str text; Vector forward; Vector right; Vector up; Vector delta; Vector v; int n; int i; if ( ev->NumArgs() < 1 ) { ev->Error( "Usage: spawn entityname [keyname] [value]..." ); return; } name = ev->GetString( 1 ); if ( !name || !name[ 0 ] ) { ev->Error( "Must specify an entity name" ); return; } // create a new entity G_InitSpawnArguments(); if ( name ) { cls = getClassForID( name ); if ( !cls ) { cls = getClass( name ); } if ( !cls ) { str n; n = name; if ( !strstr( n.c_str(), ".def" ) ) { n += ".def"; } G_SetSpawnArg( "model", n.c_str() ); } else { G_SetSpawnArg( "classname", name ); } } angles.AngleVectors( &forward, &right, &up ); v = worldorigin + ( forward + up ) * 80; text = va( "%f %f %f", v[ 0 ], v[ 1 ], v[ 2 ] ); G_SetSpawnArg( "origin", text.c_str() ); delta = worldorigin - v; v = delta.toAngles(); text = va( "%f", v[ 1 ] ); G_SetSpawnArg( "angle", text.c_str() ); if ( ev->NumArgs() > 2 ) { n = ev->NumArgs(); for( i = 2; i <= n; i += 2 ) { G_SetSpawnArg( ev->GetString( i ), ev->GetString( i + 1 ) ); } } cls = G_GetClassFromArgs(); if ( !cls ) { ev->Error( "'%s' is not a valid entity name", name ); return; } ent = ( Entity * )cls->newInstance(); G_InitSpawnArguments(); } void Player::SpawnActor ( Event *ev ) { Entity *ent; str name; str text; Vector forward; Vector right; Vector up; Vector delta; Vector v; int n; int i; ClassDef *cls; if ( ev->NumArgs() < 1 ) { ev->Error( "Usage: actor [modelname] [keyname] [value]..." ); return; } name = ev->GetString( 1 ); if ( !name[ 0 ] ) { ev->Error( "Must specify a model name" ); return; } if ( !strstr( name.c_str(), ".def" ) ) { name += ".def"; } // create a new entity G_InitSpawnArguments(); G_SetSpawnArg( "model", name.c_str() ); angles.AngleVectors( &forward, &right, &up ); v = worldorigin + ( forward + up ) * 80; text = va( "%f %f %f", v[ 0 ], v[ 1 ], v[ 2 ] ); G_SetSpawnArg( "origin", text.c_str() ); delta = worldorigin - v; v = delta.toAngles(); text = va( "%f", v[ 1 ] ); G_SetSpawnArg( "angle", text.c_str() ); if ( ev->NumArgs() > 2 ) { n = ev->NumArgs(); for( i = 2; i <= n; i += 2 ) { G_SetSpawnArg( ev->GetString( i ), ev->GetString( i + 1 ) ); } } cls = G_GetClassFromArgs(); if ( !cls ) { G_SetSpawnArg( "model", name.c_str() ); ent = new Actor; } else { ent = ( Entity * )cls->newInstance(); } G_InitSpawnArguments(); } void Player::EventPreviousWeapon ( Event *ev ) { if ( deadflag ) { return; } if ( vehicle && vehicle->HasWeapon() ) return; if ( flags & (FL_MUTANT|FL_SP_MUTANT) ) return; // Cycle backwards through weapons if ( currentWeapon && currentWeapon->AttackDone() && !currentWeapon->ChangingWeapons() ) { ProcessEvent( EV_Player_ZoomOut ); ChangeWeapon( PreviousWeapon( currentWeapon ) ); } } void Player::EventNextWeapon ( Event *ev ) { if ( deadflag ) { return; } if ( vehicle && vehicle->HasWeapon() ) return; if ( flags & (FL_MUTANT|FL_SP_MUTANT) ) return; // Cycle forwards through weapons if ( currentWeapon && currentWeapon->AttackDone() && !currentWeapon->ChangingWeapons() ) { ProcessEvent( EV_Player_ZoomOut ); ChangeWeapon( NextWeapon( currentWeapon ) ); } } void Player::EventNextItem ( Event *ev ) { Item *nextItem; if ( deadflag ) return; nextItem = NextItem( currentItem ); if (nextItem) currentItem = (InventoryItem *)nextItem; } void Player::EventPreviousItem ( Event *ev ) { Item *prevItem; if ( deadflag ) return; prevItem = PrevItem( currentItem ); if (prevItem) currentItem = (InventoryItem *)prevItem; } void Player::GameVersion ( Event *ev ) { gi.cprintf( edict, PRINT_HIGH, "%s : %s\n", GAMEVERSION, __DATE__ ); } void Player::Fov ( Event *ev ) { if ( ev->NumArgs() < 1 ) { gi.cprintf( edict, PRINT_HIGH, "Fov = %d\n", fov ); return; } fov = ev->GetFloat( 1 ); if ( ( fov < 90 ) && DM_FLAG( DF_FIXED_FOV ) ) { fov = 90; return; } if ( fov < 1 ) fov = 90; else if ( fov > 160 ) fov = 160; } void Player::SaveFov ( Event *ev ) { savedfov = fov; } void Player::RestoreFov ( Event *ev ) { if ( savedfov ) fov = savedfov; savedfov = 0; } void Player::ToggleViewMode ( Event *ev ) { if ( viewmode == CAMERA_VIEW || ( vehicle && !vehicle->IsDrivable() ) ) { return; } // Spectators don't need 3rd person if ( spectator ) { defaultViewMode = SPECTATOR; SetViewMode( SPECTATOR ); return; } if ( defaultViewMode == FIRST_PERSON ) { defaultViewMode = THIRD_PERSON; SetViewMode( THIRD_PERSON ); } else { defaultViewMode = FIRST_PERSON; SetViewMode( FIRST_PERSON ); } } /* ========================================================================= Player::ToggleZoomMode - Plays a zoom sound, sets the layout to display a crosshair and calls the FOV event for the player. ========================================================================= */ void Player::ToggleZoomMode ( Event *ev ) { if ( zoom_mode == ZOOMED_IN ) { zoom_mode = ZOOMED_OUT; fov = atof( Info_ValueForKey( client->pers.userinfo, "fov" ) ); if ( fov < 1 ) { fov = 90; } else if ( fov > 160 ) { fov = 160; } RandomGlobalSound( "scope_zoomout", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_MovementSound ); } else { RandomGlobalSound( "scope_zoomin", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_MovementSound ); zoom_mode = ZOOMED_IN; fov = 20; } } void Player::ZoomOut ( Event *ev ) { if ( zoom_mode == ZOOMED_IN ) { zoom_mode = ZOOMED_OUT; fov = atof( Info_ValueForKey( client->pers.userinfo, "fov" ) ); if ( fov < 1 ) { fov = 90; } else if ( fov > 160 ) { fov = 160; } } } void Player::EnterConsole ( Event *ev ) { velocity = vec_zero; in_console = true; con_name = ev->GetString(1); // Create a console variable with the entnum of this player // who used it. Director.CreateConsoleUser(con_name.c_str(), entnum); } void Player::ExitConsole ( Event *ev ) { ProcessEvent(EV_KickFromConsole); in_console = false; con_name = ""; SetCamera( NULL ); showModel(); hidestats = false; } void Player::KickConsole ( Event *ev ) { char msg[ MAX_MSGLEN ]; in_console = false; // Send a message to the client to kick us out of this console. if ( !consoleManager.ConsoleExists( con_name.c_str() ) ) { Event event = new Event( ev ); PostEvent(event,1.0f); return; } sprintf( msg, "pku %s", con_name.c_str() ); gi.WriteByte (svc_console_command); gi.WriteString (msg); gi.unicast (edict, true); } /* =============== CalcRoll =============== */ float Player::CalcRoll ( void ) { float sign; float side; float value; Vector r; angles.AngleVectors( NULL, &r, NULL ); side = velocity * r; sign = side < 0 ? -4 : 4; side = fabs( side ); value = sv_rollangle->value; if ( side < sv_rollspeed->value ) { side = side * value / sv_rollspeed->value; } else { side = value; } return side * sign; } /* =============== CalcViewOffset Auto pitching on slopes? fall from 128: 400 = 160000 fall from 256: 580 = 336400 fall from 384: 720 = 518400 fall from 512: 800 = 640000 fall from 640: 960 = damage = deltavelocity*deltavelocity * 0.0001 =============== */ void Player::CalcViewOffset ( void ) { float bob; float ratio; float pitch; float roll; float delta; Vector forward; Vector right; Vector ang; // Initialize kick for this frame v_kick = vec_zero; // don't add any kick when dead if ( !deadflag ) { // add angles based on weapon kick v_kick = kick_angles; // add angles based on damage kick ratio = ( v_dmg_time - level.time ) / DAMAGE_TIME; if ( ratio < 0 ) { ratio = 0; v_dmg_pitch = 0; v_dmg_roll = 0; } pitch = v_kick.pitch() + ratio * v_dmg_pitch; roll = v_kick.roll() + ratio * v_dmg_roll; // add pitch based on fall kick ratio = ( fall_time - level.time ) / FALL_TIME; if ( ratio < 0 ) { ratio = 0; } pitch += ratio * fall_value; // calculate forward and right based upon yaw ang[ 1 ] = v_angle[ 1 ]; ang.AngleVectors( &forward, &right, NULL ); //FIXME: need to handle alternate gravity axis // add pitch based on forward velocity delta = velocity * forward; pitch += delta * run_pitch->value; // add roll based on side velocity delta = -( velocity * right ); roll += delta * run_pitch->value; // add angles based on bob delta = bobfracsin * bob_pitch->value * xyspeed; if ( ( waterlevel <= 1 ) && ( client->ps.pmove.pm_flags & PMF_DUCKED ) ) { delta *= 6; // crouching } pitch += delta; delta = bobfracsin * bob_roll->value * xyspeed; if ( ( waterlevel <= 1 ) && ( client->ps.pmove.pm_flags & PMF_DUCKED ) ) { delta *= 6; // crouching } if ( bobcycle & 1 ) { delta = -delta; } roll += delta; v_kick.setPitch( pitch ); v_kick.setRoll( roll ); } // add fall height ratio = ( fall_time - level.time ) / FALL_TIME; if ( ratio < 0 ) { ratio = 0; } v_offset = Vector( 0, 0, viewheight - ratio * fall_value * 0.4 ); // add bob height bob = bobfracsin * xyspeed * bob_up->value; if ( bob > 6 ) { bob = 6; } //gi.DebugGraph (bob *2, 255); v_offset.z += bob; // add kick offset v_offset += kick_origin; // absolutely bound offsets // so the view can never be outside the player box if ( v_offset[ 0 ] < -14 ) { v_offset[ 0 ] = -14; } else if ( v_offset[ 0 ] > 14 ) { v_offset[ 0 ] = 14; } if ( v_offset[ 1 ] < -14 ) { v_offset[ 1 ] = -14; } else if ( v_offset[ 1 ] > 14 ) { v_offset[ 1 ] = 14; } if ( v_offset[ 2 ] < 0 ) { v_offset[ 2 ] = 0; } else if ( v_offset[ 2 ] > STAND_HEIGHT - 2 ) { v_offset[ 2 ] = STAND_HEIGHT - 2; } // clear weapon kicks kick_origin = vec_zero; kick_angles = vec_zero; } /* ============== CalcGunOffset ============== */ void Player::CalcGunOffset ( void ) { int i; float delta; // gun angles from bobbing v_gunangles[ ROLL ] = xyspeed * bobfracsin * 0.005; v_gunangles[ YAW ] = xyspeed * bobfracsin * 0.01; if ( bobcycle & 1 ) { v_gunangles[ ROLL ] = -v_gunangles[ ROLL ]; v_gunangles[ YAW ] = -v_gunangles[ YAW ]; } v_gunangles[ PITCH ] = xyspeed * bobfracsin * 0.005; // gun angles from delta movement for( i = 0; i < 3; i++ ) { delta = oldviewangles[ i ] - v_angle[ i ]; if ( delta > 180 ) { delta -= 360; } if ( delta < -180 ) { delta += 360; } if ( delta > 45 ) { delta = 45; } if ( delta < -45 ) { delta = -45; } if ( i == YAW ) { v_gunangles[ ROLL ] += 0.1 * delta; } v_gunangles[ i ] += 0.2 * delta; } oldviewangles = v_angle; // gun height VectorClear( v_gunoffset ); // gun_x / gun_y / gun_z are development tools for( i = 0; i < 3; i++ ) { v_gunoffset[ i ] += orientation[ 0 ][ i ] * gun_y->value; v_gunoffset[ i ] += orientation[ 1 ][ i ] * gun_x->value; v_gunoffset[ i ] += orientation[ 2 ][ i ] * -gun_z->value; } // // put gun offset and angles into client playerstate // client->ps.gunoffset[ 0 ] = v_gunoffset[0]; client->ps.gunoffset[ 1 ] = v_gunoffset[1]; client->ps.gunoffset[ 2 ] = v_gunoffset[2]; client->ps.gunangles[ 0 ] = v_gunangles[0]; client->ps.gunangles[ 1 ] = v_gunangles[1]; client->ps.gunangles[ 2 ] = v_gunangles[2]; if ( currentWeapon ) { currentWeapon->SetGravityAxis( gravaxis ); } } void Player::GravityNodes ( void ) { Vector grav,gravnorm,velnorm; float dot; qboolean force; // // Check for gravity pulling points // // no pull on ladders or during waterjumps if ( onladder || ( client->ps.pmove.pm_flags & PMF_TIME_WATERJUMP ) ) { return; } grav = gravPathManager.CalculateGravityPull( *this, worldorigin, &force ); // Check for unfightable gravity. if ( force && grav != vec_zero ) { velnorm = velocity; velnorm.normalize(); gravnorm = grav; gravnorm.normalize(); dot = gravnorm.x * velnorm.x + gravnorm.y * velnorm.y + gravnorm.z * velnorm.z; // This prevents the player from trying to swim upstream if ( dot < 0 ) { float tempdot; Vector tempvec; tempdot = 0.2f - dot; tempvec = velocity * tempdot; velocity = velocity - tempvec; } } #if 0 OutputDebugString(va("DOT : %f\n", dot)); OutputDebugString(va("GRAV: %f %f %f\n", grav.x, grav.y, grav.z)); OutputDebugString(va("VELN: %f %f %f\n", velnorm.x,velnorm.y,velnorm.z)); OutputDebugString(va("GRVN: %f %f %f\n", gravnorm.x,gravnorm.y,gravnorm.z)); #endif velocity = velocity + grav; } /* ============= CheckWater ============= */ void Player::CheckWater ( void ) { Vector point; int cont; int sample1; int sample2; const gravityaxis_t &grav = gravity_axis[ gravaxis ]; unlink(); if ( vehicle ) { vehicle->unlink(); } // // get waterlevel, accounting for ducking // waterlevel = 0; watertype = 0; sample2 = viewheight - mins[ grav.z ]; sample1 = sample2 / 2; point[ grav.x ] = worldorigin[ grav.x ]; point[ grav.y ] = worldorigin[ grav.y ]; point[ grav.z ] = worldorigin[ grav.z ] + mins[ grav.z ] + grav.sign; cont = gi.pointcontents( point.vec3() ); if ( cont & MASK_WATER ) { watertype = cont; waterlevel = 1; point[ grav.z ] = worldorigin[ grav.z ] + mins[ grav.z ] + sample1; cont = gi.pointcontents( point.vec3() ); if ( cont & MASK_WATER ) { waterlevel = 2; point[ grav.z ] = worldorigin[ grav.z ] + mins[ grav.z ] + sample2; cont = gi.pointcontents( point.vec3() ); if ( cont & MASK_WATER ) { waterlevel = 3; } } } link(); if ( vehicle ) { vehicle->link(); } } /* ============= WorldEffects ============= */ void Player::WorldEffects ( void ) { if ( movetype == MOVETYPE_NOCLIP ) { // don't need air air_finished = level.time + 20; return; } // // Check for earthquakes // if ( groundentity && ( level.earthquake > level.time ) ) { velocity += Vector(EARTHQUAKE_STRENGTH*G_CRandom(),EARTHQUAKE_STRENGTH*G_CRandom(),fabs(150*G_CRandom())); } // // if just entered a water volume, play a sound // if ( !old_waterlevel && waterlevel ) { if ( watertype & CONTENTS_LAVA ) { RandomSound( "snd_burn", 1, CHAN_BODY, ATTN_NORM ); ProcessEvent( EV_MovementSound ); } else if ( ( watertype & CONTENTS_WATER ) && waterlevel < 3) { RandomGlobalSound( "impact_playersplash", 1, CHAN_BODY, ATTN_NORM ); ProcessEvent( EV_MovementSound ); } flags |= FL_INWATER; } // // if just completely exited a water volume, play a sound // if ( old_waterlevel && !waterlevel ) { RandomGlobalSound( "impact_playerleavewater", 1, CHAN_BODY, ATTN_NORM ); ProcessEvent( EV_MovementSound ); flags &= ~FL_INWATER; } // // check for head just going under water // if ( old_waterlevel && old_waterlevel != 3 && waterlevel == 3 ) { RandomGlobalSound( "impact_playersubmerge", 1, CHAN_BODY, ATTN_NORM ); ProcessEvent( EV_MovementSound ); } // // check for head just coming out of water // if ( old_waterlevel == 3 && waterlevel != 3 ) { if ( air_finished < level.time ) { // gasp for air RandomSound( "snd_gasp", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_VoiceSound ); } else if ( air_finished < level.time + 11 ) { // just break surface RandomSound( "snd_gasp", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_VoiceSound ); } } // // check for lava // if ( watertype & CONTENTS_LAVA ) { if ( next_drown_time < level.time ) { next_drown_time = level.time + 0.2f; Damage( world, world, 10 * waterlevel, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR, MOD_LAVA, -1, -1, 1.0f ); } } // // check for drowning // if (waterlevel == 3) { // if out of air, start drowning if ( ( air_finished < level.time ) && !( flags & FL_OXYGEN ) && !( flags & FL_GODMODE ) ) { // drown! if ( next_drown_time < level.time && health > 0 ) { next_drown_time = level.time + 1; // take more damage the longer underwater drown_damage += 2; if ( drown_damage > 15 ) { drown_damage = 15; } // play a gurp sound instead of a normal pain sound if ( health <= drown_damage ) { RandomSound( "snd_drown", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_PainSound ); } else if ( rand() & 1 ) { RandomSound( "snd_choke", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_PainSound ); } else { RandomSound( "snd_choke", 1, CHAN_VOICE, ATTN_NORM ); ProcessEvent( EV_PainSound ); } Damage( world, world, drown_damage, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR, MOD_DROWN, -1, -1, 1.0f ); } } } else { air_finished = level.time + 20; drown_damage = 2; } GravityNodes(); old_waterlevel = waterlevel; } /* ============= AddBlend ============= */ void Player::AddBlend ( float r, float g, float b, float a ) { float a2; float a3; if ( a <= 0 ) { return; } // new total alpha a2 = blend[ 3 ] + ( 1 - blend[ 3 ] ) * a; // fraction of color from old a3 = blend[ 3 ] / a2; blend[ 0 ] = blend[ 0 ] * a3 + r * ( 1 - a3 ); blend[ 1 ] = blend[ 1 ] * a3 + g * ( 1 - a3 ); blend[ 2 ] = blend[ 2 ] * a3 + b * ( 1 - a3 ); blend[ 3 ] = a2; } /* ============= CalcBlend ============= */ void Player::CalcBlend ( void ) { int contents; Vector vieworg; const gravityaxis_t &grav = gravity_axis[ gravaxis ]; blend[ 0 ] = blend[ 1 ] = blend[ 2 ] = blend[ 3 ] = 0; // add for contents vieworg[ grav.x ] = worldorigin[ grav.x ] + v_offset[ 0 ]; vieworg[ grav.y ] = worldorigin[ grav.y ] + v_offset[ 1 ] * grav.sign; vieworg[ grav.z ] = worldorigin[ grav.z ] + v_offset[ 2 ] * grav.sign; contents = gi.pointcontents( vieworg.vec3() ); if ( contents & CONTENTS_SOLID ) { // Outside of world AddBlend( 0.8, 0.5, 0.0, 0.2 ); } else if ( contents & CONTENTS_LAVA ) { AddBlend( level.lava_color[0], level.lava_color[1], level.lava_color[2], level.lava_alpha ); } else if ( contents & CONTENTS_WATER ) { AddBlend( level.water_color[0], level.water_color[1], level.water_color[2], level.water_alpha ); } if ( contents & CONTENTS_LIGHTVOLUME ) { AddBlend( level.lightvolume_color[0], level.lightvolume_color[1], level.lightvolume_color[2], level.lightvolume_alpha ); } // Flashes AddBlend( flash_color[0], flash_color[1], flash_color[2], flash_color[3] ); // add for zoom if ( zoom_mode == ZOOMED_IN ) { AddBlend( 0.4, 1, 0.1, 0.1 ); } // add for damage if ( damage_alpha > 0 ) { AddBlend( damage_blend[ 0 ], damage_blend[ 1 ], damage_blend[ 2 ], damage_alpha ); } if ( flags & FL_ADRENALINE ) { AddBlend( 1.0f, 1.0f, 0.0f, 0.2f ); } // drop the damage value damage_alpha -= 0.06; if ( damage_alpha < 0 ) { damage_alpha = 0; } // Drop the flash flash_color[3] -= 0.06; if ( flash_color[3] < 0 ) { flash_color[3] = 0; } } /* =============== P_DamageFeedback Handles color blends and view kicks =============== */ void Player::DamageFeedback ( void ) { float realcount; float count; // flash the backgrounds behind the status numbers client->ps.stats[ STAT_FLASHES ] = 0; if ( damage_blood ) { client->ps.stats[ STAT_FLASHES ] |= 1; } // total points of damage shot at the player this frame if ( !damage_blood ) { // didn't take any damage return; } count = damage_blood; realcount = count; if ( count < 10 ) { // always make a visible effect count = 10; } // the total alpha of the blend is always proportional to count if ( damage_alpha < 0 ) { damage_alpha = 0; } damage_alpha += count * 0.01; if ( damage_alpha < 0.2 ) { damage_alpha = 0.2; } if ( damage_alpha > 0.6 ) { // don't go too saturated damage_alpha = 0.6; } // the color of the blend will vary based on how much was absorbed // by different armors damage_blend = vec_zero; if ( damage_blood ) { damage_blend += ( damage_blood / realcount ) * bcolor; } // // clear totals // damage_blood = 0; } EXPORT_FROM_DLL const char * Player::AnimPrefixForWeapon ( void ) { if ( currentWeapon ) { switch ( currentWeapon->GetType() ) { case WEAPON_MELEE: return ""; break; case WEAPON_1HANDED: return "1hand_"; break; case WEAPON_2HANDED_HI: return "hi2hand_"; break; case WEAPON_2HANDED_LO: return "lo2hand_"; break; default: return ""; break; } } else { return ""; } return ""; } EXPORT_FROM_DLL void Player::ChooseAnim ( void ) { str prefix; str aname; if ( deadflag ) { return; } if ( vehicle ) { SetAnim( vehicleanim.c_str() ); return; } if ( onladder ) { if ( falling ) { Event * ev; ev = new Event( EV_Sentient_AnimLoop ); ProcessEvent( ev ); falling = false; } if ( fabs( velocity[ 2 ] ) > 0 ) { SetAnim( "climb" ); } else if (!animOverride) { StopAnimating(); } return; } if ( client->ps.pmove.pm_flags & PMF_DUCKED ) { if ( !( old_pmove.pm_flags & PMF_DUCKED ) ) { SetAnim( "crouch" ); return; } } else if ( old_pmove.pm_flags & PMF_DUCKED ) { SetAnim( "uncrouch" ); return; } // // put the appropriate prefix on the animation prefix = AnimPrefixForPlayer(); if ( currentWeapon ) { if ( currentWeapon->WeaponRaising() ) { aname = prefix + str( "readyweapon" ); SetAnim( aname.c_str() ); return; } else if ( currentWeapon->WeaponPuttingAway() ) { aname = prefix + str( "putaway" ); SetAnim( aname.c_str() ); return; } else if ( currentWeapon->Reloading() ) { aname = prefix + str( "reload" ); SetAnim( aname.c_str() ); return; } } // // append the prefix based on which weapon we are holding // prefix += str( AnimPrefixForWeapon() ); if ( waterlevel > 2 || (!groundentity && waterlevel ) ) { if ( xyspeed > 20 ) { aname = prefix + str( "run" ); } else { aname = prefix + str( "idle" ); } } else { if ( xyspeed > 250 ) { aname = prefix + str( "run" ); } else if ( xyspeed > 20 ) { if ( client->ps.pmove.pm_flags & PMF_DUCKED ) { aname = prefix + str( "run" ); } else { aname = prefix + str( "walk" ); } } else { aname = prefix + str( "idle" ); } } SetAnim( aname.c_str() ); } void Player::SetCameraValues ( Vector position, Vector cameraoffset, Vector ang, Vector camerakick, Vector vel, float camerablend[ 4 ], float camerafov ) { client->ps.viewangles[ 0 ] = ang[ 0 ]; client->ps.viewangles[ 1 ] = ang[ 1 ]; client->ps.viewangles[ 2 ] = ang[ 2 ]; client->ps.viewoffset[ 0 ] = cameraoffset[ 0 ]; client->ps.viewoffset[ 1 ] = cameraoffset[ 1 ]; client->ps.viewoffset[ 2 ] = cameraoffset[ 2 ]; client->ps.pmove.origin[ 0 ] = position[ 0 ] * 8; client->ps.pmove.origin[ 1 ] = position[ 1 ] * 8; client->ps.pmove.origin[ 2 ] = position[ 2 ] * 8; client->ps.pmove.velocity[ 0 ] = vel[ 0 ] * 8.0; client->ps.pmove.velocity[ 1 ] = vel[ 1 ] * 8.0; client->ps.pmove.velocity[ 2 ] = vel[ 2 ] * 8.0; client->ps.blend[ 0 ] = camerablend[ 0 ]; client->ps.blend[ 1 ] = camerablend[ 1 ]; client->ps.blend[ 2 ] = camerablend[ 2 ]; client->ps.blend[ 3 ] = camerablend[ 3 ]; client->ps.fov = camerafov; client->ps.kick_angles[ 0 ] = camerakick[ 0 ]; client->ps.kick_angles[ 1 ] = camerakick[ 1 ]; client->ps.kick_angles[ 2 ] = camerakick[ 2 ]; } void Player::SetCameraEntity ( Entity *cameraEnt ) { assert( cameraEnt ); // In release, we should never be without a camera if ( !cameraEnt ) { cameraEnt = this; } // should we see the player's body? if ( cameraEnt == this ) { edict->s.renderfx |= RF_VIEWERMODEL; if ( currentWeapon ) { if ( !vehicle || vehicle->ShowWeapon() ) { currentWeapon->edict->s.renderfx &= ~RF_DONTDRAW; currentWeapon->edict->s.renderfx |= RF_VIEWERMODEL; } else { currentWeapon->edict->s.renderfx |= RF_DONTDRAW; } } if ( vehicle && vehicle->IsDrivable() ) { SetCameraValues( worldorigin, v_offset, v_angle, v_kick, velocity, blend, fov*1.25 ); } else { SetCameraValues( worldorigin, v_offset, v_angle, v_kick, velocity, blend, fov ); } } else { float noblend[ 4 ]; float camerafov; Vector pos; /* if ( vehicle && cameraEnt == thirdpersonCamera ) { Event * event; event = new Event( EV_Camera_SetDistance ); event->AddFloat( 256 ); cameraEnt->ProcessEvent( event ); } */ edict->s.renderfx &= ~RF_VIEWERMODEL; if ( currentWeapon ) { // Take the weapon out of the view currentWeapon->edict->s.renderfx &= ~RF_VIEWERMODEL; } if ( in_console ) { // Make the client act like a viewmodel so it doesn't block // the camera to the console. edict->s.renderfx |= RF_VIEWERMODEL; } // FIXME // should add all these fields to entity or camera or whatever. noblend[ 0 ] = 0; noblend[ 1 ] = 0; noblend[ 2 ] = 0; noblend[ 3 ] = 0; pos = vec_zero; camerafov = 90; if ( cameraEnt->isSubclassOf( Mine ) ) { Vector dir; vec3_t mat[3]; camerafov = ( ( Projectile * )cameraEnt )->fov; AnglesToMat( cameraEnt->worldangles.vec3(), mat ); dir = mat[0]; if ( cameraEnt->velocity == vec_zero ) { pos = dir * 30; } else { pos = pos + Vector(0,0,1) * 30; } } else if ( cameraEnt->isSubclassOf( Camera ) ) { camerafov = ( ( Camera * )cameraEnt )->fov; if ( cameraEnt->isSubclassOf( SecurityCamera ) ) cameraEnt->edict->s.renderfx |= RF_DONTDRAW; } else if ( trappedInQuantum ) { Sentient *sent; if ( cameraEnt->isSubclassOf( Sentient ) ) { Vector dir; sent = ( Sentient * )cameraEnt; sent->GetMuzzlePositionAndDirection( &pos, &dir ); } } else if ( cameraEnt->isSubclassOf( Sentient ) ) { pos = ( ( Sentient * )cameraEnt )->EyePosition() - cameraEnt->worldorigin; } SetCameraValues( cameraEnt->worldorigin, pos, cameraEnt->worldangles, vec_zero, cameraEnt->velocity, noblend, camerafov ); //SetCameraValues( "0 0 64", pos, "0 270 0", vec_zero, // cameraEnt->velocity, noblend, camerafov ); } if ( flags & FL_SHIELDS ) { edict->s.renderfx |= RF_ENVMAPPED; } else edict->s.renderfx &= ~RF_ENVMAPPED; if ( flags & FL_CLOAK ) { setAlpha( 0 ); } else setAlpha( 1.0f ); if ( currentWeapon ) { if ( flags & FL_SHIELDS ) currentWeapon->edict->s.renderfx |= RF_ENVMAPPED; else currentWeapon->edict->s.renderfx &= ~RF_ENVMAPPED; if ( flags & FL_CLOAK ) { currentWeapon->edict->s.alpha = 0.1f; currentWeapon->edict->s.renderfx |= RF_TRANSLUCENT; } else { currentWeapon->edict->s.alpha = 1.0f; currentWeapon->edict->s.renderfx &= ~RF_TRANSLUCENT; } if ( cameraEnt != this ) { if ( edict->s.renderfx & RF_DONTDRAW ) { currentWeapon->edict->s.renderfx |= RF_DONTDRAW; } else { currentWeapon->edict->s.renderfx &= ~RF_DONTDRAW; } } } if ( ( viewmode == THIRD_PERSON ) && crosshair && currentWeapon ) { Vector dir, src, end; trace_t trace; currentWeapon->GetMuzzlePosition( &src, &dir ); end = src + dir * 8192; trace = G_FullTrace( src, vec_zero, vec_zero, end, 5, this, MASK_SHOT, "Player::SetCameraEntity" ); if ( trace.intersect.valid ) { crosshair->edict->s.frame = 1; } else { crosshair->edict->s.frame = 0; } crosshair->setOrigin( trace.endpos - dir * 16 ); crosshair->edict->s.scale = ( crosshair->worldorigin - worldorigin ).length() / 256; } } EXPORT_FROM_DLL void Player::CalcBob ( void ) { float time; Vector hvel; const gravityaxis_t &grav = gravity_axis[ gravaxis ]; // // calculate speed and cycle to be used for // all cyclic walking effects // hvel[ grav.x ] = velocity[ grav.x ]; hvel[ grav.y ] = velocity[ grav.y ]; hvel[ grav.z ] = 0; xyspeed = hvel.length(); if ( xyspeed < 5 ) { // start at beginning of cycle again bobmove = 0; bobtime = 0; } else if ( groundentity ) { // so bobbing only cycles when on ground if ( xyspeed > 210 ) { bobmove = 0.25; } else if ( xyspeed > 100 ) { bobmove = 0.125; } else { bobmove = 0.0625; } } bobtime += bobmove; time = bobtime; if ( client->ps.pmove.pm_flags & PMF_DUCKED ) { time *= 4; } bobcycle = ( int )time; bobfracsin = fabs( sin( time * M_PI ) ); } /* ================= P_FallingDamage ================= */ void Player::FallingDamage ( void ) { float delta; float damage; csurface_t *surf; int z; z = gravity_axis[ gravaxis ].z; if ( deadflag ) { return; } if ( flags & (FL_MUTANT|FL_SP_MUTANT|FL_ADRENALINE) ) { return; } if ( getMoveType() == MOVETYPE_NOCLIP ) { return; } if ( !fallsurface ) { return; } surf = fallsurface; fallsurface = NULL; delta = velocity[ z ] - oldvelocity[ z ]; delta = delta * delta * 0.0001; // never take falling damage if completely underwater switch( waterlevel ) { case 1 : delta *= 0.5; break; case 2 : delta *= 0.25; break; case 3 : return; break; } if ( delta < 3 ) { return; } fall_value = delta * 0.5; if ( fall_value > 40 ) { fall_value = 40; } fall_time = level.time + FALL_TIME; if ( delta > 30 ) { damage = ( delta - 30 ) / 2; if ( surf ) { // modify damage based on surface switch ( surf->flags & MASK_SURF_TYPE ) { // Can this happen? case SURF_TYPE_WATER: break; // no damage case SURF_TYPE_FABRIC: damage *= 0; break; // low damage case SURF_TYPE_FLESH: case SURF_TYPE_VEGETATION: damage *= 0.5; break; // medium damage case SURF_TYPE_DIRT: damage *= 0.6; break; case SURF_TYPE_WOOD: damage *= 0.8; break; // full damage case SURF_TYPE_GRAVEL: case SURF_TYPE_GRILL: case SURF_TYPE_METAL: case SURF_TYPE_STONE: case SURF_TYPE_CONCRETE: case SURF_TYPE_DUCT: default: break; } } if ( surf && surf->frequency != 0 ) { damage = 0; } if ( ( damage >= 1 ) && ( !DM_FLAG( DF_NO_FALLING ) ) ) { Damage( world, world, ( int )damage, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR, MOD_FALLING, -1, -1, 1.0f ); } } if ( surf && surf->frequency != 0 ) { fall_time = 0; fall_value = 0; } } EXPORT_FROM_DLL void Player::FinishMove ( void ) { Vector t[ 3 ]; Vector forward; Vector right; Vector up; Vector temp; if ( ai_createnodes->value ) { AddPathNodes(); } // // If the origin or velocity have changed since ClientThink(), // update the pmove values. This will happen when the client // is pushed by a bmodel or kicked by an explosion. // // If it wasn't updated here, the view position would lag a frame // behind the body position when pushed -- "sinking into plats" // if ( ( GetMovePlayerMoveType() != PM_LOCKVIEW ) && ( GetMovePlayerMoveType() != PM_FREEZE ) ) { client->ps.pmove.origin[ 0 ] = worldorigin.x * 8.0; client->ps.pmove.origin[ 1 ] = worldorigin.y * 8.0; client->ps.pmove.origin[ 2 ] = worldorigin.z * 8.0; client->ps.pmove.velocity[ 0 ] = velocity.x * 8.0; client->ps.pmove.velocity[ 1 ] = velocity.y * 8.0; client->ps.pmove.velocity[ 2 ] = velocity.z * 8.0; } // // set model angles from view angles so other things in // the world can tell which direction you are looking // if ( waterlevel >= 3 ) { angles[ PITCH ] = v_angle[ PITCH ]; } else if ( v_angle[ PITCH ] > 180 ) { angles[ PITCH ] = ( -360 + v_angle[ PITCH ] ) / 12; } else { angles[ PITCH ] = v_angle[ PITCH ] / 12; } angles[ YAW ] = v_angle[ YAW ]; angles[ ROLL ] = CalcRoll(); // Orient the angles to coincide with our special gravity vector const gravityaxis_t &grav = gravity_axis[ gravaxis ]; angles.AngleVectors( &t[0], &t[1], &t[2] ); forward[ grav.x ] = t[ 0 ][ 0 ]; forward[ grav.y ] = t[ 0 ][ 1 ] * grav.sign; forward[ grav.z ] = t[ 0 ][ 2 ] * grav.sign; right[ grav.x ] = t[ 1 ][ 0 ]; right[ grav.y ] = t[ 1 ][ 1 ] * grav.sign; right[ grav.z ] = t[ 1 ][ 2 ] * grav.sign; up[ grav.x ] = t[ 2 ][ 0 ]; up[ grav.y ] = t[ 2 ][ 1 ] * grav.sign; up[ grav.z ] = t[ 2 ][ 2 ] * grav.sign; VectorsToEulerAngles( forward.vec3(), right.vec3(), up.vec3(), angles.vec3() ); if ( !level.playerfrozen ) { setAngles( angles ); AnglesToMat( v_angle.vec3(), orientation ); } CalcBob(); // check if we're over the limit health-wise if ( ( (int)health > (int)max_health ) && ( ( float )( ( int )level.time ) == level.time ) ) { health -= 1; } // mutant mode if ( ( flags & FL_SP_MUTANT ) && !( flags & FL_GODMODE ) && ( ( float )( ( int )level.time ) == level.time ) ) { Damage( world, world, 1, worldorigin, vec_zero, vec_zero, 0, DAMAGE_NO_ARMOR, MOD_MUTANT_DRAIN, -1, -1, 1.0f ); } // Check for silencer if ( !(flags & FL_SILENCER) && FindItem( "Silencer" ) ) { flags |= FL_SILENCER; } // Check for O2 if ( !(flags & FL_OXYGEN) && FindItem( "ScubaGear" ) ) { flags |= FL_OXYGEN; } // burn from lava, etc WorldEffects(); FallingDamage(); ChooseAnim(); // determine the view offsets CalcViewOffset(); CalcGunOffset(); DamageFeedback(); CalcBlend(); oldvelocity = velocity; } EXPORT_FROM_DLL qboolean Player::CanMoveTo ( Vector pos ) { Vector min; trace_t trace; Vector start; Vector end; Vector s; s = Vector( 0, 0, 20 ); start = worldorigin + s; end = pos + s; trace = G_Trace( start, mins, maxs, end, this, MASK_SOLID, "Player::CanMoveTo" ); if ( trace.fraction == 1 ) { return true; } return false; } EXPORT_FROM_DLL qboolean Player::ClearPathTo ( Vector pos ) { Vector dir; Vector midpos; Vector end_trace; Vector delta; Vector start; Vector min; Vector max; trace_t trace; float dist; float t; min = Vector( -16, -16, 12 ); max = Vector( 16, 16, 40 ); start = worldorigin; dir = pos - worldorigin; delta = dir; delta[ 2 ] = 0; if ( delta.length() >= PATHMAP_CELLSIZE ) { return false; } if ( !CanMoveTo( pos ) ) { return false; } // only do a full test when we train a level if ( !ai_createnodes->value ) { midpos = start + dir * 0.5; end_trace = midpos - Vector( 0, 0, 40 ); // check that the midpos is onground (down 28 units) trace = G_Trace( midpos, min, max, end_trace, this, MASK_SOLID, "Player::ClearPathTo 1" ); if ( trace.fraction == 1 ) { return false; } return true; } dist = dir.length(); if ( dist < 32 ) { return true; } dir[ 2 ] = 0; dist = dir.length(); dir.normalize(); min = Vector( -16, -16, 0 ); // check the entire move midpos = start; for( t = 0; t < dist; t += 8 ) { midpos[ 0 ] = start[ 0 ] + t * dir[ 0 ]; midpos[ 1 ] = start[ 1 ] + t * dir[ 1 ]; midpos[ 2 ] += 18; end_trace = midpos - Vector( 0, 0, 2048 );//140 );//128 ); trace = G_Trace( midpos, min, max, end_trace, this, MASK_SOLID, "Player::ClearPathTo 2" ); if ( ( trace.fraction == 1 ) || ( trace.startsolid ) ) { return false; } midpos = trace.endpos; } // Check if we're close enough delta = midpos - pos; return ( delta.length() < 32 ); } EXPORT_FROM_DLL void Player::AddPathNode ( Event *ev ) { if ( ai_createnodes->value ) { lastNode = new PathNode; lastNode->Setup( worldorigin ); } } EXPORT_FROM_DLL void Player::AddPathNodes ( void ) { StandardMovePath find; if ( ai_createnodes->value && groundentity ) { if ( !lastNode || !lastNode->CheckMove( worldorigin, mins, maxs ) || !ClearPathTo( lastNode->worldorigin ) ) { gi.dprintf( "Can't see lastNode\n" ); lastNode = new PathNode; lastNode->Setup( lastVisible ); // so that we don't just keep putting nodes in the same place lastVisible = worldorigin; } nearestNode = PathManager.NearestNode( worldorigin ); if ( !nearestNode ) { gi.dprintf( "Can't see NearestNode\n" ); lastNode = new PathNode; lastNode->Setup( worldorigin ); lastVisible = worldorigin; } else if ( lastNode && ( !lastNode->CheckPath( nearestNode, mins, maxs ) || !nearestNode->CheckPath( lastNode, mins, maxs ) ) ) { gi.dprintf( "Nearest can't see last\n" ); lastNode = new PathNode; lastNode->Setup( worldorigin ); lastVisible = worldorigin; } if ( !lastNode || ( lastNode->CheckMove( worldorigin, mins, maxs ) && ClearPathTo( lastNode->worldorigin ) ) ) { lastVisible = worldorigin; } if ( nearestNode ) { lastNode = nearestNode; } //gi.dprintf( "Num Nodes %d\n", PathManager.NumNodes() ); } if ( searchTime <= level.time ) { nearestNode = PathManager.NearestNode( worldorigin ); if ( path ) { delete path; path = NULL; } if ( ai_showpath->value ) { if ( nearestNode ) { if ( !goalNode ) { goalNode = nearestNode; } find.heuristic.setSize( size ); path = find.FindPath( nearestNode, goalNode ); } else if ( ai_debugpath->value ) { gi.dprintf( "%d : No nearest node\n", level.framenum ); } } searchTime = level.time + 0.1; if ( ai_showpath->value ) { if ( path ) { path->DrawPath( 0, 0.7, 0, 0.1 ); } if ( nearestNode ) { G_DebugLine( nearestNode->worldorigin + "0 0 16", worldorigin + "0 0 16", 0, 0, 0.7, 1 ); } } } } EXPORT_FROM_DLL void Player::UpdateStats ( void ) { Armor *armor; int i; // Current Ammo if ( currentWeapon ) { client->ps.stats[ STAT_AMMO ] = currentWeapon->AmmoAvailable(); client->ps.stats[ STAT_CLIPAMMO ] = currentWeapon->ClipAmmo(); } else { client->ps.stats[ STAT_AMMO ] = 0; } // not used, so don't set to save net bandwidth #if 0 // All ammo types for( i = 0; i < NUM_AMMO_TYPES; i++ ) { Ammo *ammo; assert( ammo_types[ i ] ); ammo = ( Ammo * )FindItem( ammo_types[ i ] ); if ( ammo ) { client->ps.stats[ STAT_AMMO_BASE + i ] = ammo->Amount(); } else { client->ps.stats[ STAT_AMMO_BASE + i ] = 0; } } #endif // // Armor // client->ps.stats[ STAT_ARMOR ] = 0; for( i = 0; i < NUM_ARMOR_TYPES; i++ ) { assert( armor_types[ i ] ); armor = ( Armor * )FindItem( armor_types[ i ] ); if ( armor ) { client->ps.stats[ STAT_ARMOR_BASE + i ] = armor->Amount(); client->ps.stats[ STAT_ARMOR ] += armor->Amount(); } else { client->ps.stats[ STAT_ARMOR_BASE + i ] = 0; } } // Average the armor into a single value client->ps.stats[ STAT_ARMOR ] /= 3; if ( currentWeapon ) { client->ps.stats[ STAT_CURRENT_WEAPON ] = currentWeapon->GetIconIndex(); } else { client->ps.stats[ STAT_CURRENT_WEAPON ] = 0; } // // Weapon list // client->ps.stats[ STAT_WEAPONLIST ] = 0; // // Inventory // if ( currentItem && ( !( flags & ( FL_SP_MUTANT | FL_MUTANT ) ) ) ) { InventoryItem *nextItem; InventoryItem *prevItem; nextItem = ( InventoryItem * )NextItem( currentItem ); prevItem = ( InventoryItem * )PrevItem( currentItem ); client->ps.stats[ STAT_SELECTED_ICON ] = currentItem->GetIconIndex(); client->ps.stats[ STAT_SELECTED_NAME ] = currentItem->GetItemIndex(); client->ps.stats[ STAT_SELECTED_AMOUNT ] = currentItem->Amount(); client->ps.stats[ STAT_SELECTED_MODELINDEX ] = currentItem->edict->s.modelindex; if ( prevItem ) client->ps.stats[ STAT_PREVIOUS_ICON ] = prevItem->GetIconIndex(); else client->ps.stats[ STAT_PREVIOUS_ICON ] = 0; if ( nextItem ) client->ps.stats[ STAT_NEXT_ICON ] = nextItem->GetIconIndex(); else client->ps.stats[ STAT_NEXT_ICON ] = 0; } else { client->ps.stats[ STAT_SELECTED_ICON ] = 0; client->ps.stats[ STAT_PREVIOUS_ICON ] = 0; client->ps.stats[ STAT_NEXT_ICON ] = 0; client->ps.stats[ STAT_SELECTED_AMOUNT ] = 0; } // // Health // if ( ( health < 1 ) && ( health > 0 ) ) client->ps.stats[ STAT_HEALTH ] = 1; else client->ps.stats[ STAT_HEALTH ] = health; // // Frags // client->ps.stats[ STAT_FRAGS ] = client->resp.score; if ( spectator ) { client->ps.stats[ STAT_LAYOUTS ] = DRAW_SPECTATOR; } else { if ( !hidestats ) client->ps.stats[ STAT_LAYOUTS ] = DRAW_STATS; else client->ps.stats[ STAT_LAYOUTS ] = 0; } // // Overlays // if ( drawoverlay ) { client->ps.stats[ STAT_LAYOUTS ] |= DRAW_OVERLAY; } // // Show scores in dealthmatch during intermission or if the client wants to see them // if ( deathmatch->value && ( level.intermissiontime || client->showinfo ) ) { client->ps.stats[ STAT_LAYOUTS ] |= DRAW_SCORES; } // // Powerups timer // if ( poweruptimer > 0 ) { client->ps.stats[ STAT_POWERUPTIMER ] = poweruptimer; client->ps.stats[ STAT_POWERUPTYPE ] = poweruptype; } else { client->ps.stats[ STAT_POWERUPTIMER ] = 0; client->ps.stats[ STAT_POWERUPTYPE ] = 0; } // // Mission Computer // if ( client->showinfo && !deathmatch->value ) { client->ps.stats[ STAT_LAYOUTS ] |= DRAW_MISSIONCPU; } // // Clear out the exit sign // if we are in the trigger_exit field, than this will constantly be set // so this will clear it out on subsequent calls to UpdateStats // if ( client->ps.stats[ STAT_EXITSIGN ] > 0 ) { client->ps.stats[ STAT_EXITSIGN ]--; } // // if the scoreboard is up, update it // if ( client->showinfo && deathmatch->value && !( level.framenum & 31 ) ) { G_DeathmatchScoreboardMessage( this, enemy ); gi.unicast( edict, false ); } } EXPORT_FROM_DLL void Player::UpdateMusic ( void ) { if ( music_forced ) { client->ps.current_music_mood = music_current_mood; client->ps.fallback_music_mood = music_fallback_mood; } else if ( action_level > 30 ) { music_current_mood = mood_normal; music_fallback_mood = mood_normal; client->ps.current_music_mood = mood_action; client->ps.fallback_music_mood = mood_normal; } else if ( ( action_level < 15 ) && ( client->ps.current_music_mood == mood_action ) ) { music_current_mood = mood_normal; music_fallback_mood = mood_normal; client->ps.current_music_mood = music_current_mood; client->ps.fallback_music_mood = music_fallback_mood; } else if ( client->ps.current_music_mood != mood_action ) { client->ps.current_music_mood = music_current_mood; client->ps.fallback_music_mood = music_fallback_mood; } if (action_level > 0) { action_level -= 0.2f; if (action_level > 80) action_level = 80; } else action_level = 0; // // set the music // naturally decay the action level // if (s_debugmusic->value) { warning("DebugMusic","%s's action_level = %4.2f\n", client->pers.netname, action_level); } } /* ================= EndFrame Called for each player at the end of the server frame and right after spawning ================= */ EXPORT_FROM_DLL void Player::EndFrame ( Event *ev ) { FinishMove(); UpdateStats(); UpdateMusic(); // set the crouch flag if ( client->ps.pmove.pm_flags & PMF_DUCKED ) { edict->s.effects |= EF_CROUCH; } else { edict->s.effects &= ~EF_CROUCH; } if ( movieCamera != CinematicCamera ) { if ( movieCamera && movieCamera->isSubclassOf( SecurityCamera ) ) { movieCamera->edict->s.renderfx &= ~RF_DONTDRAW; } movieCamera = CinematicCamera; if ( movieCamera ) { Entity * ent; Camera * cam; SetViewMode( CAMERA_VIEW, movieCamera ); if ( movieCamera->isSubclassOf( Camera ) ) { ent = movieCamera; cam = ( Camera * )ent; if ( cam->Overlay().length() ) { SendOverlay( this, cam->Overlay() ); drawoverlay = true; hidestats = true; } } } else { drawoverlay = false; hidestats = false; SetViewMode( defaultViewMode ); } } if ( ( viewmode == THIRD_PERSON ) && ( zoom_mode == ZOOMED_IN ) ) { SetCameraEntity( this ); if ( crosshair ) { crosshair->hideModel(); } } else if ( ( viewmode == THIRD_PERSON ) && ( gravaxis ) ) { SetCameraEntity( this ); if ( crosshair ) { crosshair->hideModel(); } } else { if ( crosshair ) { crosshair->showModel(); } assert( watchCamera ); if ( !watchCamera ) { // fix it in release watchCamera = this; } SetCameraEntity( watchCamera ); } } EXPORT_FROM_DLL void Player::ShowInfo ( Event *ev ) { client->showinfo = !client->showinfo; if ( deathmatch->value && client->showinfo ) { G_DeathmatchScoreboard( this ); return; } } void Player::ReadyToFire ( Event *ev ) { int frame; frame = ev->GetInteger( 1 ); if ( ( buttons & BUTTON_ATTACK ) && WeaponReady() ) { NextFrame( frame ); } } void Player::WaitingToFire ( Event *ev ) { int frame; frame = ev->GetInteger( 1 ); if ( ( buttons & BUTTON_ATTACK ) && !WeaponReady() ) { NextFrame( frame ); } } void Player::DoneFiring ( Event *ev ) { firing = false; } void Player::AddItemToFloatingInventory ( Item *item ) { floating_inventory.AddObject( item->entnum ); } void Player::SendFloatingInventory ( void ) { int i,n; // Send over the floating inventory icons n = floating_inventory.NumObjects(); assert( n < MAX_ITEMS ); gi.WriteByte( svc_inventory ); gi.WriteShort( n ); for( i=1; i<=n; i++) { Item *item; item = ( Item * )G_GetEntity( floating_inventory.ObjectAt( i ) ); assert( item ); if ( item ) { gi.WriteShort( item->GetIconIndex() ); gi.WriteShort( item->Amount() ); } } gi.unicast( this->edict, false ); } void Player::ClearFloatingInventory ( Event *ev ) { // Clear the items floating_inventory.ClearObjectList(); // Clear the owner; floating_owner = NULL; // Clear the client's list SendFloatingInventory(); } void Player::SetFloatingOwner ( Sentient *deceased_owner ) { floating_owner = deceased_owner; } Sentient *Player::GetFloatingOwner ( void ) { return floating_owner; } void Player::PickupFloatingInventory ( void ) { int i,n; Event *event; qboolean inventory_changed = false; // Make sure there is an inventory to pickup if (!floating_owner) return; n = floating_inventory.NumObjects(); if (!n) return; assert( n < MAX_ITEMS ); for( i=n; i>0; i--) { Item *item; item = ( Item * )G_GetEntity( floating_inventory.ObjectAt( i ) ); assert( item ); // Check to see if we want to pick this up if ( !item->Pickupable( this ) ) continue; // Remove it from the dead body item->Drop(); // Add item to player's inventory event = new Event( EV_Item_Pickup ); event->AddEntity( this ); item->ProcessEvent( event ); item->ProcessEvent( EV_Trigger_StartThread ); // Remove it from the floating inventory floating_inventory.RemoveObjectAt( i ); inventory_changed = true; } if ( inventory_changed ) { // Update the client if the inventory changed SendFloatingInventory(); } else { // Make this guy useless in 60 seconds Event *re; re = new Event( "remove_useless" ); floating_owner->PostEvent( re, 60 ); RandomSound("snd_refusepickup"); } if ( !floating_inventory.NumObjects() ) { Event *re; re = new Event( "remove_useless" ); floating_owner->ProcessEvent( re ); } } void Player::ChangeSpectator ( void ) { edict_t *cl_ent; currentCameraTarget = ( currentCameraTarget + 1 ) % game.maxclients; cl_ent = g_edicts + 1 + currentCameraTarget; while ( !cl_ent->inuse ) { currentCameraTarget = ( currentCameraTarget + 1 ) % game.maxclients; cl_ent = g_edicts + 1 + currentCameraTarget; } SetViewMode( SPECTATOR ); } void Player::TestThread ( Event *ev ) { const char *scriptfile; const char *label = NULL; ScriptThread * thread; if ( ev->NumArgs() < 1 ) { gi.cprintf( edict, PRINT_HIGH, "Syntax: testthread scriptfile