Confronta il testo

Trova la differenza tra due file di testo

Real-time diff

Unified diff

Collapse lines

Highlight change

Syntax highlighting

Strumenti

Diffchecker Desktop The most secure way to run Diffchecker. Get the Diffchecker Desktop app: your diffs never leave your computer!Get Desktop

Untitled diff

Created 8 years agoDiff never expires

Lines
Total
Removed

Words
Total
Removed

To continue using this feature, upgrade to Diffchecker Pro View Pricing

640 lines

Lines
Total
Added

Words
Total
Added

To continue using this feature, upgrade to Diffchecker Pro View Pricing

660 lines

// 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

#include "ai_senses.h"

#include "soundent.h"

// 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:

public:

CBasePlayer *m_pParent;

};

class IBot;

class CSquad;

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; }

//IBotController *GetBotController() { return &m_PlayerInfo; }

virtual IBot *GetBotController() {

return NULL;

}

virtual void SetBotController( IBot *pBot ) { }

virtual void SetUpBot() { }

virtual CAI_Senses *GetSenses() {

return NULL;

}

virtual const CAI_Senses *GetSenses() const {

return NULL;

}

virtual CSound *GetBestSound( int validTypes = ALL_SOUNDS ) {

return NULL;

}

virtual CSound *GetBestScent( void ) {

return NULL;

}

// Squad

virtual CSquad *GetSquad() {

return NULL;

}

virtual void SetSquad( CSquad *pSquad ) { }

virtual void SetSquad( const char *name ) { }

virtual void OnNewLeader( CBasePlayer *pMember ) { }

virtual void OnMemberTakeDamage( CBasePlayer *pMember, const CTakeDamageInfo &info ) { }

virtual void OnMemberDeath( CBasePlayer *pMember, const CTakeDamageInfo &info ) { }

virtual void OnMemberReportEnemy( CBasePlayer *pMember, CBaseEntity *pEnemy ) { }

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 );

int GetUserID() { return engine->GetPlayerUserId( edict() ); }

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 );

CBaseCombatWeapon *GetLastWeapon( void ) { return m_hLastWeapon.Get(); }

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

virtual void ChangeTeam( int iTeamNum ) { ChangeTeam(iTeamNum,false, false); }

virtual void ChangeTeam( int iTeamNum, bool bAutoTeam, bool bSilent );

// 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 );

virtual bool ShouldAnnounceAchievement( void );

#if defined USES_ECON_ITEMS

// Wearables

virtual void EquipWearable( CEconWearable *pItem );

virtual vo

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 );

Diff salvati

Testo originale

Apri file

//========= 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 );

int						GetUserID() { return engine->GetPlayerUserId( edict() ); }
	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 );
	CBaseCombatWeapon		*GetLastWeapon( void ) { return m_hLastWeapon.Get(); }

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
	virtual void			ChangeTeam( int iTeamNum ) { ChangeTeam(iTeamNum,false, false); }
	virtual void			ChangeTeam( int iTeamNum, bool bAutoTeam, bool bSilent );

// 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 );

virtual bool			ShouldAnnounceAchievement( void );

#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		GetLockViewanglesTickNumber() const { return m_iLockViewanglesTickNumber; }
	QAngle	GetLockViewanglesData() const { return m_qangLockViewangles; }

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:
	
	// How long since this player last interacted with something the game considers an objective/target/goal
	float				GetTimeSinceLastObjective( void ) const { return ( m_flLastObjectiveTime == -1.f ) ? 999.f : gpGlobals->curtime - m_flLastObjectiveTime; }
	void				SetLastObjectiveTime( float flTime ) { m_flLastObjectiveTime = flTime; }

// 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]; }
	const CEconWearable		*GetWearable( int i ) const { return m_hMyWearables[i]; }
	int						GetNumWearables( void ) const { return m_hMyWearables.Count(); }
#endif

private:

Activity				m_Activity;
	float					m_flLastObjectiveTime;				// Last curtime player touched/killed something the gamemode considers an objective

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;
	int						m_iLockViewanglesTickNumber;
	QAngle					m_qangLockViewangles;

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;

// used to prevent achievement announcement spam
	CUtlVector< float >		m_flAchievementTimes;

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

Testo modificato

Apri file

#ifndef PLAYER_H
#define PLAYER_H
#ifdef _WIN32
#pragma once
#endif

#if defined USES_ECON_ITEMS
#include "game_item_schema.h"
#include "econ_item_view.h"
#endif

#include "ai_senses.h"
#include "soundent.h"

// 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;
};

#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 )

// If you add another flag here check that you aren't 
	// overwriting phys flags in the HL2 of TF2 player classes
};

#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

enum PlayerConnectedState
{
	PlayerConnected,
	PlayerDisconnecting,
	PlayerDisconnected,
};

extern bool gInitHUD;
extern ConVar *sv_cheats;

virtual void RunPlayerMove( CBotCmd *ucmd );
	virtual void SetLastUserCommand( const CBotCmd &cmd );

virtual CBotCmd GetLastUserCommand();

public:
	CBasePlayer *m_pParent; 
};

class IBot;
class CSquad;

// IPlayerInfo passthrough (because we can't do multiple inheritance)
	IPlayerInfo *GetPlayerInfo() { return &m_PlayerInfo; }
	//IBotController *GetBotController() { return &m_PlayerInfo; }

virtual IBot *GetBotController() {
        return NULL;
    }

virtual void SetBotController( IBot *pBot ) { }
    virtual void SetUpBot() { }

virtual CAI_Senses *GetSenses() {
        return NULL;
    }

virtual const CAI_Senses *GetSenses() const {
        return NULL;
    }

virtual CSound *GetBestSound( int validTypes = ALL_SOUNDS ) {
        return NULL;
    }

virtual CSound *GetBestScent( void ) {
        return NULL;
    }
    
    // Squad
    virtual CSquad *GetSquad() {
        return NULL;
    }

virtual void SetSquad( CSquad *pSquad ) { }
    virtual void SetSquad( const char *name ) { }

virtual void OnNewLeader( CBasePlayer *pMember ) { }
    virtual void OnMemberTakeDamage( CBasePlayer *pMember, const CTakeDamageInfo &info ) { }
    virtual void OnMemberDeath( CBasePlayer *pMember, const CTakeDamageInfo &info ) { }
    virtual void OnMemberReportEnemy( CBasePlayer *pMember, CBaseEntity *pEnemy ) { }