H3cJP/source-engine
1
0
Fork 0
mirror of https://github.com/nillerusr/source-engine.git synced 2024-12-23 14:46:53 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
c625d789a7
source-engine/game/server/player.h

1553 lines
53 KiB
C
Raw Normal View History

1
2020-04-22 16:56:21 +00:00
//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//===========================================================================//
#ifndef PLAYER_H
#define PLAYER_H
#ifdef _WIN32
#pragma once
#endif
#include "basecombatcharacter.h"
#include "usercmd.h"
#include "playerlocaldata.h"
#include "PlayerState.h"
#include "game/server/iplayerinfo.h"
#include "hintsystem.h"
#include "SoundEmitterSystem/isoundemittersystembase.h"
#include "util_shared.h"
#if defined USES_ECON_ITEMS
#include "game_item_schema.h"
#include "econ_item_view.h"
#endif
// For queuing and processing usercmds
class CCommandContext
{
public:
CUtlVector< CUserCmd > cmds;
int numcmds;
int totalcmds;
int dropped_packets;
bool paused;
};
// Info about last 20 or so updates to the
class CPlayerCmdInfo
{
public:
CPlayerCmdInfo() :
m_flTime( 0.0f ), m_nNumCmds( 0 ), m_nDroppedPackets( 0 )
{
}
// realtime of sample
float m_flTime;
// # of CUserCmds in this update
int m_nNumCmds;
// # of dropped packets on the link
int m_nDroppedPackets;
};
class CPlayerSimInfo
{
public:
CPlayerSimInfo() :
m_flTime( 0.0f ), m_nNumCmds( 0 ), m_nTicksCorrected( 0 ), m_flFinalSimulationTime( 0.0f ), m_flGameSimulationTime( 0.0f ), m_flServerFrameTime( 0.0f ), m_vecAbsOrigin( 0, 0, 0 )
{
}
// realtime of sample
float m_flTime;
// # of CUserCmds in this update
int m_nNumCmds;
// If clock needed correction, # of ticks added/removed
int m_nTicksCorrected; // +ve or -ve
// player's m_flSimulationTime at end of frame
float m_flFinalSimulationTime;
float m_flGameSimulationTime;
// estimate of server perf
float m_flServerFrameTime;
Vector m_vecAbsOrigin;
};
//-----------------------------------------------------------------------------
// Forward declarations:
//-----------------------------------------------------------------------------
class CBaseCombatWeapon;
class CBaseViewModel;
class CTeam;
class IPhysicsPlayerController;
class IServerVehicle;
class CUserCmd;
class CFuncLadder;
class CNavArea;
class CHintSystem;
class CAI_Expresser;
#if defined USES_ECON_ITEMS
class CEconWearable;
#endif // USES_ECON_ITEMS
// for step sounds
struct surfacedata_t;
// !!!set this bit on guns and stuff that should never respawn.
#define SF_NORESPAWN ( 1 << 30 )
//
// Player PHYSICS FLAGS bits
//
enum PlayerPhysFlag_e
{
PFLAG_DIROVERRIDE = ( 1<<0 ), // override the player's directional control (trains, physics gun, etc.)
PFLAG_DUCKING = ( 1<<1 ), // In the process of ducking, but totally squatted yet
PFLAG_USING = ( 1<<2 ), // Using a continuous entity
PFLAG_OBSERVER = ( 1<<3 ), // player is locked in stationary cam mode. Spectators can move, observers can't.
PFLAG_VPHYSICS_MOTIONCONTROLLER = ( 1<<4 ), // player is physically attached to a motion controller
PFLAG_GAMEPHYSICS_ROTPUSH = (1<<5), // game physics did a rotating push that we may want to override with vphysics
// If you add another flag here check that you aren't
// overwriting phys flags in the HL2 of TF2 player classes
};
//
// generic player
//
//-----------------------------------------------------
//This is Half-Life player entity
//-----------------------------------------------------
#define CSUITPLAYLIST 4 // max of 4 suit sentences queued up at any time
#define SUIT_REPEAT_OK 0
#define SUIT_NEXT_IN_30SEC 30
#define SUIT_NEXT_IN_1MIN 60
#define SUIT_NEXT_IN_5MIN 300
#define SUIT_NEXT_IN_10MIN 600
#define SUIT_NEXT_IN_30MIN 1800
#define SUIT_NEXT_IN_1HOUR 3600
#define CSUITNOREPEAT 32
#define TEAM_NAME_LENGTH 16
// constant items
#define ITEM_HEALTHKIT 1
#define ITEM_BATTERY 4
#define AUTOAIM_2DEGREES 0.0348994967025
#define AUTOAIM_5DEGREES 0.08715574274766
#define AUTOAIM_8DEGREES 0.1391731009601
#define AUTOAIM_10DEGREES 0.1736481776669
#define AUTOAIM_20DEGREES 0.3490658503989
// useful cosines
#define DOT_1DEGREE 0.9998476951564
#define DOT_2DEGREE 0.9993908270191
#define DOT_3DEGREE 0.9986295347546
#define DOT_4DEGREE 0.9975640502598
#define DOT_5DEGREE 0.9961946980917
#define DOT_6DEGREE 0.9945218953683
#define DOT_7DEGREE 0.9925461516413
#define DOT_8DEGREE 0.9902680687416
#define DOT_9DEGREE 0.9876883405951
#define DOT_10DEGREE 0.9848077530122
#define DOT_15DEGREE 0.9659258262891
#define DOT_20DEGREE 0.9396926207859
#define DOT_25DEGREE 0.9063077870367
#define DOT_30DEGREE 0.866025403784
#define DOT_45DEGREE 0.707106781187
enum
{
VPHYS_WALK = 0,
VPHYS_CROUCH,
VPHYS_NOCLIP,
};
enum PlayerConnectedState
{
PlayerConnected,
PlayerDisconnecting,
PlayerDisconnected,
};
extern bool gInitHUD;
extern ConVar *sv_cheats;
class CBasePlayer;
class CPlayerInfo : public IBotController, public IPlayerInfo
{
public:
CPlayerInfo () { m_pParent = NULL; }
~CPlayerInfo () {}
void SetParent( CBasePlayer *parent ) { m_pParent = parent; }
// IPlayerInfo interface
virtual const char *GetName();
virtual int GetUserID();
virtual const char *GetNetworkIDString();
virtual int GetTeamIndex();
virtual void ChangeTeam( int iTeamNum );
virtual int GetFragCount();
virtual int GetDeathCount();
virtual bool IsConnected();
virtual int GetArmorValue();
virtual bool IsHLTV();
virtual bool IsReplay();
virtual bool IsPlayer();
virtual bool IsFakeClient();
virtual bool IsDead();
virtual bool IsInAVehicle();
virtual bool IsObserver();
virtual const Vector GetAbsOrigin();
virtual const QAngle GetAbsAngles();
virtual const Vector GetPlayerMins();
virtual const Vector GetPlayerMaxs();
virtual const char *GetWeaponName();
virtual const char *GetModelName();
virtual const int GetHealth();
virtual const int GetMaxHealth();
// bot specific functions
virtual void SetAbsOrigin( Vector & vec );
virtual void SetAbsAngles( QAngle & ang );
virtual void RemoveAllItems( bool removeSuit );
virtual void SetActiveWeapon( const char *WeaponName );
virtual void SetLocalOrigin( const Vector& origin );
virtual const Vector GetLocalOrigin( void );
virtual void SetLocalAngles( const QAngle& angles );
virtual const QAngle GetLocalAngles( void );
virtual bool IsEFlagSet( int nEFlagMask );
virtual void RunPlayerMove( CBotCmd *ucmd );
virtual void SetLastUserCommand( const CBotCmd &cmd );
virtual CBotCmd GetLastUserCommand();
private:
CBasePlayer *m_pParent;
};
class CBasePlayer : public CBaseCombatCharacter
{
public:
DECLARE_CLASS( CBasePlayer, CBaseCombatCharacter );
protected:
// HACK FOR BOTS
friend class CBotManager;
static edict_t *s_PlayerEdict; // must be set before calling constructor
public:
DECLARE_DATADESC();
DECLARE_SERVERCLASS();
CBasePlayer();
~CBasePlayer();
// IPlayerInfo passthrough (because we can't do multiple inheritance)
IPlayerInfo *GetPlayerInfo() { return &m_PlayerInfo; }
IBotController *GetBotController() { return &m_PlayerInfo; }
virtual void SetModel( const char *szModelName );
void SetBodyPitch( float flPitch );
virtual void UpdateOnRemove( void );
static CBasePlayer *CreatePlayer( const char *className, edict_t *ed );
virtual void CreateViewModel( int viewmodelindex = 0 );
CBaseViewModel *GetViewModel( int viewmodelindex = 0, bool bObserverOK = true );
void HideViewModels( void );
void DestroyViewModels( void );
CPlayerState *PlayerData( void ) { return &pl; }
int RequiredEdictIndex( void ) { return ENTINDEX(edict()); }
void LockPlayerInPlace( void );
void UnlockPlayer( void );
virtual void DrawDebugGeometryOverlays(void);
// Networking is about to update this entity, let it override and specify it's own pvs
virtual void SetupVisibility( CBaseEntity *pViewEntity, unsigned char *pvs, int pvssize );
virtual int UpdateTransmitState();
virtual int ShouldTransmit( const CCheckTransmitInfo *pInfo );
// Returns true if this player wants pPlayer to be moved back in time when this player runs usercmds.
// Saves a lot of overhead on the server if we can cull out entities that don't need to lag compensate
// (like team members, entities out of our PVS, etc).
virtual bool WantsLagCompensationOnEntity( const CBasePlayer *pPlayer, const CUserCmd *pCmd, const CBitVec<MAX_EDICTS> *pEntityTransmitBits ) const;
virtual void Spawn( void );
virtual void Activate( void );
virtual void SharedSpawn(); // Shared between client and server.
virtual void ForceRespawn( void );
virtual void InitialSpawn( void );
virtual void InitHUD( void ) {}
virtual void ShowViewPortPanel( const char * name, bool bShow = true, KeyValues *data = NULL );
virtual void PlayerDeathThink( void );
virtual void Jump( void );
virtual void Duck( void );
const char *GetTracerType( void );
void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType );
void DoImpactEffect( trace_t &tr, int nDamageType );
#if !defined( NO_ENTITY_PREDICTION )
void AddToPlayerSimulationList( CBaseEntity *other );
void RemoveFromPlayerSimulationList( CBaseEntity *other );
void SimulatePlayerSimulatedEntities( void );
void ClearPlayerSimulationList( void );
#endif
// Physics simulation (player executes it's usercmd's here)
virtual void PhysicsSimulate( void );
// Forces processing of usercmds (e.g., even if game is paused, etc.)
void ForceSimulation();
virtual unsigned int PhysicsSolidMaskForEntity( void ) const;
virtual void PreThink( void );
virtual void PostThink( void );
virtual int TakeHealth( float flHealth, int bitsDamageType );
virtual void TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr, CDmgAccumulator *pAccumulator );
bool ShouldTakeDamageInCommentaryMode( const CTakeDamageInfo &inputInfo );
virtual int OnTakeDamage( const CTakeDamageInfo &info );
virtual void DamageEffect(float flDamage, int fDamageType);
virtual void OnDamagedByExplosion( const CTakeDamageInfo &info );
void PauseBonusProgress( bool bPause = true );
void SetBonusProgress( int iBonusProgress );
void SetBonusChallenge( int iBonusChallenge );
int GetBonusProgress() const { return m_iBonusProgress; }
int GetBonusChallenge() const { return m_iBonusChallenge; }
virtual Vector EyePosition( ); // position of eyes
const QAngle &EyeAngles( );
void EyePositionAndVectors( Vector *pPosition, Vector *pForward, Vector *pRight, Vector *pUp );
virtual const QAngle &LocalEyeAngles(); // Direction of eyes
void EyeVectors( Vector *pForward, Vector *pRight = NULL, Vector *pUp = NULL );
void CacheVehicleView( void ); // Calculate and cache the position of the player in the vehicle
// Sets the view angles
void SnapEyeAngles( const QAngle &viewAngles );
virtual QAngle BodyAngles();
virtual Vector BodyTarget( const Vector &posSrc, bool bNoisy);
virtual bool ShouldFadeOnDeath( void ) { return FALSE; }
virtual const impactdamagetable_t &GetPhysicsImpactDamageTable();
virtual int OnTakeDamage_Alive( const CTakeDamageInfo &info );
virtual void Event_Killed( const CTakeDamageInfo &info );
// Notifier that I've killed some other entity. (called from Victim's Event_Killed).
virtual void Event_KilledOther( CBaseEntity *pVictim, const CTakeDamageInfo &info );
virtual void Event_Dying( const CTakeDamageInfo &info );
bool IsHLTV( void ) const { return pl.hltv; }
bool IsReplay( void ) const { return pl.replay; }
virtual bool IsPlayer( void ) const { return true; } // Spectators return TRUE for this, use IsObserver to separate cases
virtual bool IsNetClient( void ) const { return true; } // Bots should return FALSE for this, they can't receive NET messages
// Spectators should return TRUE for this
virtual bool IsFakeClient( void ) const;
// Get the client index (entindex-1).
int GetClientIndex() { return ENTINDEX( edict() ) - 1; }
// returns the player name
const char * GetPlayerName() { return m_szNetname; }
void SetPlayerName( const char *name );
add source-sdk-2013
2022-03-01 20:00:42 +00:00
int GetUserID() { return engine->GetPlayerUserId( edict() ); }
1
2020-04-22 16:56:21 +00:00
const char * GetNetworkIDString();
virtual const Vector GetPlayerMins( void ) const; // uses local player
virtual const Vector GetPlayerMaxs( void ) const; // uses local player
void VelocityPunch( const Vector &vecForce );
void ViewPunch( const QAngle &angleOffset );
void ViewPunchReset( float tolerance = 0 );
void ShowViewModel( bool bShow );
void ShowCrosshair( bool bShow );
// View model prediction setup
void CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov );
// Handle view smoothing when going up stairs
void SmoothViewOnStairs( Vector& eyeOrigin );
virtual float CalcRoll (const QAngle& angles, const Vector& velocity, float rollangle, float rollspeed);
void CalcViewRoll( QAngle& eyeAngles );
virtual int Save( ISave &save );
virtual int Restore( IRestore &restore );
virtual bool ShouldSavePhysics();
virtual void OnRestore( void );
virtual void PackDeadPlayerItems( void );
virtual void RemoveAllItems( bool removeSuit );
bool IsDead() const;
#ifdef CSTRIKE_DLL
virtual bool IsRunning( void ) const { return false; } // bot support under cstrike (AR)
#endif
bool HasPhysicsFlag( unsigned int flag ) { return (m_afPhysicsFlags & flag) != 0; }
// Weapon stuff
virtual Vector Weapon_ShootPosition( );
virtual bool Weapon_CanUse( CBaseCombatWeapon *pWeapon );
virtual void Weapon_Equip( CBaseCombatWeapon *pWeapon );
virtual void Weapon_Drop( CBaseCombatWeapon *pWeapon, const Vector *pvecTarget /* = NULL */, const Vector *pVelocity /* = NULL */ );
virtual bool Weapon_Switch( CBaseCombatWeapon *pWeapon, int viewmodelindex = 0 ); // Switch to given weapon if has ammo (false if failed)
virtual void Weapon_SetLast( CBaseCombatWeapon *pWeapon );
virtual bool Weapon_ShouldSetLast( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon ) { return true; }
virtual bool Weapon_ShouldSelectItem( CBaseCombatWeapon *pWeapon );
void Weapon_DropSlot( int weaponSlot );
add source-sdk-2013
2022-03-01 20:00:42 +00:00
CBaseCombatWeapon *Weapon_GetLast( void ) { return m_hLastWeapon.Get(); }
1
2020-04-22 16:56:21 +00:00
virtual void OnMyWeaponFired( CBaseCombatWeapon *weapon ); // call this when this player fires a weapon to allow other systems to react
virtual float GetTimeSinceWeaponFired( void ) const; // returns the time, in seconds, since this player fired a weapon
virtual bool IsFiringWeapon( void ) const; // return true if this player is currently firing their weapon
bool HasAnyAmmoOfType( int nAmmoIndex );
// JOHN: sends custom messages if player HUD data has changed (eg health, ammo)
virtual void UpdateClientData( void );
void RumbleEffect( unsigned char index, unsigned char rumbleData, unsigned char rumbleFlags );
// Player is moved across the transition by other means
virtual int ObjectCaps( void ) { return BaseClass::ObjectCaps() & ~FCAP_ACROSS_TRANSITION; }
virtual void Precache( void );
bool IsOnLadder( void );
virtual void ExitLadder() {}
virtual surfacedata_t *GetLadderSurface( const Vector &origin );
virtual void SetFlashlightEnabled( bool bState ) { };
virtual int FlashlightIsOn( void ) { return false; }
virtual void FlashlightTurnOn( void ) { };
virtual void FlashlightTurnOff( void ) { };
virtual bool IsIlluminatedByFlashlight( CBaseEntity *pEntity, float *flReturnDot ) {return false; }
void UpdatePlayerSound ( void );
virtual void UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity );
virtual void PlayStepSound( Vector &vecOrigin, surfacedata_t *psurface, float fvol, bool force );
virtual const char *GetOverrideStepSound( const char *pszBaseStepSoundName ) { return pszBaseStepSoundName; }
virtual void GetStepSoundVelocities( float *velwalk, float *velrun );
virtual void SetStepSoundTime( stepsoundtimes_t iStepSoundTime, bool bWalking );
virtual void DeathSound( const CTakeDamageInfo &info );
virtual const char* GetSceneSoundToken( void ) { return ""; }
virtual void OnEmitFootstepSound( const CSoundParameters& params, const Vector& vecOrigin, float fVolume ) {}
Class_T Classify ( void );
virtual void SetAnimation( PLAYER_ANIM playerAnim );
void SetWeaponAnimType( const char *szExtention );
// custom player functions
virtual void ImpulseCommands( void );
virtual void CheatImpulseCommands( int iImpulse );
virtual bool ClientCommand( const CCommand &args );
void NotifySinglePlayerGameEnding() { m_bSinglePlayerGameEnding = true; }
bool IsSinglePlayerGameEnding() { return m_bSinglePlayerGameEnding == true; }
bool HandleVoteCommands( const CCommand &args );
// Observer functions
virtual bool StartObserverMode(int mode); // true, if successful
virtual void StopObserverMode( void ); // stop spectator mode
virtual bool ModeWantsSpectatorGUI( int iMode ) { return true; }
virtual bool SetObserverMode(int mode); // sets new observer mode, returns true if successful
virtual int GetObserverMode( void ); // returns observer mode or OBS_NONE
virtual bool SetObserverTarget(CBaseEntity * target);
virtual void ObserverUse( bool bIsPressed ); // observer pressed use
virtual CBaseEntity *GetObserverTarget( void ); // returns players targer or NULL
virtual CBaseEntity *FindNextObserverTarget( bool bReverse ); // returns next/prev player to follow or NULL
virtual int GetNextObserverSearchStartPoint( bool bReverse ); // Where we should start looping the player list in a FindNextObserverTarget call
virtual bool IsValidObserverTarget(CBaseEntity * target); // true, if player is allowed to see this target
virtual void CheckObserverSettings(); // checks, if target still valid (didn't die etc)
virtual void JumptoPosition(const Vector &origin, const QAngle &angles);
virtual void ForceObserverMode(int mode); // sets a temporary mode, force because of invalid targets
virtual void ResetObserverMode(); // resets all observer related settings
virtual void ValidateCurrentObserverTarget( void ); // Checks the current observer target, and moves on if it's not valid anymore
virtual void AttemptToExitFreezeCam( void );
virtual bool StartReplayMode( float fDelay, float fDuration, int iEntity );
virtual void StopReplayMode();
virtual int GetDelayTicks();
virtual int GetReplayEntity();
virtual void CreateCorpse( void ) { }
virtual CBaseEntity *EntSelectSpawnPoint( void );
// Vehicles
virtual bool IsInAVehicle( void ) const;
bool CanEnterVehicle( IServerVehicle *pVehicle, int nRole );
virtual bool GetInVehicle( IServerVehicle *pVehicle, int nRole );
virtual void LeaveVehicle( const Vector &vecExitPoint = vec3_origin, const QAngle &vecExitAngles = vec3_angle );
int GetVehicleAnalogControlBias() { return m_iVehicleAnalogBias; }
void SetVehicleAnalogControlBias( int bias ) { m_iVehicleAnalogBias = bias; }
// override these for
virtual void OnVehicleStart() {}
virtual void OnVehicleEnd( Vector &playerDestPosition ) {}
IServerVehicle *GetVehicle();
CBaseEntity *GetVehicleEntity( void );
bool UsingStandardWeaponsInVehicle( void );
void AddPoints( int score, bool bAllowNegativeScore );
void AddPointsToTeam( int score, bool bAllowNegativeScore );
virtual bool BumpWeapon( CBaseCombatWeapon *pWeapon );
bool RemovePlayerItem( CBaseCombatWeapon *pItem );
CBaseEntity *HasNamedPlayerItem( const char *pszItemName );
bool HasWeapons( void );// do I have ANY weapons?
virtual void SelectLastItem(void);
virtual void SelectItem( const char *pstr, int iSubType = 0 );
void ItemPreFrame( void );
virtual void ItemPostFrame( void );
virtual CBaseEntity *GiveNamedItem( const char *szName, int iSubType = 0 );
void EnableControl(bool fControl);
virtual void CheckTrainUpdate( void );
void AbortReload( void );
void SendAmmoUpdate(void);
void WaterMove( void );
float GetWaterJumpTime() const;
void SetWaterJumpTime( float flWaterJumpTime );
float GetSwimSoundTime( void ) const;
void SetSwimSoundTime( float flSwimSoundTime );
virtual void SetPlayerUnderwater( bool state );
void UpdateUnderwaterState( void );
bool IsPlayerUnderwater( void ) { return m_bPlayerUnderwater; }
virtual bool CanBreatheUnderwater() const { return false; }
virtual void PlayerUse( void );
virtual void PlayUseDenySound() {}
virtual CBaseEntity *FindUseEntity( void );
virtual bool IsUseableEntity( CBaseEntity *pEntity, unsigned int requiredCaps );
bool ClearUseEntity();
CBaseEntity *DoubleCheckUseNPC( CBaseEntity *pNPC, const Vector &vecSrc, const Vector &vecDir );
// physics interactions
// mass/size limit set to zero for none
static bool CanPickupObject( CBaseEntity *pObject, float massLimit, float sizeLimit );
virtual void PickupObject( CBaseEntity *pObject, bool bLimitMassAndSize = true ) {}
virtual void ForceDropOfCarriedPhysObjects( CBaseEntity *pOnlyIfHoldindThis = NULL ) {}
virtual float GetHeldObjectMass( IPhysicsObject *pHeldObject );
void CheckSuitUpdate();
void SetSuitUpdate(const char *name, int fgroup, int iNoRepeat);
virtual void UpdateGeigerCounter( void );
void CheckTimeBasedDamage( void );
void ResetAutoaim( void );
virtual Vector GetAutoaimVector( float flScale );
virtual Vector GetAutoaimVector( float flScale, float flMaxDist );
virtual void GetAutoaimVector( autoaim_params_t &params );
float GetAutoaimScore( const Vector &eyePosition, const Vector &viewDir, const Vector &vecTarget, CBaseEntity *pTarget, float fScale, CBaseCombatWeapon *pActiveWeapon );
QAngle AutoaimDeflection( Vector &vecSrc, autoaim_params_t &params );
virtual bool ShouldAutoaim( void );
void SetTargetInfo( Vector &vecSrc, float flDist );
void SetViewEntity( CBaseEntity *pEntity );
CBaseEntity *GetViewEntity( void ) { return m_hViewEntity; }
virtual void ForceClientDllUpdate( void ); // Forces all client .dll specific data to be resent to client.
void DeathMessage( CBaseEntity *pKiller );
virtual void ProcessUsercmds( CUserCmd *cmds, int numcmds, int totalcmds,
int dropped_packets, bool paused );
bool IsUserCmdDataValid( CUserCmd *pCmd );
void AvoidPhysicsProps( CUserCmd *pCmd );
// Run a user command. The default implementation calls ::PlayerRunCommand. In TF, this controls a vehicle if
// the player is in one.
virtual void PlayerRunCommand(CUserCmd *ucmd, IMoveHelper *moveHelper);
void RunNullCommand();
CUserCmd * GetCurrentCommand( void ) { return m_pCurrentCommand; }
float GetTimeSinceLastUserCommand( void ) { return ( !IsConnected() || IsFakeClient() || IsBot() ) ? 0.f : gpGlobals->curtime - m_flLastUserCommandTime; }
// Team Handling
add source-sdk-2013
2022-03-01 20:00:42 +00:00
virtual void ChangeTeam( int iTeamNum ) { ChangeTeam(iTeamNum,false, false); }
virtual void ChangeTeam( int iTeamNum, bool bAutoTeam, bool bSilent );
1
2020-04-22 16:56:21 +00:00
// say/sayteam allowed?
virtual bool CanHearAndReadChatFrom( CBasePlayer *pPlayer ) { return true; }
virtual bool CanSpeak( void ) { return true; }
audioparams_t &GetAudioParams() { return m_Local.m_audio; }
virtual void ModifyOrAppendPlayerCriteria( AI_CriteriaSet& set );
const QAngle& GetPunchAngle();
void SetPunchAngle( const QAngle &punchAngle );
virtual void DoMuzzleFlash();
const char *GetLastKnownPlaceName( void ) const { return m_szLastPlaceName; } // return the last nav place name the player occupied
virtual void CheckChatText( char *p, int bufsize ) {}
virtual void CreateRagdollEntity( void ) { return; }
virtual void HandleAnimEvent( animevent_t *pEvent );
add source-sdk-2013
2022-03-01 20:00:42 +00:00
virtual bool ShouldAnnounceAchievement( void ){ return true; }
1
2020-04-22 16:56:21 +00:00
#if defined USES_ECON_ITEMS
// Wearables
virtual void EquipWearable( CEconWearable *pItem );
virtual void RemoveWearable( CEconWearable *pItem );
void PlayWearableAnimsForPlaybackEvent( wearableanimplayback_t iPlayback );
#endif
public:
// Player Physics Shadow
void SetupVPhysicsShadow( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity, CPhysCollide *pStandModel, const char *pStandHullName, CPhysCollide *pCrouchModel, const char *pCrouchHullName );
IPhysicsPlayerController* GetPhysicsController() { return m_pPhysicsController; }
virtual void VPhysicsCollision( int index, gamevcollisionevent_t *pEvent );
void VPhysicsUpdate( IPhysicsObject *pPhysics );
virtual void VPhysicsShadowUpdate( IPhysicsObject *pPhysics );
virtual bool IsFollowingPhysics( void ) { return false; }
bool IsRideablePhysics( IPhysicsObject *pPhysics );
IPhysicsObject *GetGroundVPhysics();
virtual void Touch( CBaseEntity *pOther );
void SetTouchedPhysics( bool bTouch );
bool TouchedPhysics( void );
Vector GetSmoothedVelocity( void );
virtual void RefreshCollisionBounds( void );
virtual void InitVCollision( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity );
virtual void VPhysicsDestroyObject();
void SetVCollisionState( const Vector &vecAbsOrigin, const Vector &vecAbsVelocity, int collisionState );
void PostThinkVPhysics( void );
virtual void UpdatePhysicsShadowToCurrentPosition();
void UpdatePhysicsShadowToPosition( const Vector &vecAbsOrigin );
void UpdateVPhysicsPosition( const Vector &position, const Vector &velocity, float secondsToArrival );
// Hint system
virtual CHintSystem *Hints( void ) { return NULL; }
bool ShouldShowHints( void ) { return Hints() ? Hints()->ShouldShowHints() : false; }
void SetShowHints( bool bShowHints ) { if (Hints()) Hints()->SetShowHints( bShowHints ); }
bool HintMessage( int hint, bool bForce = false ) { return Hints() ? Hints()->HintMessage( hint, bForce ) : false; }
void HintMessage( const char *pMessage ) { if (Hints()) Hints()->HintMessage( pMessage ); }
void StartHintTimer( int iHintID ) { if (Hints()) Hints()->StartHintTimer( iHintID ); }
void StopHintTimer( int iHintID ) { if (Hints()) Hints()->StopHintTimer( iHintID ); }
void RemoveHintTimer( int iHintID ) { if (Hints()) Hints()->RemoveHintTimer( iHintID ); }
// Accessor methods
int FragCount() const { return m_iFrags; }
int DeathCount() const { return m_iDeaths;}
bool IsConnected() const { return m_iConnected != PlayerDisconnected; }
bool IsDisconnecting() const { return m_iConnected == PlayerDisconnecting; }
bool IsSuitEquipped() const { return m_Local.m_bWearingSuit; }
int ArmorValue() const { return m_ArmorValue; }
bool HUDNeedsRestart() const { return m_fInitHUD; }
float MaxSpeed() const { return m_flMaxspeed; }
Activity GetActivity( ) const { return m_Activity; }
inline void SetActivity( Activity eActivity ) { m_Activity = eActivity; }
bool IsPlayerLockedInPlace() const { return m_iPlayerLocked != 0; }
bool IsObserver() const { return (m_afPhysicsFlags & PFLAG_OBSERVER) != 0; }
bool IsOnTarget() const { return m_fOnTarget; }
float MuzzleFlashTime() const { return m_flFlashTime; }
float PlayerDrownTime() const { return m_AirFinished; }
int GetObserverMode() const { return m_iObserverMode; }
CBaseEntity *GetObserverTarget() const { return m_hObserverTarget; }
// Round gamerules
virtual bool IsReadyToPlay( void ) { return true; }
virtual bool IsReadyToSpawn( void ) { return true; }
virtual bool ShouldGainInstantSpawn( void ) { return false; }
virtual void ResetPerRoundStats( void ) { return; }
void AllowInstantSpawn( void ) { m_bAllowInstantSpawn = true; }
virtual void ResetScores( void ) { ResetFragCount(); ResetDeathCount(); }
void ResetFragCount();
void IncrementFragCount( int nCount );
void ResetDeathCount();
void IncrementDeathCount( int nCount );
void SetArmorValue( int value );
void IncrementArmorValue( int nCount, int nMaxValue = -1 );
void SetConnected( PlayerConnectedState iConnected ) { m_iConnected = iConnected; }
virtual void EquipSuit( bool bPlayEffects = true );
virtual void RemoveSuit( void );
void SetMaxSpeed( float flMaxSpeed ) { m_flMaxspeed = flMaxSpeed; }
void NotifyNearbyRadiationSource( float flRange );
void SetAnimationExtension( const char *pExtension );
void SetAdditionalPVSOrigin( const Vector &vecOrigin );
void SetCameraPVSOrigin( const Vector &vecOrigin );
void SetMuzzleFlashTime( float flTime );
void SetUseEntity( CBaseEntity *pUseEntity );
CBaseEntity *GetUseEntity();
virtual float GetPlayerMaxSpeed();
// Used to set private physics flags PFLAG_*
void SetPhysicsFlag( int nFlag, bool bSet );
void AllowImmediateDecalPainting();
// Suicide...
virtual void CommitSuicide( bool bExplode = false, bool bForce = false );
virtual void CommitSuicide( const Vector &vecForce, bool bExplode = false, bool bForce = false );
// For debugging...
void ForceOrigin( const Vector &vecOrigin );
// Bot accessors...
void SetTimeBase( float flTimeBase );
float GetTimeBase() const;
void SetLastUserCommand( const CUserCmd &cmd );
const CUserCmd *GetLastUserCommand( void );
virtual bool IsBot() const; // IMPORTANT: This returns true for ANY type of bot. If your game uses different, incompatible types of bots check your specific bot type before casting
virtual bool IsBotOfType( int botType ) const; // return true if this player is a bot of the specific type (zero is invalid)
virtual int GetBotType( void ) const; // return a unique int representing the type of bot instance this is
bool IsPredictingWeapons( void ) const;
int CurrentCommandNumber() const;
const CUserCmd *GetCurrentUserCommand() const;
int GetFOV( void ); // Get the current FOV value
int GetDefaultFOV( void ) const; // Default FOV if not specified otherwise
int GetFOVForNetworking( void ); // Get the current FOV used for network computations
bool SetFOV( CBaseEntity *pRequester, int FOV, float zoomRate = 0.0f, int iZoomStart = 0 ); // Alters the base FOV of the player (must have a valid requester)
void SetDefaultFOV( int FOV ); // Sets the base FOV if nothing else is affecting it by zooming
CBaseEntity *GetFOVOwner( void ) { return m_hZoomOwner; }
float GetFOVDistanceAdjustFactor(); // shared between client and server
float GetFOVDistanceAdjustFactorForNetworking();
int GetImpulse( void ) const { return m_nImpulse; }
// Movement constraints
void ActivateMovementConstraint( CBaseEntity *pEntity, const Vector &vecCenter, float flRadius, float flConstraintWidth, float flSpeedFactor );
void DeactivateMovementConstraint( );
// talk control
void NotePlayerTalked() { m_fLastPlayerTalkTime = gpGlobals->curtime; }
float LastTimePlayerTalked() { return m_fLastPlayerTalkTime; }
void DisableButtons( int nButtons );
void EnableButtons( int nButtons );
void ForceButtons( int nButtons );
void UnforceButtons( int nButtons );
//---------------------------------
// Inputs
//---------------------------------
void InputSetHealth( inputdata_t &inputdata );
void InputSetHUDVisibility( inputdata_t &inputdata );
void InputHandleMapEvent( inputdata_t &inputdata );
surfacedata_t *GetSurfaceData( void ) { return m_pSurfaceData; }
void SetLadderNormal( Vector vecLadderNormal ) { m_vecLadderNormal = vecLadderNormal; }
// Here so that derived classes can use the expresser
virtual CAI_Expresser *GetExpresser() { return NULL; };
#if !defined(NO_STEAM)
//----------------------------
// Steam handling
bool GetSteamID( CSteamID *pID );
uint64 GetSteamIDAsUInt64( void );
#endif
float GetRemainingMovementTimeForUserCmdProcessing() const { return m_flMovementTimeForUserCmdProcessingRemaining; }
float ConsumeMovementTimeForUserCmdProcessing( float flTimeNeeded )
{
if ( m_flMovementTimeForUserCmdProcessingRemaining <= 0.0f )
{
return 0.0f;
}
else if ( flTimeNeeded > m_flMovementTimeForUserCmdProcessingRemaining + FLT_EPSILON )
{
float flResult = m_flMovementTimeForUserCmdProcessingRemaining;
m_flMovementTimeForUserCmdProcessingRemaining = 0.0f;
return flResult;
}
else
{
m_flMovementTimeForUserCmdProcessingRemaining -= flTimeNeeded;
if ( m_flMovementTimeForUserCmdProcessingRemaining < 0.0f )
m_flMovementTimeForUserCmdProcessingRemaining = 0.0f;
return flTimeNeeded;
}
}
private:
// How much of a movement time buffer can we process from this user?
float m_flMovementTimeForUserCmdProcessingRemaining;
// For queueing up CUserCmds and running them from PhysicsSimulate
int GetCommandContextCount( void ) const;
CCommandContext *GetCommandContext( int index );
CCommandContext *AllocCommandContext( void );
void RemoveCommandContext( int index );
void RemoveAllCommandContexts( void );
CCommandContext *RemoveAllCommandContextsExceptNewest( void );
void ReplaceContextCommands( CCommandContext *ctx, CUserCmd *pCommands, int nCommands );
int DetermineSimulationTicks( void );
void AdjustPlayerTimeBase( int simulation_ticks );
public:
add source-sdk-2013
2022-03-01 20:00:42 +00:00
1
2020-04-22 16:56:21 +00:00
// Used by gamemovement to check if the entity is stuck.
int m_StuckLast;
// FIXME: Make these protected or private!
// This player's data that should only be replicated to
// the player and not to other players.
CNetworkVarEmbedded( CPlayerLocalData, m_Local );
#if defined USES_ECON_ITEMS
CNetworkVarEmbedded( CAttributeList, m_AttributeList );
#endif
void InitFogController( void );
void InputSetFogController( inputdata_t &inputdata );
// Used by env_soundscape_triggerable to manage when the player is touching multiple
// soundscape triggers simultaneously.
// The one at the HEAD of the list is always the current soundscape for the player.
CUtlVector<EHANDLE> m_hTriggerSoundscapeList;
// Player data that's sometimes needed by the engine
CNetworkVarEmbedded( CPlayerState, pl );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_fFlags );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_vecViewOffset );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_flFriction );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iAmmo );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_hGroundEntity );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_lifeState );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_iHealth );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_vecBaseVelocity );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_nNextThinkTick );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_vecVelocity );
IMPLEMENT_NETWORK_VAR_FOR_DERIVED( m_nWaterLevel );
int m_nButtons;
int m_afButtonPressed;
int m_afButtonReleased;
int m_afButtonLast;
int m_afButtonDisabled; // A mask of input flags that are cleared automatically
int m_afButtonForced; // These are forced onto the player's inputs
CNetworkVar( bool, m_fOnTarget ); //Is the crosshair on a target?
char m_szAnimExtension[32];
int m_nUpdateRate; // user snapshot rate cl_updaterate
float m_fLerpTime; // users cl_interp
bool m_bLagCompensation; // user wants lag compenstation
bool m_bPredictWeapons; // user has client side predicted weapons
float GetDeathTime( void ) { return m_flDeathTime; }
void ClearZoomOwner( void );
void SetPreviouslyPredictedOrigin( const Vector &vecAbsOrigin );
const Vector &GetPreviouslyPredictedOrigin() const;
float GetFOVTime( void ){ return m_flFOVTime; }
void AdjustDrownDmg( int nAmount );
#if defined USES_ECON_ITEMS
CEconWearable *GetWearable( int i ) { return m_hMyWearables[i]; }
add source-sdk-2013
2022-03-01 20:00:42 +00:00
int GetNumWearables( void ) { return m_hMyWearables.Count(); }
1
2020-04-22 16:56:21 +00:00
#endif
private:
Activity m_Activity;
protected:
void CalcPlayerView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
void CalcVehicleView( IServerVehicle *pVehicle, Vector& eyeOrigin, QAngle& eyeAngles,
float& zNear, float& zFar, float& fov );
void CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
void CalcViewModelView( const Vector& eyeOrigin, const QAngle& eyeAngles);
virtual void Internal_HandleMapEvent( inputdata_t &inputdata ){}
// FIXME: Make these private! (tf_player uses them)
// Secondary point to derive PVS from when zoomed in with binoculars/sniper rifle. The PVS is
// a merge of the standing origin and this additional origin
Vector m_vecAdditionalPVSOrigin;
// Extra PVS origin if we are using a camera object
Vector m_vecCameraPVSOrigin;
CNetworkHandle( CBaseEntity, m_hUseEntity ); // the player is currently controlling this entity because of +USE latched, NULL if no entity
int m_iTrain; // Train control position
float m_iRespawnFrames; // used in PlayerDeathThink() to make sure players can always respawn
unsigned int m_afPhysicsFlags; // physics flags - set when 'normal' physics should be revisited or overriden
// Vehicles
CNetworkHandle( CBaseEntity, m_hVehicle );
int m_iVehicleAnalogBias;
void UpdateButtonState( int nUserCmdButtonMask );
bool m_bPauseBonusProgress;
CNetworkVar( int, m_iBonusProgress );
CNetworkVar( int, m_iBonusChallenge );
int m_lastDamageAmount; // Last damage taken
Vector m_DmgOrigin;
float m_DmgTake;
float m_DmgSave;
int m_bitsDamageType; // what types of damage has player taken
int m_bitsHUDDamage; // Damage bits for the current fame. These get sent to the hud via gmsgDamage
CNetworkVar( float, m_flDeathTime ); // the time at which the player died (used in PlayerDeathThink())
float m_flDeathAnimTime; // the time at which the player finished their death anim (used in PlayerDeathThink() and ShouldTransmit())
CNetworkVar( int, m_iObserverMode ); // if in spectator mode != 0
CNetworkVar( int, m_iFOV ); // field of view
CNetworkVar( int, m_iDefaultFOV ); // default field of view
CNetworkVar( int, m_iFOVStart ); // What our FOV started at
CNetworkVar( float, m_flFOVTime ); // Time our FOV change started
int m_iObserverLastMode; // last used observer mode
CNetworkHandle( CBaseEntity, m_hObserverTarget ); // entity handle to m_iObserverTarget
bool m_bForcedObserverMode; // true, player was forced by invalid targets to switch mode
CNetworkHandle( CBaseEntity, m_hZoomOwner ); //This is a pointer to the entity currently controlling the player's zoom
//Only this entity can change the zoom state once it has ownership
float m_tbdPrev; // Time-based damage timer
int m_idrowndmg; // track drowning damage taken
int m_idrownrestored; // track drowning damage restored
int m_nPoisonDmg; // track recoverable poison damage taken
int m_nPoisonRestored; // track poison damage restored
// NOTE: bits damage type appears to only be used for time-based damage
BYTE m_rgbTimeBasedDamage[CDMG_TIMEBASED];
// Player Physics Shadow
int m_vphysicsCollisionState;
virtual int SpawnArmorValue( void ) const { return 0; }
float m_fNextSuicideTime; // the time after which the player can next use the suicide command
int m_iSuicideCustomKillFlags;
// Replay mode
float m_fDelay; // replay delay in seconds
float m_fReplayEnd; // time to stop replay mode
int m_iReplayEntity; // follow this entity in replay
private:
void HandleFuncTrain();
// DATA
private:
CUtlVector< CCommandContext > m_CommandContext;
// Player Physics Shadow
protected: //used to be private, but need access for portal mod (Dave Kircher)
IPhysicsPlayerController *m_pPhysicsController;
IPhysicsObject *m_pShadowStand;
IPhysicsObject *m_pShadowCrouch;
Vector m_oldOrigin;
Vector m_vecSmoothedVelocity;
bool m_touchedPhysObject;
bool m_bPhysicsWasFrozen;
private:
int m_iPlayerSound;// the index of the sound list slot reserved for this player
int m_iTargetVolume;// ideal sound volume.
int m_rgItems[MAX_ITEMS];
// these are time-sensitive things that we keep track of
float m_flSwimTime; // how long player has been underwater
float m_flDuckTime; // how long we've been ducking
float m_flDuckJumpTime;
float m_flSuitUpdate; // when to play next suit update
int m_rgSuitPlayList[CSUITPLAYLIST];// next sentencenum to play for suit update
int m_iSuitPlayNext; // next sentence slot for queue storage;
int m_rgiSuitNoRepeat[CSUITNOREPEAT]; // suit sentence no repeat list
float m_rgflSuitNoRepeatTime[CSUITNOREPEAT]; // how long to wait before allowing repeat
float m_flgeigerRange; // range to nearest radiation source
float m_flgeigerDelay; // delay per update of range msg to client
int m_igeigerRangePrev;
bool m_fInitHUD; // True when deferred HUD restart msg needs to be sent
bool m_fGameHUDInitialized;
bool m_fWeapon; // Set this to FALSE to force a reset of the current weapon HUD info
int m_iUpdateTime; // stores the number of frame ticks before sending HUD update messages
int m_iClientBattery; // the Battery currently known by the client. If this changes, send a new
// Autoaim data
QAngle m_vecAutoAim;
int m_lastx, m_lasty; // These are the previous update's crosshair angles, DON"T SAVE/RESTORE
int m_iFrags;
int m_iDeaths;
float m_flNextDecalTime;// next time this player can spray a decal
// Team Handling
// char m_szTeamName[TEAM_NAME_LENGTH];
// Multiplayer handling
PlayerConnectedState m_iConnected;
// from edict_t
// CBasePlayer doesn't send this but CCSPlayer does.
CNetworkVarForDerived( int, m_ArmorValue );
float m_AirFinished;
float m_PainFinished;
// player locking
int m_iPlayerLocked;
protected:
// the player's personal view model
typedef CHandle<CBaseViewModel> CBaseViewModelHandle;
CNetworkArray( CBaseViewModelHandle, m_hViewModel, MAX_VIEWMODELS );
// Last received usercmd (in case we drop a lot of packets )
CUserCmd m_LastCmd;
CUserCmd *m_pCurrentCommand;
float m_flStepSoundTime; // time to check for next footstep sound
bool m_bAllowInstantSpawn;
#if defined USES_ECON_ITEMS
// Wearables
CUtlVector<CHandle<CEconWearable > > m_hMyWearables;
#endif
private:
// Replicated to all clients
CNetworkVar( float, m_flMaxspeed );
// Not transmitted
float m_flWaterJumpTime; // used to be called teleport_time
Vector m_vecWaterJumpVel;
int m_nImpulse;
float m_flSwimSoundTime;
Vector m_vecLadderNormal;
float m_flFlashTime;
int m_nDrownDmgRate; // Drowning damage in points per second without air.
int m_nNumCrouches; // Number of times we've crouched (for hinting)
bool m_bDuckToggled; // If true, the player is crouching via a toggle
public:
bool GetToggledDuckState( void ) { return m_bDuckToggled; }
void ToggleDuck( void );
float GetStickDist( void );
float m_flForwardMove;
float m_flSideMove;
int m_nNumCrateHudHints;
private:
// Used in test code to teleport the player to random locations in the map.
Vector m_vForcedOrigin;
bool m_bForceOrigin;
// Clients try to run on their own realtime clock, this is this client's clock
CNetworkVar( int, m_nTickBase );
bool m_bGamePaused;
float m_fLastPlayerTalkTime;
CNetworkVar( CBaseCombatWeaponHandle, m_hLastWeapon );
#if !defined( NO_ENTITY_PREDICTION )
CUtlVector< CHandle< CBaseEntity > > m_SimulatedByThisPlayer;
#endif
float m_flOldPlayerZ;
float m_flOldPlayerViewOffsetZ;
bool m_bPlayerUnderwater;
EHANDLE m_hViewEntity;
// Movement constraints
CNetworkHandle( CBaseEntity, m_hConstraintEntity );
CNetworkVector( m_vecConstraintCenter );
CNetworkVar( float, m_flConstraintRadius );
CNetworkVar( float, m_flConstraintWidth );
CNetworkVar( float, m_flConstraintSpeedFactor );
friend class CPlayerMove;
friend class CPlayerClass;
// Player name
char m_szNetname[MAX_PLAYER_NAME_LENGTH];
protected:
// HACK FOR TF2 Prediction
friend class CTFGameMovementRecon;
friend class CGameMovement;
friend class CTFGameMovement;
friend class CHL1GameMovement;
friend class CCSGameMovement;
friend class CHL2GameMovement;
friend class CDODGameMovement;
friend class CPortalGameMovement;
// Accessors for gamemovement
bool IsDucked( void ) const { return m_Local.m_bDucked; }
bool IsDucking( void ) const { return m_Local.m_bDucking; }
float GetStepSize( void ) const { return m_Local.m_flStepSize; }
CNetworkVar( float, m_flLaggedMovementValue );
// These are generated while running usercmds, then given to UpdateVPhysicsPosition after running all queued commands.
Vector m_vNewVPhysicsPosition;
Vector m_vNewVPhysicsVelocity;
Vector m_vecVehicleViewOrigin; // Used to store the calculated view of the player while riding in a vehicle
QAngle m_vecVehicleViewAngles; // Vehicle angles
float m_flVehicleViewFOV; // FOV of the vehicle driver
int m_nVehicleViewSavedFrame; // Used to mark which frame was the last one the view was calculated for
Vector m_vecPreviouslyPredictedOrigin; // Used to determine if non-gamemovement game code has teleported, or tweaked the player's origin
int m_nBodyPitchPoseParam;
CNetworkString( m_szLastPlaceName, MAX_PLACE_NAME_LENGTH );
char m_szNetworkIDString[MAX_NETWORKID_LENGTH];
CPlayerInfo m_PlayerInfo;
// Texture names and surface data, used by CGameMovement
int m_surfaceProps;
surfacedata_t* m_pSurfaceData;
float m_surfaceFriction;
char m_chTextureType;
char m_chPreviousTextureType; // Separate from m_chTextureType. This is cleared if the player's not on the ground.
bool m_bSinglePlayerGameEnding;
public:
float GetLaggedMovementValue( void ){ return m_flLaggedMovementValue; }
void SetLaggedMovementValue( float flValue ) { m_flLaggedMovementValue = flValue; }
inline bool IsAutoKickDisabled( void ) const;
inline void DisableAutoKick( bool disabled );
void DumpPerfToRecipient( CBasePlayer *pRecipient, int nMaxRecords );
// NVNT returns true if user has a haptic device
virtual bool HasHaptics(){return m_bhasHaptics;}
// NVNT sets weather a user should receive haptic device messages.
virtual void SetHaptics(bool has) { m_bhasHaptics = has;}
private:
// NVNT member variable holding if this user is using a haptic device.
bool m_bhasHaptics;
bool m_autoKickDisabled;
struct StepSoundCache_t
{
StepSoundCache_t() : m_usSoundNameIndex( 0 ) {}
CSoundParameters m_SoundParameters;
unsigned short m_usSoundNameIndex;
};
// One for left and one for right side of step
StepSoundCache_t m_StepSoundCache[ 2 ];
CUtlLinkedList< CPlayerSimInfo > m_vecPlayerSimInfo;
CUtlLinkedList< CPlayerCmdInfo > m_vecPlayerCmdInfo;
IntervalTimer m_weaponFiredTimer;
// Store the last time we successfully processed a usercommand
float m_flLastUserCommandTime;
public:
virtual unsigned int PlayerSolidMask( bool brushOnly = false ) const; // returns the solid mask for the given player, so bots can have a more-restrictive set
};
typedef CHandle<CBasePlayer> CBasePlayerHandle;
EXTERN_SEND_TABLE(DT_BasePlayer)
//-----------------------------------------------------------------------------
// Inline methods
//-----------------------------------------------------------------------------
inline bool CBasePlayer::IsBotOfType( int botType ) const
{
// bot type of zero is invalid
return ( GetBotType() != 0 ) && ( GetBotType() == botType );
}
inline int CBasePlayer::GetBotType( void ) const
{
return 0;
}
inline bool CBasePlayer::IsAutoKickDisabled( void ) const
{
return m_autoKickDisabled;
}
inline void CBasePlayer::DisableAutoKick( bool disabled )
{
m_autoKickDisabled = disabled;
}
inline void CBasePlayer::SetAdditionalPVSOrigin( const Vector &vecOrigin )
{
m_vecAdditionalPVSOrigin = vecOrigin;
}
inline void CBasePlayer::SetCameraPVSOrigin( const Vector &vecOrigin )
{
m_vecCameraPVSOrigin = vecOrigin;
}
inline void CBasePlayer::SetMuzzleFlashTime( float flTime )
{
m_flFlashTime = flTime;
}
inline void CBasePlayer::SetUseEntity( CBaseEntity *pUseEntity )
{
m_hUseEntity = pUseEntity;
}
inline CBaseEntity *CBasePlayer::GetUseEntity()
{
return m_hUseEntity;
}
// Bot accessors...
inline void CBasePlayer::SetTimeBase( float flTimeBase )
{
m_nTickBase = TIME_TO_TICKS( flTimeBase );
}
inline void CBasePlayer::SetLastUserCommand( const CUserCmd &cmd )
{
m_LastCmd = cmd;
}
inline CUserCmd const *CBasePlayer::GetLastUserCommand( void )
{
return &m_LastCmd;
}
inline bool CBasePlayer::IsPredictingWeapons( void ) const
{
return m_bPredictWeapons;
}
inline int CBasePlayer::CurrentCommandNumber() const
{
Assert( m_pCurrentCommand );
return m_pCurrentCommand->command_number;
}
inline const CUserCmd *CBasePlayer::GetCurrentUserCommand() const
{
Assert( m_pCurrentCommand );
return m_pCurrentCommand;
}
inline IServerVehicle *CBasePlayer::GetVehicle()
{
CBaseEntity *pVehicleEnt = m_hVehicle.Get();
return pVehicleEnt ? pVehicleEnt->GetServerVehicle() : NULL;
}
inline CBaseEntity *CBasePlayer::GetVehicleEntity()
{
return m_hVehicle.Get();
}
inline bool CBasePlayer::IsInAVehicle( void ) const
{
return ( NULL != m_hVehicle.Get() ) ? true : false;
}
inline void CBasePlayer::SetTouchedPhysics( bool bTouch )
{
m_touchedPhysObject = bTouch;
}
inline bool CBasePlayer::TouchedPhysics( void )
{
return m_touchedPhysObject;
}
inline void CBasePlayer::OnMyWeaponFired( CBaseCombatWeapon *weapon )
{
m_weaponFiredTimer.Start();
}
inline float CBasePlayer::GetTimeSinceWeaponFired( void ) const
{
return m_weaponFiredTimer.GetElapsedTime();
}
inline bool CBasePlayer::IsFiringWeapon( void ) const
{
return m_weaponFiredTimer.HasStarted() && m_weaponFiredTimer.IsLessThen( 1.0f );
}
//-----------------------------------------------------------------------------
// Converts an entity to a player
//-----------------------------------------------------------------------------
inline CBasePlayer *ToBasePlayer( CBaseEntity *pEntity )
{
if ( !pEntity || !pEntity->IsPlayer() )
return NULL;
#if _DEBUG
return dynamic_cast<CBasePlayer *>( pEntity );
#else
return static_cast<CBasePlayer *>( pEntity );
#endif
}
inline const CBasePlayer *ToBasePlayer( const CBaseEntity *pEntity )
{
if ( !pEntity || !pEntity->IsPlayer() )
return NULL;
#if _DEBUG
return dynamic_cast<const CBasePlayer *>( pEntity );
#else
return static_cast<const CBasePlayer *>( pEntity );
#endif
}
//--------------------------------------------------------------------------------------------------------------
/**
* DEPRECATED: Use CollectPlayers() instead.
* Iterate over all active players in the game, invoking functor on each.
* If functor returns false, stop iteration and return false.
*/
template < typename Functor >
bool ForEachPlayer( Functor &func )
{
for( int i=1; i<=gpGlobals->maxClients; ++i )
{
CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
if (player == NULL)
continue;
if (FNullEnt( player->edict() ))
continue;
if (!player->IsPlayer())
continue;
if( !player->IsConnected() )
continue;
if (func( player ) == false)
return false;
}
return true;
}
//-----------------------------------------------------------------------------------------------
/**
* The interface for an iterative player functor
*/
class IPlayerFunctor
{
public:
virtual void OnBeginIteration( void ) { } // invoked once before iteration begins
virtual bool operator() ( CBasePlayer *player ) = 0;
virtual void OnEndIteration( bool allElementsIterated ) { } // invoked once after iteration is complete whether successful or not
};
//--------------------------------------------------------------------------------------------------------------
/**
* DEPRECATED: Use CollectPlayers() instead.
* Specialization of ForEachPlayer template for IPlayerFunctors
*/
template <>
inline bool ForEachPlayer( IPlayerFunctor &func )
{
func.OnBeginIteration();
bool isComplete = true;
for( int i=1; i<=gpGlobals->maxClients; ++i )
{
CBasePlayer *player = static_cast<CBasePlayer *>( UTIL_PlayerByIndex( i ) );
if (player == NULL)
continue;
if (FNullEnt( player->edict() ))
continue;
if (!player->IsPlayer())
continue;
if( !player->IsConnected() )
continue;
if (func( player ) == false)
{
isComplete = false;
break;
}
}
func.OnEndIteration( isComplete );
return isComplete;
}
//--------------------------------------------------------------------------------------------------------------
//
// Collect all valid, connected players into given vector.
// Returns number of players collected.
//
#define COLLECT_ONLY_LIVING_PLAYERS true
#define APPEND_PLAYERS true
template < typename T >
int CollectPlayers( CUtlVector< T * > *playerVector, int team = TEAM_ANY, bool isAlive = false, bool shouldAppend = false )
{
if ( !shouldAppend )
{
playerVector->RemoveAll();
}
for( int i=1; i<=gpGlobals->maxClients; ++i )
{
CBasePlayer *player = UTIL_PlayerByIndex( i );
if ( player == NULL )
continue;
if ( FNullEnt( player->edict() ) )
continue;
if ( !player->IsPlayer() )
continue;
if ( !player->IsConnected() )
continue;
if ( team != TEAM_ANY && player->GetTeamNumber() != team )
continue;
if ( isAlive && !player->IsAlive() )
continue;
playerVector->AddToTail( assert_cast< T * >( player ) );
}
return playerVector->Count();
}
template < typename T >
int CollectHumanPlayers( CUtlVector< T * > *playerVector, int team = TEAM_ANY, bool isAlive = false, bool shouldAppend = false )
{
if ( !shouldAppend )
{
playerVector->RemoveAll();
}
for( int i=1; i<=gpGlobals->maxClients; ++i )
{
CBasePlayer *player = UTIL_PlayerByIndex( i );
if ( player == NULL )
continue;
if ( FNullEnt( player->edict() ) )
continue;
if ( !player->IsPlayer() )
continue;
if ( player->IsBot() )
continue;
if ( !player->IsConnected() )
continue;
if ( team != TEAM_ANY && player->GetTeamNumber() != team )
continue;
if ( isAlive && !player->IsAlive() )
continue;
playerVector->AddToTail( assert_cast< T * >( player ) );
}
return playerVector->Count();
}
enum
{
VEHICLE_ANALOG_BIAS_NONE = 0,
VEHICLE_ANALOG_BIAS_FORWARD,
VEHICLE_ANALOG_BIAS_REVERSE,
};
#endif // PLAYER_H
Reference in New Issue Copy Permalink