expvintl/source-engine-2018-hl2_src
0
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
master
source-engine-2018-hl2_src/game/server/player.cpp

9384 lines
248 KiB
C++
Raw Permalink Normal View History

1
2020-04-23 00:56:21 +08:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Functions dealing with the player.
//
//===========================================================================//
#include "cbase.h"
#include "const.h"
#include "baseplayer_shared.h"
#include "trains.h"
#include "soundent.h"
#include "gib.h"
#include "shake.h"
#include "decals.h"
#include "gamerules.h"
#include "game.h"
#include "entityapi.h"
#include "entitylist.h"
#include "eventqueue.h"
#include "worldsize.h"
#include "isaverestore.h"
#include "globalstate.h"
#include "basecombatweapon.h"
#include "ai_basenpc.h"
#include "ai_network.h"
#include "ai_node.h"
#include "ai_networkmanager.h"
#include "ammodef.h"
#include "mathlib/mathlib.h"
#include "ndebugoverlay.h"
#include "baseviewmodel.h"
#include "in_buttons.h"
#include "client.h"
#include "team.h"
#include "particle_smokegrenade.h"
#include "IEffects.h"
#include "vstdlib/random.h"
#include "engine/IEngineSound.h"
#include "movehelper_server.h"
#include "igamemovement.h"
#include "saverestoretypes.h"
#include "iservervehicle.h"
#include "movevars_shared.h"
#include "vcollide_parse.h"
#include "player_command.h"
#include "vehicle_base.h"
#include "AI_Criteria.h"
#include "globals.h"
#include "usermessages.h"
#include "gamevars_shared.h"
#include "world.h"
#include "physobj.h"
#include "KeyValues.h"
#include "coordsize.h"
#include "vphysics/player_controller.h"
#include "saverestore_utlvector.h"
#include "hltvdirector.h"
#include "nav_mesh.h"
#include "env_zoom.h"
#include "rumble_shared.h"
#include "gamestats.h"
#include "npcevent.h"
#include "datacache/imdlcache.h"
#include "hintsystem.h"
#include "env_debughistory.h"
#include "fogcontroller.h"
#include "gameinterface.h"
#include "hl2orange.spa.h"
#include "dt_utlvector_send.h"
#include "vote_controller.h"
#include "ai_speech.h"
#if defined USES_ECON_ITEMS
#include "econ_wearable.h"
#endif
// NVNT haptic utils
#include "haptics/haptic_utils.h"
#ifdef HL2_DLL
#include "combine_mine.h"
#include "weapon_physcannon.h"
#endif
ConVar autoaim_max_dist( "autoaim_max_dist", "2160" ); // 2160 = 180 feet
ConVar autoaim_max_deflect( "autoaim_max_deflect", "0.99" );
#ifdef CSTRIKE_DLL
ConVar spec_freeze_time( "spec_freeze_time", "5.0", FCVAR_CHEAT | FCVAR_REPLICATED, "Time spend frozen in observer freeze cam." );
ConVar spec_freeze_traveltime( "spec_freeze_traveltime", "0.7", FCVAR_CHEAT | FCVAR_REPLICATED, "Time taken to zoom in to frame a target in observer freeze cam.", true, 0.01, false, 0 );
#else
ConVar spec_freeze_time( "spec_freeze_time", "4.0", FCVAR_CHEAT | FCVAR_REPLICATED, "Time spend frozen in observer freeze cam." );
ConVar spec_freeze_traveltime( "spec_freeze_traveltime", "0.4", FCVAR_CHEAT | FCVAR_REPLICATED, "Time taken to zoom in to frame a target in observer freeze cam.", true, 0.01, false, 0 );
#endif
ConVar sv_bonus_challenge( "sv_bonus_challenge", "0", FCVAR_REPLICATED, "Set to values other than 0 to select a bonus map challenge type." );
static ConVar sv_maxusrcmdprocessticks( "sv_maxusrcmdprocessticks", "24", FCVAR_NOTIFY, "Maximum number of client-issued usrcmd ticks that can be replayed in packet loss conditions, 0 to allow no restrictions" );
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
static ConVar old_armor( "player_old_armor", "0" );
static ConVar physicsshadowupdate_render( "physicsshadowupdate_render", "0" );
bool IsInCommentaryMode( void );
bool IsListeningToCommentary( void );
#if !defined( CSTRIKE_DLL )
ConVar cl_sidespeed( "cl_sidespeed", "450", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar cl_upspeed( "cl_upspeed", "320", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar cl_forwardspeed( "cl_forwardspeed", "450", FCVAR_REPLICATED | FCVAR_CHEAT );
ConVar cl_backspeed( "cl_backspeed", "450", FCVAR_REPLICATED | FCVAR_CHEAT );
#endif // CSTRIKE_DLL
// This is declared in the engine, too
ConVar sv_noclipduringpause( "sv_noclipduringpause", "0", FCVAR_REPLICATED | FCVAR_CHEAT, "If cheats are enabled, then you can noclip with the game paused (for doing screenshots, etc.)." );
extern ConVar sv_maxunlag;
extern ConVar sv_turbophysics;
extern ConVar *sv_maxreplay;
extern CServerGameDLL g_ServerGameDLL;
// TIME BASED DAMAGE AMOUNT
// tweak these values based on gameplay feedback:
#define PARALYZE_DURATION 2 // number of 2 second intervals to take damage
#define PARALYZE_DAMAGE 1.0 // damage to take each 2 second interval
#define NERVEGAS_DURATION 2
#define NERVEGAS_DAMAGE 5.0
#define POISON_DURATION 5
#define POISON_DAMAGE 2.0
#define RADIATION_DURATION 2
#define RADIATION_DAMAGE 1.0
#define ACID_DURATION 2
#define ACID_DAMAGE 5.0
#define SLOWBURN_DURATION 2
#define SLOWBURN_DAMAGE 1.0
#define SLOWFREEZE_DURATION 2
#define SLOWFREEZE_DAMAGE 1.0
//----------------------------------------------------
// Player Physics Shadow
//----------------------------------------------------
#define VPHYS_MAX_DISTANCE 2.0
#define VPHYS_MAX_VEL 10
#define VPHYS_MAX_DISTSQR (VPHYS_MAX_DISTANCE*VPHYS_MAX_DISTANCE)
#define VPHYS_MAX_VELSQR (VPHYS_MAX_VEL*VPHYS_MAX_VEL)
extern bool g_fDrawLines;
int gEvilImpulse101;
bool gInitHUD = true;
extern void respawn(CBaseEntity *pEdict, bool fCopyCorpse);
int MapTextureTypeStepType(char chTextureType);
extern void SpawnBlood(Vector vecSpot, const Vector &vecDir, int bloodColor, float flDamage);
extern void AddMultiDamage( const CTakeDamageInfo &info, CBaseEntity *pEntity );
#define CMD_MOSTRECENT 0
//#define FLASH_DRAIN_TIME 1.2 //100 units/3 minutes
//#define FLASH_CHARGE_TIME 0.2 // 100 units/20 seconds (seconds per unit)
//#define PLAYER_MAX_SAFE_FALL_DIST 20// falling any farther than this many feet will inflict damage
//#define PLAYER_FATAL_FALL_DIST 60// 100% damage inflicted if player falls this many feet
//#define DAMAGE_PER_UNIT_FALLEN (float)( 100 ) / ( ( PLAYER_FATAL_FALL_DIST - PLAYER_MAX_SAFE_FALL_DIST ) * 12 )
//#define MAX_SAFE_FALL_UNITS ( PLAYER_MAX_SAFE_FALL_DIST * 12 )
// player damage adjusters
ConVar sk_player_head( "sk_player_head","2" );
ConVar sk_player_chest( "sk_player_chest","1" );
ConVar sk_player_stomach( "sk_player_stomach","1" );
ConVar sk_player_arm( "sk_player_arm","1" );
ConVar sk_player_leg( "sk_player_leg","1" );
ConVar sv_player_usercommand_timeout( "sv_player_usercommand_timeout", "3", FCVAR_CHEAT, "After this many seconds without a usercommand from a player, the server will RunNullCommand as if client sends an empty command." );
#ifdef _DEBUG
ConVar sv_player_net_suppress_usercommands( "sv_player_net_suppress_usercommands", "0", FCVAR_CHEAT, "For testing usercommand hacking sideeffects. DO NOT SHIP" );
#endif // _DEBUG
ConVar sv_player_display_usercommand_errors( "sv_player_display_usercommand_errors", "0", FCVAR_CHEAT, "1 = Display warning when command values are out-of-range. 2 = Spew invalid ranges." );
ConVar player_debug_print_damage( "player_debug_print_damage", "0", FCVAR_CHEAT, "When true, print amount and type of all damage received by player to console." );
void CC_GiveCurrentAmmo( void )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex(1);
if( pPlayer )
{
CBaseCombatWeapon *pWeapon = pPlayer->GetActiveWeapon();
if( pWeapon )
{
if( pWeapon->UsesPrimaryAmmo() )
{
int ammoIndex = pWeapon->GetPrimaryAmmoType();
if( ammoIndex != -1 )
{
int giveAmount;
giveAmount = GetAmmoDef()->MaxCarry(ammoIndex);
pPlayer->GiveAmmo( giveAmount, GetAmmoDef()->GetAmmoOfIndex(ammoIndex)->pName );
}
}
if( pWeapon->UsesSecondaryAmmo() && pWeapon->HasSecondaryAmmo() )
{
// Give secondary ammo out, as long as the player already has some
// from a presumeably natural source. This prevents players on XBox
// having Combine Balls and so forth in areas of the game that
// were not tested with these items.
int ammoIndex = pWeapon->GetSecondaryAmmoType();
if( ammoIndex != -1 )
{
int giveAmount;
giveAmount = GetAmmoDef()->MaxCarry(ammoIndex);
pPlayer->GiveAmmo( giveAmount, GetAmmoDef()->GetAmmoOfIndex(ammoIndex)->pName );
}
}
}
}
}
static ConCommand givecurrentammo("givecurrentammo", CC_GiveCurrentAmmo, "Give a supply of ammo for current weapon..\n", FCVAR_CHEAT );
// pl
BEGIN_SIMPLE_DATADESC( CPlayerState )
// DEFINE_FIELD( netname, FIELD_STRING ), // Don't stomp player name with what's in save/restore
DEFINE_FIELD( v_angle, FIELD_VECTOR ),
DEFINE_FIELD( deadflag, FIELD_BOOLEAN ),
// this is always set to true on restore, don't bother saving it.
// DEFINE_FIELD( fixangle, FIELD_INTEGER ),
// DEFINE_FIELD( anglechange, FIELD_FLOAT ),
// DEFINE_FIELD( hltv, FIELD_BOOLEAN ),
// DEFINE_FIELD( replay, FIELD_BOOLEAN ),
// DEFINE_FIELD( frags, FIELD_INTEGER ),
// DEFINE_FIELD( deaths, FIELD_INTEGER ),
END_DATADESC()
// Global Savedata for player
BEGIN_DATADESC( CBasePlayer )
DEFINE_EMBEDDED( m_Local ),
#if defined USES_ECON_ITEMS
DEFINE_EMBEDDED( m_AttributeList ),
#endif
DEFINE_UTLVECTOR( m_hTriggerSoundscapeList, FIELD_EHANDLE ),
DEFINE_EMBEDDED( pl ),
DEFINE_FIELD( m_StuckLast, FIELD_INTEGER ),
DEFINE_FIELD( m_nButtons, FIELD_INTEGER ),
DEFINE_FIELD( m_afButtonLast, FIELD_INTEGER ),
DEFINE_FIELD( m_afButtonPressed, FIELD_INTEGER ),
DEFINE_FIELD( m_afButtonReleased, FIELD_INTEGER ),
DEFINE_FIELD( m_afButtonDisabled, FIELD_INTEGER ),
DEFINE_FIELD( m_afButtonForced, FIELD_INTEGER ),
DEFINE_FIELD( m_iFOV, FIELD_INTEGER ),
DEFINE_FIELD( m_iFOVStart, FIELD_INTEGER ),
DEFINE_FIELD( m_flFOVTime, FIELD_TIME ),
DEFINE_FIELD( m_iDefaultFOV,FIELD_INTEGER ),
DEFINE_FIELD( m_flVehicleViewFOV, FIELD_FLOAT ),
//DEFINE_FIELD( m_fOnTarget, FIELD_BOOLEAN ), // Don't need to restore
DEFINE_FIELD( m_iObserverMode, FIELD_INTEGER ),
DEFINE_FIELD( m_iObserverLastMode, FIELD_INTEGER ),
DEFINE_FIELD( m_hObserverTarget, FIELD_EHANDLE ),
DEFINE_FIELD( m_bForcedObserverMode, FIELD_BOOLEAN ),
DEFINE_AUTO_ARRAY( m_szAnimExtension, FIELD_CHARACTER ),
// DEFINE_CUSTOM_FIELD( m_Activity, ActivityDataOps() ),
DEFINE_FIELD( m_nUpdateRate, FIELD_INTEGER ),
DEFINE_FIELD( m_fLerpTime, FIELD_FLOAT ),
DEFINE_FIELD( m_bLagCompensation, FIELD_BOOLEAN ),
DEFINE_FIELD( m_bPredictWeapons, FIELD_BOOLEAN ),
DEFINE_FIELD( m_vecAdditionalPVSOrigin, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_vecCameraPVSOrigin, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_hUseEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_iTrain, FIELD_INTEGER ),
DEFINE_FIELD( m_iRespawnFrames, FIELD_FLOAT ),
DEFINE_FIELD( m_afPhysicsFlags, FIELD_INTEGER ),
DEFINE_FIELD( m_hVehicle, FIELD_EHANDLE ),
// recreate, don't restore
// DEFINE_FIELD( m_CommandContext, CUtlVector < CCommandContext > ),
//DEFINE_FIELD( m_pPhysicsController, FIELD_POINTER ),
//DEFINE_FIELD( m_pShadowStand, FIELD_POINTER ),
//DEFINE_FIELD( m_pShadowCrouch, FIELD_POINTER ),
//DEFINE_FIELD( m_vphysicsCollisionState, FIELD_INTEGER ),
DEFINE_ARRAY( m_szNetworkIDString, FIELD_CHARACTER, MAX_NETWORKID_LENGTH ),
DEFINE_FIELD( m_oldOrigin, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_vecSmoothedVelocity, FIELD_VECTOR ),
//DEFINE_FIELD( m_touchedPhysObject, FIELD_BOOLEAN ),
//DEFINE_FIELD( m_bPhysicsWasFrozen, FIELD_BOOLEAN ),
//DEFINE_FIELD( m_iPlayerSound, FIELD_INTEGER ), // Don't restore, set in Precache()
DEFINE_FIELD( m_iTargetVolume, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( m_rgItems, FIELD_INTEGER ),
//DEFINE_FIELD( m_fNextSuicideTime, FIELD_TIME ),
// DEFINE_FIELD( m_PlayerInfo, CPlayerInfo ),
DEFINE_FIELD( m_flSwimTime, FIELD_TIME ),
DEFINE_FIELD( m_flDuckTime, FIELD_TIME ),
DEFINE_FIELD( m_flDuckJumpTime, FIELD_TIME ),
DEFINE_FIELD( m_flSuitUpdate, FIELD_TIME ),
DEFINE_AUTO_ARRAY( m_rgSuitPlayList, FIELD_INTEGER ),
DEFINE_FIELD( m_iSuitPlayNext, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( m_rgiSuitNoRepeat, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( m_rgflSuitNoRepeatTime, FIELD_TIME ),
DEFINE_FIELD( m_bPauseBonusProgress, FIELD_BOOLEAN ),
DEFINE_FIELD( m_iBonusProgress, FIELD_INTEGER ),
DEFINE_FIELD( m_iBonusChallenge, FIELD_INTEGER ),
DEFINE_FIELD( m_lastDamageAmount, FIELD_INTEGER ),
DEFINE_FIELD( m_tbdPrev, FIELD_TIME ),
DEFINE_FIELD( m_flStepSoundTime, FIELD_FLOAT ),
DEFINE_ARRAY( m_szNetname, FIELD_CHARACTER, MAX_PLAYER_NAME_LENGTH ),
//DEFINE_FIELD( m_flgeigerRange, FIELD_FLOAT ), // Don't restore, reset in Precache()
//DEFINE_FIELD( m_flgeigerDelay, FIELD_FLOAT ), // Don't restore, reset in Precache()
//DEFINE_FIELD( m_igeigerRangePrev, FIELD_FLOAT ), // Don't restore, reset in Precache()
//DEFINE_FIELD( m_iStepLeft, FIELD_INTEGER ), // Don't need to restore
//DEFINE_FIELD( m_chTextureType, FIELD_CHARACTER ), // Don't need to restore
//DEFINE_FIELD( m_surfaceProps, FIELD_INTEGER ), // don't need to restore, reset by gamemovement
// DEFINE_FIELD( m_pSurfaceData, surfacedata_t* ),
//DEFINE_FIELD( m_surfaceFriction, FIELD_FLOAT ),
//DEFINE_FIELD( m_chPreviousTextureType, FIELD_CHARACTER ),
DEFINE_FIELD( m_idrowndmg, FIELD_INTEGER ),
DEFINE_FIELD( m_idrownrestored, FIELD_INTEGER ),
DEFINE_FIELD( m_nPoisonDmg, FIELD_INTEGER ),
DEFINE_FIELD( m_nPoisonRestored, FIELD_INTEGER ),
DEFINE_FIELD( m_bitsHUDDamage, FIELD_INTEGER ),
DEFINE_FIELD( m_fInitHUD, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flDeathTime, FIELD_TIME ),
DEFINE_FIELD( m_flDeathAnimTime, FIELD_TIME ),
//DEFINE_FIELD( m_fGameHUDInitialized, FIELD_BOOLEAN ), // only used in multiplayer games
//DEFINE_FIELD( m_fWeapon, FIELD_BOOLEAN ), // Don't restore, client needs reset
//DEFINE_FIELD( m_iUpdateTime, FIELD_INTEGER ), // Don't need to restore
//DEFINE_FIELD( m_iClientBattery, FIELD_INTEGER ), // Don't restore, client needs reset
//DEFINE_FIELD( m_iClientHideHUD, FIELD_INTEGER ), // Don't restore, client needs reset
//DEFINE_FIELD( m_vecAutoAim, FIELD_VECTOR ), // Don't save/restore - this is recomputed
//DEFINE_FIELD( m_lastx, FIELD_INTEGER ),
//DEFINE_FIELD( m_lasty, FIELD_INTEGER ),
DEFINE_FIELD( m_iFrags, FIELD_INTEGER ),
DEFINE_FIELD( m_iDeaths, FIELD_INTEGER ),
DEFINE_FIELD( m_bAllowInstantSpawn, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flNextDecalTime, FIELD_TIME ),
//DEFINE_AUTO_ARRAY( m_szTeamName, FIELD_STRING ), // mp
//DEFINE_FIELD( m_iConnected, FIELD_INTEGER ),
// from edict_t
DEFINE_FIELD( m_ArmorValue, FIELD_INTEGER ),
DEFINE_FIELD( m_DmgOrigin, FIELD_VECTOR ),
DEFINE_FIELD( m_DmgTake, FIELD_FLOAT ),
DEFINE_FIELD( m_DmgSave, FIELD_FLOAT ),
DEFINE_FIELD( m_AirFinished, FIELD_TIME ),
DEFINE_FIELD( m_PainFinished, FIELD_TIME ),
DEFINE_FIELD( m_iPlayerLocked, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( m_hViewModel, FIELD_EHANDLE ),
DEFINE_FIELD( m_flMaxspeed, FIELD_FLOAT ),
DEFINE_FIELD( m_flWaterJumpTime, FIELD_TIME ),
DEFINE_FIELD( m_vecWaterJumpVel, FIELD_VECTOR ),
DEFINE_FIELD( m_nImpulse, FIELD_INTEGER ),
DEFINE_FIELD( m_flSwimSoundTime, FIELD_TIME ),
DEFINE_FIELD( m_vecLadderNormal, FIELD_VECTOR ),
DEFINE_FIELD( m_flFlashTime, FIELD_TIME ),
DEFINE_FIELD( m_nDrownDmgRate, FIELD_INTEGER ),
DEFINE_FIELD( m_iSuicideCustomKillFlags, FIELD_INTEGER ),
// NOT SAVED
//DEFINE_FIELD( m_vForcedOrigin, FIELD_VECTOR ),
//DEFINE_FIELD( m_bForceOrigin, FIELD_BOOLEAN ),
//DEFINE_FIELD( m_nTickBase, FIELD_INTEGER ),
//DEFINE_FIELD( m_LastCmd, FIELD_ ),
// DEFINE_FIELD( m_pCurrentCommand, CUserCmd ),
//DEFINE_FIELD( m_bGamePaused, FIELD_BOOLEAN ),
// DEFINE_FIELD( m_iVehicleAnalogBias, FIELD_INTEGER ),
// m_flVehicleViewFOV
// m_vecVehicleViewOrigin
// m_vecVehicleViewAngles
// m_nVehicleViewSavedFrame
DEFINE_FIELD( m_bitsDamageType, FIELD_INTEGER ),
DEFINE_AUTO_ARRAY( m_rgbTimeBasedDamage, FIELD_CHARACTER ),
DEFINE_FIELD( m_fLastPlayerTalkTime, FIELD_FLOAT ),
DEFINE_FIELD( m_hLastWeapon, FIELD_EHANDLE ),
#if !defined( NO_ENTITY_PREDICTION )
// DEFINE_FIELD( m_SimulatedByThisPlayer, CUtlVector < CHandle < CBaseEntity > > ),
#endif
DEFINE_FIELD( m_flOldPlayerZ, FIELD_FLOAT ),
DEFINE_FIELD( m_flOldPlayerViewOffsetZ, FIELD_FLOAT ),
DEFINE_FIELD( m_bPlayerUnderwater, FIELD_BOOLEAN ),
DEFINE_FIELD( m_hViewEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_hConstraintEntity, FIELD_EHANDLE ),
DEFINE_FIELD( m_vecConstraintCenter, FIELD_VECTOR ),
DEFINE_FIELD( m_flConstraintRadius, FIELD_FLOAT ),
DEFINE_FIELD( m_flConstraintWidth, FIELD_FLOAT ),
DEFINE_FIELD( m_flConstraintSpeedFactor, FIELD_FLOAT ),
DEFINE_FIELD( m_hZoomOwner, FIELD_EHANDLE ),
DEFINE_FIELD( m_flLaggedMovementValue, FIELD_FLOAT ),
DEFINE_FIELD( m_vNewVPhysicsPosition, FIELD_VECTOR ),
DEFINE_FIELD( m_vNewVPhysicsVelocity, FIELD_VECTOR ),
DEFINE_FIELD( m_bSinglePlayerGameEnding, FIELD_BOOLEAN ),
DEFINE_ARRAY( m_szLastPlaceName, FIELD_CHARACTER, MAX_PLACE_NAME_LENGTH ),
DEFINE_FIELD( m_autoKickDisabled, FIELD_BOOLEAN ),
// Function Pointers
DEFINE_FUNCTION( PlayerDeathThink ),
// Inputs
DEFINE_INPUTFUNC( FIELD_INTEGER, "SetHealth", InputSetHealth ),
DEFINE_INPUTFUNC( FIELD_BOOLEAN, "SetHUDVisibility", InputSetHUDVisibility ),
DEFINE_INPUTFUNC( FIELD_STRING, "SetFogController", InputSetFogController ),
DEFINE_INPUTFUNC( FIELD_STRING, "HandleMapEvent", InputHandleMapEvent ),
DEFINE_FIELD( m_nNumCrouches, FIELD_INTEGER ),
DEFINE_FIELD( m_bDuckToggled, FIELD_BOOLEAN ),
DEFINE_FIELD( m_flForwardMove, FIELD_FLOAT ),
DEFINE_FIELD( m_flSideMove, FIELD_FLOAT ),
DEFINE_FIELD( m_vecPreviouslyPredictedOrigin, FIELD_POSITION_VECTOR ),
DEFINE_FIELD( m_nNumCrateHudHints, FIELD_INTEGER ),
// DEFINE_FIELD( m_nBodyPitchPoseParam, FIELD_INTEGER ),
// DEFINE_ARRAY( m_StepSoundCache, StepSoundCache_t, 2 ),
// DEFINE_UTLVECTOR( m_vecPlayerCmdInfo ),
// DEFINE_UTLVECTOR( m_vecPlayerSimInfo ),
END_DATADESC()
int giPrecacheGrunt = 0;
edict_t *CBasePlayer::s_PlayerEdict = NULL;
inline bool ShouldRunCommandsInContext( const CCommandContext *ctx )
{
// TODO: This should be enabled at some point. If usercmds can run while paused, then
// they can create entities which will never die and it will fill up the entity list.
#ifdef NO_USERCMDS_DURING_PAUSE
return !ctx->paused || sv_noclipduringpause.GetInt();
#else
return true;
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : CBaseViewModel
//-----------------------------------------------------------------------------
CBaseViewModel *CBasePlayer::GetViewModel( int index /*= 0*/, bool bObserverOK )
{
Assert( index >= 0 && index < MAX_VIEWMODELS );
return m_hViewModel[ index ].Get();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::CreateViewModel( int index /*=0*/ )
{
Assert( index >= 0 && index < MAX_VIEWMODELS );
if ( GetViewModel( index ) )
return;
CBaseViewModel *vm = ( CBaseViewModel * )CreateEntityByName( "viewmodel" );
if ( vm )
{
vm->SetAbsOrigin( GetAbsOrigin() );
vm->SetOwner( this );
vm->SetIndex( index );
DispatchSpawn( vm );
vm->FollowEntity( this );
m_hViewModel.Set( index, vm );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::DestroyViewModels( void )
{
int i;
for ( i = MAX_VIEWMODELS - 1; i >= 0; i-- )
{
CBaseViewModel *vm = GetViewModel( i );
if ( !vm )
continue;
UTIL_Remove( vm );
m_hViewModel.Set( i, NULL );
}
}
//-----------------------------------------------------------------------------
// Purpose: Static member function to create a player of the specified class
// Input : *className -
// *ed -
// Output : CBasePlayer
//-----------------------------------------------------------------------------
CBasePlayer *CBasePlayer::CreatePlayer( const char *className, edict_t *ed )
{
CBasePlayer *player;
CBasePlayer::s_PlayerEdict = ed;
player = ( CBasePlayer * )CreateEntityByName( className );
return player;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
CBasePlayer::CBasePlayer( )
{
AddEFlags( EFL_NO_AUTO_EDICT_ATTACH );
#ifdef _DEBUG
m_vecAutoAim.Init();
m_vecAdditionalPVSOrigin.Init();
m_vecCameraPVSOrigin.Init();
m_DmgOrigin.Init();
m_vecLadderNormal.Init();
m_oldOrigin.Init();
m_vecSmoothedVelocity.Init();
#endif
if ( s_PlayerEdict )
{
// take the assigned edict_t and attach it
Assert( s_PlayerEdict != NULL );
NetworkProp()->AttachEdict( s_PlayerEdict );
s_PlayerEdict = NULL;
}
m_flFlashTime = -1;
pl.fixangle = FIXANGLE_ABSOLUTE;
pl.hltv = false;
pl.replay = false;
pl.frags = 0;
pl.deaths = 0;
m_szNetname[0] = '\0';
m_iHealth = 0;
Weapon_SetLast( NULL );
m_bitsDamageType = 0;
m_bForceOrigin = false;
m_hVehicle = NULL;
m_pCurrentCommand = NULL;
m_iLockViewanglesTickNumber = 0;
m_qangLockViewangles.Init();
// Setup our default FOV
m_iDefaultFOV = g_pGameRules->DefaultFOV();
m_hZoomOwner = NULL;
m_nUpdateRate = 20; // cl_updaterate defualt
m_fLerpTime = 0.1f; // cl_interp default
m_bPredictWeapons = true;
m_bLagCompensation = false;
m_flLaggedMovementValue = 1.0f;
m_StuckLast = 0;
m_impactEnergyScale = 1.0f;
m_fLastPlayerTalkTime = 0.0f;
m_PlayerInfo.SetParent( this );
ResetObserverMode();
m_surfaceProps = 0;
m_pSurfaceData = NULL;
m_surfaceFriction = 1.0f;
m_chTextureType = 0;
m_chPreviousTextureType = 0;
m_iSuicideCustomKillFlags = 0;
m_fDelay = 0.0f;
m_fReplayEnd = -1;
m_iReplayEntity = 0;
m_autoKickDisabled = false;
m_nNumCrouches = 0;
m_bDuckToggled = false;
m_bPhysicsWasFrozen = false;
// Used to mask off buttons
m_afButtonDisabled = 0;
m_afButtonForced = 0;
m_nBodyPitchPoseParam = -1;
m_flForwardMove = 0;
m_flSideMove = 0;
// NVNT default to no haptics
m_bhasHaptics = false;
m_vecConstraintCenter = vec3_origin;
m_flLastUserCommandTime = 0.f;
m_flMovementTimeForUserCmdProcessingRemaining = 0.0f;
m_flLastObjectiveTime = -1.f;
}
CBasePlayer::~CBasePlayer( )
{
VPhysicsDestroyObject();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input :
// Output :
//-----------------------------------------------------------------------------
void CBasePlayer::UpdateOnRemove( void )
{
VPhysicsDestroyObject();
// Remove him from his current team
if ( GetTeam() )
{
GetTeam()->RemovePlayer( this );
}
// Chain at end to mimic destructor unwind order
BaseClass::UpdateOnRemove();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : **pvs -
// **pas -
//-----------------------------------------------------------------------------
void CBasePlayer::SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize )
{
// If we have a viewentity, we don't add the player's origin.
if ( pViewEntity )
return;
Vector org;
org = EyePosition();
engine->AddOriginToPVS( org );
}
int CBasePlayer::UpdateTransmitState()
{
// always call ShouldTransmit() for players
return SetTransmitState( FL_EDICT_FULLCHECK );
}
int CBasePlayer::ShouldTransmit( const CCheckTransmitInfo *pInfo )
{
// Allow me to introduce myself to, err, myself.
// I.e., always update the recipient player data even if it's nodraw (first person mode)
if ( pInfo->m_pClientEnt == edict() )
{
return FL_EDICT_ALWAYS;
}
// when HLTV/Replay is connected and spectators press +USE, they
// signal that they are recording a interesting scene
// so transmit these 'cameramans' to the HLTV or Replay client
if ( HLTVDirector()->GetCameraMan() == entindex() )
{
CBaseEntity *pRecipientEntity = CBaseEntity::Instance( pInfo->m_pClientEnt );
Assert( pRecipientEntity->IsPlayer() );
CBasePlayer *pRecipientPlayer = static_cast<CBasePlayer*>( pRecipientEntity );
if ( pRecipientPlayer->IsHLTV() ||
pRecipientPlayer->IsReplay() )
{
// HACK force calling RecomputePVSInformation to update PVS data
NetworkProp()->AreaNum();
return FL_EDICT_ALWAYS;
}
}
// Transmit for a short time after death and our death anim finishes so ragdolls can access reliable player data.
// Note that if m_flDeathAnimTime is never set, as long as m_lifeState is set to LIFE_DEAD after dying, this
// test will act as if the death anim is finished.
if ( IsEffectActive( EF_NODRAW ) || ( IsObserver() && ( gpGlobals->curtime - m_flDeathTime > 0.5 ) &&
( m_lifeState == LIFE_DEAD ) && ( gpGlobals->curtime - m_flDeathAnimTime > 0.5 ) ) )
{
return FL_EDICT_DONTSEND;
}
return BaseClass::ShouldTransmit( pInfo );
}
bool CBasePlayer::WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const
{
// Team members shouldn't be adjusted unless friendly fire is on.
if ( !friendlyfire.GetInt() && pPlayer->GetTeamNumber() == GetTeamNumber() )
return false;
// If this entity hasn't been transmitted to us and acked, then don't bother lag compensating it.
if ( pEntityTransmitBits && !pEntityTransmitBits->Get( pPlayer->entindex() ) )
return false;
const Vector &vMyOrigin = GetAbsOrigin();
const Vector &vHisOrigin = pPlayer->GetAbsOrigin();
// get max distance player could have moved within max lag compensation time,
// multiply by 1.5 to to avoid "dead zones" (sqrt(2) would be the exact value)
float maxDistance = 1.5 * pPlayer->MaxSpeed() * sv_maxunlag.GetFloat();
// If the player is within this distance, lag compensate them in case they're running past us.
if ( vHisOrigin.DistTo( vMyOrigin ) < maxDistance )
return true;
// If their origin is not within a 45 degree cone in front of us, no need to lag compensate.
Vector vForward;
AngleVectors( pCmd->viewangles, &vForward );
Vector vDiff = vHisOrigin - vMyOrigin;
VectorNormalize( vDiff );
float flCosAngle = 0.707107f; // 45 degree angle
if ( vForward.Dot( vDiff ) < flCosAngle )
return false;
return true;
}
void CBasePlayer::PauseBonusProgress( bool bPause )
{
m_bPauseBonusProgress = bPause;
}
void CBasePlayer::SetBonusProgress( int iBonusProgress )
{
if ( !m_bPauseBonusProgress )
m_iBonusProgress = iBonusProgress;
}
void CBasePlayer::SetBonusChallenge( int iBonusChallenge )
{
m_iBonusChallenge = iBonusChallenge;
}
//-----------------------------------------------------------------------------
// Sets the view angles
//-----------------------------------------------------------------------------
void CBasePlayer::SnapEyeAngles( const QAngle &viewAngles )
{
pl.v_angle = viewAngles;
pl.fixangle = FIXANGLE_ABSOLUTE;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : iSpeed -
// iMax -
// Output : int
//-----------------------------------------------------------------------------
int TrainSpeed(int iSpeed, int iMax)
{
float fSpeed, fMax;
int iRet = 0;
fMax = (float)iMax;
fSpeed = iSpeed;
fSpeed = fSpeed/fMax;
if (iSpeed < 0)
iRet = TRAIN_BACK;
else if (iSpeed == 0)
iRet = TRAIN_NEUTRAL;
else if (fSpeed < 0.33)
iRet = TRAIN_SLOW;
else if (fSpeed < 0.66)
iRet = TRAIN_MEDIUM;
else
iRet = TRAIN_FAST;
return iRet;
}
void CBasePlayer::DeathSound( const CTakeDamageInfo &info )
{
// temporarily using pain sounds for death sounds
// Did we die from falling?
if ( m_bitsDamageType & DMG_FALL )
{
// They died in the fall. Play a splat sound.
EmitSound( "Player.FallGib" );
}
else
{
EmitSound( "Player.Death" );
}
// play one of the suit death alarms
if ( IsSuitEquipped() )
{
UTIL_EmitGroupnameSuit(edict(), "HEV_DEAD");
}
}
// override takehealth
// bitsDamageType indicates type of damage healed.
int CBasePlayer::TakeHealth( float flHealth, int bitsDamageType )
{
// clear out any damage types we healed.
// UNDONE: generic health should not heal any
// UNDONE: time-based damage
if (m_takedamage)
{
int bitsDmgTimeBased = g_pGameRules->Damage_GetTimeBased();
m_bitsDamageType &= ~( bitsDamageType & ~bitsDmgTimeBased );
}
// I disabled reporting history into the dbghist because it was super spammy.
// But, if you need to reenable it, the code is below in the "else" clause.
#if 1 // #ifdef DISABLE_DEBUG_HISTORY
return BaseClass::TakeHealth (flHealth, bitsDamageType);
#else
const int healingTaken = BaseClass::TakeHealth(flHealth,bitsDamageType);
char buf[256];
Q_snprintf(buf, 256, "[%f] Player %s healed for %d with damagetype %X\n", gpGlobals->curtime, GetDebugName(), healingTaken, bitsDamageType);
ADD_DEBUG_HISTORY( HISTORY_PLAYER_DAMAGE, buf );
return healingTaken;
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Draw all overlays (should be implemented in cascade by subclass to add
// any additional non-text overlays)
// Input :
// Output : Current text offset from the top
//-----------------------------------------------------------------------------
void CBasePlayer::DrawDebugGeometryOverlays(void)
{
// --------------------------------------------------------
// If in buddha mode and dead draw lines to indicate death
// --------------------------------------------------------
if ((m_debugOverlays & OVERLAY_BUDDHA_MODE) && m_iHealth == 1)
{
Vector vBodyDir = BodyDirection2D( );
Vector eyePos = EyePosition() + vBodyDir*10.0;
Vector vUp = Vector(0,0,8);
Vector vSide;
CrossProduct( vBodyDir, vUp, vSide);
NDebugOverlay::Line(eyePos+vSide+vUp, eyePos-vSide-vUp, 255,0,0, false, 0);
NDebugOverlay::Line(eyePos+vSide-vUp, eyePos-vSide+vUp, 255,0,0, false, 0);
}
BaseClass::DrawDebugGeometryOverlays();
}
//=========================================================
// TraceAttack
//=========================================================
void CBasePlayer::TraceAttack( const CTakeDamageInfo &inputInfo, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator )
{
if ( m_takedamage )
{
CTakeDamageInfo info = inputInfo;
if ( info.GetAttacker() )
{
// --------------------------------------------------
// If an NPC check if friendly fire is disallowed
// --------------------------------------------------
CAI_BaseNPC *pNPC = info.GetAttacker()->MyNPCPointer();
if ( pNPC && (pNPC->CapabilitiesGet() & bits_CAP_NO_HIT_PLAYER) && pNPC->IRelationType( this ) != D_HT )
return;
// Prevent team damage here so blood doesn't appear
if ( info.GetAttacker()->IsPlayer() )
{
if ( !g_pGameRules->FPlayerCanTakeDamage( this, info.GetAttacker(), info ) )
return;
}
}
SetLastHitGroup( ptr->hitgroup );
switch ( ptr->hitgroup )
{
case HITGROUP_GENERIC:
break;
case HITGROUP_HEAD:
info.ScaleDamage( sk_player_head.GetFloat() );
break;
case HITGROUP_CHEST:
info.ScaleDamage( sk_player_chest.GetFloat() );
break;
case HITGROUP_STOMACH:
info.ScaleDamage( sk_player_stomach.GetFloat() );
break;
case HITGROUP_LEFTARM:
case HITGROUP_RIGHTARM:
info.ScaleDamage( sk_player_arm.GetFloat() );
break;
case HITGROUP_LEFTLEG:
case HITGROUP_RIGHTLEG:
info.ScaleDamage( sk_player_leg.GetFloat() );
break;
default:
break;
}
#ifdef HL2_EPISODIC
// If this damage type makes us bleed, then do so
bool bShouldBleed = !g_pGameRules->Damage_ShouldNotBleed( info.GetDamageType() );
if ( bShouldBleed )
#endif
{
SpawnBlood(ptr->endpos, vecDir, BloodColor(), info.GetDamage());// a little surface blood.
TraceBleed( info.GetDamage(), vecDir, ptr, info.GetDamageType() );
}
AddMultiDamage( info, this );
}
}
//------------------------------------------------------------------------------
// Purpose : Do some kind of damage effect for the type of damage
// Input :
// Output :
//------------------------------------------------------------------------------
void CBasePlayer::DamageEffect(float flDamage, int fDamageType)
{
if (fDamageType & DMG_CRUSH)
{
//Red damage indicator
color32 red = {128,0,0,128};
UTIL_ScreenFade( this, red, 1.0f, 0.1f, FFADE_IN );
}
else if (fDamageType & DMG_DROWN)
{
//Blue damage indicator
color32 blue = {0,0,128,128};
UTIL_ScreenFade( this, blue, 1.0f, 0.1f, FFADE_IN );
}
else if (fDamageType & DMG_SLASH)
{
// If slash damage shoot some blood
SpawnBlood(EyePosition(), g_vecAttackDir, BloodColor(), flDamage);
}
else if (fDamageType & DMG_PLASMA)
{
// Blue screen fade
color32 blue = {0,0,255,100};
UTIL_ScreenFade( this, blue, 0.2, 0.4, FFADE_MODULATE );
// Very small screen shake
// Both -0.1 and 0.1 map to 0 when converted to integer, so all of these RandomInt
// calls are just expensive ways of returning zero. This code has always been this
// way and has never had any value. clang complains about the conversion from a
// literal floating-point number to an integer.
//ViewPunch(QAngle(random->RandomInt(-0.1,0.1), random->RandomInt(-0.1,0.1), random->RandomInt(-0.1,0.1)));
// Burn sound
EmitSound( "Player.PlasmaDamage" );
}
else if (fDamageType & DMG_SONIC)
{
// Sonic damage sound
EmitSound( "Player.SonicDamage" );
}
else if ( fDamageType & DMG_BULLET )
{
EmitSound( "Flesh.BulletImpact" );
}
}
/*
Take some damage.
NOTE: each call to OnTakeDamage with bitsDamageType set to a time-based damage
type will cause the damage time countdown to be reset. Thus the ongoing effects of poison, radiation
etc are implemented with subsequent calls to OnTakeDamage using DMG_GENERIC.
*/
// Old values
#define OLD_ARMOR_RATIO 0.2 // Armor Takes 80% of the damage
#define OLD_ARMOR_BONUS 0.5 // Each Point of Armor is work 1/x points of health
// New values
#define ARMOR_RATIO 0.2
#define ARMOR_BONUS 1.0
//---------------------------------------------------------
//---------------------------------------------------------
bool CBasePlayer::ShouldTakeDamageInCommentaryMode( const CTakeDamageInfo &inputInfo )
{
// Only ignore damage when we're listening to a commentary node
if ( !IsListeningToCommentary() )
return true;
// Allow SetHealth inputs to kill player.
if ( inputInfo.GetInflictor() == this && inputInfo.GetAttacker() == this )
return true;
#ifdef PORTAL
if ( inputInfo.GetDamageType() & DMG_ACID )
return true;
#endif
// In commentary, ignore all damage except for falling and leeches
if ( !(inputInfo.GetDamageType() & (DMG_BURN | DMG_PLASMA | DMG_FALL | DMG_CRUSH)) && inputInfo.GetDamageType() != DMG_GENERIC )
return false;
// We let DMG_CRUSH pass the check above so that we can check here for stress damage. Deny the CRUSH damage if there is no attacker,
// or if the attacker isn't a BSP model. Therefore, we're allowing any CRUSH damage done by a BSP model.
if ( (inputInfo.GetDamageType() & DMG_CRUSH) && ( inputInfo.GetAttacker() == NULL || !inputInfo.GetAttacker()->IsBSPModel() ) )
return false;
return true;
}
int CBasePlayer::OnTakeDamage( const CTakeDamageInfo &inputInfo )
{
// have suit diagnose the problem - ie: report damage type
int bitsDamage = inputInfo.GetDamageType();
int ffound = true;
int fmajor;
int fcritical;
int fTookDamage;
int ftrivial;
float flRatio;
float flBonus;
float flHealthPrev = m_iHealth;
CTakeDamageInfo info = inputInfo;
IServerVehicle *pVehicle = GetVehicle();
if ( pVehicle )
{
// Let the vehicle decide if we should take this damage or not
if ( pVehicle->PassengerShouldReceiveDamage( info ) == false )
return 0;
}
if ( IsInCommentaryMode() )
{
if( !ShouldTakeDamageInCommentaryMode( info ) )
return 0;
}
if ( GetFlags() & FL_GODMODE )
return 0;
if ( m_debugOverlays & OVERLAY_BUDDHA_MODE )
{
if ((m_iHealth - info.GetDamage()) <= 0)
{
m_iHealth = 1;
return 0;
}
}
// Early out if there's no damage
if ( !info.GetDamage() )
return 0;
if( old_armor.GetBool() )
{
flBonus = OLD_ARMOR_BONUS;
flRatio = OLD_ARMOR_RATIO;
}
else
{
flBonus = ARMOR_BONUS;
flRatio = ARMOR_RATIO;
}
if ( ( info.GetDamageType() & DMG_BLAST ) && g_pGameRules->IsMultiplayer() )
{
// blasts damage armor more.
flBonus *= 2;
}
// Already dead
if ( !IsAlive() )
return 0;
// go take the damage first
if ( !g_pGameRules->FPlayerCanTakeDamage( this, info.GetAttacker(), inputInfo ) )
{
// Refuse the damage
return 0;
}
// print to console if the appropriate cvar is set
#ifdef DISABLE_DEBUG_HISTORY
if (player_debug_print_damage.GetBool() && info.GetDamage() > 0)
#endif
{
char dmgtype[64];
CTakeDamageInfo::DebugGetDamageTypeString( info.GetDamageType(), dmgtype, 512 );
char outputString[256];
Q_snprintf( outputString, 256, "%f: Player %s at [%0.2f %0.2f %0.2f] took %f damage from %s, type %s\n", gpGlobals->curtime, GetDebugName(),
GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z, info.GetDamage(), info.GetInflictor()->GetDebugName(), dmgtype );
//Msg( "%f: Player %s at [%0.2f %0.2f %0.2f] took %f damage from %s, type %s\n", gpGlobals->curtime, GetDebugName(),
// GetAbsOrigin().x, GetAbsOrigin().y, GetAbsOrigin().z, info.GetDamage(), info.GetInflictor()->GetDebugName(), dmgtype );
ADD_DEBUG_HISTORY( HISTORY_PLAYER_DAMAGE, outputString );
#ifndef DISABLE_DEBUG_HISTORY
if ( player_debug_print_damage.GetBool() ) // if we're not in here just for the debug history
#endif
{
Msg( "%s", outputString);
}
}
// keep track of amount of damage last sustained
m_lastDamageAmount = info.GetDamage();
// Armor.
if (m_ArmorValue && !(info.GetDamageType() & (DMG_FALL | DMG_DROWN | DMG_POISON | DMG_RADIATION)) )// armor doesn't protect against fall or drown damage!
{
float flNew = info.GetDamage() * flRatio;
float flArmor;
flArmor = (info.GetDamage() - flNew) * flBonus;
if( !old_armor.GetBool() )
{
if( flArmor < 1.0 )
{
flArmor = 1.0;
}
}
// Does this use more armor than we have?
if (flArmor > m_ArmorValue)
{
flArmor = m_ArmorValue;
flArmor *= (1/flBonus);
flNew = info.GetDamage() - flArmor;
m_DmgSave = m_ArmorValue;
m_ArmorValue = 0;
}
else
{
m_DmgSave = flArmor;
m_ArmorValue -= flArmor;
}
info.SetDamage( flNew );
}
#if defined( WIN32 ) && !defined( _X360 )
// NVNT if player's client has a haptic device send them a user message with the damage.
if(HasHaptics())
HapticsDamage(this,info);
#endif
// this cast to INT is critical!!! If a player ends up with 0.5 health, the engine will get that
// as an int (zero) and think the player is dead! (this will incite a clientside screentilt, etc)
// NOTENOTE: jdw - We are now capable of retaining the mantissa of this damage value and deferring its application
// info.SetDamage( (int)info.GetDamage() );
// Call up to the base class
fTookDamage = BaseClass::OnTakeDamage( info );
// Early out if the base class took no damage
if ( !fTookDamage )
return 0;
// add to the damage total for clients, which will be sent as a single
// message at the end of the frame
// todo: remove after combining shotgun blasts?
if ( info.GetInflictor() && info.GetInflictor()->edict() )
m_DmgOrigin = info.GetInflictor()->GetAbsOrigin();
m_DmgTake += (int)info.GetDamage();
// Reset damage time countdown for each type of time based damage player just sustained
for (int i = 0; i < CDMG_TIMEBASED; i++)
{
// Make sure the damage type is really time-based.
// This is kind of hacky but necessary until we setup DamageType as an enum.
int iDamage = ( DMG_PARALYZE << i );
if ( ( info.GetDamageType() & iDamage ) && g_pGameRules->Damage_IsTimeBased( iDamage ) )
{
m_rgbTimeBasedDamage[i] = 0;
}
}
// Display any effect associate with this damage type
DamageEffect(info.GetDamage(),bitsDamage);
// how bad is it, doc?
ftrivial = (m_iHealth > 75 || m_lastDamageAmount < 5);
fmajor = (m_lastDamageAmount > 25);
fcritical = (m_iHealth < 30);
// handle all bits set in this damage message,
// let the suit give player the diagnosis
// UNDONE: add sounds for types of damage sustained (ie: burn, shock, slash )
// UNDONE: still need to record damage and heal messages for the following types
// DMG_BURN
// DMG_FREEZE
// DMG_BLAST
// DMG_SHOCK
m_bitsDamageType |= bitsDamage; // Save this so we can report it to the client
m_bitsHUDDamage = -1; // make sure the damage bits get resent
while (fTookDamage && (!ftrivial || g_pGameRules->Damage_IsTimeBased( bitsDamage ) ) && ffound && bitsDamage)
{
ffound = false;
if (bitsDamage & DMG_CLUB)
{
if (fmajor)
SetSuitUpdate("!HEV_DMG4", false, SUIT_NEXT_IN_30SEC); // minor fracture
bitsDamage &= ~DMG_CLUB;
ffound = true;
}
if (bitsDamage & (DMG_FALL | DMG_CRUSH))
{
if (fmajor)
SetSuitUpdate("!HEV_DMG5", false, SUIT_NEXT_IN_30SEC); // major fracture
else
SetSuitUpdate("!HEV_DMG4", false, SUIT_NEXT_IN_30SEC); // minor fracture
bitsDamage &= ~(DMG_FALL | DMG_CRUSH);
ffound = true;
}
if (bitsDamage & DMG_BULLET)
{
if (m_lastDamageAmount > 5)
SetSuitUpdate("!HEV_DMG6", false, SUIT_NEXT_IN_30SEC); // blood loss detected
//else
// SetSuitUpdate("!HEV_DMG0", false, SUIT_NEXT_IN_30SEC); // minor laceration
bitsDamage &= ~DMG_BULLET;
ffound = true;
}
if (bitsDamage & DMG_SLASH)
{
if (fmajor)
SetSuitUpdate("!HEV_DMG1", false, SUIT_NEXT_IN_30SEC); // major laceration
else
SetSuitUpdate("!HEV_DMG0", false, SUIT_NEXT_IN_30SEC); // minor laceration
bitsDamage &= ~DMG_SLASH;
ffound = true;
}
if (bitsDamage & DMG_SONIC)
{
if (fmajor)
SetSuitUpdate("!HEV_DMG2", false, SUIT_NEXT_IN_1MIN); // internal bleeding
bitsDamage &= ~DMG_SONIC;
ffound = true;
}
if (bitsDamage & (DMG_POISON | DMG_PARALYZE))
{
if (bitsDamage & DMG_POISON)
{
m_nPoisonDmg += info.GetDamage();
m_tbdPrev = gpGlobals->curtime;
m_rgbTimeBasedDamage[itbd_PoisonRecover] = 0;
}
SetSuitUpdate("!HEV_DMG3", false, SUIT_NEXT_IN_1MIN); // blood toxins detected
bitsDamage &= ~( DMG_POISON | DMG_PARALYZE );
ffound = true;
}
if (bitsDamage & DMG_ACID)
{
SetSuitUpdate("!HEV_DET1", false, SUIT_NEXT_IN_1MIN); // hazardous chemicals detected
bitsDamage &= ~DMG_ACID;
ffound = true;
}
if (bitsDamage & DMG_NERVEGAS)
{
SetSuitUpdate("!HEV_DET0", false, SUIT_NEXT_IN_1MIN); // biohazard detected
bitsDamage &= ~DMG_NERVEGAS;
ffound = true;
}
if (bitsDamage & DMG_RADIATION)
{
SetSuitUpdate("!HEV_DET2", false, SUIT_NEXT_IN_1MIN); // radiation detected
bitsDamage &= ~DMG_RADIATION;
ffound = true;
}
if (bitsDamage & DMG_SHOCK)
{
bitsDamage &= ~DMG_SHOCK;
ffound = true;
}
}
float flPunch = -2;
if( hl2_episodic.GetBool() && info.GetAttacker() && !FInViewCone( info.GetAttacker() ) )
{
if( info.GetDamage() > 10.0f )
flPunch = -10;
else
flPunch = RandomFloat( -5, -7 );
}
m_Local.m_vecPunchAngle.SetX( flPunch );
if (fTookDamage && !ftrivial && fmajor && flHealthPrev >= 75)
{
// first time we take major damage...
// turn automedic on if not on
SetSuitUpdate("!HEV_MED1", false, SUIT_NEXT_IN_30MIN); // automedic on
// give morphine shot if not given recently
SetSuitUpdate("!HEV_HEAL7", false, SUIT_NEXT_IN_30MIN); // morphine shot
}
if (fTookDamage && !ftrivial && fcritical && flHealthPrev < 75)
{
// already took major damage, now it's critical...
if (m_iHealth < 6)
SetSuitUpdate("!HEV_HLTH3", false, SUIT_NEXT_IN_10MIN); // near death
else if (m_iHealth < 20)
SetSuitUpdate("!HEV_HLTH2", false, SUIT_NEXT_IN_10MIN); // health critical
// give critical health warnings
if (!random->RandomInt(0,3) && flHealthPrev < 50)
SetSuitUpdate("!HEV_DMG7", false, SUIT_NEXT_IN_5MIN); //seek medical attention
}
// if we're taking time based damage, warn about its continuing effects
if (fTookDamage && g_pGameRules->Damage_IsTimeBased( info.GetDamageType() ) && flHealthPrev < 75)
{
if (flHealthPrev < 50)
{
if (!random->RandomInt(0,3))
SetSuitUpdate("!HEV_DMG7", false, SUIT_NEXT_IN_5MIN); //seek medical attention
}
else
SetSuitUpdate("!HEV_HLTH1", false, SUIT_NEXT_IN_10MIN); // health dropping
}
// Do special explosion damage effect
if ( bitsDamage & DMG_BLAST )
{
OnDamagedByExplosion( info );
}
return fTookDamage;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
// damageAmount -
//-----------------------------------------------------------------------------
#define MIN_SHOCK_AND_CONFUSION_DAMAGE 30.0f
#define MIN_EAR_RINGING_DISTANCE 240.0f // 20 feet
//-----------------------------------------------------------------------------
// Purpose:
// Input : &info -
//-----------------------------------------------------------------------------
void CBasePlayer::OnDamagedByExplosion( const CTakeDamageInfo &info )
{
float lastDamage = info.GetDamage();
float distanceFromPlayer = 9999.0f;
CBaseEntity *inflictor = info.GetInflictor();
if ( inflictor )
{
Vector delta = GetAbsOrigin() - inflictor->GetAbsOrigin();
distanceFromPlayer = delta.Length();
}
bool ear_ringing = distanceFromPlayer < MIN_EAR_RINGING_DISTANCE ? true : false;
bool shock = lastDamage >= MIN_SHOCK_AND_CONFUSION_DAMAGE;
if ( !shock && !ear_ringing )
return;
int effect = shock ?
random->RandomInt( 35, 37 ) :
random->RandomInt( 32, 34 );
CSingleUserRecipientFilter user( this );
enginesound->SetPlayerDSP( user, effect, false );
}
//=========================================================
// PackDeadPlayerItems - call this when a player dies to
// pack up the appropriate weapons and ammo items, and to
// destroy anything that shouldn't be packed.
//
// This is pretty brute force :(
//=========================================================
void CBasePlayer::PackDeadPlayerItems( void )
{
int iWeaponRules;
int iAmmoRules;
int i;
CBaseCombatWeapon *rgpPackWeapons[ 20 ];// 20 hardcoded for now. How to determine exactly how many weapons we have?
int iPackAmmo[ MAX_AMMO_SLOTS + 1];
int iPW = 0;// index into packweapons array
int iPA = 0;// index into packammo array
memset(rgpPackWeapons, NULL, sizeof(rgpPackWeapons) );
memset(iPackAmmo, -1, sizeof(iPackAmmo) );
// get the game rules
iWeaponRules = g_pGameRules->DeadPlayerWeapons( this );
iAmmoRules = g_pGameRules->DeadPlayerAmmo( this );
if ( iWeaponRules == GR_PLR_DROP_GUN_NO && iAmmoRules == GR_PLR_DROP_AMMO_NO )
{
// nothing to pack. Remove the weapons and return. Don't call create on the box!
RemoveAllItems( true );
return;
}
// go through all of the weapons and make a list of the ones to pack
for ( i = 0 ; i < WeaponCount() ; i++ )
{
// there's a weapon here. Should I pack it?
CBaseCombatWeapon *pPlayerItem = GetWeapon( i );
if ( pPlayerItem )
{
switch( iWeaponRules )
{
case GR_PLR_DROP_GUN_ACTIVE:
if ( GetActiveWeapon() && pPlayerItem == GetActiveWeapon() )
{
// this is the active item. Pack it.
rgpPackWeapons[ iPW++ ] = pPlayerItem;
}
break;
case GR_PLR_DROP_GUN_ALL:
rgpPackWeapons[ iPW++ ] = pPlayerItem;
break;
default:
break;
}
}
}
// now go through ammo and make a list of which types to pack.
if ( iAmmoRules != GR_PLR_DROP_AMMO_NO )
{
for ( i = 0 ; i < MAX_AMMO_SLOTS ; i++ )
{
if ( GetAmmoCount( i ) > 0 )
{
// player has some ammo of this type.
switch ( iAmmoRules )
{
case GR_PLR_DROP_AMMO_ALL:
iPackAmmo[ iPA++ ] = i;
break;
case GR_PLR_DROP_AMMO_ACTIVE:
// WEAPONTODO: Make this work
/*
if ( GetActiveWeapon() && i == GetActiveWeapon()->m_iPrimaryAmmoType )
{
// this is the primary ammo type for the active weapon
iPackAmmo[ iPA++ ] = i;
}
else if ( GetActiveWeapon() && i == GetActiveWeapon()->m_iSecondaryAmmoType )
{
// this is the secondary ammo type for the active weapon
iPackAmmo[ iPA++ ] = i;
}
*/
break;
default:
break;
}
}
}
}
RemoveAllItems( true );// now strip off everything that wasn't handled by the code above.
}
void CBasePlayer::RemoveAllItems( bool removeSuit )
{
if (GetActiveWeapon())
{
ResetAutoaim( );
GetActiveWeapon()->Holster( );
}
Weapon_SetLast( NULL );
RemoveAllWeapons();
RemoveAllAmmo();
if ( removeSuit )
{
RemoveSuit();
}
UpdateClientData();
}
bool CBasePlayer::IsDead() const
{
return m_lifeState == LIFE_DEAD;
}
static float DamageForce( const Vector &size, float damage )
{
float force = damage * ((32 * 32 * 72.0) / (size.x * size.y * size.z)) * 5;
if ( force > 1000.0)
{
force = 1000.0;
}
return force;
}
const impactdamagetable_t &CBasePlayer::GetPhysicsImpactDamageTable()
{
return gDefaultPlayerImpactDamageTable;
}
int CBasePlayer::OnTakeDamage_Alive( const CTakeDamageInfo &info )
{
// set damage type sustained
m_bitsDamageType |= info.GetDamageType();
if ( !BaseClass::OnTakeDamage_Alive( info ) )
return 0;
CBaseEntity * attacker = info.GetAttacker();
if ( !attacker )
return 0;
Vector vecDir = vec3_origin;
if ( info.GetInflictor() )
{
vecDir = info.GetInflictor()->WorldSpaceCenter() - Vector ( 0, 0, 10 ) - WorldSpaceCenter();
VectorNormalize( vecDir );
}
if ( info.GetInflictor() && (GetMoveType() == MOVETYPE_WALK) &&
( !attacker->IsSolidFlagSet(FSOLID_TRIGGER)) )
{
Vector force = vecDir * -DamageForce( WorldAlignSize(), info.GetBaseDamage() );
if ( force.z > 250.0f )
{
force.z = 250.0f;
}
ApplyAbsVelocityImpulse( force );
}
// fire global game event
IGameEvent * event = gameeventmanager->CreateEvent( "player_hurt" );
if ( event )
{
event->SetInt("userid", GetUserID() );
event->SetInt("health", MAX(0, m_iHealth) );
event->SetInt("priority", 5 ); // HLTV event priority, not transmitted
if ( attacker->IsPlayer() )
{
CBasePlayer *player = ToBasePlayer( attacker );
event->SetInt("attacker", player->GetUserID() ); // hurt by other player
}
else
{
event->SetInt("attacker", 0 ); // hurt by "world"
}
gameeventmanager->FireEvent( event );
}
// Insert a combat sound so that nearby NPCs hear battle
if ( attacker->IsNPC() )
{
CSoundEnt::InsertSound( SOUND_COMBAT, GetAbsOrigin(), 512, 0.5, this );//<<TODO>>//magic number
}
return 1;
}
void CBasePlayer::Event_Killed( const CTakeDamageInfo &info )
{
CSound *pSound;
if ( Hints() )
{
Hints()->ResetHintTimers();
}
g_pGameRules->PlayerKilled( this, info );
gamestats->Event_PlayerKilled( this, info );
RumbleEffect( RUMBLE_STOP_ALL, 0, RUMBLE_FLAGS_NONE );
#if defined( WIN32 ) && !defined( _X360 )
// NVNT set the drag to zero in the case of underwater death.
HapticSetDrag(this,0);
#endif
ClearUseEntity();
// this client isn't going to be thinking for a while, so reset the sound until they respawn
pSound = CSoundEnt::SoundPointerForIndex( CSoundEnt::ClientSoundIndex( edict() ) );
{
if ( pSound )
{
pSound->Reset();
}
}
// don't let the status bar glitch for players with <0 health.
if (m_iHealth < -99)
{
m_iHealth = 0;
}
// holster the current weapon
if ( GetActiveWeapon() )
{
GetActiveWeapon()->Holster();
}
SetAnimation( PLAYER_DIE );
if ( !IsObserver() )
{
SetViewOffset( VEC_DEAD_VIEWHEIGHT_SCALED( this ) );
}
m_lifeState = LIFE_DYING;
pl.deadflag = true;
AddSolidFlags( FSOLID_NOT_SOLID );
// force contact points to get flushed if no longer valid
// UNDONE: Always do this on RecheckCollisionFilter() ?
IPhysicsObject *pObject = VPhysicsGetObject();
if ( pObject )
{
pObject->RecheckContactPoints();
}
SetMoveType( MOVETYPE_FLYGRAVITY );
SetGroundEntity( NULL );
// clear out the suit message cache so we don't keep chattering
SetSuitUpdate(NULL, false, 0);
// reset FOV
SetFOV( this, 0 );
if ( FlashlightIsOn() )
{
FlashlightTurnOff();
}
m_flDeathTime = gpGlobals->curtime;
ClearLastKnownArea();
BaseClass::Event_Killed( info );
}
void CBasePlayer::Event_Dying( const CTakeDamageInfo& info )
{
// NOT GIBBED, RUN THIS CODE
DeathSound( info );
// The dead body rolls out of the vehicle.
if ( IsInAVehicle() )
{
LeaveVehicle();
}
QAngle angles = GetLocalAngles();
angles.x = 0;
angles.z = 0;
SetLocalAngles( angles );
SetThink(&CBasePlayer::PlayerDeathThink);
SetNextThink( gpGlobals->curtime + 0.1f );
BaseClass::Event_Dying( info );
}
// Set the activity based on an event or current state
void CBasePlayer::SetAnimation( PLAYER_ANIM playerAnim )
{
int animDesired;
char szAnim[64];
float speed;
speed = GetAbsVelocity().Length2D();
if (GetFlags() & (FL_FROZEN|FL_ATCONTROLS))
{
speed = 0;
playerAnim = PLAYER_IDLE;
}
Activity idealActivity = ACT_WALK;// TEMP!!!!!
// This could stand to be redone. Why is playerAnim abstracted from activity? (sjb)
if (playerAnim == PLAYER_JUMP)
{
idealActivity = ACT_HOP;
}
else if (playerAnim == PLAYER_SUPERJUMP)
{
idealActivity = ACT_LEAP;
}
else if (playerAnim == PLAYER_DIE)
{
if ( m_lifeState == LIFE_ALIVE )
{
idealActivity = GetDeathActivity();
}
}
else if (playerAnim == PLAYER_ATTACK1)
{
if ( m_Activity == ACT_HOVER ||
m_Activity == ACT_SWIM ||
m_Activity == ACT_HOP ||
m_Activity == ACT_LEAP ||
m_Activity == ACT_DIESIMPLE )
{
idealActivity = m_Activity;
}
else
{
idealActivity = ACT_RANGE_ATTACK1;
}
}
else if (playerAnim == PLAYER_IDLE || playerAnim == PLAYER_WALK)
{
if ( !( GetFlags() & FL_ONGROUND ) && (m_Activity == ACT_HOP || m_Activity == ACT_LEAP) ) // Still jumping
{
idealActivity = m_Activity;
}
else if ( GetWaterLevel() > 1 )
{
if ( speed == 0 )
idealActivity = ACT_HOVER;
else
idealActivity = ACT_SWIM;
}
else
{
idealActivity = ACT_WALK;
}
}
if (idealActivity == ACT_RANGE_ATTACK1)
{
if ( GetFlags() & FL_DUCKING ) // crouching
{
Q_strncpy( szAnim, "crouch_shoot_" ,sizeof(szAnim));
}
else
{
Q_strncpy( szAnim, "ref_shoot_" ,sizeof(szAnim));
}
Q_strncat( szAnim, m_szAnimExtension ,sizeof(szAnim), COPY_ALL_CHARACTERS );
animDesired = LookupSequence( szAnim );
if (animDesired == -1)
animDesired = 0;
if ( GetSequence() != animDesired || !SequenceLoops() )
{
SetCycle( 0 );
}
// Tracker 24588: In single player when firing own weapon this causes eye and punchangle to jitter
//if (!SequenceLoops())
//{
// IncrementInterpolationFrame();
//}
SetActivity( idealActivity );
ResetSequence( animDesired );
}
else if (idealActivity == ACT_WALK)
{
if (GetActivity() != ACT_RANGE_ATTACK1 || IsActivityFinished())
{
if ( GetFlags() & FL_DUCKING ) // crouching
{
Q_strncpy( szAnim, "crouch_aim_" ,sizeof(szAnim));
}
else
{
Q_strncpy( szAnim, "ref_aim_" ,sizeof(szAnim));
}
Q_strncat( szAnim, m_szAnimExtension,sizeof(szAnim), COPY_ALL_CHARACTERS );
animDesired = LookupSequence( szAnim );
if (animDesired == -1)
animDesired = 0;
SetActivity( ACT_WALK );
}
else
{
animDesired = GetSequence();
}
}
else
{
if ( GetActivity() == idealActivity)
return;
SetActivity( idealActivity );
animDesired = SelectWeightedSequence( m_Activity );
// Already using the desired animation?
if (GetSequence() == animDesired)
return;
ResetSequence( animDesired );
SetCycle( 0 );
return;
}
// Already using the desired animation?
if (GetSequence() == animDesired)
return;
//Msg( "Set animation to %d\n", animDesired );
// Reset to first frame of desired animation
ResetSequence( animDesired );
SetCycle( 0 );
}
/*
===========
WaterMove
============
*/
#ifdef HL2_DLL
// test for HL2 drowning damage increase (aux power used instead)
#define AIRTIME 7 // lung full of air lasts this many seconds
#define DROWNING_DAMAGE_INITIAL 10
#define DROWNING_DAMAGE_MAX 10
#else
#define AIRTIME 12 // lung full of air lasts this many seconds
#define DROWNING_DAMAGE_INITIAL 2
#define DROWNING_DAMAGE_MAX 5
#endif
void CBasePlayer::WaterMove()
{
if ( ( GetMoveType() == MOVETYPE_NOCLIP ) && !GetMoveParent() )
{
m_AirFinished = gpGlobals->curtime + AIRTIME;
return;
}
if ( m_iHealth < 0 || !IsAlive() )
{
UpdateUnderwaterState();
return;
}
// waterlevel 0 - not in water (WL_NotInWater)
// waterlevel 1 - feet in water (WL_Feet)
// waterlevel 2 - waist in water (WL_Waist)
// waterlevel 3 - head in water (WL_Eyes)
if (GetWaterLevel() != WL_Eyes || CanBreatheUnderwater())
{
// not underwater
// play 'up for air' sound
if (m_AirFinished < gpGlobals->curtime)
{
EmitSound( "Player.DrownStart" );
}
m_AirFinished = gpGlobals->curtime + AIRTIME;
m_nDrownDmgRate = DROWNING_DAMAGE_INITIAL;
// if we took drowning damage, give it back slowly
if (m_idrowndmg > m_idrownrestored)
{
// set drowning damage bit. hack - dmg_drownrecover actually
// makes the time based damage code 'give back' health over time.
// make sure counter is cleared so we start count correctly.
// NOTE: this actually causes the count to continue restarting
// until all drowning damage is healed.
m_bitsDamageType |= DMG_DROWNRECOVER;
m_bitsDamageType &= ~DMG_DROWN;
m_rgbTimeBasedDamage[itbd_DrownRecover] = 0;
}
}
else
{ // fully under water
// stop restoring damage while underwater
m_bitsDamageType &= ~DMG_DROWNRECOVER;
m_rgbTimeBasedDamage[itbd_DrownRecover] = 0;
if (m_AirFinished < gpGlobals->curtime && !(GetFlags() & FL_GODMODE) ) // drown!
{
if (m_PainFinished < gpGlobals->curtime)
{
// take drowning damage
m_nDrownDmgRate += 1;
if (m_nDrownDmgRate > DROWNING_DAMAGE_MAX)
{
m_nDrownDmgRate = DROWNING_DAMAGE_MAX;
}
OnTakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), m_nDrownDmgRate, DMG_DROWN ) );
m_PainFinished = gpGlobals->curtime + 1;
// track drowning damage, give it back when
// player finally takes a breath
m_idrowndmg += m_nDrownDmgRate;
}
}
else
{
m_bitsDamageType &= ~DMG_DROWN;
}
}
UpdateUnderwaterState();
}
// true if the player is attached to a ladder
bool CBasePlayer::IsOnLadder( void )
{
return (GetMoveType() == MOVETYPE_LADDER);
}
float CBasePlayer::GetWaterJumpTime() const
{
return m_flWaterJumpTime;
}
void CBasePlayer::SetWaterJumpTime( float flWaterJumpTime )
{
m_flWaterJumpTime = flWaterJumpTime;
}
float CBasePlayer::GetSwimSoundTime( void ) const
{
return m_flSwimSoundTime;
}
void CBasePlayer::SetSwimSoundTime( float flSwimSoundTime )
{
m_flSwimSoundTime = flSwimSoundTime;
}
void CBasePlayer::ShowViewPortPanel( const char * name, bool bShow, KeyValues *data )
{
CSingleUserRecipientFilter filter( this );
filter.MakeReliable();
int count = 0;
KeyValues *subkey = NULL;
if ( data )
{
subkey = data->GetFirstSubKey();
while ( subkey )
{
count++; subkey = subkey->GetNextKey();
}
subkey = data->GetFirstSubKey(); // reset
}
UserMessageBegin( filter, "VGUIMenu" );
WRITE_STRING( name ); // menu name
WRITE_BYTE( bShow?1:0 );
WRITE_BYTE( count );
// write additional data (be careful not more than 192 bytes!)
while ( subkey )
{
WRITE_STRING( subkey->GetName() );
WRITE_STRING( subkey->GetString() );
subkey = subkey->GetNextKey();
}
MessageEnd();
}
void CBasePlayer::PlayerDeathThink(void)
{
float flForward;
SetNextThink( gpGlobals->curtime + 0.1f );
if (GetFlags() & FL_ONGROUND)
{
flForward = GetAbsVelocity().Length() - 20;
if (flForward <= 0)
{
SetAbsVelocity( vec3_origin );
}
else
{
Vector vecNewVelocity = GetAbsVelocity();
VectorNormalize( vecNewVelocity );
vecNewVelocity *= flForward;
SetAbsVelocity( vecNewVelocity );
}
}
if ( HasWeapons() )
{
// we drop the guns here because weapons that have an area effect and can kill their user
// will sometimes crash coming back from CBasePlayer::Killed() if they kill their owner because the
// player class sometimes is freed. It's safer to manipulate the weapons once we know
// we aren't calling into any of their code anymore through the player pointer.
PackDeadPlayerItems();
}
if (GetModelIndex() && (!IsSequenceFinished()) && (m_lifeState == LIFE_DYING))
{
StudioFrameAdvance( );
m_iRespawnFrames++;
if ( m_iRespawnFrames < 60 ) // animations should be no longer than this
return;
}
if (m_lifeState == LIFE_DYING)
{
m_lifeState = LIFE_DEAD;
m_flDeathAnimTime = gpGlobals->curtime;
}
StopAnimation();
IncrementInterpolationFrame();
m_flPlaybackRate = 0.0;
int fAnyButtonDown = (m_nButtons & ~IN_SCORE);
// Strip out the duck key from this check if it's toggled
if ( (fAnyButtonDown & IN_DUCK) && GetToggledDuckState())
{
fAnyButtonDown &= ~IN_DUCK;
}
// wait for all buttons released
if (m_lifeState == LIFE_DEAD)
{
if (fAnyButtonDown)
return;
if ( g_pGameRules->FPlayerCanRespawn( this ) )
{
m_lifeState = LIFE_RESPAWNABLE;
}
return;
}
// if the player has been dead for one second longer than allowed by forcerespawn,
// forcerespawn isn't on. Send the player off to an intermission camera until they
// choose to respawn.
if ( g_pGameRules->IsMultiplayer() && ( gpGlobals->curtime > (m_flDeathTime + DEATH_ANIMATION_TIME) ) && !IsObserver() )
{
// go to dead camera.
StartObserverMode( m_iObserverLastMode );
}
// wait for any button down, or mp_forcerespawn is set and the respawn time is up
if (!fAnyButtonDown
&& !( g_pGameRules->IsMultiplayer() && forcerespawn.GetInt() > 0 && (gpGlobals->curtime > (m_flDeathTime + 5))) )
return;
m_nButtons = 0;
m_iRespawnFrames = 0;
//Msg( "Respawn\n");
respawn( this, !IsObserver() );// don't copy a corpse if we're in deathcam.
SetNextThink( TICK_NEVER_THINK );
}
/*
//=========================================================
// StartDeathCam - find an intermission spot and send the
// player off into observer mode
//=========================================================
void CBasePlayer::StartDeathCam( void )
{
CBaseEntity *pSpot, *pNewSpot;
int iRand;
if ( GetViewOffset() == vec3_origin )
{
// don't accept subsequent attempts to StartDeathCam()
return;
}
pSpot = gEntList.FindEntityByClassname( NULL, "info_intermission");
if ( pSpot )
{
// at least one intermission spot in the world.
iRand = random->RandomInt( 0, 3 );
while ( iRand > 0 )
{
pNewSpot = gEntList.FindEntityByClassname( pSpot, "info_intermission");
if ( pNewSpot )
{
pSpot = pNewSpot;
}
iRand--;
}
CreateCorpse();
StartObserverMode( pSpot->GetAbsOrigin(), pSpot->GetAbsAngles() );
}
else
{
// no intermission spot. Push them up in the air, looking down at their corpse
trace_t tr;
CreateCorpse();
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector( 0, 0, 128 ),
MASK_PLAYERSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
QAngle angles;
VectorAngles( GetAbsOrigin() - tr.endpos, angles );
StartObserverMode( tr.endpos, angles );
return;
}
} */
void CBasePlayer::StopObserverMode()
{
m_bForcedObserverMode = false;
m_afPhysicsFlags &= ~PFLAG_OBSERVER;
if ( m_iObserverMode == OBS_MODE_NONE )
return;
if ( m_iObserverMode > OBS_MODE_DEATHCAM )
{
m_iObserverLastMode = m_iObserverMode;
}
m_iObserverMode.Set( OBS_MODE_NONE );
ShowViewPortPanel( "specmenu", false );
ShowViewPortPanel( "specgui", false );
ShowViewPortPanel( "overview", false );
}
bool CBasePlayer::StartObserverMode(int mode)
{
if ( !IsObserver() )
{
// set position to last view offset
SetAbsOrigin( GetAbsOrigin() + GetViewOffset() );
SetViewOffset( vec3_origin );
}
Assert( mode > OBS_MODE_NONE );
m_afPhysicsFlags |= PFLAG_OBSERVER;
// Holster weapon immediately, to allow it to cleanup
if ( GetActiveWeapon() )
GetActiveWeapon()->Holster();
// clear out the suit message cache so we don't keep chattering
SetSuitUpdate(NULL, FALSE, 0);
SetGroundEntity( (CBaseEntity *)NULL );
RemoveFlag( FL_DUCKING );
AddSolidFlags( FSOLID_NOT_SOLID );
SetObserverMode( mode );
if ( gpGlobals->eLoadType != MapLoad_Background )
{
ShowViewPortPanel( "specgui" , ModeWantsSpectatorGUI(mode) );
}
// Setup flags
m_Local.m_iHideHUD = HIDEHUD_HEALTH;
m_takedamage = DAMAGE_NO;
// Become invisible
AddEffects( EF_NODRAW );
m_iHealth = 1;
m_lifeState = LIFE_DEAD; // Can't be dead, otherwise movement doesn't work right.
m_flDeathAnimTime = gpGlobals->curtime;
pl.deadflag = true;
return true;
}
bool CBasePlayer::SetObserverMode(int mode )
{
if ( mode < OBS_MODE_NONE || mode >= NUM_OBSERVER_MODES )
return false;
// check mp_forcecamera settings for dead players
if ( mode > OBS_MODE_FIXED && GetTeamNumber() > TEAM_SPECTATOR )
{
switch ( mp_forcecamera.GetInt() )
{
case OBS_ALLOW_ALL : break; // no restrictions
case OBS_ALLOW_TEAM : mode = OBS_MODE_IN_EYE; break;
case OBS_ALLOW_NONE : mode = OBS_MODE_FIXED; break; // don't allow anything
}
}
if ( m_iObserverMode > OBS_MODE_DEATHCAM )
{
// remember mode if we were really spectating before
m_iObserverLastMode = m_iObserverMode;
}
m_iObserverMode = mode;
switch ( mode )
{
case OBS_MODE_NONE:
case OBS_MODE_FIXED :
case OBS_MODE_DEATHCAM :
SetFOV( this, 0 ); // Reset FOV
SetViewOffset( vec3_origin );
SetMoveType( MOVETYPE_NONE );
break;
case OBS_MODE_CHASE :
case OBS_MODE_POI: // PASSTIME
case OBS_MODE_IN_EYE :
// udpate FOV and viewmodels
SetObserverTarget( m_hObserverTarget );
SetMoveType( MOVETYPE_OBSERVER );
break;
//=============================================================================
// HPE_BEGIN:
// [menglish] Added freeze cam to the setter. Uses same setup as the roaming mode
//=============================================================================
case OBS_MODE_ROAMING :
case OBS_MODE_FREEZECAM :
SetFOV( this, 0 ); // Reset FOV
SetObserverTarget( m_hObserverTarget );
SetViewOffset( vec3_origin );
SetMoveType( MOVETYPE_OBSERVER );
break;
//=============================================================================
// HPE_END
//=============================================================================
}
CheckObserverSettings();
return true;
}
int CBasePlayer::GetObserverMode()
{
return m_iObserverMode;
}
void CBasePlayer::ForceObserverMode(int mode)
{
int tempMode = OBS_MODE_ROAMING;
if ( m_iObserverMode == mode )
return;
// don't change last mode if already in forced mode
if ( m_bForcedObserverMode )
{
tempMode = m_iObserverLastMode;
}
SetObserverMode( mode );
if ( m_bForcedObserverMode )
{
m_iObserverLastMode = tempMode;
}
m_bForcedObserverMode = true;
}
void CBasePlayer::CheckObserverSettings()
{
// check if we are in forced mode and may go back to old mode
if ( m_bForcedObserverMode )
{
CBaseEntity * target = m_hObserverTarget;
if ( !IsValidObserverTarget(target) )
{
// if old target is still invalid, try to find valid one
target = FindNextObserverTarget( false );
}
if ( target )
{
// we found a valid target
m_bForcedObserverMode = false; // disable force mode
SetObserverMode( m_iObserverLastMode ); // switch to last mode
SetObserverTarget( target ); // goto target
// TODO check for HUD icons
return;
}
else
{
// else stay in forced mode, no changes
return;
}
}
// make sure our last mode is valid
if ( m_iObserverLastMode < OBS_MODE_FIXED )
{
m_iObserverLastMode = OBS_MODE_ROAMING;
}
// check if our spectating target is still a valid one
if ( m_iObserverMode == OBS_MODE_IN_EYE || m_iObserverMode == OBS_MODE_CHASE || m_iObserverMode == OBS_MODE_FIXED || m_iObserverMode == OBS_MODE_POI )
{
ValidateCurrentObserverTarget();
CBasePlayer *target = ToBasePlayer( m_hObserverTarget.Get() );
// for ineye mode we have to copy several data to see exactly the same
if ( target && m_iObserverMode == OBS_MODE_IN_EYE )
{
int flagMask = FL_ONGROUND | FL_DUCKING ;
int flags = target->GetFlags() & flagMask;
if ( (GetFlags() & flagMask) != flags )
{
flags |= GetFlags() & (~flagMask); // keep other flags
ClearFlags();
AddFlag( flags );
}
if ( target->GetViewOffset() != GetViewOffset() )
{
SetViewOffset( target->GetViewOffset() );
}
}
// Update the fog.
if ( target )
{
if ( target->m_Local.m_PlayerFog.m_hCtrl.Get() != m_Local.m_PlayerFog.m_hCtrl.Get() )
{
m_Local.m_PlayerFog.m_hCtrl.Set( target->m_Local.m_PlayerFog.m_hCtrl.Get() );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::ValidateCurrentObserverTarget( void )
{
if ( !IsValidObserverTarget( m_hObserverTarget.Get() ) )
{
// our target is not valid, try to find new target
CBaseEntity * target = FindNextObserverTarget( false );
if ( target )
{
// switch to new valid target
SetObserverTarget( target );
}
else
{
#if !defined( TF_DLL )
// couldn't find new target, switch to temporary mode
if ( mp_forcecamera.GetInt() == OBS_ALLOW_ALL )
{
// let player roam around
ForceObserverMode( OBS_MODE_ROAMING );
}
else
#endif
{
// fix player view right where it is
ForceObserverMode( OBS_MODE_FIXED );
m_hObserverTarget.Set( NULL ); // no target to follow
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::AttemptToExitFreezeCam( void )
{
StartObserverMode( OBS_MODE_DEATHCAM );
}
bool CBasePlayer::StartReplayMode( float fDelay, float fDuration, int iEntity )
{
if ( ( sv_maxreplay == NULL ) || ( sv_maxreplay->GetFloat() <= 0 ) )
return false;
m_fDelay = fDelay;
m_fReplayEnd = gpGlobals->curtime + fDuration;
m_iReplayEntity = iEntity;
return true;
}
void CBasePlayer::StopReplayMode()
{
m_fDelay = 0.0f;
m_fReplayEnd = -1;
m_iReplayEntity = 0;
}
int CBasePlayer::GetDelayTicks()
{
if ( m_fReplayEnd > gpGlobals->curtime )
{
return TIME_TO_TICKS( m_fDelay );
}
else
{
if ( m_fDelay > 0.0f )
StopReplayMode();
return 0;
}
}
int CBasePlayer::GetReplayEntity()
{
return m_iReplayEntity;
}
CBaseEntity * CBasePlayer::GetObserverTarget()
{
return m_hObserverTarget.Get();
}
void CBasePlayer::ObserverUse( bool bIsPressed )
{
#ifndef _XBOX
if ( !HLTVDirector()->IsActive() )
return;
if ( GetTeamNumber() != TEAM_SPECTATOR )
return; // only pure spectators can play cameraman
if ( !bIsPressed )
return;
bool bIsHLTV = HLTVDirector()->IsActive();
if ( bIsHLTV )
{
int iCameraManIndex = HLTVDirector()->GetCameraMan();
if ( iCameraManIndex == 0 )
{
// turn camera on
HLTVDirector()->SetCameraMan( entindex() );
}
else if ( iCameraManIndex == entindex() )
{
// turn camera off
HLTVDirector()->SetCameraMan( 0 );
}
else
{
ClientPrint( this, HUD_PRINTTALK, "Camera in use by other player." );
}
}
/* UTIL_SayText( "Spectator can not USE anything", this );
Vector dir,end;
Vector start = GetAbsOrigin();
AngleVectors( GetAbsAngles(), &dir );
VectorNormalize( dir );
VectorMA( start, 32.0f, dir, end );
trace_t tr;
UTIL_TraceLine( start, end, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
if ( tr.fraction == 1.0f )
return; // no obstacles in spectators way
VectorMA( start, 128.0f, dir, end );
Ray_t ray;
ray.Init( end, start, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX );
UTIL_TraceRay( ray, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
if ( tr.startsolid || tr.allsolid )
return;
SetAbsOrigin( tr.endpos ); */
#endif
}
void CBasePlayer::JumptoPosition(const Vector &origin, const QAngle &angles)
{
SetAbsOrigin( origin );
SetAbsVelocity( vec3_origin ); // stop movement
SetLocalAngles( angles );
SnapEyeAngles( angles );
}
bool CBasePlayer::SetObserverTarget(CBaseEntity *target)
{
if ( !IsValidObserverTarget( target ) )
return false;
// set new target
m_hObserverTarget.Set( target );
// reset fov to default
SetFOV( this, 0 );
if ( m_iObserverMode == OBS_MODE_ROAMING )
{
Vector dir, end;
Vector start = target->EyePosition();
QAngle ang = target->EyeAngles();
ang.z = 0; // PASSTIME no view roll when spectating ball
AngleVectors( ang, &dir );
VectorNormalize( dir );
VectorMA( start, -64.0f, dir, end );
Ray_t ray;
ray.Init( start, end, VEC_DUCK_HULL_MIN , VEC_DUCK_HULL_MAX );
trace_t tr;
UTIL_TraceRay( ray, MASK_PLAYERSOLID, target, COLLISION_GROUP_PLAYER_MOVEMENT, &tr );
JumptoPosition( tr.endpos, ang );
}
return true;
}
bool CBasePlayer::IsValidObserverTarget(CBaseEntity * target)
{
if ( target == NULL )
return false;
// MOD AUTHORS: Add checks on target here or in derived method
if ( !target->IsPlayer() ) // only track players
return false;
CBasePlayer * player = ToBasePlayer( target );
/* Don't spec observers or players who haven't picked a class yet
if ( player->IsObserver() )
return false; */
if( player == this )
return false; // We can't observe ourselves.
if ( player->IsEffectActive( EF_NODRAW ) ) // don't watch invisible players
return false;
if ( player->m_lifeState == LIFE_RESPAWNABLE ) // target is dead, waiting for respawn
return false;
if ( player->m_lifeState == LIFE_DEAD || player->m_lifeState == LIFE_DYING )
{
if ( (player->m_flDeathTime + DEATH_ANIMATION_TIME ) < gpGlobals->curtime )
{
return false; // allow watching until 3 seconds after death to see death animation
}
}
// check forcecamera settings for active players
if ( GetTeamNumber() != TEAM_SPECTATOR )
{
switch ( mp_forcecamera.GetInt() )
{
case OBS_ALLOW_ALL : break;
case OBS_ALLOW_TEAM : if ( GetTeamNumber() != target->GetTeamNumber() )
return false;
break;
case OBS_ALLOW_NONE : return false;
}
}
return true; // passed all test
}
int CBasePlayer::GetNextObserverSearchStartPoint( bool bReverse )
{
int iDir = bReverse ? -1 : 1;
int startIndex;
if ( m_hObserverTarget )
{
// start using last followed player
startIndex = m_hObserverTarget->entindex();
}
else
{
// start using own player index
startIndex = this->entindex();
}
startIndex += iDir;
if (startIndex > gpGlobals->maxClients)
startIndex = 1;
else if (startIndex < 1)
startIndex = gpGlobals->maxClients;
return startIndex;
}
CBaseEntity * CBasePlayer::FindNextObserverTarget(bool bReverse)
{
// MOD AUTHORS: Modify the logic of this function if you want to restrict the observer to watching
// only a subset of the players. e.g. Make it check the target's team.
/* if ( m_flNextFollowTime && m_flNextFollowTime > gpGlobals->time )
{
return;
}
m_flNextFollowTime = gpGlobals->time + 0.25;
*/ // TODO move outside this function
int startIndex = GetNextObserverSearchStartPoint( bReverse );
int currentIndex = startIndex;
int iDir = bReverse ? -1 : 1;
do
{
CBaseEntity * nextTarget = UTIL_PlayerByIndex( currentIndex );
if ( IsValidObserverTarget( nextTarget ) )
{
return nextTarget; // found next valid player
}
currentIndex += iDir;
// Loop through the clients
if (currentIndex > gpGlobals->maxClients)
currentIndex = 1;
else if (currentIndex < 1)
currentIndex = gpGlobals->maxClients;
} while ( currentIndex != startIndex );
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Return true if this object can be +used by the player
//-----------------------------------------------------------------------------
bool CBasePlayer::IsUseableEntity( CBaseEntity *pEntity, unsigned int requiredCaps )
{
if ( pEntity )
{
int caps = pEntity->ObjectCaps();
if ( caps & (FCAP_IMPULSE_USE|FCAP_CONTINUOUS_USE|FCAP_ONOFF_USE|FCAP_DIRECTIONAL_USE) )
{
if ( (caps & requiredCaps) == requiredCaps )
{
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBasePlayer::CanPickupObject( CBaseEntity *pObject, float massLimit, float sizeLimit )
{
// UNDONE: Make this virtual and move to HL2 player
#ifdef HL2_DLL
//Must be valid
if ( pObject == NULL )
return false;
//Must move with physics
if ( pObject->GetMoveType() != MOVETYPE_VPHYSICS )
return false;
IPhysicsObject *pList[VPHYSICS_MAX_OBJECT_LIST_COUNT];
int count = pObject->VPhysicsGetObjectList( pList, ARRAYSIZE(pList) );
//Must have a physics object
if (!count)
return false;
float objectMass = 0;
bool checkEnable = false;
for ( int i = 0; i < count; i++ )
{
objectMass += pList[i]->GetMass();
if ( !pList[i]->IsMoveable() )
{
checkEnable = true;
}
if ( pList[i]->GetGameFlags() & FVPHYSICS_NO_PLAYER_PICKUP )
return false;
if ( pList[i]->IsHinged() )
return false;
}
//Msg( "Target mass: %f\n", pPhys->GetMass() );
//Must be under our threshold weight
if ( massLimit > 0 && objectMass > massLimit )
return false;
if ( checkEnable )
{
// Allowing picking up of bouncebombs.
CBounceBomb *pBomb = dynamic_cast<CBounceBomb*>(pObject);
if( pBomb )
return true;
// Allow pickup of phys props that are motion enabled on player pickup
CPhysicsProp *pProp = dynamic_cast<CPhysicsProp*>(pObject);
CPhysBox *pBox = dynamic_cast<CPhysBox*>(pObject);
if ( !pProp && !pBox )
return false;
if ( pProp && !(pProp->HasSpawnFlags( SF_PHYSPROP_ENABLE_ON_PHYSCANNON )) )
return false;
if ( pBox && !(pBox->HasSpawnFlags( SF_PHYSBOX_ENABLE_ON_PHYSCANNON )) )
return false;
}
if ( sizeLimit > 0 )
{
const Vector &size = pObject->CollisionProp()->OBBSize();
if ( size.x > sizeLimit || size.y > sizeLimit || size.z > sizeLimit )
return false;
}
return true;
#else
return false;
#endif
}
float CBasePlayer::GetHeldObjectMass( IPhysicsObject *pHeldObject )
{
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Server side of jumping rules. Most jumping logic is already
// handled in shared gamemovement code. Put stuff here that should
// only be done server side.
//-----------------------------------------------------------------------------
void CBasePlayer::Jump()
{
}
void CBasePlayer::Duck( )
{
if (m_nButtons & IN_DUCK)
{
if ( m_Activity != ACT_LEAP )
{
SetAnimation( PLAYER_WALK );
}
}
}
//
// ID's player as such.
//
Class_T CBasePlayer::Classify ( void )
{
return CLASS_PLAYER;
}
void CBasePlayer::ResetFragCount()
{
m_iFrags = 0;
pl.frags = m_iFrags;
}
void CBasePlayer::IncrementFragCount( int nCount )
{
m_iFrags += nCount;
pl.frags = m_iFrags;
}
void CBasePlayer::ResetDeathCount()
{
m_iDeaths = 0;
pl.deaths = m_iDeaths;
}
void CBasePlayer::IncrementDeathCount( int nCount )
{
m_iDeaths += nCount;
pl.deaths = m_iDeaths;
}
void CBasePlayer::AddPoints( int score, bool bAllowNegativeScore )
{
// Positive score always adds
if ( score < 0 )
{
if ( !bAllowNegativeScore )
{
if ( m_iFrags < 0 ) // Can't go more negative
return;
if ( -score > m_iFrags ) // Will this go negative?
{
score = -m_iFrags; // Sum will be 0
}
}
}
m_iFrags += score;
pl.frags = m_iFrags;
}
void CBasePlayer::AddPointsToTeam( int score, bool bAllowNegativeScore )
{
if ( GetTeam() )
{
GetTeam()->AddScore( score );
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Output : int
//-----------------------------------------------------------------------------
int CBasePlayer::GetCommandContextCount( void ) const
{
return m_CommandContext.Count();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : index -
// Output : CCommandContext
//-----------------------------------------------------------------------------
CCommandContext *CBasePlayer::GetCommandContext( int index )
{
if ( index < 0 || index >= m_CommandContext.Count() )
return NULL;
return &m_CommandContext[ index ];
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CCommandContext *CBasePlayer::AllocCommandContext( void )
{
int idx = m_CommandContext.AddToTail();
if ( m_CommandContext.Count() > 1000 )
{
Assert( 0 );
}
return &m_CommandContext[ idx ];
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : index -
//-----------------------------------------------------------------------------
void CBasePlayer::RemoveCommandContext( int index )
{
m_CommandContext.Remove( index );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::RemoveAllCommandContexts()
{
m_CommandContext.RemoveAll();
}
//-----------------------------------------------------------------------------
// Purpose: Removes all existing contexts, but leaves the last one around ( or creates it if it doesn't exist -- which would be a bug )
//-----------------------------------------------------------------------------
CCommandContext *CBasePlayer::RemoveAllCommandContextsExceptNewest( void )
{
int count = m_CommandContext.Count();
int toRemove = count - 1;
if ( toRemove > 0 )
{
m_CommandContext.RemoveMultiple( 0, toRemove );
}
if ( !m_CommandContext.Count() )
{
Assert( 0 );
CCommandContext *ctx = AllocCommandContext();
Q_memset( ctx, 0, sizeof( *ctx ) );
}
return &m_CommandContext[ 0 ];
}
//-----------------------------------------------------------------------------
// Purpose: Replaces the first nCommands CUserCmds in the context with the ones passed in -- this is used to help meter out CUserCmds over the number of simulation ticks on the server
//-----------------------------------------------------------------------------
void CBasePlayer::ReplaceContextCommands( CCommandContext *ctx, CUserCmd *pCommands, int nCommands )
{
// Blow away all of the commands
ctx->cmds.RemoveAll();
ctx->numcmds = nCommands;
ctx->totalcmds = nCommands;
ctx->dropped_packets = 0; // meaningless in this context
// Add them in so the most recent is at slot 0
for ( int i = nCommands - 1; i >= 0; --i )
{
ctx->cmds.AddToTail( pCommands[ i ] );
}
}
//-----------------------------------------------------------------------------
// Purpose: Determine how much time we will be running this frame
// Output : float
//-----------------------------------------------------------------------------
int CBasePlayer::DetermineSimulationTicks( void )
{
int command_context_count = GetCommandContextCount();
int context_number;
int simulation_ticks = 0;
// Determine how much time we will be running this frame and fixup player clock as needed
for ( context_number = 0; context_number < command_context_count; context_number++ )
{
CCommandContext const *ctx = GetCommandContext( context_number );
Assert( ctx );
Assert( ctx->numcmds > 0 );
Assert( ctx->dropped_packets >= 0 );
// Determine how long it will take to run those packets
simulation_ticks += ctx->numcmds + ctx->dropped_packets;
}
return simulation_ticks;
}
// 2 ticks ahead or behind current clock means we need to fix clock on client
static ConVar sv_clockcorrection_msecs( "sv_clockcorrection_msecs", "60", 0, "The server tries to keep each player's m_nTickBase withing this many msecs of the server absolute tickcount" );
static ConVar sv_playerperfhistorycount( "sv_playerperfhistorycount", "60", 0, "Number of samples to maintain in player perf history", true, 1.0f, true, 128.0 );
//-----------------------------------------------------------------------------
// Purpose: Based upon amount of time in simulation time, adjust m_nTickBase so that
// we just end at the end of the current frame (so the player is basically on clock
// with the server)
// Input : simulation_ticks -
//-----------------------------------------------------------------------------
void CBasePlayer::AdjustPlayerTimeBase( int simulation_ticks )
{
Assert( simulation_ticks >= 0 );
if ( simulation_ticks < 0 )
return;
CPlayerSimInfo *pi = NULL;
if ( sv_playerperfhistorycount.GetInt() > 0 )
{
while ( m_vecPlayerSimInfo.Count() > sv_playerperfhistorycount.GetInt() )
{
m_vecPlayerSimInfo.Remove( m_vecPlayerSimInfo.Head() );
}
pi = &m_vecPlayerSimInfo[ m_vecPlayerSimInfo.AddToTail() ];
}
// Start in the past so that we get to the sv.time that we'll hit at the end of the
// frame, just as we process the final command
if ( gpGlobals->maxClients == 1 )
{
// set TickBase so that player simulation tick matches gpGlobals->tickcount after
// all commands have been executed
m_nTickBase = gpGlobals->tickcount - simulation_ticks + gpGlobals->simTicksThisFrame;
}
else // multiplayer
{
float flCorrectionSeconds = clamp( sv_clockcorrection_msecs.GetFloat() / 1000.0f, 0.0f, 1.0f );
int nCorrectionTicks = TIME_TO_TICKS( flCorrectionSeconds );
// Set the target tick flCorrectionSeconds (rounded to ticks) ahead in the future. this way the client can
// alternate around this target tick without getting smaller than gpGlobals->tickcount.
// After running the commands simulation time should be equal or after current gpGlobals->tickcount,
// otherwise the simulation time drops out of the client side interpolated var history window.
int nIdealFinalTick = gpGlobals->tickcount + nCorrectionTicks;
int nEstimatedFinalTick = m_nTickBase + simulation_ticks;
// If client gets ahead of this, we'll need to correct
int too_fast_limit = nIdealFinalTick + nCorrectionTicks;
// If client falls behind this, we'll also need to correct
int too_slow_limit = nIdealFinalTick - nCorrectionTicks;
// See if we are too fast
if ( nEstimatedFinalTick > too_fast_limit ||
nEstimatedFinalTick < too_slow_limit )
{
int nCorrectedTick = nIdealFinalTick - simulation_ticks + gpGlobals->simTicksThisFrame;
if ( pi )
{
pi->m_nTicksCorrected = nCorrectionTicks;
}
m_nTickBase = nCorrectedTick;
}
}
if ( pi )
{
pi->m_flFinalSimulationTime = TICKS_TO_TIME( m_nTickBase + simulation_ticks + gpGlobals->simTicksThisFrame );
}
}
void CBasePlayer::RunNullCommand( void )
{
CUserCmd cmd; // NULL command
// Store off the globals.. they're gonna get whacked
float flOldFrametime = gpGlobals->frametime;
float flOldCurtime = gpGlobals->curtime;
pl.fixangle = FIXANGLE_NONE;
if ( IsReplay() )
{
cmd.viewangles = QAngle( 0, 0, 0 );
}
else
{
cmd.viewangles = EyeAngles();
}
float flTimeBase = gpGlobals->curtime;
SetTimeBase( flTimeBase );
MoveHelperServer()->SetHost( this );
PlayerRunCommand( &cmd, MoveHelperServer() );
// save off the last good usercmd
SetLastUserCommand( cmd );
// Restore the globals..
gpGlobals->frametime = flOldFrametime;
gpGlobals->curtime = flOldCurtime;
MoveHelperServer()->SetHost( NULL );
}
//-----------------------------------------------------------------------------
// Purpose: Note, don't chain to BaseClass::PhysicsSimulate
//-----------------------------------------------------------------------------
void CBasePlayer::PhysicsSimulate( void )
{
VPROF_BUDGET( "CBasePlayer::PhysicsSimulate", VPROF_BUDGETGROUP_PLAYER );
// If we've got a moveparent, we must simulate that first.
CBaseEntity *pMoveParent = GetMoveParent();
if (pMoveParent)
{
pMoveParent->PhysicsSimulate();
}
// Make sure not to simulate this guy twice per frame
if ( m_nSimulationTick == gpGlobals->tickcount )
{
return;
}
m_nSimulationTick = gpGlobals->tickcount;
// See how many CUserCmds are queued up for running
int simulation_ticks = DetermineSimulationTicks();
// If some time will elapse, make sure our clock (m_nTickBase) starts at the correct time
if ( simulation_ticks > 0 )
{
AdjustPlayerTimeBase( simulation_ticks );
}
if ( IsHLTV() || IsReplay() )
{
// just run a single, empty command to make sure
// all PreThink/PostThink functions are called as usual
Assert ( GetCommandContextCount() == 0 );
RunNullCommand();
RemoveAllCommandContexts();
return;
}
// Store off true server timestamps
float savetime = gpGlobals->curtime;
float saveframetime = gpGlobals->frametime;
int command_context_count = GetCommandContextCount();
// Build a list of all available commands
CUtlVector< CUserCmd > vecAvailCommands;
// Contexts go from oldest to newest
for ( int context_number = 0; context_number < command_context_count; context_number++ )
{
// Get oldest ( newer are added to tail )
CCommandContext *ctx = GetCommandContext( context_number );
if ( !ShouldRunCommandsInContext( ctx ) )
continue;
if ( !ctx->cmds.Count() )
continue;
int numbackup = ctx->totalcmds - ctx->numcmds;
// If we haven't dropped too many packets, then run some commands
if ( ctx->dropped_packets < 24 )
{
int droppedcmds = ctx->dropped_packets;
// run the last known cmd for each dropped cmd we don't have a backup for
while ( droppedcmds > numbackup )
{
m_LastCmd.tick_count++;
vecAvailCommands.AddToTail( m_LastCmd );
droppedcmds--;
}
// Now run the "history" commands if we still have dropped packets
while ( droppedcmds > 0 )
{
int cmdnum = ctx->numcmds + droppedcmds - 1;
vecAvailCommands.AddToTail( ctx->cmds[cmdnum] );
droppedcmds--;
}
}
// Now run any new command(s). Go backward because the most recent command is at index 0.
for ( int i = ctx->numcmds - 1; i >= 0; i-- )
{
vecAvailCommands.AddToTail( ctx->cmds[i] );
}
// Save off the last good command in case we drop > numbackup packets and need to rerun them
// we'll use this to "guess" at what was in the missing packets
m_LastCmd = ctx->cmds[ CMD_MOSTRECENT ];
}
// gpGlobals->simTicksThisFrame == number of ticks remaining to be run, so we should take the last N CUserCmds and postpone them until the next frame
// If we're running multiple ticks this frame, don't peel off all of the commands, spread them out over
// the server ticks. Use blocks of two in alternate ticks
int commandLimit = CBaseEntity::IsSimulatingOnAlternateTicks() ? 2 : 1;
int commandsToRun = vecAvailCommands.Count();
if ( gpGlobals->simTicksThisFrame >= commandLimit && vecAvailCommands.Count() > commandLimit )
{
int commandsToRollOver = MIN( vecAvailCommands.Count(), ( gpGlobals->simTicksThisFrame - 1 ) );
commandsToRun = vecAvailCommands.Count() - commandsToRollOver;
Assert( commandsToRun >= 0 );
// Clear all contexts except the last one
if ( commandsToRollOver > 0 )
{
CCommandContext *ctx = RemoveAllCommandContextsExceptNewest();
ReplaceContextCommands( ctx, &vecAvailCommands[ commandsToRun ], commandsToRollOver );
}
else
{
// Clear all contexts
RemoveAllCommandContexts();
}
}
else
{
// Clear all contexts
RemoveAllCommandContexts();
}
float vphysicsArrivalTime = TICK_INTERVAL;
#ifdef _DEBUG
if ( sv_player_net_suppress_usercommands.GetBool() )
{
commandsToRun = 0;
}
#endif // _DEBUG
int numUsrCmdProcessTicksMax = sv_maxusrcmdprocessticks.GetInt();
if ( gpGlobals->maxClients != 1 && numUsrCmdProcessTicksMax ) // don't apply this filter in SP games
{
// Grant the client some time buffer to execute user commands
m_flMovementTimeForUserCmdProcessingRemaining += TICK_INTERVAL;
// but never accumulate more than N ticks
if ( m_flMovementTimeForUserCmdProcessingRemaining > numUsrCmdProcessTicksMax * TICK_INTERVAL )
m_flMovementTimeForUserCmdProcessingRemaining = numUsrCmdProcessTicksMax * TICK_INTERVAL;
}
else
{
// Otherwise we don't care to track time
m_flMovementTimeForUserCmdProcessingRemaining = FLT_MAX;
}
// Now run the commands
if ( commandsToRun > 0 )
{
m_flLastUserCommandTime = savetime;
MoveHelperServer()->SetHost( this );
// Suppress predicted events, etc.
if ( IsPredictingWeapons() )
{
IPredictionSystem::SuppressHostEvents( this );
}
for ( int i = 0; i < commandsToRun; ++i )
{
PlayerRunCommand( &vecAvailCommands[ i ], MoveHelperServer() );
// Update our vphysics object.
if ( m_pPhysicsController )
{
VPROF( "CBasePlayer::PhysicsSimulate-UpdateVPhysicsPosition" );
// If simulating at 2 * TICK_INTERVAL, add an extra TICK_INTERVAL to position arrival computation
UpdateVPhysicsPosition( m_vNewVPhysicsPosition, m_vNewVPhysicsVelocity, vphysicsArrivalTime );
vphysicsArrivalTime += TICK_INTERVAL;
}
}
// Always reset after running commands
IPredictionSystem::SuppressHostEvents( NULL );
MoveHelperServer()->SetHost( NULL );
// Copy in final origin from simulation
CPlayerSimInfo *pi = NULL;
if ( m_vecPlayerSimInfo.Count() > 0 )
{
pi = &m_vecPlayerSimInfo[ m_vecPlayerSimInfo.Tail() ];
pi->m_flTime = Plat_FloatTime();
pi->m_vecAbsOrigin = GetAbsOrigin();
pi->m_flGameSimulationTime = gpGlobals->curtime;
pi->m_nNumCmds = commandsToRun;
}
}
else if ( GetTimeSinceLastUserCommand() > sv_player_usercommand_timeout.GetFloat() )
{
// no usercommand from player after some threshold
// server should start RunNullCommand as if client sends an empty command so that Think and gamestate related things run properly
RunNullCommand();
}
// Restore the true server clock
// FIXME: Should this occur after simulation of children so
// that they are in the timespace of the player?
gpGlobals->curtime = savetime;
gpGlobals->frametime = saveframetime;
}
unsigned int CBasePlayer::PhysicsSolidMaskForEntity() const
{
return MASK_PLAYERSOLID;
}
//-----------------------------------------------------------------------------
// Purpose: This will force usercmd processing to actually consume commands even if the global tick counter isn't incrementing
//-----------------------------------------------------------------------------
void CBasePlayer::ForceSimulation()
{
m_nSimulationTick = -1;
}
ConVar sv_usercmd_custom_random_seed( "sv_usercmd_custom_random_seed", "1", FCVAR_CHEAT, "When enabled server will populate an additional random seed independent of the client" );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *buf -
// totalcmds -
// dropped_packets -
// ignore -
// paused -
// Output : float -- Time in seconds of last movement command
//-----------------------------------------------------------------------------
void CBasePlayer::ProcessUsercmds( CUserCmd *cmds, int numcmds, int totalcmds,
int dropped_packets, bool paused )
{
CCommandContext *ctx = AllocCommandContext();
Assert( ctx );
int i;
for ( i = totalcmds - 1; i >= 0; i-- )
{
CUserCmd *pCmd = &cmds[totalcmds - 1 - i];
// Validate values
if ( !IsUserCmdDataValid( pCmd ) )
{
pCmd->MakeInert();
}
if ( sv_usercmd_custom_random_seed.GetBool() )
{
float fltTimeNow = float( Plat_FloatTime() * 1000.0 );
pCmd->server_random_seed = *reinterpret_cast<int*>( (char*)&fltTimeNow );
}
else
{
pCmd->server_random_seed = pCmd->random_seed;
}
ctx->cmds.AddToTail( *pCmd );
}
ctx->numcmds = numcmds;
ctx->totalcmds = totalcmds,
ctx->dropped_packets = dropped_packets;
ctx->paused = paused;
// If the server is paused, zero out motion,buttons,view changes
if ( ctx->paused )
{
bool clear_angles = true;
// If no clipping and cheats enabled and sv_noclipduringpause enabled, then don't zero out movement part of CUserCmd
if ( GetMoveType() == MOVETYPE_NOCLIP &&
sv_cheats->GetBool() &&
sv_noclipduringpause.GetBool() )
{
clear_angles = false;
}
for ( i = 0; i < ctx->numcmds; i++ )
{
ctx->cmds[ i ].buttons = 0;
if ( clear_angles )
{
ctx->cmds[ i ].forwardmove = 0;
ctx->cmds[ i ].sidemove = 0;
ctx->cmds[ i ].upmove = 0;
VectorCopy ( pl.v_angle, ctx->cmds[ i ].viewangles );
}
}
ctx->dropped_packets = 0;
}
// Set global pause state for this player
m_bGamePaused = paused;
if ( paused )
{
ForceSimulation();
// Just run the commands right away if paused
PhysicsSimulate();
}
if ( sv_playerperfhistorycount.GetInt() > 0 )
{
CPlayerCmdInfo pi;
pi.m_flTime = Plat_FloatTime();
pi.m_nDroppedPackets = dropped_packets;
pi.m_nNumCmds = numcmds;
while ( m_vecPlayerCmdInfo.Count() >= sv_playerperfhistorycount.GetInt() )
{
m_vecPlayerCmdInfo.Remove( m_vecPlayerCmdInfo.Head() );
}
m_vecPlayerCmdInfo.AddToTail( pi );
}
}
//-----------------------------------------------------------------------------
// Purpose: Check that command values are reasonable
//-----------------------------------------------------------------------------
bool CBasePlayer::IsUserCmdDataValid( CUserCmd *pCmd )
{
if ( IsBot() || IsFakeClient() )
return true;
// Maximum difference between client's and server's tick_count
const int nCmdMaxTickDelta = ( 1.f / gpGlobals->interval_per_tick ) * 2.5f;
const int nMinDelta = Max( 0, gpGlobals->tickcount - nCmdMaxTickDelta );
const int nMaxDelta = gpGlobals->tickcount + nCmdMaxTickDelta;
bool bValid = ( pCmd->tick_count >= nMinDelta && pCmd->tick_count < nMaxDelta ) &&
// Prevent clients from sending invalid view angles to try to get leaf server code to crash
( pCmd->viewangles.IsValid() && IsEntityQAngleReasonable( pCmd->viewangles ) ) &&
// Movement ranges
( IsFinite( pCmd->forwardmove ) && IsEntityCoordinateReasonable( pCmd->forwardmove ) ) &&
( IsFinite( pCmd->sidemove ) && IsEntityCoordinateReasonable( pCmd->sidemove ) ) &&
( IsFinite( pCmd->upmove ) && IsEntityCoordinateReasonable( pCmd->upmove ) );
int nWarningLevel = sv_player_display_usercommand_errors.GetInt();
if ( !bValid && nWarningLevel > 0 )
{
DevMsg( "UserCommand out-of-range for userid %i\n", GetUserID() );
if ( nWarningLevel == 2 )
{
DevMsg( " tick_count: %i\n viewangles: %5.2f %5.2f %5.2f \n forward: %5.2f \n side: \t%5.2f \n up: \t%5.2f\n",
pCmd->tick_count,
pCmd->viewangles.x,
pCmd->viewangles.y,
pCmd->viewangles.x,
pCmd->forwardmove,
pCmd->sidemove,
pCmd->upmove );
}
}
return bValid;
}
void CBasePlayer::DumpPerfToRecipient( CBasePlayer *pRecipient, int nMaxRecords )
{
if ( !pRecipient )
return;
char buf[ 256 ] = { 0 };
int curpos = 0;
int nDumped = 0;
Vector prevo( 0, 0, 0 );
float prevt = 0.0f;
for ( int i = m_vecPlayerSimInfo.Tail(); i != m_vecPlayerSimInfo.InvalidIndex() ; i = m_vecPlayerSimInfo.Previous( i ) )
{
const CPlayerSimInfo *pi = &m_vecPlayerSimInfo[ i ];
float vel = 0.0f;
// Note we're walking from newest backward
float dt = prevt - pi->m_flFinalSimulationTime;
if ( nDumped > 0 && dt > 0.0f )
{
Vector d = pi->m_vecAbsOrigin - prevo;
vel = d.Length() / dt;
}
char line[ 128 ];
int len = Q_snprintf( line, sizeof( line ), "%.3f %d %d %.3f %.3f vel %.2f\n",
pi->m_flTime,
pi->m_nNumCmds,
pi->m_nTicksCorrected,
pi->m_flFinalSimulationTime,
pi->m_flGameSimulationTime,
vel );
if ( curpos + len > 200 )
{
ClientPrint( pRecipient, HUD_PRINTCONSOLE, (char const *)buf );
buf[ 0 ] = 0;
curpos = 0;
}
Q_strncpy( &buf[ curpos ], line, sizeof( buf ) - curpos );
curpos += len;
++nDumped;
if ( nMaxRecords != -1 && nDumped >= nMaxRecords )
break;
prevo = pi->m_vecAbsOrigin;
prevt = pi->m_flFinalSimulationTime;
}
if ( curpos > 0 )
{
ClientPrint( pRecipient, HUD_PRINTCONSOLE, buf );
}
nDumped = 0;
curpos = 0;
for ( int i = m_vecPlayerCmdInfo.Tail(); i != m_vecPlayerCmdInfo.InvalidIndex() ; i = m_vecPlayerCmdInfo.Previous( i ) )
{
const CPlayerCmdInfo *pi = &m_vecPlayerCmdInfo[ i ];
char line[ 128 ];
int len = Q_snprintf( line, sizeof( line ), "%.3f %d %d\n",
pi->m_flTime,
pi->m_nNumCmds,
pi->m_nDroppedPackets );
if ( curpos + len > 200 )
{
ClientPrint( pRecipient, HUD_PRINTCONSOLE, (char const *)buf );
buf[ 0 ] = 0;
curpos = 0;
}
Q_strncpy( &buf[ curpos ], line, sizeof( buf ) - curpos );
curpos += len;
++nDumped;
if ( nMaxRecords != -1 && nDumped >= nMaxRecords )
break;
}
if ( curpos > 0 )
{
ClientPrint( pRecipient, HUD_PRINTCONSOLE, buf );
}
}
// Duck debouncing code to stop menu changes from disallowing crouch/uncrouch
ConVar xc_crouch_debounce( "xc_crouch_debounce", "0", FCVAR_NONE );
//-----------------------------------------------------------------------------
// Purpose:
// Input : *ucmd -
// *moveHelper -
//-----------------------------------------------------------------------------
void CBasePlayer::PlayerRunCommand(CUserCmd *ucmd, IMoveHelper *moveHelper)
{
m_touchedPhysObject = false;
if ( pl.fixangle == FIXANGLE_NONE)
{
VectorCopy ( ucmd->viewangles, pl.v_angle );
}
// Handle FL_FROZEN.
// Prevent player moving for some seconds after New Game, so that they pick up everything
if( GetFlags() & FL_FROZEN ||
(developer.GetInt() == 0 && gpGlobals->eLoadType == MapLoad_NewGame && gpGlobals->curtime < 3.0 ) )
{
ucmd->forwardmove = 0;
ucmd->sidemove = 0;
ucmd->upmove = 0;
ucmd->buttons = 0;
ucmd->impulse = 0;
VectorCopy ( pl.v_angle, ucmd->viewangles );
}
else
{
// Force a duck if we're toggled
if ( GetToggledDuckState() )
{
// If this is set, we've altered our menu options and need to debounce the duck
if ( xc_crouch_debounce.GetBool() )
{
ToggleDuck();
// Mark it as handled
xc_crouch_debounce.SetValue( 0 );
}
else
{
ucmd->buttons |= IN_DUCK;
}
}
}
PlayerMove()->RunCommand(this, ucmd, moveHelper);
}
//-----------------------------------------------------------------------------
// Purpose: Strips off IN_xxx flags from the player's input
//-----------------------------------------------------------------------------
void CBasePlayer::DisableButtons( int nButtons )
{
m_afButtonDisabled |= nButtons;
}
//-----------------------------------------------------------------------------
// Purpose: Re-enables stripped IN_xxx flags to the player's input
//-----------------------------------------------------------------------------
void CBasePlayer::EnableButtons( int nButtons )
{
m_afButtonDisabled &= ~nButtons;
}
//-----------------------------------------------------------------------------
// Purpose: Strips off IN_xxx flags from the player's input
//-----------------------------------------------------------------------------
void CBasePlayer::ForceButtons( int nButtons )
{
m_afButtonForced |= nButtons;
}
//-----------------------------------------------------------------------------
// Purpose: Re-enables stripped IN_xxx flags to the player's input
//-----------------------------------------------------------------------------
void CBasePlayer::UnforceButtons( int nButtons )
{
m_afButtonForced &= ~nButtons;
}
void CBasePlayer::HandleFuncTrain(void)
{
if ( m_afPhysicsFlags & PFLAG_DIROVERRIDE )
AddFlag( FL_ONTRAIN );
else
RemoveFlag( FL_ONTRAIN );
// Train speed control
if (( m_afPhysicsFlags & PFLAG_DIROVERRIDE ) == 0)
{
if (m_iTrain & TRAIN_ACTIVE)
{
m_iTrain = TRAIN_NEW; // turn off train
}
return;
}
CBaseEntity *pTrain = GetGroundEntity();
float vel;
if ( pTrain )
{
if ( !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) )
pTrain = NULL;
}
if ( !pTrain )
{
if ( GetActiveWeapon()->ObjectCaps() & FCAP_DIRECTIONAL_USE )
{
m_iTrain = TRAIN_ACTIVE | TRAIN_NEW;
if ( m_nButtons & IN_FORWARD )
{
m_iTrain |= TRAIN_FAST;
}
else if ( m_nButtons & IN_BACK )
{
m_iTrain |= TRAIN_BACK;
}
else
{
m_iTrain |= TRAIN_NEUTRAL;
}
return;
}
else
{
trace_t trainTrace;
// Maybe this is on the other side of a level transition
UTIL_TraceLine( GetAbsOrigin(), GetAbsOrigin() + Vector(0,0,-38),
MASK_PLAYERSOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &trainTrace );
if ( trainTrace.fraction != 1.0 && trainTrace.m_pEnt )
pTrain = trainTrace.m_pEnt;
if ( !pTrain || !(pTrain->ObjectCaps() & FCAP_DIRECTIONAL_USE) || !pTrain->OnControls(this) )
{
m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE;
m_iTrain = TRAIN_NEW|TRAIN_OFF;
return;
}
}
}
else if ( !( GetFlags() & FL_ONGROUND ) || pTrain->HasSpawnFlags( SF_TRACKTRAIN_NOCONTROL ) || (m_nButtons & (IN_MOVELEFT|IN_MOVERIGHT) ) )
{
// Turn off the train if you jump, strafe, or the train controls go dead
m_afPhysicsFlags &= ~PFLAG_DIROVERRIDE;
m_iTrain = TRAIN_NEW|TRAIN_OFF;
return;
}
SetAbsVelocity( vec3_origin );
vel = 0;
if ( m_afButtonPressed & IN_FORWARD )
{
vel = 1;
pTrain->Use( this, this, USE_SET, (float)vel );
}
else if ( m_afButtonPressed & IN_BACK )
{
vel = -1;
pTrain->Use( this, this, USE_SET, (float)vel );
}
if (vel)
{
m_iTrain = TrainSpeed(pTrain->m_flSpeed, ((CFuncTrackTrain*)pTrain)->GetMaxSpeed());
m_iTrain |= TRAIN_ACTIVE|TRAIN_NEW;
}
}
void CBasePlayer::PreThink(void)
{
if ( g_fGameOver || m_iPlayerLocked )
return; // intermission or finale
if ( Hints() )
{
Hints()->Update();
}
ItemPreFrame( );
WaterMove();
if ( g_pGameRules && g_pGameRules->FAllowFlashlight() )
m_Local.m_iHideHUD &= ~HIDEHUD_FLASHLIGHT;
else
m_Local.m_iHideHUD |= HIDEHUD_FLASHLIGHT;
// checks if new client data (for HUD and view control) needs to be sent to the client
UpdateClientData();
CheckTimeBasedDamage();
CheckSuitUpdate();
if ( GetObserverMode() > OBS_MODE_FREEZECAM )
{
CheckObserverSettings(); // do this each frame
}
if ( m_lifeState >= LIFE_DYING )
{
// track where we are in the nav mesh even when dead
UpdateLastKnownArea();
return;
}
HandleFuncTrain();
if (m_nButtons & IN_JUMP)
{
// If on a ladder, jump off the ladder
// else Jump
Jump();
}
// If trying to duck, already ducked, or in the process of ducking
if ((m_nButtons & IN_DUCK) || (GetFlags() & FL_DUCKING) || (m_afPhysicsFlags & PFLAG_DUCKING) )
Duck();
//
// If we're not on the ground, we're falling. Update our falling velocity.
//
if ( !( GetFlags() & FL_ONGROUND ) )
{
m_Local.m_flFallVelocity = -GetAbsVelocity().z;
}
// track where we are in the nav mesh
UpdateLastKnownArea();
// StudioFrameAdvance( );//!!!HACKHACK!!! Can't be hit by traceline when not animating?
}
/* Time based Damage works as follows:
1) There are several types of timebased damage:
#define DMG_PARALYZE (1 << 14) // slows affected creature down
#define DMG_NERVEGAS (1 << 15) // nerve toxins, very bad
#define DMG_POISON (1 << 16) // blood poisioning
#define DMG_RADIATION (1 << 17) // radiation exposure
#define DMG_DROWNRECOVER (1 << 18) // drown recovery
#define DMG_ACID (1 << 19) // toxic chemicals or acid burns
#define DMG_SLOWBURN (1 << 20) // in an oven
2) A new hit inflicting tbd restarts the tbd counter - each NPC has an 8bit counter,
per damage type. The counter is decremented every second, so the maximum time
an effect will last is 255/60 = 4.25 minutes. Of course, staying within the radius
of a damaging effect like fire, nervegas, radiation will continually reset the counter to max.
3) Every second that a tbd counter is running, the player takes damage. The damage
is determined by the type of tdb.
Paralyze - 1/2 movement rate, 30 second duration.
Nervegas - 5 points per second, 16 second duration = 80 points max dose.
Poison - 2 points per second, 25 second duration = 50 points max dose.
Radiation - 1 point per second, 50 second duration = 50 points max dose.
Drown - 5 points per second, 2 second duration.
Acid/Chemical - 5 points per second, 10 second duration = 50 points max.
Burn - 10 points per second, 2 second duration.
Freeze - 3 points per second, 10 second duration = 30 points max.
4) Certain actions or countermeasures counteract the damaging effects of tbds:
Armor/Heater/Cooler - Chemical(acid),burn, freeze all do damage to armor power, then to body
- recharged by suit recharger
Air In Lungs - drowning damage is done to air in lungs first, then to body
- recharged by poking head out of water
- 10 seconds if swiming fast
Air In SCUBA - drowning damage is done to air in tanks first, then to body
- 2 minutes in tanks. Need new tank once empty.
Radiation Syringe - Each syringe full provides protection vs one radiation dosage
Antitoxin Syringe - Each syringe full provides protection vs one poisoning (nervegas or poison).
Health kit - Immediate stop to acid/chemical, fire or freeze damage.
Radiation Shower - Immediate stop to radiation damage, acid/chemical or fire damage.
*/
// If player is taking time based damage, continue doing damage to player -
// this simulates the effect of being poisoned, gassed, dosed with radiation etc -
// anything that continues to do damage even after the initial contact stops.
// Update all time based damage counters, and shut off any that are done.
// The m_bitsDamageType bit MUST be set if any damage is to be taken.
// This routine will detect the initial on value of the m_bitsDamageType
// and init the appropriate counter. Only processes damage every second.
//#define PARALYZE_DURATION 30 // number of 2 second intervals to take damage
//#define PARALYZE_DAMAGE 0.0 // damage to take each 2 second interval
//#define NERVEGAS_DURATION 16
//#define NERVEGAS_DAMAGE 5.0
//#define POISON_DURATION 25
//#define POISON_DAMAGE 2.0
//#define RADIATION_DURATION 50
//#define RADIATION_DAMAGE 1.0
//#define ACID_DURATION 10
//#define ACID_DAMAGE 5.0
//#define SLOWBURN_DURATION 2
//#define SLOWBURN_DAMAGE 1.0
//#define SLOWFREEZE_DURATION 1.0
//#define SLOWFREEZE_DAMAGE 3.0
/* */
void CBasePlayer::CheckTimeBasedDamage()
{
int i;
byte bDuration = 0;
static float gtbdPrev = 0.0;
// If we don't have any time based damage return.
if ( !g_pGameRules->Damage_IsTimeBased( m_bitsDamageType ) )
return;
// only check for time based damage approx. every 2 seconds
if ( abs( gpGlobals->curtime - m_tbdPrev ) < 2.0 )
return;
m_tbdPrev = gpGlobals->curtime;
for (i = 0; i < CDMG_TIMEBASED; i++)
{
// Make sure the damage type is really time-based.
// This is kind of hacky but necessary until we setup DamageType as an enum.
int iDamage = ( DMG_PARALYZE << i );
if ( !g_pGameRules->Damage_IsTimeBased( iDamage ) )
continue;
// make sure bit is set for damage type
if ( m_bitsDamageType & iDamage )
{
switch (i)
{
case itbd_Paralyze:
// UNDONE - flag movement as half-speed
bDuration = PARALYZE_DURATION;
break;
case itbd_NerveGas:
// OnTakeDamage(pev, pev, NERVEGAS_DAMAGE, DMG_GENERIC);
bDuration = NERVEGAS_DURATION;
break;
// case itbd_Poison:
// OnTakeDamage( CTakeDamageInfo( this, this, POISON_DAMAGE, DMG_GENERIC ) );
// bDuration = POISON_DURATION;
// break;
case itbd_Radiation:
// OnTakeDamage(pev, pev, RADIATION_DAMAGE, DMG_GENERIC);
bDuration = RADIATION_DURATION;
break;
case itbd_DrownRecover:
// NOTE: this hack is actually used to RESTORE health
// after the player has been drowning and finally takes a breath
if (m_idrowndmg > m_idrownrestored)
{
int idif = MIN(m_idrowndmg - m_idrownrestored, 10);
TakeHealth(idif, DMG_GENERIC);
m_idrownrestored += idif;
}
bDuration = 4; // get up to 5*10 = 50 points back
break;
case itbd_PoisonRecover:
{
// NOTE: this hack is actually used to RESTORE health
// after the player has been poisoned.
if (m_nPoisonDmg > m_nPoisonRestored)
{
int nDif = MIN(m_nPoisonDmg - m_nPoisonRestored, 10);
TakeHealth(nDif, DMG_GENERIC);
m_nPoisonRestored += nDif;
}
bDuration = 9; // get up to 10*10 = 100 points back
break;
}
case itbd_Acid:
// OnTakeDamage(pev, pev, ACID_DAMAGE, DMG_GENERIC);
bDuration = ACID_DURATION;
break;
case itbd_SlowBurn:
// OnTakeDamage(pev, pev, SLOWBURN_DAMAGE, DMG_GENERIC);
bDuration = SLOWBURN_DURATION;
break;
case itbd_SlowFreeze:
// OnTakeDamage(pev, pev, SLOWFREEZE_DAMAGE, DMG_GENERIC);
bDuration = SLOWFREEZE_DURATION;
break;
default:
bDuration = 0;
}
if (m_rgbTimeBasedDamage[i])
{
// decrement damage duration, detect when done.
if (!m_rgbTimeBasedDamage[i] || --m_rgbTimeBasedDamage[i] == 0)
{
m_rgbTimeBasedDamage[i] = 0;
// if we're done, clear damage bits
m_bitsDamageType &= ~(DMG_PARALYZE << i);
}
}
else
// first time taking this damage type - init damage duration
m_rgbTimeBasedDamage[i] = bDuration;
}
}
}
/*
THE POWER SUIT
The Suit provides 3 main functions: Protection, Notification and Augmentation.
Some functions are automatic, some require power.
The player gets the suit shortly after getting off the train in C1A0 and it stays
with him for the entire game.
Protection
Heat/Cold
When the player enters a hot/cold area, the heating/cooling indicator on the suit
will come on and the battery will drain while the player stays in the area.
After the battery is dead, the player starts to take damage.
This feature is built into the suit and is automatically engaged.
Radiation Syringe
This will cause the player to be immune from the effects of radiation for N seconds. Single use item.
Anti-Toxin Syringe
This will cure the player from being poisoned. Single use item.
Health
Small (1st aid kits, food, etc.)
Large (boxes on walls)
Armor
The armor works using energy to create a protective field that deflects a
percentage of damage projectile and explosive attacks. After the armor has been deployed,
it will attempt to recharge itself to full capacity with the energy reserves from the battery.
It takes the armor N seconds to fully charge.
Notification (via the HUD)
x Health
x Ammo
x Automatic Health Care
Notifies the player when automatic healing has been engaged.
x Geiger counter
Classic Geiger counter sound and status bar at top of HUD
alerts player to dangerous levels of radiation. This is not visible when radiation levels are normal.
x Poison
Armor
Displays the current level of armor.
Augmentation
Reanimation (w/adrenaline)
Causes the player to come back to life after he has been dead for 3 seconds.
Will not work if player was gibbed. Single use.
Long Jump
Used by hitting the ??? key(s). Caused the player to further than normal.
SCUBA
Used automatically after picked up and after player enters the water.
Works for N seconds. Single use.
Things powered by the battery
Armor
Uses N watts for every M units of damage.
Heat/Cool
Uses N watts for every second in hot/cold area.
Long Jump
Uses N watts for every jump.
Alien Cloak
Uses N watts for each use. Each use lasts M seconds.
Alien Shield
Augments armor. Reduces Armor drain by one half
*/
// if in range of radiation source, ping geiger counter
#define GEIGERDELAY 0.25
void CBasePlayer::UpdateGeigerCounter( void )
{
byte range;
// delay per update ie: don't flood net with these msgs
if (gpGlobals->curtime < m_flgeigerDelay)
return;
m_flgeigerDelay = gpGlobals->curtime + GEIGERDELAY;
// send range to radition source to client
range = (byte) clamp(Floor2Int(m_flgeigerRange / 4), 0, 255);
// This is to make sure you aren't driven crazy by geiger while in the airboat
if ( IsInAVehicle() )
{
range = clamp( (int)range * 4, 0, 255 );
}
if (range != m_igeigerRangePrev)
{
m_igeigerRangePrev = range;
CSingleUserRecipientFilter user( this );
user.MakeReliable();
UserMessageBegin( user, "Geiger" );
WRITE_BYTE( range );
MessageEnd();
}
// reset counter and semaphore
if (!random->RandomInt(0,3))
{
m_flgeigerRange = 1000;
}
}
/*
================
CheckSuitUpdate
Play suit update if it's time
================
*/
#define SUITUPDATETIME 3.5
#define SUITFIRSTUPDATETIME 0.1
void CBasePlayer::CheckSuitUpdate()
{
int i;
int isentence = 0;
int isearch = m_iSuitPlayNext;
// Ignore suit updates if no suit
if ( !IsSuitEquipped() )
return;
// if in range of radiation source, ping geiger counter
UpdateGeigerCounter();
if ( g_pGameRules->IsMultiplayer() )
{
// don't bother updating HEV voice in multiplayer.
return;
}
if ( gpGlobals->curtime >= m_flSuitUpdate && m_flSuitUpdate > 0)
{
// play a sentence off of the end of the queue
for (i = 0; i < CSUITPLAYLIST; i++)
{
if ((isentence = m_rgSuitPlayList[isearch]) != 0)
break;
if (++isearch == CSUITPLAYLIST)
isearch = 0;
}
if (isentence)
{
m_rgSuitPlayList[isearch] = 0;
if (isentence > 0)
{
// play sentence number
char sentence[512];
Q_snprintf( sentence, sizeof( sentence ), "!%s", engine->SentenceNameFromIndex( isentence ) );
UTIL_EmitSoundSuit( edict(), sentence );
}
else
{
// play sentence group
UTIL_EmitGroupIDSuit(edict(), -isentence);
}
m_flSuitUpdate = gpGlobals->curtime + SUITUPDATETIME;
}
else
// queue is empty, don't check
m_flSuitUpdate = 0;
}
}
// add sentence to suit playlist queue. if fgroup is true, then
// name is a sentence group (HEV_AA), otherwise name is a specific
// sentence name ie: !HEV_AA0. If iNoRepeat is specified in
// seconds, then we won't repeat playback of this word or sentence
// for at least that number of seconds.
void CBasePlayer::SetSuitUpdate(const char *name, int fgroup, int iNoRepeatTime)
{
int i;
int isentence;
int iempty = -1;
// Ignore suit updates if no suit
if ( !IsSuitEquipped() )
return;
if ( g_pGameRules->IsMultiplayer() )
{
// due to static channel design, etc. We don't play HEV sounds in multiplayer right now.
return;
}
// if name == NULL, then clear out the queue
if (!name)
{
for (i = 0; i < CSUITPLAYLIST; i++)
m_rgSuitPlayList[i] = 0;
return;
}
// get sentence or group number
if (!fgroup)
{
isentence = SENTENCEG_Lookup(name); // Lookup sentence index (not group) by name
if (isentence < 0)
return;
}
else
// mark group number as negative
isentence = -SENTENCEG_GetIndex(name); // Lookup group index by name
// check norepeat list - this list lets us cancel
// the playback of words or sentences that have already
// been played within a certain time.
for (i = 0; i < CSUITNOREPEAT; i++)
{
if (isentence == m_rgiSuitNoRepeat[i])
{
// this sentence or group is already in
// the norepeat list
if (m_rgflSuitNoRepeatTime[i] < gpGlobals->curtime)
{
// norepeat time has expired, clear it out
m_rgiSuitNoRepeat[i] = 0;
m_rgflSuitNoRepeatTime[i] = 0.0;
iempty = i;
break;
}
else
{
// don't play, still marked as norepeat
return;
}
}
// keep track of empty slot
if (!m_rgiSuitNoRepeat[i])
iempty = i;
}
// sentence is not in norepeat list, save if norepeat time was given
if (iNoRepeatTime)
{
if (iempty < 0)
iempty = random->RandomInt(0, CSUITNOREPEAT-1); // pick random slot to take over
m_rgiSuitNoRepeat[iempty] = isentence;
m_rgflSuitNoRepeatTime[iempty] = iNoRepeatTime + gpGlobals->curtime;
}
// find empty spot in queue, or overwrite last spot
m_rgSuitPlayList[m_iSuitPlayNext++] = isentence;
if (m_iSuitPlayNext == CSUITPLAYLIST)
m_iSuitPlayNext = 0;
if (m_flSuitUpdate <= gpGlobals->curtime)
{
if (m_flSuitUpdate == 0)
// play queue is empty, don't delay too long before playback
m_flSuitUpdate = gpGlobals->curtime + SUITFIRSTUPDATETIME;
else
m_flSuitUpdate = gpGlobals->curtime + SUITUPDATETIME;
}
}
//=========================================================
// UpdatePlayerSound - updates the position of the player's
// reserved sound slot in the sound list.
//=========================================================
void CBasePlayer::UpdatePlayerSound ( void )
{
int iBodyVolume;
int iVolume;
CSound *pSound;
pSound = CSoundEnt::SoundPointerForIndex( CSoundEnt::ClientSoundIndex( edict() ) );
if ( !pSound )
{
Msg( "Client lost reserved sound!\n" );
return;
}
if (GetFlags() & FL_NOTARGET)
{
pSound->m_iVolume = 0;
return;
}
// now figure out how loud the player's movement is.
if ( GetFlags() & FL_ONGROUND )
{
iBodyVolume = GetAbsVelocity().Length();
// clamp the noise that can be made by the body, in case a push trigger,
// weapon recoil, or anything shoves the player abnormally fast.
// NOTE: 512 units is a pretty large radius for a sound made by the player's body.
// then again, I think some materials are pretty loud.
if ( iBodyVolume > 512 )
{
iBodyVolume = 512;
}
}
else
{
iBodyVolume = 0;
}
if ( m_nButtons & IN_JUMP )
{
// Jumping is a little louder.
iBodyVolume += 100;
}
m_iTargetVolume = iBodyVolume;
// if target volume is greater than the player sound's current volume, we paste the new volume in
// immediately. If target is less than the current volume, current volume is not set immediately to the
// lower volume, rather works itself towards target volume over time. This gives NPCs a much better chance
// to hear a sound, especially if they don't listen every frame.
iVolume = pSound->Volume();
if ( m_iTargetVolume > iVolume )
{
iVolume = m_iTargetVolume;
}
else if ( iVolume > m_iTargetVolume )
{
iVolume -= 250 * gpGlobals->frametime;
if ( iVolume < m_iTargetVolume )
{
iVolume = 0;
}
}
if ( pSound )
{
pSound->SetSoundOrigin( GetAbsOrigin() );
pSound->m_iType = SOUND_PLAYER;
pSound->m_iVolume = iVolume;
}
// Below are a couple of useful little bits that make it easier to visualize just how much noise the
// player is making.
//Vector forward = UTIL_YawToVector( pl.v_angle.y );
//UTIL_Sparks( GetAbsOrigin() + forward * iVolume );
//Msg( "%d/%d\n", iVolume, m_iTargetVolume );
}
// This is a glorious hack to find free space when you've crouched into some solid space
// Our crouching collisions do not work correctly for some reason and this is easier
// than fixing the problem :(
void FixPlayerCrouchStuck( CBasePlayer *pPlayer )
{
trace_t trace;
// Move up as many as 18 pixels if the player is stuck.
int i;
Vector org = pPlayer->GetAbsOrigin();;
for ( i = 0; i < 18; i++ )
{
UTIL_TraceHull( pPlayer->GetAbsOrigin(), pPlayer->GetAbsOrigin(),
VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( trace.startsolid )
{
Vector origin = pPlayer->GetAbsOrigin();
origin.z += 1.0f;
pPlayer->SetLocalOrigin( origin );
}
else
return;
}
pPlayer->SetAbsOrigin( org );
for ( i = 0; i < 18; i++ )
{
UTIL_TraceHull( pPlayer->GetAbsOrigin(), pPlayer->GetAbsOrigin(),
VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX, MASK_PLAYERSOLID, pPlayer, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( trace.startsolid )
{
Vector origin = pPlayer->GetAbsOrigin();
origin.z -= 1.0f;
pPlayer->SetLocalOrigin( origin );
}
else
return;
}
}
#define SMOOTHING_FACTOR 0.9
extern CMoveData *g_pMoveData;
// UNDONE: Look and see if the ground entity is in hierarchy with a MOVETYPE_VPHYSICS?
// Behavior in that case is not as good currently when the parent is rideable
bool CBasePlayer::IsRideablePhysics( IPhysicsObject *pPhysics )
{
if ( pPhysics )
{
if ( pPhysics->GetMass() > (VPhysicsGetObject()->GetMass()*2) )
return true;
}
return false;
}
IPhysicsObject *CBasePlayer::GetGroundVPhysics()
{
CBaseEntity *pGroundEntity = GetGroundEntity();
if ( pGroundEntity && pGroundEntity->GetMoveType() == MOVETYPE_VPHYSICS )
{
IPhysicsObject *pPhysGround = pGroundEntity->VPhysicsGetObject();
if ( pPhysGround && pPhysGround->IsMoveable() )
return pPhysGround;
}
return NULL;
}
//-----------------------------------------------------------------------------
// For debugging...
//-----------------------------------------------------------------------------
void CBasePlayer::ForceOrigin( const Vector &vecOrigin )
{
m_bForceOrigin = true;
m_vForcedOrigin = vecOrigin;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::PostThink()
{
m_vecSmoothedVelocity = m_vecSmoothedVelocity * SMOOTHING_FACTOR + GetAbsVelocity() * ( 1 - SMOOTHING_FACTOR );
if ( !g_fGameOver && !m_iPlayerLocked )
{
if ( IsAlive() )
{
// set correct collision bounds (may have changed in player movement code)
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-Bounds" );
if ( GetFlags() & FL_DUCKING )
{
SetCollisionBounds( VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX );
}
else
{
SetCollisionBounds( VEC_HULL_MIN, VEC_HULL_MAX );
}
VPROF_SCOPE_END();
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-Use" );
// Handle controlling an entity
if ( m_hUseEntity != NULL )
{
// if they've moved too far from the gun, or deployed another weapon, unuse the gun
if ( m_hUseEntity->OnControls( this ) &&
( !GetActiveWeapon() || GetActiveWeapon()->IsEffectActive( EF_NODRAW ) ||
( GetActiveWeapon()->GetActivity() == ACT_VM_HOLSTER )
#ifdef PORTAL // Portalgun view model stays up when holding an object -Jeep
|| FClassnameIs( GetActiveWeapon(), "weapon_portalgun" )
#endif //#ifdef PORTAL
) )
{
m_hUseEntity->Use( this, this, USE_SET, 2 ); // try fire the gun
}
else
{
// they've moved off the controls
ClearUseEntity();
}
}
VPROF_SCOPE_END();
// do weapon stuff
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-ItemPostFrame" );
ItemPostFrame();
VPROF_SCOPE_END();
if ( GetFlags() & FL_ONGROUND )
{
if (m_Local.m_flFallVelocity > 64 && !g_pGameRules->IsMultiplayer())
{
CSoundEnt::InsertSound ( SOUND_PLAYER, GetAbsOrigin(), m_Local.m_flFallVelocity, 0.2, this );
// Msg( "fall %f\n", m_Local.m_flFallVelocity );
}
m_Local.m_flFallVelocity = 0;
}
// select the proper animation for the player character
VPROF( "CBasePlayer::PostThink-Animation" );
// If he's in a vehicle, sit down
if ( IsInAVehicle() )
SetAnimation( PLAYER_IN_VEHICLE );
else if (!GetAbsVelocity().x && !GetAbsVelocity().y)
SetAnimation( PLAYER_IDLE );
else if ((GetAbsVelocity().x || GetAbsVelocity().y) && ( GetFlags() & FL_ONGROUND ))
SetAnimation( PLAYER_WALK );
else if (GetWaterLevel() > 1)
SetAnimation( PLAYER_WALK );
}
// Don't allow bogus sequence on player
if ( GetSequence() == -1 )
{
SetSequence( 0 );
}
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-StudioFrameAdvance" );
StudioFrameAdvance();
VPROF_SCOPE_END();
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-DispatchAnimEvents" );
DispatchAnimEvents( this );
VPROF_SCOPE_END();
SetSimulationTime( gpGlobals->curtime );
//Let the weapon update as well
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-Weapon_FrameUpdate" );
Weapon_FrameUpdate();
VPROF_SCOPE_END();
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-UpdatePlayerSound" );
UpdatePlayerSound();
VPROF_SCOPE_END();
if ( m_bForceOrigin )
{
SetLocalOrigin( m_vForcedOrigin );
SetLocalAngles( m_Local.m_vecPunchAngle );
m_Local.m_vecPunchAngle = RandomAngle( -25, 25 );
m_Local.m_vecPunchAngleVel.Init();
}
VPROF_SCOPE_BEGIN( "CBasePlayer::PostThink-PostThinkVPhysics" );
PostThinkVPhysics();
VPROF_SCOPE_END();
}
#if !defined( NO_ENTITY_PREDICTION )
// Even if dead simulate entities
SimulatePlayerSimulatedEntities();
#endif
}
// handles touching physics objects
void CBasePlayer::Touch( CBaseEntity *pOther )
{
if ( pOther == GetGroundEntity() )
return;
if ( pOther->GetMoveType() != MOVETYPE_VPHYSICS || pOther->GetSolid() != SOLID_VPHYSICS || (pOther->GetSolidFlags() & FSOLID_TRIGGER) )
return;
IPhysicsObject *pPhys = pOther->VPhysicsGetObject();
if ( !pPhys || !pPhys->IsMoveable() )
return;
SetTouchedPhysics( true );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::PostThinkVPhysics( void )
{
// Check to see if things are initialized!
if ( !m_pPhysicsController )
return;
Vector newPosition = GetAbsOrigin();
float frametime = gpGlobals->frametime;
if ( frametime <= 0 || frametime > 0.1f )
frametime = 0.1f;
IPhysicsObject *pPhysGround = GetGroundVPhysics();
if ( !pPhysGround && m_touchedPhysObject && g_pMoveData->m_outStepHeight <= 0.f && (GetFlags() & FL_ONGROUND) )
{
newPosition = m_oldOrigin + frametime * g_pMoveData->m_outWishVel;
newPosition = (GetAbsOrigin() * 0.5f) + (newPosition * 0.5f);
}
int collisionState = VPHYS_WALK;
if ( GetMoveType() == MOVETYPE_NOCLIP || GetMoveType() == MOVETYPE_OBSERVER )
{
collisionState = VPHYS_NOCLIP;
}
else if ( GetFlags() & FL_DUCKING )
{
collisionState = VPHYS_CROUCH;
}
if ( collisionState != m_vphysicsCollisionState )
{
SetVCollisionState( GetAbsOrigin(), GetAbsVelocity(), collisionState );
}
if ( !(TouchedPhysics() || pPhysGround) )
{
float maxSpeed = m_flMaxspeed > 0.0f ? m_flMaxspeed : sv_maxspeed.GetFloat();
g_pMoveData->m_outWishVel.Init( maxSpeed, maxSpeed, maxSpeed );
}
// teleport the physics object up by stepheight (game code does this - reflect in the physics)
if ( g_pMoveData->m_outStepHeight > 0.1f )
{
if ( g_pMoveData->m_outStepHeight > 4.0f )
{
VPhysicsGetObject()->SetPosition( GetAbsOrigin(), vec3_angle, true );
}
else
{
// don't ever teleport into solid
Vector position, end;
VPhysicsGetObject()->GetPosition( &position, NULL );
end = position;
end.z += g_pMoveData->m_outStepHeight;
trace_t trace;
UTIL_TraceEntity( this, position, end, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( trace.DidHit() )
{
g_pMoveData->m_outStepHeight = trace.endpos.z - position.z;
}
m_pPhysicsController->StepUp( g_pMoveData->m_outStepHeight );
}
m_pPhysicsController->Jump();
}
g_pMoveData->m_outStepHeight = 0.0f;
// Store these off because after running the usercmds, it'll pass them
// to UpdateVPhysicsPosition.
m_vNewVPhysicsPosition = newPosition;
m_vNewVPhysicsVelocity = g_pMoveData->m_outWishVel;
m_oldOrigin = GetAbsOrigin();
}
void CBasePlayer::UpdateVPhysicsPosition( const Vector &position, const Vector &velocity, float secondsToArrival )
{
bool onground = (GetFlags() & FL_ONGROUND) ? true : false;
IPhysicsObject *pPhysGround = GetGroundVPhysics();
// if the object is much heavier than the player, treat it as a local coordinate system
// the player controller will solve movement differently in this case.
if ( !IsRideablePhysics(pPhysGround) )
{
pPhysGround = NULL;
}
m_pPhysicsController->Update( position, velocity, secondsToArrival, onground, pPhysGround );
}
void CBasePlayer::UpdatePhysicsShadowToCurrentPosition()
{
UpdateVPhysicsPosition( GetAbsOrigin(), vec3_origin, gpGlobals->frametime );
}
void CBasePlayer::UpdatePhysicsShadowToPosition( const Vector &vecAbsOrigin )
{
UpdateVPhysicsPosition( vecAbsOrigin, vec3_origin, gpGlobals->frametime );
}
Vector CBasePlayer::GetSmoothedVelocity( void )
{
if ( IsInAVehicle() )
{
return GetVehicle()->GetVehicleEnt()->GetSmoothedVelocity();
}
return m_vecSmoothedVelocity;
}
CBaseEntity *g_pLastSpawn = NULL;
//-----------------------------------------------------------------------------
// Purpose: Finds a player start entity of the given classname. If any entity of
// of the given classname has the SF_PLAYER_START_MASTER flag set, that
// is the entity that will be returned. Otherwise, the first entity of
// the given classname is returned.
// Input : pszClassName - should be "info_player_start", "info_player_coop", or
// "info_player_deathmatch"
//-----------------------------------------------------------------------------
CBaseEntity *FindPlayerStart(const char *pszClassName)
{
#define SF_PLAYER_START_MASTER 1
CBaseEntity *pStart = gEntList.FindEntityByClassname(NULL, pszClassName);
CBaseEntity *pStartFirst = pStart;
while (pStart != NULL)
{
if (pStart->HasSpawnFlags(SF_PLAYER_START_MASTER))
{
return pStart;
}
pStart = gEntList.FindEntityByClassname(pStart, pszClassName);
}
return pStartFirst;
}
/*
============
EntSelectSpawnPoint
Returns the entity to spawn at
USES AND SETS GLOBAL g_pLastSpawn
============
*/
CBaseEntity *CBasePlayer::EntSelectSpawnPoint()
{
CBaseEntity *pSpot;
edict_t *player;
player = edict();
// choose a info_player_deathmatch point
if (g_pGameRules->IsCoOp())
{
pSpot = gEntList.FindEntityByClassname( g_pLastSpawn, "info_player_coop");
if ( pSpot )
goto ReturnSpot;
pSpot = gEntList.FindEntityByClassname( g_pLastSpawn, "info_player_start");
if ( pSpot )
goto ReturnSpot;
}
else if ( g_pGameRules->IsDeathmatch() )
{
pSpot = g_pLastSpawn;
// Randomize the start spot
for ( int i = random->RandomInt(1,5); i > 0; i-- )
pSpot = gEntList.FindEntityByClassname( pSpot, "info_player_deathmatch" );
if ( !pSpot ) // skip over the null point
pSpot = gEntList.FindEntityByClassname( pSpot, "info_player_deathmatch" );
CBaseEntity *pFirstSpot = pSpot;
do
{
if ( pSpot )
{
// check if pSpot is valid
if ( g_pGameRules->IsSpawnPointValid( pSpot, this ) )
{
if ( pSpot->GetLocalOrigin() == vec3_origin )
{
pSpot = gEntList.FindEntityByClassname( pSpot, "info_player_deathmatch" );
continue;
}
// if so, go to pSpot
goto ReturnSpot;
}
}
// increment pSpot
pSpot = gEntList.FindEntityByClassname( pSpot, "info_player_deathmatch" );
} while ( pSpot != pFirstSpot ); // loop if we're not back to the start
// we haven't found a place to spawn yet, so kill any guy at the first spawn point and spawn there
if ( pSpot )
{
CBaseEntity *ent = NULL;
for ( CEntitySphereQuery sphere( pSpot->GetAbsOrigin(), 128 ); (ent = sphere.GetCurrentEntity()) != NULL; sphere.NextEntity() )
{
// if ent is a client, kill em (unless they are ourselves)
if ( ent->IsPlayer() && !(ent->edict() == player) )
ent->TakeDamage( CTakeDamageInfo( GetContainingEntity(INDEXENT(0)), GetContainingEntity(INDEXENT(0)), 300, DMG_GENERIC ) );
}
goto ReturnSpot;
}
}
// If startspot is set, (re)spawn there.
if ( !gpGlobals->startspot || !strlen(STRING(gpGlobals->startspot)))
{
pSpot = FindPlayerStart( "info_player_start" );
if ( pSpot )
goto ReturnSpot;
}
else
{
pSpot = gEntList.FindEntityByName( NULL, gpGlobals->startspot );
if ( pSpot )
goto ReturnSpot;
}
ReturnSpot:
if ( !pSpot )
{
Warning( "PutClientInServer: no info_player_start on level\n");
return CBaseEntity::Instance( INDEXENT( 0 ) );
}
g_pLastSpawn = pSpot;
return pSpot;
}
//-----------------------------------------------------------------------------
// Purpose: Called the first time the player's created
//-----------------------------------------------------------------------------
void CBasePlayer::InitialSpawn( void )
{
m_iConnected = PlayerConnected;
gamestats->Event_PlayerConnected( this );
}
//-----------------------------------------------------------------------------
// Purpose: Called everytime the player respawns
//-----------------------------------------------------------------------------
void CBasePlayer::Spawn( void )
{
// Needs to be done before weapons are given
if ( Hints() )
{
Hints()->ResetHints();
}
SetClassname( "player" );
// Shared spawning code..
SharedSpawn();
SetSimulatedEveryTick( true );
SetAnimatedEveryTick( true );
m_ArmorValue = SpawnArmorValue();
SetBlocksLOS( false );
m_iMaxHealth = m_iHealth;
// Clear all flags except for FL_FULLEDICT
if ( GetFlags() & FL_FAKECLIENT )
{
ClearFlags();
AddFlag( FL_CLIENT | FL_FAKECLIENT );
}
else
{
ClearFlags();
AddFlag( FL_CLIENT );
}
AddFlag( FL_AIMTARGET );
m_AirFinished = gpGlobals->curtime + AIRTIME;
m_nDrownDmgRate = DROWNING_DAMAGE_INITIAL;
// only preserve the shadow flag
int effects = GetEffects() & EF_NOSHADOW;
SetEffects( effects );
IncrementInterpolationFrame();
// Initialize the fog and postprocess controllers.
InitFogController();
m_DmgTake = 0;
m_DmgSave = 0;
m_bitsHUDDamage = -1;
m_bitsDamageType = 0;
m_afPhysicsFlags = 0;
m_idrownrestored = m_idrowndmg;
SetFOV( this, 0 );
m_flNextDecalTime = 0;// let this player decal as soon as he spawns.
m_flgeigerDelay = gpGlobals->curtime + 2.0; // wait a few seconds until user-defined message registrations
// are recieved by all clients
m_flFieldOfView = 0.766;// some NPCs use this to determine whether or not the player is looking at them.
m_vecAdditionalPVSOrigin = vec3_origin;
m_vecCameraPVSOrigin = vec3_origin;
if ( !m_fGameHUDInitialized )
g_pGameRules->SetDefaultPlayerTeam( this );
g_pGameRules->GetPlayerSpawnSpot( this );
m_Local.m_bDucked = false;// This will persist over round restart if you hold duck otherwise.
m_Local.m_bDucking = false;
SetViewOffset( VEC_VIEW_SCALED( this ) );
Precache();
m_bitsDamageType = 0;
m_bitsHUDDamage = -1;
SetPlayerUnderwater( false );
m_iTrain = TRAIN_NEW;
m_HackedGunPos = Vector( 0, 32, 0 );
m_iBonusChallenge = sv_bonus_challenge.GetInt();
sv_bonus_challenge.SetValue( 0 );
if ( m_iPlayerSound == SOUNDLIST_EMPTY )
{
Msg( "Couldn't alloc player sound slot!\n" );
}
SetThink(NULL);
m_fInitHUD = true;
m_fWeapon = false;
m_iClientBattery = -1;
m_lastx = m_lasty = 0;
Q_strncpy( m_szLastPlaceName.GetForModify(), "", MAX_PLACE_NAME_LENGTH );
CSingleUserRecipientFilter user( this );
enginesound->SetPlayerDSP( user, 0, false );
CreateViewModel();
SetCollisionGroup( COLLISION_GROUP_PLAYER );
// if the player is locked, make sure he stays locked
if ( m_iPlayerLocked )
{
m_iPlayerLocked = false;
LockPlayerInPlace();
}
if ( GetTeamNumber() != TEAM_SPECTATOR )
{
StopObserverMode();
}
else
{
StartObserverMode( m_iObserverLastMode );
}
StopReplayMode();
// Clear any screenfade
color32 nothing = {0,0,0,255};
UTIL_ScreenFade( this, nothing, 0, 0, FFADE_IN | FFADE_PURGE );
g_pGameRules->PlayerSpawn( this );
m_flLaggedMovementValue = 1.0f;
m_vecSmoothedVelocity = vec3_origin;
InitVCollision( GetAbsOrigin(), GetAbsVelocity() );
#if !defined( TF_DLL )
IGameEvent *event = gameeventmanager->CreateEvent( "player_spawn" );
if ( event )
{
event->SetInt("userid", GetUserID() );
gameeventmanager->FireEvent( event );
}
#endif
RumbleEffect( RUMBLE_STOP_ALL, 0, RUMBLE_FLAGS_NONE );
// Calculate this immediately
m_nVehicleViewSavedFrame = 0;
// track where we are in the nav mesh
UpdateLastKnownArea();
BaseClass::Spawn();
// track where we are in the nav mesh
UpdateLastKnownArea();
m_weaponFiredTimer.Invalidate();
}
void CBasePlayer::Activate( void )
{
BaseClass::Activate();
AimTarget_ForceRepopulateList();
RumbleEffect( RUMBLE_STOP_ALL, 0, RUMBLE_FLAGS_NONE );
// Reset the analog bias. If the player is in a vehicle when the game
// reloads, it will autosense and apply the correct bias.
m_iVehicleAnalogBias = VEHICLE_ANALOG_BIAS_NONE;
}
void CBasePlayer::Precache( void )
{
BaseClass::Precache();
PrecacheScriptSound( "Player.FallGib" );
PrecacheScriptSound( "Player.Death" );
PrecacheScriptSound( "Player.PlasmaDamage" );
PrecacheScriptSound( "Player.SonicDamage" );
PrecacheScriptSound( "Player.DrownStart" );
PrecacheScriptSound( "Player.DrownContinue" );
PrecacheScriptSound( "Player.Wade" );
PrecacheScriptSound( "Player.AmbientUnderWater" );
enginesound->PrecacheSentenceGroup( "HEV" );
// These are always needed
#ifndef TF_DLL
PrecacheParticleSystem( "slime_splash_01" );
PrecacheParticleSystem( "slime_splash_02" );
PrecacheParticleSystem( "slime_splash_03" );
#endif
// in the event that the player JUST spawned, and the level node graph
// was loaded, fix all of the node graph pointers before the game starts.
// !!!BUGBUG - now that we have multiplayer, this needs to be moved!
/* todo - put in better spot and use new ainetowrk stuff
if ( WorldGraph.m_fGraphPresent && !WorldGraph.m_fGraphPointersSet )
{
if ( !WorldGraph.FSetGraphPointers() )
{
Msg( "**Graph pointers were not set!\n");
}
else
{
Msg( "**Graph Pointers Set!\n" );
}
}
*/
// SOUNDS / MODELS ARE PRECACHED in ClientPrecache() (game specific)
// because they need to precache before any clients have connected
// init geiger counter vars during spawn and each time
// we cross a level transition
m_flgeigerRange = 1000;
m_igeigerRangePrev = 1000;
#if 0
// @Note (toml 04-19-04): These are saved, used to be slammed here
m_bitsDamageType = 0;
m_bitsHUDDamage = -1;
SetPlayerUnderwter( false );
m_iTrain = TRAIN_NEW;
#endif
m_iClientBattery = -1;
m_iUpdateTime = 5; // won't update for 1/2 a second
if ( gInitHUD )
m_fInitHUD = true;
}
//-----------------------------------------------------------------------------
// Purpose: Force this player to immediately respawn
//-----------------------------------------------------------------------------
void CBasePlayer::ForceRespawn( void )
{
RemoveAllItems( true );
// Reset ground state for airwalk animations
SetGroundEntity( NULL );
// Stop any firing that was taking place before respawn.
m_nButtons = 0;
Spawn();
}
int CBasePlayer::Save( ISave &save )
{
if ( !BaseClass::Save(save) )
return 0;
return 1;
}
// Friend class of CBaseEntity to access private member data.
class CPlayerRestoreHelper
{
public:
const Vector &GetAbsOrigin( CBaseEntity *pent )
{
return pent->m_vecAbsOrigin;
}
const Vector &GetAbsVelocity( CBaseEntity *pent )
{
return pent->m_vecAbsVelocity;
}
};
int CBasePlayer::Restore( IRestore &restore )
{
int status = BaseClass::Restore(restore);
if ( !status )
return 0;
CSaveRestoreData *pSaveData = gpGlobals->pSaveData;
// landmark isn't present.
if ( !pSaveData->levelInfo.fUseLandmark )
{
Msg( "No Landmark:%s\n", pSaveData->levelInfo.szLandmarkName );
// default to normal spawn
CBaseEntity *pSpawnSpot = EntSelectSpawnPoint();
SetLocalOrigin( pSpawnSpot->GetLocalOrigin() + Vector(0,0,1) );
SetLocalAngles( pSpawnSpot->GetLocalAngles() );
}
QAngle newViewAngles = pl.v_angle;
newViewAngles.z = 0; // Clear out roll
SetLocalAngles( newViewAngles );
SnapEyeAngles( newViewAngles );
// Copied from spawn() for now
SetBloodColor( BLOOD_COLOR_RED );
// clear this - it will get reset by touching the trigger again
m_afPhysicsFlags &= ~PFLAG_VPHYSICS_MOTIONCONTROLLER;
if ( GetFlags() & FL_DUCKING )
{
// Use the crouch HACK
FixPlayerCrouchStuck( this );
UTIL_SetSize(this, VEC_DUCK_HULL_MIN, VEC_DUCK_HULL_MAX);
m_Local.m_bDucked = true;
}
else
{
m_Local.m_bDucked = false;
UTIL_SetSize(this, VEC_HULL_MIN, VEC_HULL_MAX);
}
// We need to get at m_vecAbsOrigin as it was restored but can't let it be
// recalculated by a call to GetAbsOrigin because hierarchy isn't fully restored yet,
// so we use this backdoor to get at the private data in CBaseEntity.
CPlayerRestoreHelper helper;
InitVCollision( helper.GetAbsOrigin( this ), helper.GetAbsVelocity( this ) );
// success
return 1;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::OnRestore( void )
{
BaseClass::OnRestore();
SetViewEntity( m_hViewEntity );
SetDefaultFOV(m_iDefaultFOV); // force this to reset if zero
// Calculate this immediately
m_nVehicleViewSavedFrame = 0;
m_nBodyPitchPoseParam = LookupPoseParameter( "body_pitch" );
}
/* void CBasePlayer::SetTeamName( const char *pTeamName )
{
Q_strncpy( m_szTeamName, pTeamName, TEAM_NAME_LENGTH );
} */
void CBasePlayer::SetArmorValue( int value )
{
m_ArmorValue = value;
}
void CBasePlayer::IncrementArmorValue( int nCount, int nMaxValue )
{
m_ArmorValue += nCount;
if (nMaxValue > 0)
{
if (m_ArmorValue > nMaxValue)
m_ArmorValue = nMaxValue;
}
}
// used by the physics gun and game physics... is there a better interface?
void CBasePlayer::SetPhysicsFlag( int nFlag, bool bSet )
{
if (bSet)
m_afPhysicsFlags |= nFlag;
else
m_afPhysicsFlags &= ~nFlag;
}
void CBasePlayer::NotifyNearbyRadiationSource( float flRange )
{
// if player's current geiger counter range is larger
// than range to this trigger hurt, reset player's
// geiger counter range
if (m_flgeigerRange >= flRange)
m_flgeigerRange = flRange;
}
void CBasePlayer::AllowImmediateDecalPainting()
{
m_flNextDecalTime = gpGlobals->curtime;
}
// Suicide...
void CBasePlayer::CommitSuicide( bool bExplode /*= false*/, bool bForce /*= false*/ )
{
MDLCACHE_CRITICAL_SECTION();
if( !IsAlive() )
return;
// prevent suiciding too often
if ( m_fNextSuicideTime > gpGlobals->curtime && !bForce )
return;
// don't let them suicide for 5 seconds after suiciding
m_fNextSuicideTime = gpGlobals->curtime + 5;
int fDamage = DMG_PREVENT_PHYSICS_FORCE | ( bExplode ? ( DMG_BLAST | DMG_ALWAYSGIB ) : DMG_NEVERGIB );
// have the player kill themself
m_iHealth = 0;
CTakeDamageInfo info( this, this, 0, fDamage, m_iSuicideCustomKillFlags );
Event_Killed( info );
Event_Dying( info );
m_iSuicideCustomKillFlags = 0;
}
// Suicide with style...
void CBasePlayer::CommitSuicide( const Vector &vecForce, bool bExplode /*= false*/, bool bForce /*= false*/ )
{
MDLCACHE_CRITICAL_SECTION();
// Already dead.
if( !IsAlive() )
return;
// Prevent suicides for a time.
if ( m_fNextSuicideTime > gpGlobals->curtime && !bForce )
return;
m_fNextSuicideTime = gpGlobals->curtime + 5;
// Apply the force.
int nHealth = GetHealth();
// Kill the player.
CTakeDamageInfo info;
info.SetDamage( nHealth + 10 );
info.SetAttacker( this );
info.SetDamageType( bExplode ? DMG_ALWAYSGIB : DMG_GENERIC );
info.SetDamageForce( vecForce );
info.SetDamagePosition( WorldSpaceCenter() );
TakeDamage( info );
}
//==============================================
// HasWeapons - do I have any weapons at all?
//==============================================
bool CBasePlayer::HasWeapons( void )
{
int i;
for ( i = 0 ; i < WeaponCount() ; i++ )
{
if ( GetWeapon(i) )
{
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vecForce -
//-----------------------------------------------------------------------------
void CBasePlayer::VelocityPunch( const Vector &vecForce )
{
// Clear onground and add velocity.
SetGroundEntity( NULL );
ApplyAbsVelocityImpulse(vecForce );
}
//--------------------------------------------------------------------------------------------------------------
// VEHICLES
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Purpose: Whether or not the player is currently able to enter the vehicle
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBasePlayer::CanEnterVehicle( IServerVehicle *pVehicle, int nRole )
{
// Must not have a passenger there already
if ( pVehicle->GetPassenger( nRole ) )
return false;
// Must be able to holster our current weapon (ie. grav gun!)
if ( pVehicle->IsPassengerUsingStandardWeapons( nRole ) == false )
{
//Must be able to stow our weapon
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
if ( ( pWeapon != NULL ) && ( pWeapon->CanHolster() == false ) )
return false;
}
// Must be alive
if ( IsAlive() == false )
return false;
// Can't be pulled by a barnacle
if ( IsEFlagSet( EFL_IS_BEING_LIFTED_BY_BARNACLE ) )
return false;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Put this player in a vehicle
//-----------------------------------------------------------------------------
bool CBasePlayer::GetInVehicle( IServerVehicle *pVehicle, int nRole )
{
Assert( NULL == m_hVehicle.Get() );
Assert( nRole >= 0 );
// Make sure we can enter the vehicle
if ( CanEnterVehicle( pVehicle, nRole ) == false )
return false;
CBaseEntity *pEnt = pVehicle->GetVehicleEnt();
Assert( pEnt );
// Try to stow weapons
if ( pVehicle->IsPassengerUsingStandardWeapons( nRole ) == false )
{
CBaseCombatWeapon *pWeapon = GetActiveWeapon();
if ( pWeapon != NULL )
{
pWeapon->Holster( NULL );
}
#ifndef HL2_DLL
m_Local.m_iHideHUD |= HIDEHUD_WEAPONSELECTION;
#endif
m_Local.m_iHideHUD |= HIDEHUD_INVEHICLE;
}
if ( !pVehicle->IsPassengerVisible( nRole ) )
{
AddEffects( EF_NODRAW );
}
// Put us in the vehicle
pVehicle->SetPassenger( nRole, this );
ViewPunchReset();
// Setting the velocity to 0 will cause the IDLE animation to play
SetAbsVelocity( vec3_origin );
SetMoveType( MOVETYPE_NOCLIP );
// This is a hack to fixup the player's stats since they really didn't "cheat" and enter noclip from the console
gamestats->Event_DecrementPlayerEnteredNoClip( this );
// Get the seat position we'll be at in this vehicle
Vector vSeatOrigin;
QAngle qSeatAngles;
pVehicle->GetPassengerSeatPoint( nRole, &vSeatOrigin, &qSeatAngles );
// Set us to that position
SetAbsOrigin( vSeatOrigin );
SetAbsAngles( qSeatAngles );
// Parent to the vehicle
SetParent( pEnt );
SetCollisionGroup( COLLISION_GROUP_IN_VEHICLE );
// We cannot be ducking -- do all this before SetPassenger because it
// saves our view offset for restoration when we exit the vehicle.
RemoveFlag( FL_DUCKING );
SetViewOffset( VEC_VIEW_SCALED( this ) );
m_Local.m_bDucked = false;
m_Local.m_bDucking = false;
m_Local.m_flDucktime = 0.0f;
m_Local.m_flDuckJumpTime = 0.0f;
m_Local.m_flJumpTime = 0.0f;
// Turn our toggled duck off
if ( GetToggledDuckState() )
{
ToggleDuck();
}
m_hVehicle = pEnt;
// Throw an event indicating that the player entered the vehicle.
g_pNotify->ReportNamedEvent( this, "PlayerEnteredVehicle" );
m_iVehicleAnalogBias = VEHICLE_ANALOG_BIAS_NONE;
OnVehicleStart();
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Remove this player from a vehicle
//-----------------------------------------------------------------------------
void CBasePlayer::LeaveVehicle( const Vector &vecExitPoint, const QAngle &vecExitAngles )
{
if ( NULL == m_hVehicle.Get() )
return;
IServerVehicle *pVehicle = GetVehicle();
Assert( pVehicle );
int nRole = pVehicle->GetPassengerRole( this );
Assert( nRole >= 0 );
SetParent( NULL );
// Find the first non-blocked exit point:
Vector vNewPos = GetAbsOrigin();
QAngle qAngles = GetAbsAngles();
if ( vecExitPoint == vec3_origin )
{
// FIXME: this might fail to find a safe exit point!!
pVehicle->GetPassengerExitPoint( nRole, &vNewPos, &qAngles );
}
else
{
vNewPos = vecExitPoint;
qAngles = vecExitAngles;
}
OnVehicleEnd( vNewPos );
SetAbsOrigin( vNewPos );
SetAbsAngles( qAngles );
// Clear out any leftover velocity
SetAbsVelocity( vec3_origin );
qAngles[ROLL] = 0;
SnapEyeAngles( qAngles );
#ifndef HL2_DLL
m_Local.m_iHideHUD &= ~HIDEHUD_WEAPONSELECTION;
#endif
m_Local.m_iHideHUD &= ~HIDEHUD_INVEHICLE;
RemoveEffects( EF_NODRAW );
SetMoveType( MOVETYPE_WALK );
SetCollisionGroup( COLLISION_GROUP_PLAYER );
if ( VPhysicsGetObject() )
{
VPhysicsGetObject()->SetPosition( vNewPos, vec3_angle, true );
}
m_hVehicle = NULL;
pVehicle->SetPassenger(nRole, NULL);
// Re-deploy our weapon
if ( IsAlive() )
{
if ( GetActiveWeapon() && GetActiveWeapon()->IsWeaponVisible() == false )
{
GetActiveWeapon()->Deploy();
ShowCrosshair( true );
}
}
// Just cut all of the rumble effects.
RumbleEffect( RUMBLE_STOP_ALL, 0, RUMBLE_FLAGS_NONE );
}
//==============================================
// !!!UNDONE:ultra temporary SprayCan entity to apply
// decal frame at a time. For PreAlpha CD
//==============================================
class CSprayCan : public CPointEntity
{
public:
DECLARE_CLASS( CSprayCan, CPointEntity );
void Spawn ( CBasePlayer *pOwner );
void Think( void );
virtual void Precache();
virtual int ObjectCaps( void ) { return FCAP_DONT_SAVE; }
};
LINK_ENTITY_TO_CLASS( spraycan, CSprayCan );
PRECACHE_REGISTER( spraycan );
void CSprayCan::Spawn ( CBasePlayer *pOwner )
{
SetLocalOrigin( pOwner->WorldSpaceCenter() + Vector ( 0 , 0 , 32 ) );
SetLocalAngles( pOwner->EyeAngles() );
SetOwnerEntity( pOwner );
SetNextThink( gpGlobals->curtime );
EmitSound( "SprayCan.Paint" );
}
void CSprayCan::Precache()
{
BaseClass::Precache();
PrecacheScriptSound( "SprayCan.Paint" );
}
void CSprayCan::Think( void )
{
CBasePlayer *pPlayer = ToBasePlayer( GetOwnerEntity() );
if ( pPlayer )
{
int playernum = pPlayer->entindex();
Vector forward;
trace_t tr;
AngleVectors( GetAbsAngles(), &forward );
UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + forward * 128,
MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, & tr);
UTIL_PlayerDecalTrace( &tr, playernum );
}
// Just painted last custom frame.
UTIL_Remove( this );
}
class CBloodSplat : public CPointEntity
{
public:
DECLARE_CLASS( CBloodSplat, CPointEntity );
void Spawn ( CBaseEntity *pOwner );
void Think ( void );
};
void CBloodSplat::Spawn ( CBaseEntity *pOwner )
{
SetLocalOrigin( pOwner->WorldSpaceCenter() + Vector ( 0 , 0 , 32 ) );
SetLocalAngles( pOwner->GetLocalAngles() );
SetOwnerEntity( pOwner );
SetNextThink( gpGlobals->curtime + 0.1f );
}
void CBloodSplat::Think( void )
{
trace_t tr;
if ( g_Language.GetInt() != LANGUAGE_GERMAN )
{
CBasePlayer *pPlayer;
pPlayer = ToBasePlayer( GetOwnerEntity() );
Vector forward;
AngleVectors( GetAbsAngles(), &forward );
UTIL_TraceLine ( GetAbsOrigin(), GetAbsOrigin() + forward * 128,
MASK_SOLID_BRUSHONLY, pPlayer, COLLISION_GROUP_NONE, & tr);
UTIL_BloodDecalTrace( &tr, BLOOD_COLOR_RED );
}
UTIL_Remove( this );
}
//==============================================
//-----------------------------------------------------------------------------
// Purpose: Create and give the named item to the player. Then return it.
//-----------------------------------------------------------------------------
CBaseEntity *CBasePlayer::GiveNamedItem( const char *pszName, int iSubType )
{
// If I already own this type don't create one
if ( Weapon_OwnsThisType(pszName, iSubType) )
return NULL;
// Msg( "giving %s\n", pszName );
EHANDLE pent;
pent = CreateEntityByName(pszName);
if ( pent == NULL )
{
Msg( "NULL Ent in GiveNamedItem!\n" );
return NULL;
}
pent->SetLocalOrigin( GetLocalOrigin() );
pent->AddSpawnFlags( SF_NORESPAWN );
CBaseCombatWeapon *pWeapon = dynamic_cast<CBaseCombatWeapon*>( (CBaseEntity*)pent );
if ( pWeapon )
{
pWeapon->SetSubType( iSubType );
}
DispatchSpawn( pent );
if ( pent != NULL && !(pent->IsMarkedForDeletion()) )
{
pent->Touch( this );
}
return pent;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the nearest COLLIBALE entity in front of the player
// that has a clear line of sight with the given classname
// Input :
// Output :
//-----------------------------------------------------------------------------
CBaseEntity *FindEntityClassForward( CBasePlayer *pMe, char *classname )
{
trace_t tr;
Vector forward;
pMe->EyeVectors( &forward );
UTIL_TraceLine(pMe->EyePosition(),
pMe->EyePosition() + forward * MAX_COORD_RANGE,
MASK_SOLID, pMe, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 && tr.DidHitNonWorldEntity() )
{
CBaseEntity *pHit = tr.m_pEnt;
if (FClassnameIs( pHit,classname ) )
{
return pHit;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the nearest COLLIBALE entity in front of the player
// that has a clear line of sight. If HULL is true, the trace will
// hit the collision hull of entities. Otherwise, the trace will hit
// hitboxes.
// Input :
// Output :
//-----------------------------------------------------------------------------
CBaseEntity *FindEntityForward( CBasePlayer *pMe, bool fHull )
{
if ( pMe )
{
trace_t tr;
Vector forward;
int mask;
if( fHull )
{
mask = MASK_SOLID;
}
else
{
mask = MASK_SHOT;
}
pMe->EyeVectors( &forward );
UTIL_TraceLine(pMe->EyePosition(),
pMe->EyePosition() + forward * MAX_COORD_RANGE,
mask, pMe, COLLISION_GROUP_NONE, &tr );
if ( tr.fraction != 1.0 && tr.DidHitNonWorldEntity() )
{
return tr.m_pEnt;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Finds the nearest entity in front of the player of the given
// classname, preferring collidable entities, but allows selection of
// enities that are on the other side of walls or objects
//
// Input :
// Output :
//-----------------------------------------------------------------------------
CBaseEntity *FindPickerEntityClass( CBasePlayer *pPlayer, char *classname )
{
// First try to trace a hull to an entity
CBaseEntity *pEntity = FindEntityClassForward( pPlayer, classname );
// If that fails just look for the nearest facing entity
if (!pEntity)
{
Vector forward;
Vector origin;
pPlayer->EyeVectors( &forward );
origin = pPlayer->WorldSpaceCenter();
pEntity = gEntList.FindEntityClassNearestFacing( origin, forward,0.95,classname);
}
return pEntity;
}
//-----------------------------------------------------------------------------
// Purpose: Finds the nearest entity in front of the player, preferring
// collidable entities, but allows selection of enities that are
// on the other side of walls or objects
// Input :
// Output :
//-----------------------------------------------------------------------------
CBaseEntity *FindPickerEntity( CBasePlayer *pPlayer )
{
MDLCACHE_CRITICAL_SECTION();
// First try to trace a hull to an entity
CBaseEntity *pEntity = FindEntityForward( pPlayer, true );
// If that fails just look for the nearest facing entity
if (!pEntity)
{
Vector forward;
Vector origin;
pPlayer->EyeVectors( &forward );
origin = pPlayer->WorldSpaceCenter();
pEntity = gEntList.FindEntityNearestFacing( origin, forward,0.95);
}
return pEntity;
}
//-----------------------------------------------------------------------------
// Purpose: Finds the nearest node in front of the player
// Input :
// Output :
//-----------------------------------------------------------------------------
CAI_Node *FindPickerAINode( CBasePlayer *pPlayer, NodeType_e nNodeType )
{
Vector forward;
Vector origin;
pPlayer->EyeVectors( &forward );
origin = pPlayer->EyePosition();
return g_pAINetworkManager->GetEditOps()->FindAINodeNearestFacing( origin, forward,0.90, nNodeType);
}
//-----------------------------------------------------------------------------
// Purpose: Finds the nearest link in front of the player
// Input :
// Output :
//-----------------------------------------------------------------------------
CAI_Link *FindPickerAILink( CBasePlayer* pPlayer )
{
Vector forward;
Vector origin;
pPlayer->EyeVectors( &forward );
origin = pPlayer->EyePosition();
return g_pAINetworkManager->GetEditOps()->FindAILinkNearestFacing( origin, forward,0.90);
}
/*
===============
ForceClientDllUpdate
When recording a demo, we need to have the server tell us the entire client state
so that the client side .dll can behave correctly.
Reset stuff so that the state is transmitted.
===============
*/
void CBasePlayer::ForceClientDllUpdate( void )
{
m_iClientBattery = -1;
m_iTrain |= TRAIN_NEW; // Force new train message.
m_fWeapon = false; // Force weapon send
// Force all HUD data to be resent to client
m_fInitHUD = true;
// Now force all the necessary messages
// to be sent.
UpdateClientData();
UTIL_RestartAmbientSounds(); // MOTODO that updates the sounds for everybody
}
/*
============
ImpulseCommands
============
*/
void CBasePlayer::ImpulseCommands( )
{
trace_t tr;
int iImpulse = (int)m_nImpulse;
switch (iImpulse)
{
case 100:
// temporary flashlight for level designers
if ( FlashlightIsOn() )
{
FlashlightTurnOff();
}
else
{
FlashlightTurnOn();
}
break;
case 200:
if ( sv_cheats->GetBool() )
{
CBaseCombatWeapon *pWeapon;
pWeapon = GetActiveWeapon();
if( pWeapon->IsEffectActive( EF_NODRAW ) )
{
pWeapon->Deploy();
}
else
{
pWeapon->Holster();
}
}
break;
case 201:// paint decal
if ( gpGlobals->curtime < m_flNextDecalTime )
{
// too early!
break;
}
{
Vector forward;
EyeVectors( &forward );
UTIL_TraceLine ( EyePosition(),
EyePosition() + forward * 128,
MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, & tr);
}
if ( tr.fraction != 1.0 )
{// line hit something, so paint a decal
m_flNextDecalTime = gpGlobals->curtime + decalfrequency.GetFloat();
CSprayCan *pCan = CREATE_UNSAVED_ENTITY( CSprayCan, "spraycan" );
pCan->Spawn( this );
#ifdef CSTRIKE_DLL
//=============================================================================
// HPE_BEGIN:
// [pfreese] Fire off a game event - the Counter-Strike stats manager listens
// to these achievements for one of the CS achievements.
//=============================================================================
IGameEvent * event = gameeventmanager->CreateEvent( "player_decal" );
if ( event )
{
event->SetInt("userid", GetUserID() );
gameeventmanager->FireEvent( event );
}
//=============================================================================
// HPE_END
//=============================================================================
#endif
}
break;
case 202:// player jungle sound
if ( gpGlobals->curtime < m_flNextDecalTime )
{
// too early!
break;
}
EntityMessageBegin( this );
WRITE_BYTE( PLAY_PLAYER_JINGLE );
MessageEnd();
m_flNextDecalTime = gpGlobals->curtime + decalfrequency.GetFloat();
break;
default:
// check all of the cheat impulse commands now
CheatImpulseCommands( iImpulse );
break;
}
m_nImpulse = 0;
}
#ifdef HL2_EPISODIC
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static void CreateJalopy( CBasePlayer *pPlayer )
{
// Cheat to create a jeep in front of the player
Vector vecForward;
AngleVectors( pPlayer->EyeAngles(), &vecForward );
CBaseEntity *pJeep = (CBaseEntity *)CreateEntityByName( "prop_vehicle_jeep" );
if ( pJeep )
{
Vector vecOrigin = pPlayer->GetAbsOrigin() + vecForward * 256 + Vector(0,0,64);
QAngle vecAngles( 0, pPlayer->GetAbsAngles().y - 90, 0 );
pJeep->SetAbsOrigin( vecOrigin );
pJeep->SetAbsAngles( vecAngles );
pJeep->KeyValue( "model", "models/vehicle.mdl" );
pJeep->KeyValue( "solid", "6" );
pJeep->KeyValue( "targetname", "jeep" );
pJeep->KeyValue( "vehiclescript", "scripts/vehicles/jalopy.txt" );
DispatchSpawn( pJeep );
pJeep->Activate();
pJeep->Teleport( &vecOrigin, &vecAngles, NULL );
}
}
void CC_CH_CreateJalopy( void )
{
CBasePlayer *pPlayer = UTIL_GetCommandClient();
if ( !pPlayer )
return;
CreateJalopy( pPlayer );
}
static ConCommand ch_createjalopy("ch_createjalopy", CC_CH_CreateJalopy, "Spawn jalopy in front of the player.", FCVAR_CHEAT);
#endif // HL2_EPISODIC
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static void CreateJeep( CBasePlayer *pPlayer )
{
// Cheat to create a jeep in front of the player
Vector vecForward;
AngleVectors( pPlayer->EyeAngles(), &vecForward );
CBaseEntity *pJeep = (CBaseEntity *)CreateEntityByName( "prop_vehicle_jeep" );
if ( pJeep )
{
Vector vecOrigin = pPlayer->GetAbsOrigin() + vecForward * 256 + Vector(0,0,64);
QAngle vecAngles( 0, pPlayer->GetAbsAngles().y - 90, 0 );
pJeep->SetAbsOrigin( vecOrigin );
pJeep->SetAbsAngles( vecAngles );
pJeep->KeyValue( "model", "models/buggy.mdl" );
pJeep->KeyValue( "solid", "6" );
pJeep->KeyValue( "targetname", "jeep" );
pJeep->KeyValue( "vehiclescript", "scripts/vehicles/jeep_test.txt" );
DispatchSpawn( pJeep );
pJeep->Activate();
pJeep->Teleport( &vecOrigin, &vecAngles, NULL );
}
}
void CC_CH_CreateJeep( void )
{
CBasePlayer *pPlayer = UTIL_GetCommandClient();
if ( !pPlayer )
return;
CreateJeep( pPlayer );
}
static ConCommand ch_createjeep("ch_createjeep", CC_CH_CreateJeep, "Spawn jeep in front of the player.", FCVAR_CHEAT);
//-----------------------------------------------------------------------------
// Create an airboat in front of the specified player
//-----------------------------------------------------------------------------
static void CreateAirboat( CBasePlayer *pPlayer )
{
// Cheat to create a jeep in front of the player
Vector vecForward;
AngleVectors( pPlayer->EyeAngles(), &vecForward );
CBaseEntity *pJeep = ( CBaseEntity* )CreateEntityByName( "prop_vehicle_airboat" );
if ( pJeep )
{
Vector vecOrigin = pPlayer->GetAbsOrigin() + vecForward * 256 + Vector( 0,0,64 );
QAngle vecAngles( 0, pPlayer->GetAbsAngles().y - 90, 0 );
pJeep->SetAbsOrigin( vecOrigin );
pJeep->SetAbsAngles( vecAngles );
pJeep->KeyValue( "model", "models/airboat.mdl" );
pJeep->KeyValue( "solid", "6" );
pJeep->KeyValue( "targetname", "airboat" );
pJeep->KeyValue( "vehiclescript", "scripts/vehicles/airboat.txt" );
DispatchSpawn( pJeep );
pJeep->Activate();
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CC_CH_CreateAirboat( void )
{
CBasePlayer *pPlayer = UTIL_GetCommandClient();
if ( !pPlayer )
return;
CreateAirboat( pPlayer );
}
static ConCommand ch_createairboat( "ch_createairboat", CC_CH_CreateAirboat, "Spawn airboat in front of the player.", FCVAR_CHEAT );
//=========================================================
//=========================================================
void CBasePlayer::CheatImpulseCommands( int iImpulse )
{
#if !defined( HLDEMO_BUILD )
if ( !sv_cheats->GetBool() )
{
return;
}
CBaseEntity *pEntity;
trace_t tr;
switch ( iImpulse )
{
case 76:
{
if (!giPrecacheGrunt)
{
giPrecacheGrunt = 1;
Msg( "You must now restart to use Grunt-o-matic.\n");
}
else
{
Vector forward = UTIL_YawToVector( EyeAngles().y );
Create("NPC_human_grunt", GetLocalOrigin() + forward * 128, GetLocalAngles());
}
break;
}
case 81:
GiveNamedItem( "weapon_cubemap" );
break;
case 82:
// Cheat to create a jeep in front of the player
CreateJeep( this );
break;
case 83:
// Cheat to create a airboat in front of the player
CreateAirboat( this );
break;
case 101:
gEvilImpulse101 = true;
EquipSuit();
// Give the player everything!
GiveAmmo( 255, "Pistol");
GiveAmmo( 255, "AR2");
GiveAmmo( 5, "AR2AltFire");
GiveAmmo( 255, "SMG1");
GiveAmmo( 255, "Buckshot");
GiveAmmo( 3, "smg1_grenade");
GiveAmmo( 3, "rpg_round");
GiveAmmo( 5, "grenade");
GiveAmmo( 32, "357" );
GiveAmmo( 16, "XBowBolt" );
#ifdef HL2_EPISODIC
GiveAmmo( 5, "Hopwire" );
#endif
GiveNamedItem( "weapon_smg1" );
GiveNamedItem( "weapon_frag" );
GiveNamedItem( "weapon_crowbar" );
GiveNamedItem( "weapon_pistol" );
GiveNamedItem( "weapon_ar2" );
GiveNamedItem( "weapon_shotgun" );
GiveNamedItem( "weapon_physcannon" );
GiveNamedItem( "weapon_bugbait" );
GiveNamedItem( "weapon_rpg" );
GiveNamedItem( "weapon_357" );
GiveNamedItem( "weapon_crossbow" );
#ifdef HL2_EPISODIC
// GiveNamedItem( "weapon_magnade" );
#endif
if ( GetHealth() < 100 )
{
TakeHealth( 25, DMG_GENERIC );
}
gEvilImpulse101 = false;
break;
case 102:
// Gibbage!!!
CGib::SpawnRandomGibs( this, 1, GIB_HUMAN );
break;
case 103:
// What the hell are you doing?
pEntity = FindEntityForward( this, true );
if ( pEntity )
{
CAI_BaseNPC *pNPC = pEntity->MyNPCPointer();
if ( pNPC )
pNPC->ReportAIState();
}
break;
case 106:
// Give me the classname and targetname of this entity.
pEntity = FindEntityForward( this, true );
if ( pEntity )
{
Msg( "Classname: %s", pEntity->GetClassname() );
if ( pEntity->GetEntityName() != NULL_STRING )
{
Msg( " - Name: %s\n", STRING( pEntity->GetEntityName() ) );
}
else
{
Msg( " - Name: No Targetname\n" );
}
if ( pEntity->m_iParent != NULL_STRING )
Msg( "Parent: %s\n", STRING(pEntity->m_iParent) );
Msg( "Model: %s\n", STRING( pEntity->GetModelName() ) );
if ( pEntity->m_iGlobalname != NULL_STRING )
Msg( "Globalname: %s\n", STRING(pEntity->m_iGlobalname) );
}
break;
case 107:
{
trace_t tr;
edict_t *pWorld = engine->PEntityOfEntIndex( 0 );
Vector start = EyePosition();
Vector forward;
EyeVectors( &forward );
Vector end = start + forward * 1024;
UTIL_TraceLine( start, end, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &tr );
if ( tr.m_pEnt )
pWorld = tr.m_pEnt->edict();
const char *pTextureName = tr.surface.name;
if ( pTextureName )
Msg( "Texture: %s\n", pTextureName );
}
break;
//
// Sets the debug NPC to be the NPC under the crosshair.
//
case 108:
{
pEntity = FindEntityForward( this, true );
if ( pEntity )
{
CAI_BaseNPC *pNPC = pEntity->MyNPCPointer();
if ( pNPC != NULL )
{
Msg( "Debugging %s (0x%p)\n", pNPC->GetClassname(), pNPC );
CAI_BaseNPC::SetDebugNPC( pNPC );
}
}
break;
}
case 195:// show shortest paths for entire level to nearest node
{
Create("node_viewer_fly", GetLocalOrigin(), GetLocalAngles());
}
break;
case 196:// show shortest paths for entire level to nearest node
{
Create("node_viewer_large", GetLocalOrigin(), GetLocalAngles());
}
break;
case 197:// show shortest paths for entire level to nearest node
{
Create("node_viewer_human", GetLocalOrigin(), GetLocalAngles());
}
break;
case 202:// Random blood splatter
{
Vector forward;
EyeVectors( &forward );
UTIL_TraceLine ( EyePosition(),
EyePosition() + forward * 128,
MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, & tr);
if ( tr.fraction != 1.0 )
{// line hit something, so paint a decal
CBloodSplat *pBlood = CREATE_UNSAVED_ENTITY( CBloodSplat, "bloodsplat" );
pBlood->Spawn( this );
}
}
break;
case 203:// remove creature.
pEntity = FindEntityForward( this, true );
if ( pEntity )
{
UTIL_Remove( pEntity );
// if ( pEntity->m_takedamage )
// pEntity->SetThink(SUB_Remove);
}
break;
}
#endif // HLDEMO_BUILD
}
bool CBasePlayer::ClientCommand( const CCommand &args )
{
const char *cmd = args[0];
#ifdef _DEBUG
if( stricmp( cmd, "test_SmokeGrenade" ) == 0 )
{
if ( sv_cheats && sv_cheats->GetBool() )
{
ParticleSmokeGrenade *pSmoke = dynamic_cast<ParticleSmokeGrenade*>( CreateEntityByName(PARTICLESMOKEGRENADE_ENTITYNAME) );
if ( pSmoke )
{
Vector vForward;
AngleVectors( GetLocalAngles(), &vForward );
vForward.z = 0;
VectorNormalize( vForward );
pSmoke->SetLocalOrigin( GetLocalOrigin() + vForward * 100 );
pSmoke->SetFadeTime(25, 30); // Fade out between 25 seconds and 30 seconds.
pSmoke->Activate();
pSmoke->SetLifetime(30);
pSmoke->FillVolume();
return true;
}
}
}
else
#endif // _DEBUG
if( stricmp( cmd, "vehicleRole" ) == 0 )
{
// Get the vehicle role value.
if ( args.ArgC() == 2 )
{
// Check to see if a player is in a vehicle.
if ( IsInAVehicle() )
{
int nRole = atoi( args[1] );
IServerVehicle *pVehicle = GetVehicle();
if ( pVehicle )
{
// Only switch roles if role is empty!
if ( !pVehicle->GetPassenger( nRole ) )
{
LeaveVehicle();
GetInVehicle( pVehicle, nRole );
}
}
}
return true;
}
}
else if ( HandleVoteCommands( args ) )
{
return true;
}
else if ( stricmp( cmd, "spectate" ) == 0 ) // join spectator team & start observer mode
{
if ( GetTeamNumber() == TEAM_SPECTATOR )
return true;
ConVarRef mp_allowspectators( "mp_allowspectators" );
if ( mp_allowspectators.IsValid() )
{
if ( ( mp_allowspectators.GetBool() == false ) && !IsHLTV() && !IsReplay() )
{
ClientPrint( this, HUD_PRINTCENTER, "#Cannot_Be_Spectator" );
return true;
}
}
if ( !IsDead() )
{
CommitSuicide(); // kill player
}
RemoveAllItems( true );
ChangeTeam( TEAM_SPECTATOR );
StartObserverMode( OBS_MODE_ROAMING );
return true;
}
else if ( stricmp( cmd, "spec_mode" ) == 0 ) // new observer mode
{
int mode;
if ( GetObserverMode() == OBS_MODE_FREEZECAM )
{
AttemptToExitFreezeCam();
return true;
}
// not allowed to change spectator modes when mp_fadetoblack is being used
if ( mp_fadetoblack.GetBool() )
{
if ( GetTeamNumber() > TEAM_SPECTATOR )
return true;
}
// check for parameters.
if ( args.ArgC() >= 2 )
{
mode = atoi( args[1] );
if ( mode < OBS_MODE_IN_EYE || mode > LAST_PLAYER_OBSERVERMODE )
mode = OBS_MODE_IN_EYE;
}
else
{
// switch to next spec mode if no parameter given
mode = GetObserverMode() + 1;
if ( mode > LAST_PLAYER_OBSERVERMODE )
{
mode = OBS_MODE_IN_EYE;
}
else if ( mode < OBS_MODE_IN_EYE )
{
mode = OBS_MODE_ROAMING;
}
}
// don't allow input while player or death cam animation
if ( GetObserverMode() > OBS_MODE_DEATHCAM )
{
// set new spectator mode, don't allow OBS_MODE_NONE
if ( !SetObserverMode( mode ) )
ClientPrint( this, HUD_PRINTCONSOLE, "#Spectator_Mode_Unknown");
else
engine->ClientCommand( edict(), "cl_spec_mode %d", mode );
}
else
{
// remember spectator mode for later use
m_iObserverLastMode = mode;
engine->ClientCommand( edict(), "cl_spec_mode %d", mode );
}
return true;
}
else if ( stricmp( cmd, "spec_next" ) == 0 ) // chase next player
{
if ( GetObserverMode() > OBS_MODE_FIXED )
{
// set new spectator mode
CBaseEntity * target = FindNextObserverTarget( false );
if ( target )
{
SetObserverTarget( target );
}
}
else if ( GetObserverMode() == OBS_MODE_FREEZECAM )
{
AttemptToExitFreezeCam();
}
return true;
}
else if ( stricmp( cmd, "spec_prev" ) == 0 ) // chase previous player
{
if ( GetObserverMode() > OBS_MODE_FIXED )
{
// set new spectator mode
CBaseEntity * target = FindNextObserverTarget( true );
if ( target )
{
SetObserverTarget( target );
}
}
else if ( GetObserverMode() == OBS_MODE_FREEZECAM )
{
AttemptToExitFreezeCam();
}
return true;
}
else if ( stricmp( cmd, "spec_player" ) == 0 ) // chase next player
{
if ( GetObserverMode() > OBS_MODE_FIXED && args.ArgC() == 2 )
{
CBasePlayer *target = UTIL_PlayerByCommandArg( args[1] );
if ( IsValidObserverTarget( target ) )
{
SetObserverTarget( target );
}
}
return true;
}
else if ( stricmp( cmd, "spec_goto" ) == 0 ) // chase next player
{
if ( ( GetObserverMode() == OBS_MODE_FIXED ||
GetObserverMode() == OBS_MODE_ROAMING ) &&
args.ArgC() == 6 )
{
Vector origin;
origin.x = clamp( atof( args[1] ), MIN_COORD_FLOAT, MAX_COORD_FLOAT );
origin.y = clamp( atof( args[2] ), MIN_COORD_FLOAT, MAX_COORD_FLOAT );
origin.z = clamp( atof( args[3] ), MIN_COORD_FLOAT, MAX_COORD_FLOAT );
QAngle angle;
angle.x = atof( args[4] );
angle.y = atof( args[5] );
angle.z = 0.0f;
JumptoPosition( origin, angle );
}
return true;
}
else if ( stricmp( cmd, "playerperf" ) == 0 )
{
int nRecip = entindex();
if ( args.ArgC() >= 2 )
{
nRecip = clamp( Q_atoi( args.Arg( 1 ) ), 1, gpGlobals->maxClients );
}
int nRecords = -1; // all
if ( args.ArgC() >= 3 )
{
nRecords = MAX( Q_atoi( args.Arg( 2 ) ), 1 );
}
CBasePlayer *pl = UTIL_PlayerByIndex( nRecip );
if ( pl )
{
pl->DumpPerfToRecipient( this, nRecords );
}
return true;
}
return false;
}
extern bool UTIL_ItemCanBeTouchedByPlayer( CBaseEntity *pItem, CBasePlayer *pPlayer );
//-----------------------------------------------------------------------------
// Purpose: Player reacts to bumping a weapon.
// Input : pWeapon - the weapon that the player bumped into.
// Output : Returns true if player picked up the weapon
//-----------------------------------------------------------------------------
bool CBasePlayer::BumpWeapon( CBaseCombatWeapon *pWeapon )
{
CBaseCombatCharacter *pOwner = pWeapon->GetOwner();
// Can I have this weapon type?
if ( !IsAllowedToPickupWeapons() )
return false;
if ( pOwner || !Weapon_CanUse( pWeapon ) || !g_pGameRules->CanHavePlayerItem( this, pWeapon ) )
{
if ( gEvilImpulse101 )
{
UTIL_Remove( pWeapon );
}
return false;
}
// Act differently in the episodes
if ( hl2_episodic.GetBool() )
{
// Don't let the player touch the item unless unobstructed
if ( !UTIL_ItemCanBeTouchedByPlayer( pWeapon, this ) && !gEvilImpulse101 )
return false;
}
else
{
// Don't let the player fetch weapons through walls (use MASK_SOLID so that you can't pickup through windows)
if( pWeapon->FVisible( this, MASK_SOLID ) == false && !(GetFlags() & FL_NOTARGET) )
return false;
}
// ----------------------------------------
// If I already have it just take the ammo
// ----------------------------------------
if (Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType()))
{
if( Weapon_EquipAmmoOnly( pWeapon ) )
{
// Only remove me if I have no ammo left
if ( pWeapon->HasPrimaryAmmo() )
return false;
UTIL_Remove( pWeapon );
return true;
}
else
{
return false;
}
}
// -------------------------
// Otherwise take the weapon
// -------------------------
else
{
pWeapon->CheckRespawn();
pWeapon->AddSolidFlags( FSOLID_NOT_SOLID );
pWeapon->AddEffects( EF_NODRAW );
Weapon_Equip( pWeapon );
if ( IsInAVehicle() )
{
pWeapon->Holster();
}
else
{
#ifdef HL2_DLL
if ( IsX360() )
{
CFmtStr hint;
hint.sprintf( "#valve_hint_select_%s", pWeapon->GetClassname() );
UTIL_HudHintText( this, hint.Access() );
}
// Always switch to a newly-picked up weapon
if ( !PlayerHasMegaPhysCannon() )
{
// If it uses clips, load it full. (this is the first time you've picked up this type of weapon)
if ( pWeapon->UsesClipsForAmmo1() )
{
pWeapon->m_iClip1 = pWeapon->GetMaxClip1();
}
Weapon_Switch( pWeapon );
}
#endif
}
return true;
}
}
bool CBasePlayer::RemovePlayerItem( CBaseCombatWeapon *pItem )
{
if (GetActiveWeapon() == pItem)
{
ResetAutoaim( );
pItem->Holster( );
pItem->SetNextThink( TICK_NEVER_THINK );; // crowbar may be trying to swing again, etc
pItem->SetThink( NULL );
}
if ( m_hLastWeapon.Get() == pItem )
{
Weapon_SetLast( NULL );
}
return Weapon_Detach( pItem );
}
//-----------------------------------------------------------------------------
// Purpose: Hides or shows the player's view model. The "r_drawviewmodel" cvar
// can still hide the viewmodel even if this is set to true.
// Input : bShow - true to show, false to hide the view model.
//-----------------------------------------------------------------------------
void CBasePlayer::ShowViewModel(bool bShow)
{
m_Local.m_bDrawViewmodel = bShow;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bDraw -
//-----------------------------------------------------------------------------
void CBasePlayer::ShowCrosshair( bool bShow )
{
if ( bShow )
{
m_Local.m_iHideHUD &= ~HIDEHUD_CROSSHAIR;
}
else
{
m_Local.m_iHideHUD |= HIDEHUD_CROSSHAIR;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
QAngle CBasePlayer::BodyAngles()
{
return EyeAngles();
}
//------------------------------------------------------------------------------
// Purpose : Add noise to BodyTarget() to give enemy a better chance of
// getting a clear shot when the player is peeking above a hole
// or behind a ladder (eventually the randomly-picked point
// along the spine will be one that is exposed above the hole or
// between rungs of a ladder.)
// Input :
// Output :
//------------------------------------------------------------------------------
Vector CBasePlayer::BodyTarget( const Vector &posSrc, bool bNoisy )
{
if ( IsInAVehicle() )
{
return GetVehicle()->GetVehicleEnt()->BodyTarget( posSrc, bNoisy );
}
if (bNoisy)
{
return GetAbsOrigin() + (GetViewOffset() * random->RandomFloat( 0.7, 1.0 ));
}
else
{
return EyePosition();
}
};
/*
=========================================================
UpdateClientData
resends any changed player HUD info to the client.
Called every frame by PlayerPreThink
Also called at start of demo recording and playback by
ForceClientDllUpdate to ensure the demo gets messages
reflecting all of the HUD state info.
=========================================================
*/
void CBasePlayer::UpdateClientData( void )
{
CSingleUserRecipientFilter user( this );
user.MakeReliable();
if (m_fInitHUD)
{
m_fInitHUD = false;
gInitHUD = false;
UserMessageBegin( user, "ResetHUD" );
WRITE_BYTE( 0 );
MessageEnd();
if ( !m_fGameHUDInitialized )
{
g_pGameRules->InitHUD( this );
InitHUD();
m_fGameHUDInitialized = true;
if ( g_pGameRules->IsMultiplayer() )
{
variant_t value;
g_EventQueue.AddEvent( "game_player_manager", "OnPlayerJoin", value, 0, this, this );
}
}
variant_t value;
g_EventQueue.AddEvent( "game_player_manager", "OnPlayerSpawn", value, 0, this, this );
}
// HACKHACK -- send the message to display the game title
CWorld *world = GetWorldEntity();
if ( world && world->GetDisplayTitle() )
{
UserMessageBegin( user, "GameTitle" );
MessageEnd();
world->SetDisplayTitle( false );
}
if (m_ArmorValue != m_iClientBattery)
{
m_iClientBattery = m_ArmorValue;
// send "battery" update message
if ( usermessages->LookupUserMessage( "Battery" ) != -1 )
{
UserMessageBegin( user, "Battery" );
WRITE_SHORT( (int)m_ArmorValue);
MessageEnd();
}
}
#if 0 // BYE BYE!!
// Update Flashlight
if ((m_flFlashLightTime) && (m_flFlashLightTime <= gpGlobals->curtime))
{
if (FlashlightIsOn())
{
if (m_iFlashBattery)
{
m_flFlashLightTime = FLASH_DRAIN_TIME + gpGlobals->curtime;
m_iFlashBattery--;
if (!m_iFlashBattery)
FlashlightTurnOff();
}
}
else
{
if (m_iFlashBattery < 100)
{
m_flFlashLightTime = FLASH_CHARGE_TIME + gpGlobals->curtime;
m_iFlashBattery++;
}
else
m_flFlashLightTime = 0;
}
}
#endif
CheckTrainUpdate();
// Update all the items
for ( int i = 0; i < WeaponCount(); i++ )
{
if ( GetWeapon(i) ) // each item updates it's successors
GetWeapon(i)->UpdateClientData( this );
}
// update the client with our poison state
m_Local.m_bPoisoned = ( m_bitsDamageType & DMG_POISON )
&& ( m_nPoisonDmg > m_nPoisonRestored )
&& ( m_iHealth < 100 );
// Check if the bonus progress HUD element should be displayed
if ( m_iBonusChallenge == 0 && m_iBonusProgress == 0 && !( m_Local.m_iHideHUD & HIDEHUD_BONUS_PROGRESS ) )
m_Local.m_iHideHUD |= HIDEHUD_BONUS_PROGRESS;
if ( ( m_iBonusChallenge != 0 )&& ( m_Local.m_iHideHUD & HIDEHUD_BONUS_PROGRESS ) )
m_Local.m_iHideHUD &= ~HIDEHUD_BONUS_PROGRESS;
// Let any global rules update the HUD, too
g_pGameRules->UpdateClientData( this );
}
void CBasePlayer::RumbleEffect( unsigned char index, unsigned char rumbleData, unsigned char rumbleFlags )
{
if( !IsAlive() )
return;
CSingleUserRecipientFilter filter( this );
filter.MakeReliable();
UserMessageBegin( filter, "Rumble" );
WRITE_BYTE( index );
WRITE_BYTE( rumbleData );
WRITE_BYTE( rumbleFlags );
MessageEnd();
}
void CBasePlayer::EnableControl(bool fControl)
{
if (!fControl)
AddFlag( FL_FROZEN );
else
RemoveFlag( FL_FROZEN );
}
void CBasePlayer::CheckTrainUpdate( void )
{
if ( ( m_iTrain & TRAIN_NEW ) )
{
CSingleUserRecipientFilter user( this );
user.MakeReliable();
// send "Train" update message
UserMessageBegin( user, "Train" );
WRITE_BYTE(m_iTrain & 0xF);
MessageEnd();
m_iTrain &= ~TRAIN_NEW;
}
}
//-----------------------------------------------------------------------------
// Purpose: Returns whether the player should autoaim or not
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBasePlayer::ShouldAutoaim( void )
{
// cannot be in multiplayer
if ( gpGlobals->maxClients > 1 )
return false;
// autoaiming is only for easy and medium skill
return ( IsX360() || !g_pGameRules->IsSkillLevel(SKILL_HARD) );
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Vector CBasePlayer::GetAutoaimVector( float flScale )
{
autoaim_params_t params;
params.m_fScale = flScale;
params.m_fMaxDist = autoaim_max_dist.GetFloat();
GetAutoaimVector( params );
return params.m_vecAutoAimDir;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
Vector CBasePlayer::GetAutoaimVector( float flScale, float flMaxDist )
{
autoaim_params_t params;
params.m_fScale = flScale;
params.m_fMaxDist = flMaxDist;
GetAutoaimVector( params );
return params.m_vecAutoAimDir;
}
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
void CBasePlayer::GetAutoaimVector( autoaim_params_t &params )
{
// Assume autoaim will not be assisting.
params.m_bAutoAimAssisting = false;
if ( ( ShouldAutoaim() == false ) || ( params.m_fScale == AUTOAIM_SCALE_DIRECT_ONLY ) )
{
Vector forward;
AngleVectors( EyeAngles() + m_Local.m_vecPunchAngle, &forward );
params.m_vecAutoAimDir = forward;
params.m_hAutoAimEntity.Set(NULL);
params.m_vecAutoAimPoint = vec3_invalid;
params.m_bAutoAimAssisting = false;
return;
}
Vector vecSrc = Weapon_ShootPosition( );
m_vecAutoAim.Init( 0.0f, 0.0f, 0.0f );
QAngle angles = AutoaimDeflection( vecSrc, params );
// update ontarget if changed
if ( !g_pGameRules->AllowAutoTargetCrosshair() )
m_fOnTarget = false;
if (angles.x > 180)
angles.x -= 360;
if (angles.x < -180)
angles.x += 360;
if (angles.y > 180)
angles.y -= 360;
if (angles.y < -180)
angles.y += 360;
if (angles.x > 25)
angles.x = 25;
if (angles.x < -25)
angles.x = -25;
if (angles.y > 12)
angles.y = 12;
if (angles.y < -12)
angles.y = -12;
Vector forward;
if( IsInAVehicle() && g_pGameRules->GetAutoAimMode() == AUTOAIM_ON_CONSOLE )
{
m_vecAutoAim = angles;
AngleVectors( EyeAngles() + m_vecAutoAim, &forward );
}
else
{
// always use non-sticky autoaim
m_vecAutoAim = angles * 0.9f;
AngleVectors( EyeAngles() + m_Local.m_vecPunchAngle + m_vecAutoAim, &forward );
}
params.m_vecAutoAimDir = forward;
}
//-----------------------------------------------------------------------------
// Targets represent themselves to autoaim as a viewplane-parallel disc with
// a radius specified by the target. The player then modifies this radius
// to achieve more or less aggressive aiming assistance
//-----------------------------------------------------------------------------
float CBasePlayer::GetAutoaimScore( const Vector &eyePosition, const Vector &viewDir, const Vector &vecTarget, CBaseEntity *pTarget, float fScale, CBaseCombatWeapon *pActiveWeapon )
{
float radiusSqr;
float targetRadius = pTarget->GetAutoAimRadius() * fScale;
if( pActiveWeapon != NULL )
targetRadius *= pActiveWeapon->WeaponAutoAimScale();
float targetRadiusSqr = Square( targetRadius );
Vector vecNearestPoint = PointOnLineNearestPoint( eyePosition, eyePosition + viewDir * 8192, vecTarget );
Vector vecDiff = vecTarget - vecNearestPoint;
radiusSqr = vecDiff.LengthSqr();
if( radiusSqr <= targetRadiusSqr )
{
float score;
score = 1.0f - (radiusSqr / targetRadiusSqr);
Assert( score >= 0.0f && score <= 1.0f );
return score;
}
// 0 means no score- doesn't qualify for autoaim.
return 0.0f;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &vecSrc -
// flDist -
// flDelta -
// Output : Vector
//-----------------------------------------------------------------------------
QAngle CBasePlayer::AutoaimDeflection( Vector &vecSrc, autoaim_params_t &params )
{
float bestscore;
float score;
QAngle eyeAngles;
Vector bestdir;
CBaseEntity *bestent;
trace_t tr;
Vector v_forward, v_right, v_up;
if ( ShouldAutoaim() == false )
{
m_fOnTarget = false;
return vec3_angle;
}
eyeAngles = EyeAngles();
AngleVectors( eyeAngles + m_Local.m_vecPunchAngle + m_vecAutoAim, &v_forward, &v_right, &v_up );
// try all possible entities
bestdir = v_forward;
bestscore = 0.0f;
bestent = NULL;
//Reset this data
m_fOnTarget = false;
params.m_bOnTargetNatural = false;
CBaseEntity *pIgnore = NULL;
if( IsInAVehicle() )
{
pIgnore = GetVehicleEntity();
}
CTraceFilterSkipTwoEntities traceFilter( this, pIgnore, COLLISION_GROUP_NONE );
UTIL_TraceLine( vecSrc, vecSrc + bestdir * MAX_COORD_FLOAT, MASK_SHOT, &traceFilter, &tr );
CBaseEntity *pEntHit = tr.m_pEnt;
if ( pEntHit && pEntHit->m_takedamage != DAMAGE_NO && pEntHit->GetHealth() > 0 )
{
// don't look through water
if (!((GetWaterLevel() != 3 && pEntHit->GetWaterLevel() == 3) || (GetWaterLevel() == 3 && pEntHit->GetWaterLevel() == 0)))
{
if( pEntHit->ShouldAttractAutoAim(this) )
{
bool bAimAtThis = true;
if( pEntHit->IsNPC() && g_pGameRules->GetAutoAimMode() > AUTOAIM_NONE )
{
int iRelationType = GetDefaultRelationshipDisposition( pEntHit->Classify() );
if( iRelationType != D_HT )
{
bAimAtThis = false;
}
}
if( bAimAtThis )
{
if ( pEntHit->GetFlags() & FL_AIMTARGET )
{
m_fOnTarget = true;
}
// Player is already on target naturally, don't autoaim.
// Fill out the autoaim_params_t struct, though.
params.m_hAutoAimEntity.Set(pEntHit);
params.m_vecAutoAimDir = bestdir;
params.m_vecAutoAimPoint = tr.endpos;
params.m_bAutoAimAssisting = false;
params.m_bOnTargetNatural = true;
return vec3_angle;
}
}
//Fall through and look for an autoaim ent.
}
}
int count = AimTarget_ListCount();
if ( count )
{
CBaseEntity **pList = (CBaseEntity **)stackalloc( sizeof(CBaseEntity *) * count );
AimTarget_ListCopy( pList, count );
for ( int i = 0; i < count; i++ )
{
Vector center;
Vector dir;
CBaseEntity *pEntity = pList[i];
// Don't autoaim at anything that doesn't want to be.
if( !pEntity->ShouldAttractAutoAim(this) )
continue;
// Don't shoot yourself
if ( pEntity == this )
continue;
if ( (pEntity->IsNPC() && !pEntity->IsAlive()) || !pEntity->edict() )
continue;
if ( !g_pGameRules->ShouldAutoAim( this, pEntity->edict() ) )
continue;
// don't look through water
if ((GetWaterLevel() != 3 && pEntity->GetWaterLevel() == 3) || (GetWaterLevel() == 3 && pEntity->GetWaterLevel() == 0))
continue;
if( pEntity->MyNPCPointer() )
{
// If this entity is an NPC, only aim if it is an enemy.
if ( IRelationType( pEntity ) != D_HT )
{
if ( !pEntity->IsPlayer() && !g_pGameRules->IsDeathmatch())
// Msg( "friend\n");
continue;
}
}
// Don't autoaim at the noisy bodytarget, this makes the autoaim crosshair wobble.
//center = pEntity->BodyTarget( vecSrc, false );
center = pEntity->WorldSpaceCenter();
dir = (center - vecSrc);
float dist = dir.Length2D();
VectorNormalize( dir );
// Skip if out of range.
if( dist > params.m_fMaxDist )
continue;
float dot = DotProduct (dir, v_forward );
// make sure it's in front of the player
if( dot < 0 )
continue;
if( !(pEntity->GetFlags() & FL_FLY) )
{
// Refuse to take wild shots at targets far from reticle.
if( GetActiveWeapon() != NULL && dot < GetActiveWeapon()->GetMaxAutoAimDeflection() )
{
// Be lenient if the player is looking down, though. 30 degrees through 90 degrees of pitch.
// (90 degrees is looking down at player's own 'feet'. Looking straight ahead is 0 degrees pitch.
// This was done for XBox to make it easier to fight headcrabs around the player's feet.
if( eyeAngles.x < 30.0f || eyeAngles.x > 90.0f || g_pGameRules->GetAutoAimMode() != AUTOAIM_ON_CONSOLE )
{
continue;
}
}
}
score = GetAutoaimScore(vecSrc, v_forward, pEntity->GetAutoAimCenter(), pEntity, params.m_fScale, GetActiveWeapon() );
if( score <= bestscore )
{
continue;
}
UTIL_TraceLine( vecSrc, center, MASK_SHOT, &traceFilter, &tr );
if (tr.fraction != 1.0 && tr.m_pEnt != pEntity )
{
// Msg( "hit %s, can't see %s\n", STRING( tr.u.ent->classname ), STRING( pEdict->classname ) );
continue;
}
// This is the best candidate so far.
bestscore = score;
bestent = pEntity;
bestdir = dir;
}
if ( bestent )
{
QAngle bestang;
VectorAngles( bestdir, bestang );
if( IsInAVehicle() )
{
bestang -= EyeAngles();
}
else
{
bestang -= EyeAngles() - m_Local.m_vecPunchAngle;
}
m_fOnTarget = true;
// Autoaim detected a target for us. Aim automatically at its bodytarget.
params.m_hAutoAimEntity.Set(bestent);
params.m_vecAutoAimDir = bestdir;
params.m_vecAutoAimPoint = bestent->BodyTarget( vecSrc, false );
params.m_bAutoAimAssisting = true;
return bestang;
}
}
return vec3_angle;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::ResetAutoaim( void )
{
if (m_vecAutoAim.x != 0 || m_vecAutoAim.y != 0)
{
m_vecAutoAim = QAngle( 0, 0, 0 );
engine->CrosshairAngle( edict(), 0, 0 );
}
m_fOnTarget = false;
}
// ==========================================================================
// > Weapon stuff
// ==========================================================================
//-----------------------------------------------------------------------------
// Purpose: Override base class, player can always use weapon
// Input : A weapon
// Output : true or false
//-----------------------------------------------------------------------------
bool CBasePlayer::Weapon_CanUse( CBaseCombatWeapon *pWeapon )
{
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Override to clear dropped weapon from the hud
//-----------------------------------------------------------------------------
void CBasePlayer::Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget /* = NULL */, const Vector *pVelocity /* = NULL */ )
{
bool bWasActiveWeapon = false;
if ( pWeapon == GetActiveWeapon() )
{
bWasActiveWeapon = true;
}
if ( pWeapon )
{
if ( bWasActiveWeapon )
{
pWeapon->SendWeaponAnim( ACT_VM_IDLE );
}
}
BaseClass::Weapon_Drop( pWeapon, pvecTarget, pVelocity );
if ( bWasActiveWeapon )
{
if (!SwitchToNextBestWeapon( NULL ))
{
CBaseViewModel *vm = GetViewModel();
if ( vm )
{
vm->AddEffects( EF_NODRAW );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : weaponSlot -
//-----------------------------------------------------------------------------
void CBasePlayer::Weapon_DropSlot( int weaponSlot )
{
CBaseCombatWeapon *pWeapon;
// Check for that slot being occupied already
for ( int i=0; i < MAX_WEAPONS; i++ )
{
pWeapon = GetWeapon( i );
if ( pWeapon != NULL )
{
// If the slots match, it's already occupied
if ( pWeapon->GetSlot() == weaponSlot )
{
Weapon_Drop( pWeapon, NULL, NULL );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Override to add weapon to the hud
//-----------------------------------------------------------------------------
void CBasePlayer::Weapon_Equip( CBaseCombatWeapon *pWeapon )
{
BaseClass::Weapon_Equip( pWeapon );
bool bShouldSwitch = g_pGameRules->FShouldSwitchWeapon( this, pWeapon );
#ifdef HL2_DLL
if ( bShouldSwitch == false && PhysCannonGetHeldEntity( GetActiveWeapon() ) == pWeapon &&
Weapon_OwnsThisType( pWeapon->GetClassname(), pWeapon->GetSubType()) )
{
bShouldSwitch = true;
}
#endif//HL2_DLL
// should we switch to this item?
if ( bShouldSwitch )
{
Weapon_Switch( pWeapon );
}
}
//=========================================================
// HasNamedPlayerItem Does the player already have this item?
//=========================================================
CBaseEntity *CBasePlayer::HasNamedPlayerItem( const char *pszItemName )
{
for ( int i = 0 ; i < WeaponCount() ; i++ )
{
if ( !GetWeapon(i) )
continue;
if ( FStrEq( pszItemName, GetWeapon(i)->GetClassname() ) )
{
return GetWeapon(i);
}
}
return NULL;
}
#if defined USES_ECON_ITEMS
//-----------------------------------------------------------------------------
// Purpose: Add this wearable to the players' equipment list.
//-----------------------------------------------------------------------------
void CBasePlayer::EquipWearable( CEconWearable *pItem )
{
Assert( pItem );
if ( pItem )
{
m_hMyWearables.AddToHead( pItem );
pItem->Equip( this );
}
#ifdef DBGFLAG_ASSERT
// Double check list integrity.
for ( int i = m_hMyWearables.Count()-1; i >= 0; --i )
{
Assert( m_hMyWearables[i] != NULL );
}
// Networked Vector has a max size of MAX_WEARABLES_SENT_FROM_SERVER, should never have more then 7 wearables
// in public
// Search for : RecvPropUtlVector( RECVINFO_UTLVECTOR( m_hMyWearables ), MAX_WEARABLES_SENT_FROM_SERVER, RecvPropEHandle(NULL, 0, 0) ),
Assert( m_hMyWearables.Count() <= MAX_WEARABLES_SENT_FROM_SERVER );
#endif
}
//-----------------------------------------------------------------------------
// Purpose: Remove this wearable from the player's equipment list.
//-----------------------------------------------------------------------------
void CBasePlayer::RemoveWearable( CEconWearable *pItem )
{
Assert( pItem );
for ( int i = m_hMyWearables.Count()-1; i >= 0; --i )
{
CEconWearable *pWearable = m_hMyWearables[i];
if ( pWearable == pItem )
{
pItem->UnEquip( this );
UTIL_Remove( pWearable );
m_hMyWearables.Remove( i );
break;
}
// Integrety is failing, remove NULLs
if ( !pWearable )
{
m_hMyWearables.Remove( i );
break;
}
}
#ifdef DBGFLAG_ASSERT
// Double check list integrity.
for ( int i = m_hMyWearables.Count()-1; i >= 0; --i )
{
Assert( m_hMyWearables[i] != NULL );
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::PlayWearableAnimsForPlaybackEvent( wearableanimplayback_t iPlayback )
{
// Tell all our wearables to play their animations
FOR_EACH_VEC( m_hMyWearables, i )
{
if ( m_hMyWearables[i] )
{
m_hMyWearables[i]->PlayAnimForPlaybackEvent( iPlayback );
}
}
}
#endif // USES_ECON_ITEMS
//================================================================================
// TEAM HANDLING
//================================================================================
//-----------------------------------------------------------------------------
// Purpose: Put the player in the specified team
//-----------------------------------------------------------------------------
void CBasePlayer::ChangeTeam( int iTeamNum, bool bAutoTeam, bool bSilent, bool bAutoBalance /*= false*/ )
{
if ( !GetGlobalTeam( iTeamNum ) )
{
Warning( "CBasePlayer::ChangeTeam( %d ) - invalid team index.\n", iTeamNum );
return;
}
// if this is our current team, just abort
if ( iTeamNum == GetTeamNumber() )
{
return;
}
// Immediately tell all clients that he's changing team. This has to be done
// first, so that all user messages that follow as a result of the team change
// come after this one, allowing the client to be prepared for them.
IGameEvent * event = gameeventmanager->CreateEvent( "player_team" );
if ( event )
{
event->SetInt("userid", GetUserID() );
event->SetInt("team", iTeamNum );
event->SetInt("oldteam", GetTeamNumber() );
event->SetInt("disconnect", IsDisconnecting());
event->SetInt("autoteam", bAutoTeam );
event->SetInt("silent", bSilent );
event->SetString("name", GetPlayerName() );
gameeventmanager->FireEvent( event );
}
// Remove him from his current team
if ( GetTeam() )
{
GetTeam()->RemovePlayer( this );
}
// Are we being added to a team?
if ( iTeamNum )
{
GetGlobalTeam( iTeamNum )->AddPlayer( this );
}
BaseClass::ChangeTeam( iTeamNum );
}
//-----------------------------------------------------------------------------
// Purpose: Locks a player to the spot; they can't move, shoot, or be hurt
//-----------------------------------------------------------------------------
void CBasePlayer::LockPlayerInPlace( void )
{
if ( m_iPlayerLocked )
return;
AddFlag( FL_GODMODE | FL_FROZEN );
SetMoveType( MOVETYPE_NONE );
m_iPlayerLocked = true;
// force a client data update, so that anything that has been done to
// this player previously this frame won't get delayed in being sent
UpdateClientData();
}
//-----------------------------------------------------------------------------
// Purpose: Unlocks a previously locked player
//-----------------------------------------------------------------------------
void CBasePlayer::UnlockPlayer( void )
{
if ( !m_iPlayerLocked )
return;
RemoveFlag( FL_GODMODE | FL_FROZEN );
SetMoveType( MOVETYPE_WALK );
m_iPlayerLocked = false;
}
bool CBasePlayer::ClearUseEntity()
{
if ( m_hUseEntity != NULL )
{
// Stop controlling the train/object
// TODO: Send HUD Update
m_hUseEntity->Use( this, this, USE_OFF, 0 );
m_hUseEntity = NULL;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::HideViewModels( void )
{
for ( int i = 0 ; i < MAX_VIEWMODELS; i++ )
{
CBaseViewModel *vm = GetViewModel( i );
if ( !vm )
continue;
vm->SetWeaponModel( NULL, NULL );
}
}
class CStripWeapons : public CPointEntity
{
DECLARE_CLASS( CStripWeapons, CPointEntity );
public:
void InputStripWeapons(inputdata_t &data);
void InputStripWeaponsAndSuit(inputdata_t &data);
void StripWeapons(inputdata_t &data, bool stripSuit);
DECLARE_DATADESC();
};
LINK_ENTITY_TO_CLASS( player_weaponstrip, CStripWeapons );
BEGIN_DATADESC( CStripWeapons )
DEFINE_INPUTFUNC( FIELD_VOID, "Strip", InputStripWeapons ),
DEFINE_INPUTFUNC( FIELD_VOID, "StripWeaponsAndSuit", InputStripWeaponsAndSuit ),
END_DATADESC()
void CStripWeapons::InputStripWeapons(inputdata_t &data)
{
StripWeapons(data, false);
}
void CStripWeapons::InputStripWeaponsAndSuit(inputdata_t &data)
{
StripWeapons(data, true);
}
void CStripWeapons::StripWeapons(inputdata_t &data, bool stripSuit)
{
CBasePlayer *pPlayer = NULL;
if ( data.pActivator && data.pActivator->IsPlayer() )
{
pPlayer = (CBasePlayer *)data.pActivator;
}
else if ( !g_pGameRules->IsDeathmatch() )
{
pPlayer = UTIL_GetLocalPlayer();
}
if ( pPlayer )
{
pPlayer->RemoveAllItems( stripSuit );
}
}
class CRevertSaved : public CPointEntity
{
DECLARE_CLASS( CRevertSaved, CPointEntity );
public:
void Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value );
void LoadThink( void );
DECLARE_DATADESC();
inline float Duration( void ) { return m_Duration; }
inline float HoldTime( void ) { return m_HoldTime; }
inline float LoadTime( void ) { return m_loadTime; }
inline void SetDuration( float duration ) { m_Duration = duration; }
inline void SetHoldTime( float hold ) { m_HoldTime = hold; }
inline void SetLoadTime( float time ) { m_loadTime = time; }
//Inputs
void InputReload(inputdata_t &data);
#ifdef HL1_DLL
void MessageThink( void );
inline float MessageTime( void ) { return m_messageTime; }
inline void SetMessageTime( float time ) { m_messageTime = time; }
#endif
private:
float m_loadTime;
float m_Duration;
float m_HoldTime;
#ifdef HL1_DLL
string_t m_iszMessage;
float m_messageTime;
#endif
};
LINK_ENTITY_TO_CLASS( player_loadsaved, CRevertSaved );
BEGIN_DATADESC( CRevertSaved )
#ifdef HL1_DLL
DEFINE_KEYFIELD( m_iszMessage, FIELD_STRING, "message" ),
DEFINE_KEYFIELD( m_messageTime, FIELD_FLOAT, "messagetime" ), // These are not actual times, but durations, so save as floats
DEFINE_FUNCTION( MessageThink ),
#endif
DEFINE_KEYFIELD( m_loadTime, FIELD_FLOAT, "loadtime" ),
DEFINE_KEYFIELD( m_Duration, FIELD_FLOAT, "duration" ),
DEFINE_KEYFIELD( m_HoldTime, FIELD_FLOAT, "holdtime" ),
DEFINE_INPUTFUNC( FIELD_VOID, "Reload", InputReload ),
// Function Pointers
DEFINE_FUNCTION( LoadThink ),
END_DATADESC()
CBaseEntity *CreatePlayerLoadSave( Vector vOrigin, float flDuration, float flHoldTime, float flLoadTime )
{
CRevertSaved *pRevertSaved = (CRevertSaved *) CreateEntityByName( "player_loadsaved" );
if ( pRevertSaved == NULL )
return NULL;
UTIL_SetOrigin( pRevertSaved, vOrigin );
pRevertSaved->Spawn();
pRevertSaved->SetDuration( flDuration );
pRevertSaved->SetHoldTime( flHoldTime );
pRevertSaved->SetLoadTime( flLoadTime );
return pRevertSaved;
}
void CRevertSaved::Use( CBaseEntity *pActivator, CBaseEntity *pCaller, USE_TYPE useType, float value )
{
UTIL_ScreenFadeAll( m_clrRender, Duration(), HoldTime(), FFADE_OUT );
SetNextThink( gpGlobals->curtime + LoadTime() );
SetThink( &CRevertSaved::LoadThink );
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if ( pPlayer )
{
//Adrian: Setting this flag so we can't move or save a game.
pPlayer->pl.deadflag = true;
pPlayer->AddFlag( (FL_NOTARGET|FL_FROZEN) );
// clear any pending autosavedangerous
g_ServerGameDLL.m_fAutoSaveDangerousTime = 0.0f;
g_ServerGameDLL.m_fAutoSaveDangerousMinHealthToCommit = 0.0f;
}
}
void CRevertSaved::InputReload( inputdata_t &inputdata )
{
UTIL_ScreenFadeAll( m_clrRender, Duration(), HoldTime(), FFADE_OUT );
#ifdef HL1_DLL
SetNextThink( gpGlobals->curtime + MessageTime() );
SetThink( &CRevertSaved::MessageThink );
#else
SetNextThink( gpGlobals->curtime + LoadTime() );
SetThink( &CRevertSaved::LoadThink );
#endif
CBasePlayer *pPlayer = UTIL_GetLocalPlayer();
if ( pPlayer )
{
//Adrian: Setting this flag so we can't move or save a game.
pPlayer->pl.deadflag = true;
pPlayer->AddFlag( (FL_NOTARGET|FL_FROZEN) );
// clear any pending autosavedangerous
g_ServerGameDLL.m_fAutoSaveDangerousTime = 0.0f;
g_ServerGameDLL.m_fAutoSaveDangerousMinHealthToCommit = 0.0f;
}
}
#ifdef HL1_DLL
void CRevertSaved::MessageThink( void )
{
UTIL_ShowMessageAll( STRING( m_iszMessage ) );
float nextThink = LoadTime() - MessageTime();
if ( nextThink > 0 )
{
SetNextThink( gpGlobals->curtime + nextThink );
SetThink( &CRevertSaved::LoadThink );
}
else
LoadThink();
}
#endif
void CRevertSaved::LoadThink( void )
{
if ( !gpGlobals->deathmatch )
{
engine->ServerCommand("reload\n");
}
}
#define SF_SPEED_MOD_SUPPRESS_WEAPONS (1<<0) // Take away weapons
#define SF_SPEED_MOD_SUPPRESS_HUD (1<<1) // Take away the HUD
#define SF_SPEED_MOD_SUPPRESS_JUMP (1<<2)
#define SF_SPEED_MOD_SUPPRESS_DUCK (1<<3)
#define SF_SPEED_MOD_SUPPRESS_USE (1<<4)
#define SF_SPEED_MOD_SUPPRESS_SPEED (1<<5)
#define SF_SPEED_MOD_SUPPRESS_ATTACK (1<<6)
#define SF_SPEED_MOD_SUPPRESS_ZOOM (1<<7)
class CMovementSpeedMod : public CPointEntity
{
DECLARE_CLASS( CMovementSpeedMod, CPointEntity );
public:
void InputSpeedMod(inputdata_t &data);
private:
int GetDisabledButtonMask( void );
DECLARE_DATADESC();
};
LINK_ENTITY_TO_CLASS( player_speedmod, CMovementSpeedMod );
BEGIN_DATADESC( CMovementSpeedMod )
DEFINE_INPUTFUNC( FIELD_FLOAT, "ModifySpeed", InputSpeedMod ),
END_DATADESC()
int CMovementSpeedMod::GetDisabledButtonMask( void )
{
int nMask = 0;
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_JUMP ) )
{
nMask |= IN_JUMP;
}
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_DUCK ) )
{
nMask |= IN_DUCK;
}
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_USE ) )
{
nMask |= IN_USE;
}
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_SPEED ) )
{
nMask |= IN_SPEED;
}
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_ATTACK ) )
{
nMask |= (IN_ATTACK|IN_ATTACK2);
}
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_ZOOM ) )
{
nMask |= IN_ZOOM;
}
return nMask;
}
void CMovementSpeedMod::InputSpeedMod(inputdata_t &data)
{
CBasePlayer *pPlayer = NULL;
if ( data.pActivator && data.pActivator->IsPlayer() )
{
pPlayer = (CBasePlayer *)data.pActivator;
}
else if ( !g_pGameRules->IsDeathmatch() )
{
pPlayer = UTIL_GetLocalPlayer();
}
if ( pPlayer )
{
if ( data.value.Float() != 1.0f )
{
// Holster weapon immediately, to allow it to cleanup
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_WEAPONS ) )
{
if ( pPlayer->GetActiveWeapon() )
{
pPlayer->Weapon_SetLast( pPlayer->GetActiveWeapon() );
pPlayer->GetActiveWeapon()->Holster();
pPlayer->ClearActiveWeapon();
}
pPlayer->HideViewModels();
}
// Turn off the flashlight
if ( pPlayer->FlashlightIsOn() )
{
pPlayer->FlashlightTurnOff();
}
// Disable the flashlight's further use
pPlayer->SetFlashlightEnabled( false );
pPlayer->DisableButtons( GetDisabledButtonMask() );
// Hide the HUD
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_HUD ) )
{
pPlayer->m_Local.m_iHideHUD |= HIDEHUD_ALL;
}
}
else
{
// Bring the weapon back
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_WEAPONS ) && pPlayer->GetActiveWeapon() == NULL )
{
pPlayer->SetActiveWeapon( pPlayer->GetLastWeapon() );
if ( pPlayer->GetActiveWeapon() )
{
pPlayer->GetActiveWeapon()->Deploy();
}
}
// Allow the flashlight again
pPlayer->SetFlashlightEnabled( true );
pPlayer->EnableButtons( GetDisabledButtonMask() );
// Restore the HUD
if ( HasSpawnFlags( SF_SPEED_MOD_SUPPRESS_HUD ) )
{
pPlayer->m_Local.m_iHideHUD &= ~HIDEHUD_ALL;
}
}
pPlayer->SetLaggedMovementValue( data.value.Float() );
}
}
void SendProxy_CropFlagsToPlayerFlagBitsLength( const SendProp *pProp, const void *pStruct, const void *pVarData, DVariant *pOut, int iElement, int objectID)
{
int mask = (1<<PLAYER_FLAG_BITS) - 1;
int data = *(int *)pVarData;
pOut->m_Int = ( data & mask );
}
// -------------------------------------------------------------------------------- //
// SendTable for CPlayerState.
// -------------------------------------------------------------------------------- //
BEGIN_SEND_TABLE_NOBASE(CPlayerState, DT_PlayerState)
SendPropInt (SENDINFO(deadflag), 1, SPROP_UNSIGNED ),
END_SEND_TABLE()
// -------------------------------------------------------------------------------- //
// This data only gets sent to clients that ARE this player entity.
// -------------------------------------------------------------------------------- //
BEGIN_SEND_TABLE_NOBASE( CBasePlayer, DT_LocalPlayerExclusive )
SendPropDataTable ( SENDINFO_DT(m_Local), &REFERENCE_SEND_TABLE(DT_Local) ),
// If HL2_DLL is defined, then baseflex.cpp already sends these.
#ifndef HL2_DLL
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 0), 8, SPROP_ROUNDDOWN, -32.0, 32.0f),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 1), 8, SPROP_ROUNDDOWN, -32.0, 32.0f),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecViewOffset, 2), 20, SPROP_CHANGES_OFTEN, 0.0f, 256.0f),
#endif
SendPropFloat ( SENDINFO(m_flFriction), 8, SPROP_ROUNDDOWN, 0.0f, 4.0f),
SendPropArray3 ( SENDINFO_ARRAY3(m_iAmmo), SendPropInt( SENDINFO_ARRAY(m_iAmmo), -1, SPROP_VARINT | SPROP_UNSIGNED ) ),
SendPropInt ( SENDINFO( m_fOnTarget ), 2, SPROP_UNSIGNED ),
SendPropInt ( SENDINFO( m_nTickBase ), -1, SPROP_CHANGES_OFTEN ),
SendPropInt ( SENDINFO( m_nNextThinkTick ) ),
SendPropEHandle ( SENDINFO( m_hLastWeapon ) ),
SendPropEHandle ( SENDINFO( m_hGroundEntity ), SPROP_CHANGES_OFTEN ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecVelocity, 0), 32, SPROP_NOSCALE|SPROP_CHANGES_OFTEN ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecVelocity, 1), 32, SPROP_NOSCALE|SPROP_CHANGES_OFTEN ),
SendPropFloat ( SENDINFO_VECTORELEM(m_vecVelocity, 2), 32, SPROP_NOSCALE|SPROP_CHANGES_OFTEN ),
#if PREDICTION_ERROR_CHECK_LEVEL > 1
SendPropVector ( SENDINFO( m_vecBaseVelocity ), -1, SPROP_COORD ),
#else
SendPropVector ( SENDINFO( m_vecBaseVelocity ), 20, 0, -1000, 1000 ),
#endif
SendPropEHandle ( SENDINFO( m_hConstraintEntity)),
SendPropVector ( SENDINFO( m_vecConstraintCenter), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO( m_flConstraintRadius ), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO( m_flConstraintWidth ), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO( m_flConstraintSpeedFactor ), 0, SPROP_NOSCALE ),
SendPropFloat ( SENDINFO( m_flDeathTime ), 0, SPROP_NOSCALE ),
SendPropInt ( SENDINFO( m_nWaterLevel ), 2, SPROP_UNSIGNED ),
SendPropFloat ( SENDINFO( m_flLaggedMovementValue ), 0, SPROP_NOSCALE ),
END_SEND_TABLE()
// -------------------------------------------------------------------------------- //
// DT_BasePlayer sendtable.
// -------------------------------------------------------------------------------- //
#if defined USES_ECON_ITEMS
EXTERN_SEND_TABLE(DT_AttributeList);
#endif
IMPLEMENT_SERVERCLASS_ST( CBasePlayer, DT_BasePlayer )
#if defined USES_ECON_ITEMS
SendPropDataTable(SENDINFO_DT(m_AttributeList), &REFERENCE_SEND_TABLE(DT_AttributeList)),
#endif
SendPropDataTable(SENDINFO_DT(pl), &REFERENCE_SEND_TABLE(DT_PlayerState), SendProxy_DataTableToDataTable),
SendPropEHandle(SENDINFO(m_hVehicle)),
SendPropEHandle(SENDINFO(m_hUseEntity)),
SendPropInt (SENDINFO(m_iHealth), -1, SPROP_VARINT | SPROP_CHANGES_OFTEN ),
SendPropInt (SENDINFO(m_lifeState), 3, SPROP_UNSIGNED ),
SendPropInt (SENDINFO(m_iBonusProgress), 15 ),
SendPropInt (SENDINFO(m_iBonusChallenge), 4 ),
SendPropFloat (SENDINFO(m_flMaxspeed), 12, SPROP_ROUNDDOWN, 0.0f, 2048.0f ), // CL
SendPropInt (SENDINFO(m_fFlags), PLAYER_FLAG_BITS, SPROP_UNSIGNED|SPROP_CHANGES_OFTEN, SendProxy_CropFlagsToPlayerFlagBitsLength ),
SendPropInt (SENDINFO(m_iObserverMode), 3, SPROP_UNSIGNED ),
SendPropEHandle (SENDINFO(m_hObserverTarget) ),
SendPropInt (SENDINFO(m_iFOV), 8, SPROP_UNSIGNED ),
SendPropInt (SENDINFO(m_iFOVStart), 8, SPROP_UNSIGNED ),
SendPropFloat (SENDINFO(m_flFOVTime) ),
SendPropInt (SENDINFO(m_iDefaultFOV), 8, SPROP_UNSIGNED ),
SendPropEHandle (SENDINFO(m_hZoomOwner) ),
SendPropArray ( SendPropEHandle( SENDINFO_ARRAY( m_hViewModel ) ), m_hViewModel ),
SendPropString (SENDINFO(m_szLastPlaceName) ),
#if defined USES_ECON_ITEMS
SendPropUtlVector( SENDINFO_UTLVECTOR( m_hMyWearables ), MAX_WEARABLES_SENT_FROM_SERVER, SendPropEHandle( NULL, 0 ) ),
#endif // USES_ECON_ITEMS
// Data that only gets sent to the local player.
SendPropDataTable( "localdata", 0, &REFERENCE_SEND_TABLE(DT_LocalPlayerExclusive), SendProxy_SendLocalDataTable ),
END_SEND_TABLE()
//=============================================================================
//
// Player Physics Shadow Code
//
void CBasePlayer::SetupVPhysicsShadow( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity, CPhysCollide *pStandModel, const char *pStandHullName, CPhysCollide *pCrouchModel, const char *pCrouchHullName )
{
solid_t solid;
Q_strncpy( solid.surfaceprop, "player", sizeof(solid.surfaceprop) );
solid.params = g_PhysDefaultObjectParams;
solid.params.mass = 85.0f;
solid.params.inertia = 1e24f;
solid.params.enableCollisions = false;
//disable drag
solid.params.dragCoefficient = 0;
// create standing hull
m_pShadowStand = PhysModelCreateCustom( this, pStandModel, GetLocalOrigin(), GetLocalAngles(), pStandHullName, false, &solid );
m_pShadowStand->SetCallbackFlags( CALLBACK_GLOBAL_COLLISION | CALLBACK_SHADOW_COLLISION );
// create crouchig hull
m_pShadowCrouch = PhysModelCreateCustom( this, pCrouchModel, GetLocalOrigin(), GetLocalAngles(), pCrouchHullName, false, &solid );
m_pShadowCrouch->SetCallbackFlags( CALLBACK_GLOBAL_COLLISION | CALLBACK_SHADOW_COLLISION );
// default to stand
VPhysicsSetObject( m_pShadowStand );
// tell physics lists I'm a shadow controller object
PhysAddShadow( this );
m_pPhysicsController = physenv->CreatePlayerController( m_pShadowStand );
m_pPhysicsController->SetPushMassLimit( 350.0f );
m_pPhysicsController->SetPushSpeedLimit( 50.0f );
// Give the controller a valid position so it doesn't do anything rash.
UpdatePhysicsShadowToPosition( vecAbsOrigin );
// init state
if ( GetFlags() & FL_DUCKING )
{
SetVCollisionState( vecAbsOrigin, vecAbsVelocity, VPHYS_CROUCH );
}
else
{
SetVCollisionState( vecAbsOrigin, vecAbsVelocity, VPHYS_WALK );
}
}
//-----------------------------------------------------------------------------
// Purpose: Empty, just want to keep the baseentity version from being called
// current so we don't kick up dust, etc.
//-----------------------------------------------------------------------------
void CBasePlayer::VPhysicsCollision( int index, gamevcollisionevent_t *pEvent )
{
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::VPhysicsUpdate( IPhysicsObject *pPhysics )
{
float savedImpact = m_impactEnergyScale;
// HACKHACK: Reduce player's stress by 1/8th
m_impactEnergyScale *= 0.125f;
ApplyStressDamage( pPhysics, true );
m_impactEnergyScale = savedImpact;
}
//-----------------------------------------------------------------------------
// Purpose: Allow bots etc to use slightly different solid masks
//-----------------------------------------------------------------------------
unsigned int CBasePlayer::PlayerSolidMask( bool brushOnly ) const
{
if ( brushOnly )
{
return MASK_PLAYERSOLID_BRUSHONLY;
}
return MASK_PLAYERSOLID;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::VPhysicsShadowUpdate( IPhysicsObject *pPhysics )
{
if ( sv_turbophysics.GetBool() )
return;
Vector newPosition;
bool physicsUpdated = m_pPhysicsController->GetShadowPosition( &newPosition, NULL ) > 0 ? true : false;
// UNDONE: If the player is penetrating, but the player's game collisions are not stuck, teleport the physics shadow to the game position
if ( pPhysics->GetGameFlags() & FVPHYSICS_PENETRATING )
{
CUtlVector<CBaseEntity *> list;
PhysGetListOfPenetratingEntities( this, list );
for ( int i = list.Count()-1; i >= 0; --i )
{
// filter out anything that isn't simulated by vphysics
// UNDONE: Filter out motion disabled objects?
if ( list[i]->GetMoveType() == MOVETYPE_VPHYSICS )
{
// I'm currently stuck inside a moving object, so allow vphysics to
// apply velocity to the player in order to separate these objects
m_touchedPhysObject = true;
}
// if it's an NPC, tell them that the player is intersecting them
CAI_BaseNPC *pNPC = list[i]->MyNPCPointer();
if ( pNPC )
{
pNPC->PlayerPenetratingVPhysics();
}
}
}
bool bCheckStuck = false;
if ( m_afPhysicsFlags & PFLAG_GAMEPHYSICS_ROTPUSH )
{
bCheckStuck = true;
m_afPhysicsFlags &= ~PFLAG_GAMEPHYSICS_ROTPUSH;
}
if ( m_pPhysicsController->IsInContact() || (m_afPhysicsFlags & PFLAG_VPHYSICS_MOTIONCONTROLLER) )
{
m_touchedPhysObject = true;
}
if ( IsFollowingPhysics() )
{
m_touchedPhysObject = true;
}
if ( GetMoveType() == MOVETYPE_NOCLIP || pl.deadflag )
{
m_oldOrigin = GetAbsOrigin();
return;
}
if ( phys_timescale.GetFloat() == 0.0f )
{
physicsUpdated = false;
}
if ( !physicsUpdated )
return;
IPhysicsObject *pPhysGround = GetGroundVPhysics();
Vector newVelocity;
pPhysics->GetPosition( &newPosition, 0 );
m_pPhysicsController->GetShadowVelocity( &newVelocity );
// assume vphysics gave us back a position without penetration
Vector lastValidPosition = newPosition;
if ( physicsshadowupdate_render.GetBool() )
{
NDebugOverlay::Box( GetAbsOrigin(), WorldAlignMins(), WorldAlignMaxs(), 255, 0, 0, 24, 15.0f );
NDebugOverlay::Box( newPosition, WorldAlignMins(), WorldAlignMaxs(), 0,0,255, 24, 15.0f);
// NDebugOverlay::Box( newPosition, WorldAlignMins(), WorldAlignMaxs(), 0,0,255, 24, .01f);
}
Vector tmp = GetAbsOrigin() - newPosition;
if ( !m_touchedPhysObject && !(GetFlags() & FL_ONGROUND) )
{
tmp.z *= 0.5f; // don't care about z delta as much
}
float dist = tmp.LengthSqr();
float deltaV = (newVelocity - GetAbsVelocity()).LengthSqr();
float maxDistErrorSqr = VPHYS_MAX_DISTSQR;
float maxVelErrorSqr = VPHYS_MAX_VELSQR;
if ( IsRideablePhysics(pPhysGround) )
{
maxDistErrorSqr *= 0.25;
maxVelErrorSqr *= 0.25;
}
// player's physics was frozen, try moving to the game's simulated position if possible
if ( m_pPhysicsController->WasFrozen() )
{
m_bPhysicsWasFrozen = true;
// check my position (physics object could have simulated into my position
// physics is not very far away, check my position
trace_t trace;
UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(), MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( !trace.startsolid )
return;
// The physics shadow position is probably not in solid, try to move from there to the desired position
UTIL_TraceEntity( this, newPosition, GetAbsOrigin(), MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( !trace.startsolid )
{
// found a valid position between the two? take it.
SetAbsOrigin( trace.endpos );
UpdateVPhysicsPosition(trace.endpos, vec3_origin, 0);
return;
}
}
if ( dist >= maxDistErrorSqr || deltaV >= maxVelErrorSqr || (pPhysGround && !m_touchedPhysObject) )
{
if ( m_touchedPhysObject || pPhysGround )
{
// BUGBUG: Rewrite this code using fixed timestep
if ( deltaV >= maxVelErrorSqr && !m_bPhysicsWasFrozen )
{
Vector dir = GetAbsVelocity();
float len = VectorNormalize(dir);
float dot = DotProduct( newVelocity, dir );
if ( dot > len )
{
dot = len;
}
else if ( dot < -len )
{
dot = -len;
}
VectorMA( newVelocity, -dot, dir, newVelocity );
if ( m_afPhysicsFlags & PFLAG_VPHYSICS_MOTIONCONTROLLER )
{
float val = Lerp( 0.1f, len, dot );
VectorMA( newVelocity, val - len, dir, newVelocity );
}
if ( !IsRideablePhysics(pPhysGround) )
{
if ( !(m_afPhysicsFlags & PFLAG_VPHYSICS_MOTIONCONTROLLER ) && IsSimulatingOnAlternateTicks() )
{
newVelocity *= 0.5f;
}
ApplyAbsVelocityImpulse( newVelocity );
}
}
trace_t trace;
UTIL_TraceEntity( this, newPosition, newPosition, MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
if ( !trace.allsolid && !trace.startsolid )
{
SetAbsOrigin( newPosition );
}
}
else
{
bCheckStuck = true;
}
}
else
{
if ( m_touchedPhysObject )
{
// check my position (physics object could have simulated into my position
// physics is not very far away, check my position
trace_t trace;
UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(),
MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
// is current position ok?
if ( trace.allsolid || trace.startsolid )
{
// no use the final stuck check to move back to old if this stuck fix didn't work
bCheckStuck = true;
lastValidPosition = m_oldOrigin;
SetAbsOrigin( newPosition );
}
}
}
if ( bCheckStuck )
{
trace_t trace;
UTIL_TraceEntity( this, GetAbsOrigin(), GetAbsOrigin(), MASK_PLAYERSOLID, this, COLLISION_GROUP_PLAYER_MOVEMENT, &trace );
// current position is not ok, fixup
if ( trace.allsolid || trace.startsolid )
{
// STUCK!?!?!
//Warning( "Checkstuck failed. Stuck on %s!!\n", trace.m_pEnt->GetClassname() );
SetAbsOrigin( lastValidPosition );
}
}
m_oldOrigin = GetAbsOrigin();
m_bPhysicsWasFrozen = false;
}
// recreate physics on save/load, don't try to save the state!
bool CBasePlayer::ShouldSavePhysics()
{
return false;
}
void CBasePlayer::RefreshCollisionBounds( void )
{
BaseClass::RefreshCollisionBounds();
InitVCollision( GetAbsOrigin(), GetAbsVelocity() );
SetViewOffset( VEC_VIEW_SCALED( this ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::InitVCollision( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity )
{
// Cleanup any old vphysics stuff.
VPhysicsDestroyObject();
// in turbo physics players dont have a physics shadow
if ( sv_turbophysics.GetBool() )
return;
CPhysCollide *pModel = PhysCreateBbox( VEC_HULL_MIN_SCALED( this ), VEC_HULL_MAX_SCALED( this ) );
CPhysCollide *pCrouchModel = PhysCreateBbox( VEC_DUCK_HULL_MIN_SCALED( this ), VEC_DUCK_HULL_MAX_SCALED( this ) );
SetupVPhysicsShadow( vecAbsOrigin, vecAbsVelocity, pModel, "player_stand", pCrouchModel, "player_crouch" );
}
void CBasePlayer::VPhysicsDestroyObject()
{
// Since CBasePlayer aliases its pointer to the physics object, tell CBaseEntity to
// clear out its physics object pointer so we don't wind up deleting one of
// the aliased objects twice.
VPhysicsSetObject( NULL );
PhysRemoveShadow( this );
if ( m_pPhysicsController )
{
physenv->DestroyPlayerController( m_pPhysicsController );
m_pPhysicsController = NULL;
}
if ( m_pShadowStand )
{
m_pShadowStand->EnableCollisions( false );
PhysDestroyObject( m_pShadowStand );
m_pShadowStand = NULL;
}
if ( m_pShadowCrouch )
{
m_pShadowCrouch->EnableCollisions( false );
PhysDestroyObject( m_pShadowCrouch );
m_pShadowCrouch = NULL;
}
BaseClass::VPhysicsDestroyObject();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::SetVCollisionState( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity, int collisionState )
{
m_vphysicsCollisionState = collisionState;
switch( collisionState )
{
case VPHYS_WALK:
m_pShadowStand->SetPosition( vecAbsOrigin, vec3_angle, true );
m_pShadowStand->SetVelocity( &vecAbsVelocity, NULL );
m_pShadowCrouch->EnableCollisions( false );
m_pPhysicsController->SetObject( m_pShadowStand );
VPhysicsSwapObject( m_pShadowStand );
m_pShadowStand->EnableCollisions( true );
break;
case VPHYS_CROUCH:
m_pShadowCrouch->SetPosition( vecAbsOrigin, vec3_angle, true );
m_pShadowCrouch->SetVelocity( &vecAbsVelocity, NULL );
m_pShadowStand->EnableCollisions( false );
m_pPhysicsController->SetObject( m_pShadowCrouch );
VPhysicsSwapObject( m_pShadowCrouch );
m_pShadowCrouch->EnableCollisions( true );
break;
case VPHYS_NOCLIP:
m_pShadowCrouch->EnableCollisions( false );
m_pShadowStand->EnableCollisions( false );
break;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CBasePlayer::GetFOV( void )
{
int nDefaultFOV;
// The vehicle's FOV wins if we're asking for a default value
if ( GetVehicle() )
{
CacheVehicleView();
nDefaultFOV = ( m_flVehicleViewFOV == 0 ) ? GetDefaultFOV() : (int) m_flVehicleViewFOV;
}
else
{
nDefaultFOV = GetDefaultFOV();
}
int fFOV = ( m_iFOV == 0 ) ? nDefaultFOV : m_iFOV;
// If it's immediate, just do it
if ( m_Local.m_flFOVRate == 0.0f )
return fFOV;
float deltaTime = (float)( gpGlobals->curtime - m_flFOVTime ) / m_Local.m_flFOVRate;
if ( deltaTime >= 1.0f )
{
//If we're past the zoom time, just take the new value and stop lerping
m_iFOVStart = fFOV;
}
else
{
fFOV = SimpleSplineRemapValClamped( deltaTime, 0.0f, 1.0f, m_iFOVStart, fFOV );
}
return fFOV;
}
//-----------------------------------------------------------------------------
// Get the current FOV used for network computations
// Choose the smallest FOV, as it will open the largest number of portals
//-----------------------------------------------------------------------------
int CBasePlayer::GetFOVForNetworking( void )
{
int nDefaultFOV;
// The vehicle's FOV wins if we're asking for a default value
if ( GetVehicle() )
{
CacheVehicleView();
nDefaultFOV = ( m_flVehicleViewFOV == 0 ) ? GetDefaultFOV() : (int) m_flVehicleViewFOV;
}
else
{
nDefaultFOV = GetDefaultFOV();
}
int fFOV = ( m_iFOV == 0 ) ? nDefaultFOV : m_iFOV;
// If it's immediate, just do it
if ( m_Local.m_flFOVRate == 0.0f )
return fFOV;
if ( gpGlobals->curtime - m_flFOVTime < m_Local.m_flFOVRate )
{
fFOV = MIN( fFOV, m_iFOVStart );
}
return fFOV;
}
float CBasePlayer::GetFOVDistanceAdjustFactorForNetworking()
{
float defaultFOV = (float)GetDefaultFOV();
float localFOV = (float)GetFOVForNetworking();
if ( localFOV == defaultFOV || defaultFOV < 0.001f )
return 1.0f;
// If FOV is lower, then we're "zoomed" in and this will give a factor < 1 so apparent LOD distances can be
// shorted accordingly
return localFOV / defaultFOV;
}
//-----------------------------------------------------------------------------
// Purpose: Sets the default FOV for the player if nothing else is going on
// Input : FOV - the new base FOV for this player
//-----------------------------------------------------------------------------
void CBasePlayer::SetDefaultFOV( int FOV )
{
m_iDefaultFOV = ( FOV == 0 ) ? g_pGameRules->DefaultFOV() : FOV;
}
//-----------------------------------------------------------------------------
// Purpose: // static func
// Input : set -
//-----------------------------------------------------------------------------
void CBasePlayer::ModifyOrAppendPlayerCriteria( AI_CriteriaSet& set )
{
// Append our health
set.AppendCriteria( "playerhealth", UTIL_VarArgs( "%i", GetHealth() ) );
float healthfrac = 0.0f;
if ( GetMaxHealth() > 0 )
{
healthfrac = (float)GetHealth() / (float)GetMaxHealth();
}
set.AppendCriteria( "playerhealthfrac", UTIL_VarArgs( "%.3f", healthfrac ) );
CBaseCombatWeapon *weapon = GetActiveWeapon();
if ( weapon )
{
set.AppendCriteria( "playerweapon", weapon->GetClassname() );
}
else
{
set.AppendCriteria( "playerweapon", "none" );
}
// Append current activity name
set.AppendCriteria( "playeractivity", CAI_BaseNPC::GetActivityName( GetActivity() ) );
set.AppendCriteria( "playerspeed", UTIL_VarArgs( "%.3f", GetAbsVelocity().Length() ) );
AppendContextToCriteria( set, "player" );
}
const QAngle& CBasePlayer::GetPunchAngle()
{
return m_Local.m_vecPunchAngle.Get();
}
void CBasePlayer::SetPunchAngle( const QAngle &punchAngle )
{
m_Local.m_vecPunchAngle = punchAngle;
if ( IsAlive() )
{
int index = entindex();
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer && i != index && pPlayer->GetObserverTarget() == this && pPlayer->GetObserverMode() == OBS_MODE_IN_EYE )
{
pPlayer->SetPunchAngle( punchAngle );
}
}
}
}
//-----------------------------------------------------------------------------
// Purpose: Apply a movement constraint to the player
//-----------------------------------------------------------------------------
void CBasePlayer::ActivateMovementConstraint( CBaseEntity *pEntity, const Vector &vecCenter, float flRadius, float flConstraintWidth, float flSpeedFactor )
{
m_hConstraintEntity = pEntity;
m_vecConstraintCenter = vecCenter;
m_flConstraintRadius = flRadius;
m_flConstraintWidth = flConstraintWidth;
m_flConstraintSpeedFactor = flSpeedFactor;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::DeactivateMovementConstraint( )
{
m_hConstraintEntity = NULL;
m_flConstraintRadius = 0.0f;
m_vecConstraintCenter = vec3_origin;
}
//-----------------------------------------------------------------------------
// Perhaps a poorly-named function. This function traces against the supplied
// NPC's hitboxes (instead of hull). If the trace hits a different NPC, the
// new NPC is selected. Otherwise, the supplied NPC is determined to be the
// one the citizen wants. This function allows the selection of a citizen over
// another citizen's shoulder, which is impossible without tracing against
// hitboxes instead of the hull (sjb)
//-----------------------------------------------------------------------------
CBaseEntity *CBasePlayer::DoubleCheckUseNPC( CBaseEntity *pNPC, const Vector &vecSrc, const Vector &vecDir )
{
trace_t tr;
UTIL_TraceLine( vecSrc, vecSrc + vecDir * 1024, MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
if( tr.m_pEnt != NULL && tr.m_pEnt->MyNPCPointer() && tr.m_pEnt != pNPC )
{
// Player is selecting a different NPC through some negative space
// in the first NPC's hitboxes (between legs, over shoulder, etc).
return tr.m_pEnt;
}
return pNPC;
}
bool CBasePlayer::IsBot() const
{
return (GetFlags() & FL_FAKECLIENT) != 0;
}
bool CBasePlayer::IsFakeClient() const
{
return (GetFlags() & FL_FAKECLIENT) != 0;
}
void CBasePlayer::EquipSuit( bool bPlayEffects )
{
m_Local.m_bWearingSuit = true;
}
void CBasePlayer::RemoveSuit( void )
{
m_Local.m_bWearingSuit = false;
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : &tr -
// nDamageType -
//-----------------------------------------------------------------------------
void CBasePlayer::DoImpactEffect( trace_t &tr, int nDamageType )
{
if ( GetActiveWeapon() )
{
GetActiveWeapon()->DoImpactEffect( tr, nDamageType );
return;
}
BaseClass::DoImpactEffect( tr, nDamageType );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::InputSetHealth( inputdata_t &inputdata )
{
int iNewHealth = inputdata.value.Int();
int iDelta = abs(GetHealth() - iNewHealth);
if ( iNewHealth > GetHealth() )
{
TakeHealth( iDelta, DMG_GENERIC );
}
else if ( iNewHealth < GetHealth() )
{
// Strip off and restore armor so that it doesn't absorb any of this damage.
int armor = m_ArmorValue;
m_ArmorValue = 0;
TakeDamage( CTakeDamageInfo( this, this, iDelta, DMG_GENERIC ) );
m_ArmorValue = armor;
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::InputHandleMapEvent( inputdata_t &inputdata )
{
Internal_HandleMapEvent( inputdata );
}
//-----------------------------------------------------------------------------
// Purpose: Hides or displays the HUD
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBasePlayer::InputSetHUDVisibility( inputdata_t &inputdata )
{
bool bEnable = inputdata.value.Bool();
if ( bEnable )
{
m_Local.m_iHideHUD &= ~HIDEHUD_ALL;
}
else
{
m_Local.m_iHideHUD |= HIDEHUD_ALL;
}
}
//-----------------------------------------------------------------------------
// Purpose: Set the fog controller data per player.
// Input : &inputdata -
//-----------------------------------------------------------------------------
void CBasePlayer::InputSetFogController( inputdata_t &inputdata )
{
// Find the fog controller with the given name.
CFogController *pFogController = dynamic_cast<CFogController*>( gEntList.FindEntityByName( NULL, inputdata.value.String() ) );
if ( pFogController )
{
m_Local.m_PlayerFog.m_hCtrl.Set( pFogController );
}
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void CBasePlayer::InitFogController( void )
{
// Setup with the default master controller.
m_Local.m_PlayerFog.m_hCtrl = FogSystem()->GetMasterFogController();
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : *pEntity -
//-----------------------------------------------------------------------------
void CBasePlayer::SetViewEntity( CBaseEntity *pEntity )
{
m_hViewEntity = pEntity;
if ( m_hViewEntity )
{
engine->SetView( edict(), m_hViewEntity->edict() );
}
else
{
engine->SetView( edict(), edict() );
}
}
//-----------------------------------------------------------------------------
// Purpose: Looks at the player's reserve ammo and also all his weapons for any ammo
// of the specified type
// Input : nAmmoIndex - ammo to look for
// Output : Returns true on success, false on failure.
//-----------------------------------------------------------------------------
bool CBasePlayer::HasAnyAmmoOfType( int nAmmoIndex )
{
// Must be a valid index
if ( nAmmoIndex < 0 )
return false;
// If we have some in reserve, we're already done
if ( GetAmmoCount( nAmmoIndex ) )
return true;
CBaseCombatWeapon *pWeapon;
// Check all held weapons
for ( int i=0; i < MAX_WEAPONS; i++ )
{
pWeapon = GetWeapon( i );
if ( !pWeapon )
continue;
// We must use clips and use this sort of ammo
if ( pWeapon->UsesClipsForAmmo1() && pWeapon->GetPrimaryAmmoType() == nAmmoIndex )
{
// If we have any ammo, we're done
if ( pWeapon->HasPrimaryAmmo() )
return true;
}
// We'll check both clips for the same ammo type, just in case
if ( pWeapon->UsesClipsForAmmo2() && pWeapon->GetSecondaryAmmoType() == nAmmoIndex )
{
if ( pWeapon->HasSecondaryAmmo() )
return true;
}
}
// We're completely without this type of ammo
return false;
}
bool CBasePlayer::HandleVoteCommands( const CCommand &args )
{
if( g_voteController == NULL )
return false;
if( FStrEq( args[0], "Vote" ) )
{
if( args.ArgC() < 2 )
return true;
const char *arg2 = args[1];
char szResultString[MAX_COMMAND_LENGTH];
CVoteController::TryCastVoteResult nTryResult = g_voteController->TryCastVote( entindex(), arg2 );
switch( nTryResult )
{
case CVoteController::CAST_OK:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Voting %s.\n", arg2 );
break;
}
case CVoteController::CAST_FAIL_SERVER_DISABLE:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Vote failed: server disabled.\n" );
break;
}
case CVoteController::CAST_FAIL_NO_ACTIVE_ISSUE:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "A vote has not been called.\n" );
break;
}
case CVoteController::CAST_FAIL_TEAM_RESTRICTED:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Vote failed: team restricted.\n" );
break;
}
case CVoteController::CAST_FAIL_NO_CHANGES:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Vote failed: no changing vote.\n" );
break;
}
case CVoteController::CAST_FAIL_DUPLICATE:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Vote failed: already voting %s.\n", arg2 );
break;
}
case CVoteController::CAST_FAIL_VOTE_CLOSED:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Vote failed: voting closed.\n" );
break;
}
case CVoteController::CAST_FAIL_SYSTEM_ERROR:
default:
{
Q_snprintf( szResultString, MAX_COMMAND_LENGTH, "Vote failed: system error.\n" );
break;
}
}
DevMsg( "%s", szResultString );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// return a string version of the players network (i.e steam) ID.
//
//-----------------------------------------------------------------------------
const char *CBasePlayer::GetNetworkIDString()
{
const char *pStr = engine->GetPlayerNetworkIDString( edict() );
Q_strncpy( m_szNetworkIDString, pStr ? pStr : "", sizeof(m_szNetworkIDString) );
return m_szNetworkIDString;
}
//-----------------------------------------------------------------------------
// Assign the player a name
//-----------------------------------------------------------------------------
void CBasePlayer::SetPlayerName( const char *name )
{
Assert( name );
if ( name )
{
Assert( strlen(name) > 0 );
Q_strncpy( m_szNetname, name, sizeof(m_szNetname) );
}
}
//-----------------------------------------------------------------------------
// sets the "don't autokick me" flag on a player
//-----------------------------------------------------------------------------
class DisableAutokick
{
public:
DisableAutokick( int userID )
{
m_userID = userID;
}
bool operator()( CBasePlayer *player )
{
if ( player->GetUserID() == m_userID )
{
Msg( "autokick is disabled for %s\n", player->GetPlayerName() );
player->DisableAutoKick( true );
return false; // don't need to check other players
}
return true; // keep looking at other players
}
private:
int m_userID;
};
//-----------------------------------------------------------------------------
// sets the "don't autokick me" flag on a player
//-----------------------------------------------------------------------------
CON_COMMAND( mp_disable_autokick, "Prevents a userid from being auto-kicked" )
{
if ( !UTIL_IsCommandIssuedByServerAdmin() )
return;
if ( args.ArgC() != 2 )
{
Msg( "Usage: mp_disable_autokick <userid>\n" );
return;
}
int userID = atoi( args[1] );
DisableAutokick disable( userID );
ForEachPlayer( disable );
}
//-----------------------------------------------------------------------------
// Purpose: Toggle between the duck being on and off
//-----------------------------------------------------------------------------
void CBasePlayer::ToggleDuck( void )
{
// Toggle the state
m_bDuckToggled = !m_bDuckToggled;
}
//-----------------------------------------------------------------------------
// Just tells us how far the stick is from the center. No directional info
//-----------------------------------------------------------------------------
float CBasePlayer::GetStickDist()
{
Vector2D controlStick;
controlStick.x = m_flForwardMove;
controlStick.y = m_flSideMove;
return controlStick.Length();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CBasePlayer::HandleAnimEvent( animevent_t *pEvent )
{
if ((pEvent->type & AE_TYPE_NEWEVENTSYSTEM) && (pEvent->type & AE_TYPE_SERVER))
{
if ( pEvent->event == AE_RAGDOLL )
{
// Convert to ragdoll immediately
CreateRagdollEntity();
BecomeRagdollOnClient( vec3_origin );
// Force the player to start death thinking
SetThink(&CBasePlayer::PlayerDeathThink);
SetNextThink( gpGlobals->curtime + 0.1f );
return;
}
}
BaseClass::HandleAnimEvent( pEvent );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBasePlayer::ShouldAnnounceAchievement( void )
{
m_flAchievementTimes.AddToTail( gpGlobals->curtime );
if ( m_flAchievementTimes.Count() > 3 )
{
m_flAchievementTimes.Remove( 0 );
if ( m_flAchievementTimes.Tail() - m_flAchievementTimes.Head() <= 60.0 )
{
return false;
}
}
return true;
}
//-----------------------------------------------------------------------------
// CPlayerInfo functions (simple pass-through to get around the CBasePlayer multiple inheritance limitation)
//-----------------------------------------------------------------------------
const char *CPlayerInfo::GetName()
{
Assert( m_pParent );
return m_pParent->GetPlayerName();
}
int CPlayerInfo::GetUserID()
{
Assert( m_pParent );
return engine->GetPlayerUserId( m_pParent->edict() );
}
const char *CPlayerInfo::GetNetworkIDString()
{
Assert( m_pParent );
return m_pParent->GetNetworkIDString();
}
int CPlayerInfo::GetTeamIndex()
{
Assert( m_pParent );
return m_pParent->GetTeamNumber();
}
void CPlayerInfo::ChangeTeam( int iTeamNum )
{
Assert( m_pParent );
m_pParent->ChangeTeam(iTeamNum);
}
int CPlayerInfo::GetFragCount()
{
Assert( m_pParent );
return m_pParent->FragCount();
}
int CPlayerInfo::GetDeathCount()
{
Assert( m_pParent );
return m_pParent->DeathCount();
}
bool CPlayerInfo::IsConnected()
{
Assert( m_pParent );
return m_pParent->IsConnected();
}
int CPlayerInfo::GetArmorValue()
{
Assert( m_pParent );
return m_pParent->ArmorValue();
}
bool CPlayerInfo::IsHLTV()
{
Assert( m_pParent );
return m_pParent->IsHLTV();
}
bool CPlayerInfo::IsReplay()
{
#ifdef TF_DLL // FIXME: Need run-time check for whether replay is enabled
Assert( m_pParent );
return m_pParent->IsReplay();
#else
return false;
#endif
}
bool CPlayerInfo::IsPlayer()
{
Assert( m_pParent );
return m_pParent->IsPlayer();
}
bool CPlayerInfo::IsFakeClient()
{
Assert( m_pParent );
return m_pParent->IsFakeClient();
}
bool CPlayerInfo::IsDead()
{
Assert( m_pParent );
return m_pParent->IsDead();
}
bool CPlayerInfo::IsInAVehicle()
{
Assert( m_pParent );
return m_pParent->IsInAVehicle();
}
bool CPlayerInfo::IsObserver()
{
Assert( m_pParent );
return m_pParent->IsObserver();
}
const Vector CPlayerInfo::GetAbsOrigin()
{
Assert( m_pParent );
return m_pParent->GetAbsOrigin();
}
const QAngle CPlayerInfo::GetAbsAngles()
{
Assert( m_pParent );
return m_pParent->GetAbsAngles();
}
const Vector CPlayerInfo::GetPlayerMins()
{
Assert( m_pParent );
return m_pParent->GetPlayerMins();
}
const Vector CPlayerInfo::GetPlayerMaxs()
{
Assert( m_pParent );
return m_pParent->GetPlayerMaxs();
}
const char *CPlayerInfo::GetWeaponName()
{
Assert( m_pParent );
CBaseCombatWeapon *weap = m_pParent->GetActiveWeapon();
if ( !weap )
{
return NULL;
}
return weap->GetName();
}
const char *CPlayerInfo::GetModelName()
{
Assert( m_pParent );
return m_pParent->GetModelName().ToCStr();
}
const int CPlayerInfo::GetHealth()
{
Assert( m_pParent );
return m_pParent->GetHealth();
}
const int CPlayerInfo::GetMaxHealth()
{
Assert( m_pParent );
return m_pParent->GetMaxHealth();
}
void CPlayerInfo::SetAbsOrigin( Vector & vec )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
m_pParent->SetAbsOrigin(vec);
}
}
void CPlayerInfo::SetAbsAngles( QAngle & ang )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
m_pParent->SetAbsAngles(ang);
}
}
void CPlayerInfo::RemoveAllItems( bool removeSuit )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
m_pParent->RemoveAllItems(removeSuit);
}
}
void CPlayerInfo::SetActiveWeapon( const char *WeaponName )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
CBaseCombatWeapon *weap = m_pParent->Weapon_Create( WeaponName );
if ( weap )
{
m_pParent->Weapon_Equip(weap);
m_pParent->Weapon_Switch(weap);
}
}
}
void CPlayerInfo::SetLocalOrigin( const Vector& origin )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
m_pParent->SetLocalOrigin(origin);
}
}
const Vector CPlayerInfo::GetLocalOrigin( void )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
Vector origin = m_pParent->GetLocalOrigin();
return origin;
}
else
{
return Vector( 0, 0, 0 );
}
}
void CPlayerInfo::SetLocalAngles( const QAngle& angles )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
m_pParent->SetLocalAngles( angles );
}
}
const QAngle CPlayerInfo::GetLocalAngles( void )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
return m_pParent->GetLocalAngles();
}
else
{
return QAngle();
}
}
bool CPlayerInfo::IsEFlagSet( int nEFlagMask )
{
Assert( m_pParent );
if ( m_pParent->IsBot() )
{
return m_pParent->IsEFlagSet(nEFlagMask);
}
return false;
}
void CPlayerInfo::RunPlayerMove( CBotCmd *ucmd )
{
if ( m_pParent->IsBot() )
{
Assert( m_pParent );
CUserCmd cmd;
cmd.buttons = ucmd->buttons;
cmd.command_number = ucmd->command_number;
cmd.forwardmove = ucmd->forwardmove;
cmd.hasbeenpredicted = ucmd->hasbeenpredicted;
cmd.impulse = ucmd->impulse;
cmd.mousedx = ucmd->mousedx;
cmd.mousedy = ucmd->mousedy;
cmd.random_seed = ucmd->random_seed;
cmd.sidemove = ucmd->sidemove;
cmd.tick_count = ucmd->tick_count;
cmd.upmove = ucmd->upmove;
cmd.viewangles = ucmd->viewangles;
cmd.weaponselect = ucmd->weaponselect;
cmd.weaponsubtype = ucmd->weaponsubtype;
// Store off the globals.. they're gonna get whacked
float flOldFrametime = gpGlobals->frametime;
float flOldCurtime = gpGlobals->curtime;
m_pParent->SetTimeBase( gpGlobals->curtime );
MoveHelperServer()->SetHost( m_pParent );
m_pParent->PlayerRunCommand( &cmd, MoveHelperServer() );
// save off the last good usercmd
m_pParent->SetLastUserCommand( cmd );
// Clear out any fixangle that has been set
m_pParent->pl.fixangle = FIXANGLE_NONE;
// Restore the globals..
gpGlobals->frametime = flOldFrametime;
gpGlobals->curtime = flOldCurtime;
MoveHelperServer()->SetHost( NULL );
}
}
void CPlayerInfo::SetLastUserCommand( const CBotCmd &ucmd )
{
if ( m_pParent->IsBot() )
{
Assert( m_pParent );
CUserCmd cmd;
cmd.buttons = ucmd.buttons;
cmd.command_number = ucmd.command_number;
cmd.forwardmove = ucmd.forwardmove;
cmd.hasbeenpredicted = ucmd.hasbeenpredicted;
cmd.impulse = ucmd.impulse;
cmd.mousedx = ucmd.mousedx;
cmd.mousedy = ucmd.mousedy;
cmd.random_seed = ucmd.random_seed;
cmd.sidemove = ucmd.sidemove;
cmd.tick_count = ucmd.tick_count;
cmd.upmove = ucmd.upmove;
cmd.viewangles = ucmd.viewangles;
cmd.weaponselect = ucmd.weaponselect;
cmd.weaponsubtype = ucmd.weaponsubtype;
m_pParent->SetLastUserCommand(cmd);
}
}
CBotCmd CPlayerInfo::GetLastUserCommand()
{
CBotCmd cmd;
const CUserCmd *ucmd = m_pParent->GetLastUserCommand();
if ( ucmd )
{
cmd.buttons = ucmd->buttons;
cmd.command_number = ucmd->command_number;
cmd.forwardmove = ucmd->forwardmove;
cmd.hasbeenpredicted = ucmd->hasbeenpredicted;
cmd.impulse = ucmd->impulse;
cmd.mousedx = ucmd->mousedx;
cmd.mousedy = ucmd->mousedy;
cmd.random_seed = ucmd->random_seed;
cmd.sidemove = ucmd->sidemove;
cmd.tick_count = ucmd->tick_count;
cmd.upmove = ucmd->upmove;
cmd.viewangles = ucmd->viewangles;
cmd.weaponselect = ucmd->weaponselect;
cmd.weaponsubtype = ucmd->weaponsubtype;
}
return cmd;
}
// Notify that I've killed some other entity. (called from Victim's Event_Killed).
void CBasePlayer::Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info )
{
BaseClass::Event_KilledOther( pVictim, info );
if ( pVictim != this )
{
gamestats->Event_PlayerKilledOther( this, pVictim, info );
}
else
{
gamestats->Event_PlayerSuicide( this );
}
}
void CBasePlayer::SetModel( const char *szModelName )
{
BaseClass::SetModel( szModelName );
m_nBodyPitchPoseParam = LookupPoseParameter( "body_pitch" );
}
void CBasePlayer::SetBodyPitch( float flPitch )
{
if ( m_nBodyPitchPoseParam >= 0 )
{
SetPoseParameter( m_nBodyPitchPoseParam, flPitch );
}
}
void CBasePlayer::AdjustDrownDmg( int nAmount )
{
m_idrowndmg += nAmount;
if ( m_idrowndmg < m_idrownrestored )
{
m_idrowndmg = m_idrownrestored;
}
}
#if !defined(NO_STEAM)
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CBasePlayer::GetSteamID( CSteamID *pID )
{
const CSteamID *pClientID = engine->GetClientSteamID( edict() );
if ( pClientID )
{
*pID = *pClientID;
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
uint64 CBasePlayer::GetSteamIDAsUInt64( void )
{
CSteamID steamIDForPlayer;
if ( GetSteamID( &steamIDForPlayer ) )
return steamIDForPlayer.ConvertToUint64();
return 0;
}
#endif // NO_STEAM
Reference in New Issue Copy Permalink