1HEADmaster

1 files changed, 1297 insertions, 0 deletions

diff --git a/game/shared/tf/tf_player_shared.h b/game/shared/tf/tf_player_shared.h
new file mode 100644
index 0000000..a3eaca9
--- /dev/null
+++ b/game/shared/tf/tf_player_shared.h
@@ -0,0 +1,1297 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: Shared player code.
+//
+//=============================================================================
+#ifndef TF_PLAYER_SHARED_H
+#define TF_PLAYER_SHARED_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "networkvar.h"
+#include "tf_shareddefs.h"
+#include "tf_weaponbase.h"
+#include "basegrenade_shared.h"
+#include "SpriteTrail.h"
+#include "tf_condition.h"
+
+// Client specific.
+#ifdef CLIENT_DLL
+#include "baseobject_shared.h"
+#include "c_tf_weapon_builder.h"
+class C_TFPlayer;
+// Server specific.
+#else
+#include "entity_currencypack.h"
+#include "tf_weapon_builder.h"
+class CTFPlayer;
+#endif
+
+
+//=============================================================================
+//
+// Tables.
+//
+
+// Client specific.
+#ifdef CLIENT_DLL
+
+	EXTERN_RECV_TABLE( DT_TFPlayerShared );
+
+// Server specific.
+#else
+
+	EXTERN_SEND_TABLE( DT_TFPlayerShared );
+
+#endif
+
+enum
+{
+	MELEE_NOCRIT = 0,
+	MELEE_MINICRIT = 1,
+	MELEE_CRIT = 2,
+};
+
+struct stun_struct_t
+{
+	CHandle<CTFPlayer> hPlayer;
+	float flDuration;
+	float flExpireTime;
+	float flStartFadeTime;
+	float flStunAmount;
+	int	iStunFlags;
+};
+
+//=============================================================================
+
+#define PERMANENT_CONDITION		-1
+
+#define MOVEMENTSTUN_PARITY_BITS	2
+
+// Damage storage for crit multiplier calculation
+class CTFDamageEvent
+{
+#ifdef CLIENT_DLL
+	// This redundantly declares friendship which leads to gcc warnings.
+	//DECLARE_CLIENTCLASS_NOBASE();
+#else
+public:
+	// This redundantly declares friendship which leads to gcc warnings.
+	//DECLARE_SERVERCLASS_NOBASE();
+#endif
+	DECLARE_EMBEDDED_NETWORKVAR();
+
+public:
+	float	flDamage;
+	float	flDamageCritScaleMultiplier;		// scale the damage by this amount when taking it into consideration for "should I crit?" calculations
+	float	flTime;
+	int		nDamageType;
+	byte	nKills;
+};
+
+#ifdef CLIENT_DLL
+struct WheelEffect_t
+{
+	WheelEffect_t( float flTriggerSpeed, const char *pszRedParticleName, const char *pszBlueParticleName )
+		: m_flMinTriggerSpeed( flTriggerSpeed )
+	{
+		memset( m_pszParticleName, NULL, sizeof( m_pszParticleName ) );
+		m_pszParticleName[ TF_TEAM_RED ] = pszRedParticleName;
+		m_pszParticleName[ TF_TEAM_BLUE ] = pszBlueParticleName;
+	}
+
+	float m_flMinTriggerSpeed;
+	const char *m_pszParticleName[ TF_TEAM_COUNT ];
+};
+#endif
+
+//=============================================================================
+// Scoring data for the local player
+struct RoundStats_t;
+struct localplayerscoring_t
+{
+	DECLARE_EMBEDDED_NETWORKVAR();
+	DECLARE_CLASS_NOBASE( localplayerscoring_t );
+
+	localplayerscoring_t()
+	{
+		Reset();
+	}
+
+	void Reset( void )
+	{
+		m_iCaptures = 0;
+		m_iDefenses = 0;
+		m_iKills = 0;
+		m_iDeaths = 0;
+		m_iSuicides = 0;
+		m_iKillAssists = 0;
+		m_iBuildingsBuilt = 0;
+		m_iBuildingsDestroyed = 0;
+		m_iHeadshots = 0;
+		m_iDominations = 0;
+		m_iRevenge = 0;
+		m_iInvulns = 0;
+		m_iTeleports = 0;
+		m_iDamageDone = 0;
+		m_iCrits = 0;
+		m_iBackstabs = 0;
+		m_iHealPoints = 0;
+		m_iResupplyPoints = 0;
+		m_iBonusPoints = 0;
+		m_iPoints = 0;
+	}
+
+	void UpdateStats( RoundStats_t& roundStats, CTFPlayer *pPlayer, bool bIsRoundData );
+
+	CNetworkVar( int, m_iCaptures );
+	CNetworkVar( int, m_iDefenses );
+	CNetworkVar( int, m_iKills );
+	CNetworkVar( int, m_iDeaths );
+	CNetworkVar( int, m_iSuicides );
+	CNetworkVar( int, m_iDominations );
+	CNetworkVar( int, m_iRevenge );
+	CNetworkVar( int, m_iBuildingsBuilt );
+	CNetworkVar( int, m_iBuildingsDestroyed );
+	CNetworkVar( int, m_iHeadshots );
+	CNetworkVar( int, m_iBackstabs );
+	CNetworkVar( int, m_iHealPoints );
+	CNetworkVar( int, m_iInvulns );
+	CNetworkVar( int, m_iTeleports );
+	CNetworkVar( int, m_iDamageDone );
+	CNetworkVar( int, m_iCrits );
+	CNetworkVar( int, m_iResupplyPoints );
+	CNetworkVar( int, m_iKillAssists );
+	CNetworkVar( int, m_iBonusPoints );
+	CNetworkVar( int, m_iPoints );
+};
+
+
+// Condition Provider
+struct condition_source_t
+{
+	DECLARE_EMBEDDED_NETWORKVAR();
+	DECLARE_CLASS_NOBASE( condition_source_t );
+
+	condition_source_t()
+	{
+		m_nPreventedDamageFromCondition = 0;
+		m_flExpireTime = 0.f;
+		m_pProvider = NULL;
+		m_bPrevActive = false;
+	}
+
+	int	m_nPreventedDamageFromCondition;
+	float	m_flExpireTime;
+	CNetworkHandle( CBaseEntity, m_pProvider );
+	bool	m_bPrevActive;
+};
+
+
+//=============================================================================
+// For checkpointing upgrades Players have purchased in Mann Vs Machine
+class CUpgradeInfo
+{
+public:
+	int m_iPlayerClass;							// the character class this upgrade is being applied too
+	item_definition_index_t m_itemDefIndex;		// item that was upgraded (or INVALID_ITEM_DEF_INDEX for the player itself)
+	int m_upgrade;								// the upgrade that was applied
+	int m_nCost;								// price of the upgrade
+};
+
+//=============================================================================
+//
+// Shared player class.
+//
+class CTFPlayerShared : public CGameEventListener
+{
+public:
+
+// Client specific.
+#ifdef CLIENT_DLL
+
+	friend class C_TFPlayer;
+	typedef C_TFPlayer OuterClass;
+	DECLARE_PREDICTABLE();
+
+// Server specific.
+#else
+
+	friend class CTFPlayer;
+	typedef CTFPlayer OuterClass;
+
+#endif
+	
+	DECLARE_EMBEDDED_NETWORKVAR()
+	DECLARE_CLASS_NOBASE( CTFPlayerShared );
+
+private:
+
+	struct RageBuff
+	{
+		int m_iBuffTypeActive;
+		int m_iBuffPulseCount;
+		float m_flNextBuffPulseTime;
+	};
+
+	// Condition Provider tracking
+	CUtlVector< condition_source_t > m_ConditionData;
+
+public:
+	enum ERageBuffSlot
+	{
+		kBuffSlot_Rage,
+		kBuffSlot_Decapitation,
+		kBuffSlot_MAX,
+	};
+
+	enum ETFStreak
+	{
+		kTFStreak_Kills				= 0,
+		kTFStreak_KillsAll			= 1,	// Counts all kills not just attr based killstreak.  For Data collection purposes
+		kTFStreak_Ducks				= 2,
+		kTFStreak_Duck_levelup		= 3, 
+		kTFStreak_COUNT				= 4,
+	};
+
+	enum EKartStateFlags
+	{
+		kKartState_Driving			= 1 << 0,
+		kKartState_Braking			= 1 << 1,
+		kKartState_Reversing		= 1 << 2,
+		kKartState_Stopped			= 1 << 3,
+		kKartState_SteerLeft		= 1 << 4,
+		kKartState_SteerRight		= 1 << 5
+	};
+
+	// Initialization.
+	CTFPlayerShared();
+	void Init( OuterClass *pOuter );
+	void Spawn( void );
+
+	// State (TF_STATE_*).
+	int		GetState() const					{ return m_nPlayerState; }
+	void	SetState( int nState )				{ m_nPlayerState = nState; }
+	bool	InState( int nState )				{ return ( m_nPlayerState == nState ); }
+
+	// Condition (TF_COND_*).
+	void	AddCond( ETFCond eCond, float flDuration = PERMANENT_CONDITION, CBaseEntity *pProvider = NULL );
+	void	RemoveCond( ETFCond eCond, bool ignore_duration=false );
+	bool	InCond( ETFCond eCond ) const;
+	bool	WasInCond( ETFCond eCond ) const;
+	void	ForceRecondNextSync( ETFCond eCond );
+	void	RemoveAllCond();
+	void	OnConditionAdded( ETFCond eCond );
+	void	OnConditionRemoved( ETFCond eCond );
+	void	ConditionThink( void );
+	float	GetConditionDuration( ETFCond eCond ) const;
+	void	SetConditionDuration( ETFCond eCond, float flNewDur )
+	{
+		Assert( eCond < m_ConditionData.Count() );
+		m_ConditionData[eCond].m_flExpireTime = flNewDur;
+	}
+
+	CBaseEntity *GetConditionProvider( ETFCond eCond ) const;
+	CBaseEntity *GetConditionAssistFromVictim( void );
+	CBaseEntity *GetConditionAssistFromAttacker( void );
+
+	void	ConditionGameRulesThink( void );
+
+	void	InvisibilityThink( void );
+
+	void	CheckDisguiseTimer( void );
+
+	int		GetMaxBuffedHealth( bool bIgnoreAttributes = false, bool bIgnoreHealthOverMax = false );
+
+	bool	IsAiming( void );
+
+	void SetCarryingRuneType( RuneTypes_t rt );
+	RuneTypes_t GetCarryingRuneType( void ) const;
+	bool IsCarryingRune( void ) const { return GetCarryingRuneType() != RUNE_NONE; }
+	float		m_flRuneAcquireTime;
+
+#ifdef CLIENT_DLL
+	// This class only receives calls for these from C_TFPlayer, not
+	// natively from the networking system
+	virtual void OnPreDataChanged( void );
+	virtual void OnDataChanged( void );
+
+	// check the newly networked conditions for changes
+	void	SyncConditions( int nPreviousConditions, int nNewConditions, int nForceConditionBits, int nBaseCondBit );
+
+	enum ECritBoostUpdateType { kCritBoost_Ignore, kCritBoost_ForceRefresh };
+	void	UpdateCritBoostEffect( ECritBoostUpdateType eUpdateType = kCritBoost_Ignore );
+
+	bool	ShouldShowRecentlyTeleported( void );
+	void	EndRadiusHealEffect( void );
+	void	EndKingBuffRadiusEffect( void );
+#endif
+
+	bool	IsCritBoosted( void ) const;
+	bool	IsInvulnerable( void ) const;
+	bool	IsStealthed( void ) const;
+	bool	CanBeDebuffed( void ) const;
+
+	void	Disguise( int nTeam, int nClass, CTFPlayer* pDesiredTarget=NULL, bool bOnKill = false );
+	void	CompleteDisguise( void );
+	void	RemoveDisguise( void );
+	void	RemoveDisguiseWeapon( void );
+	void	FindDisguiseTarget( void );
+	int		GetDisguiseTeam( void ) const;
+	int		GetDisguiseClass( void ) const			{ return InCond( TF_COND_DISGUISED_AS_DISPENSER ) ? (int)TF_CLASS_ENGINEER : m_nDisguiseClass; }
+	int		GetDisguisedSkinOverride( void ) const	{ return m_nDisguiseSkinOverride; }
+	int		GetDisguiseMask( void )	const			{ return InCond( TF_COND_DISGUISED_AS_DISPENSER ) ? (int)TF_CLASS_ENGINEER : m_nMaskClass; }
+	int		GetDesiredDisguiseClass( void )	const	{ return m_nDesiredDisguiseClass; }
+	int		GetDesiredDisguiseTeam( void ) const	{ return m_nDesiredDisguiseTeam; }
+	bool	WasLastDisguiseAsOwnTeam( void ) const	{ return m_bLastDisguisedAsOwnTeam; }
+	int		GetDisguiseTargetIndex( void ) const	{ return m_iDisguiseTargetIndex; }
+	EHANDLE GetDisguiseTarget( void ) const
+	{
+#ifdef CLIENT_DLL
+		if ( m_iDisguiseTargetIndex == TF_DISGUISE_TARGET_INDEX_NONE )
+			return NULL;
+		return cl_entitylist->GetNetworkableHandle( m_iDisguiseTargetIndex );
+#else
+		return m_hDisguiseTarget.Get();
+#endif
+	}
+	CTFWeaponBase *GetDisguiseWeapon( void )			{ return m_hDisguiseWeapon; }
+	int		GetDisguiseHealth( void )			{ return m_iDisguiseHealth; }
+	void	SetDisguiseHealth( int iDisguiseHealth );
+	int		GetDisguiseMaxHealth( void );
+	int		GetDisguiseMaxBuffedHealth( bool bIgnoreAttributes = false, bool bIgnoreHealthOverMax = false );
+	void	ProcessDisguiseImpulse( CTFPlayer *pPlayer );
+	int		GetDisguiseAmmoCount( void ) { return m_iDisguiseAmmo; }
+	void	SetDisguiseAmmoCount( int nValue ) { m_iDisguiseAmmo = nValue; }
+
+	bool	CanRecieveMedigunChargeEffect( medigun_charge_types eType ) const;
+#ifdef CLIENT_DLL
+	int		GetDisplayedTeam( void ) const;
+	void	OnDisguiseChanged( void );
+
+	float	GetTimeTeleEffectAdded( void ) { return m_flGotTeleEffectAt; }
+	int		GetTeamTeleporterUsed( void ) { return m_nTeamTeleporterUsed; }
+
+	void	ClientDemoBuffThink( void );
+	void	ClientKillStreakBuffThink( void );
+#endif
+
+	int		CalculateObjectCost( CTFPlayer* pBuilder, int iObjectType );
+
+	// Pickup effects, including putting out fires, updating HUD, etc.
+	void	HealthKitPickupEffects( int iHealthGiven = 0 );
+
+#ifdef GAME_DLL
+	void	DetermineDisguiseWeapon( bool bForcePrimary = false );
+	void	DetermineDisguiseWearables();
+	void	RemoveDisguiseWearables();
+	void	Heal( CBaseEntity *pHealer, float flAmount, float flOverhealBonus, float flOverhealDecayMult, bool bDispenserHeal = false, CTFPlayer *pHealScorer = NULL );
+	float	StopHealing( CBaseEntity *pHealer );
+	void	TestAndExpireChargeEffect( medigun_charge_types iCharge );
+	void	RecalculateChargeEffects( bool bInstantRemove = false );
+	int		FindHealerIndex( CBaseEntity *pPlayer );
+	EHANDLE	GetFirstHealer();
+	void	CheckForAchievement( int iAchievement );
+
+	void	IncrementArenaNumChanges( void ) { m_nArenaNumChanges++; }
+	void	ResetArenaNumChanges( void ) { m_nArenaNumChanges = 0; }
+
+	bool	AddToSpyCloakMeter( float val, bool bForce=false );
+
+	void	AddTmpDamageBonus( float flBonus, float flExpiration );
+	float	GetTmpDamageBonus( void ) { return (InCond(TF_COND_TMPDAMAGEBONUS)) ? m_flTmpDamageBonusAmount : 1.0; }
+
+	void	SetTeamTeleporterUsed( int nTeam ){ m_nTeamTeleporterUsed.Set( nTeam ); }
+
+	void	SetBiteEffectWasApplied() { m_bBiteEffectWasApplied = true; }
+
+#endif	// GAME_DLL
+
+	int		GetArenaNumChanges( void ) { return m_nArenaNumChanges; }
+
+	CBaseEntity *GetHealerByIndex( int index );
+	bool HealerIsDispenser( int index );
+	int		GetNumHealers( void ) { return m_nNumHealers; }
+
+	void	Burn( CTFPlayer *pPlayer, CTFWeaponBase *pWeapon, float flBurningTime = -1.0f );
+	void	SelfBurn( float flBurningTime );		// Boss Burn
+	void    MakeBleed( CTFPlayer *pPlayer, CTFWeaponBase *pWeapon, float flBleedingTime, int nBleedDmg = TF_BLEEDING_DMG, bool bPermanentBleeding = false );
+#ifdef GAME_DLL
+	void	StopBleed( CTFPlayer *pPlayer, CTFWeaponBase *pWeapon );
+#endif // GAME_DLL
+
+	// Weapons.
+	CTFWeaponBase *GetActiveTFWeapon() const;
+
+	// Utility.
+	bool	IsAlly( CBaseEntity *pEntity );
+
+	// Separation force
+	bool	IsSeparationEnabled( void ) const	{ return m_bEnableSeparation; }
+	void	SetSeparation( bool bEnable )		{ m_bEnableSeparation = bEnable; }
+	const Vector &GetSeparationVelocity( void ) const { return m_vSeparationVelocity; }
+	void	SetSeparationVelocity( const Vector &vSeparationVelocity ) { m_vSeparationVelocity = vSeparationVelocity; }
+
+	void	FadeInvis( float fAdditionalRateScale );
+	float	GetPercentInvisible( void ) const;
+	float	GetPercentInvisiblePrevious( void ) { return m_flPrevInvisibility; }
+	void	NoteLastDamageTime( int nDamage );
+	void	OnSpyTouchedByEnemy( void );
+	float	GetLastStealthExposedTime( void ) { return m_flLastStealthExposeTime; }
+	void	SetNextStealthTime( float flTime ) { m_flStealthNextChangeTime = flTime; }
+#ifdef STAGING_ONLY
+	bool	IsFullyInvisible( void ) { return GetPercentInvisible() == 1.f || InCond( TF_COND_STEALTHED_PHASE ); }
+#else
+	bool	IsFullyInvisible( void ) { return ( GetPercentInvisible() == 1.f ); }
+#endif 
+
+	bool	IsEnteringOrExitingFullyInvisible( void );
+
+	bool	CanRuneCharge() const;
+	float	GetRuneCharge() const { return m_flRuneCharge; }
+	void	SetRuneCharge( float flVal ) { m_flRuneCharge = Clamp( flVal, 0.f, 100.f ); }
+	bool	IsRuneCharged() const { return m_flRuneCharge == 100.f; }
+
+#ifdef STAGING_ONLY
+	bool	HasPhaseCloakAbility( void );
+
+	float	GetSpaceJumpChargeMeter() const		{ return m_flSpaceJumpCharge; }
+	void	SetSpaceJumpChargeMeter( float val )  { m_flSpaceJumpCharge = Min( val, 100.0f); }
+
+#endif // STAGING_ONLY
+
+	int		GetDesiredPlayerClassIndex( void );
+	bool	IsInUpgradeZone( void ) { return m_bInUpgradeZone; }
+	void	SetInUpgradeZone( bool bInZone ) { m_bInUpgradeZone = bInZone; }
+
+	// Cloak, rage, phase, team juice...this should really all be done with composition?
+	void	UpdateCloakMeter( void );
+	float	GetSpyCloakMeter() const		{ return m_flCloakMeter; }
+	void	SetSpyCloakMeter( float val ) { m_flCloakMeter = val; }
+
+	void	UpdateRageBuffsAndRage();
+	bool	IsRageDraining() const			{ return m_bRageDraining; }
+	float	GetRageMeter() const		{ return m_flRageMeter; }
+	void	SetRageMeter( float val );
+	void	ModifyRage( float fDelta );
+	void	ResetRageMeter( void );
+	void	PulseRageBuff( ERageBuffSlot eBuffSlot );
+	void	StartRageDrain( void ) { m_bRageDraining = true; }
+	void	ResetRageSystem( void );
+
+	void	ActivateRageBuff( CBaseEntity *pBuffItem, int iBuffType );
+	void	SetupRageBuffTimer( int iBuffType, int iPulseCount, ERageBuffSlot eBuffSlot );
+	void	ResetRageBuffs( void );
+
+	void	UpdatePhaseEffects( void );
+	void	AddPhaseEffects( void );
+	void	RemovePhaseEffects( void );
+
+	void	PulseMedicRadiusHeal( void );
+
+	float	GetScoutEnergyDrinkMeter() const{ return m_flEnergyDrinkMeter; }
+	void	SetScoutEnergyDrinkMeter( float val ) { m_flEnergyDrinkMeter = val; }
+	void	UpdateEnergyDrinkMeter( void );
+
+	float	GetScoutHypeMeter() const		{ return m_flHypeMeter; }
+	void	SetScoutHypeMeter( float val );
+	void	StopScoutHypeDrain( void )		{ RemoveCond( TF_COND_SODAPOPPER_HYPE ); }
+	bool	IsHypeBuffed( void ) const		{ return InCond( TF_COND_SODAPOPPER_HYPE ); }
+
+	void	DemoShieldChargeThink( void );
+	void	UpdateChargeMeter( void );
+	float	GetDemomanChargeMeter() const		{ return m_flChargeMeter; }
+	void	EndCharge( void );
+	float	CalculateChargeCap( void ) const;
+	void	SetDemomanChargeMeter( float val )  { m_flChargeMeter = Clamp( val, 0.0f, 100.0f); }
+	void	CalcChargeCrit( bool bForceCrit=false );
+	bool	HasDemoShieldEquipped() const;
+
+	bool	IsJumping( void ) const			{ return m_bJumping; }
+	void	SetJumping( bool bJumping );
+	bool    IsAirDashing( void ) const		{ return (m_iAirDash > 0); }
+	int		GetAirDash( void ) const		{ return m_iAirDash; }
+	void    SetAirDash( int iAirDash );
+	void	SetAirDucked( int nAirDucked )	{ m_nAirDucked = nAirDucked; }
+	int		AirDuckedCount( void )			{ return m_nAirDucked; }
+	void	SetDuckTimer( float flTime )	{ m_flDuckTimer = flTime; }
+	float	GetDuckTimer( void ) const		{ return m_flDuckTimer; }
+
+	void	DebugPrintConditions( void );
+	void	InstantlySniperUnzoom( void );
+
+	float	GetStealthNoAttackExpireTime( void );
+
+	void	SetPlayerDominated( CTFPlayer *pPlayer, bool bDominated );
+	bool	IsPlayerDominated( int iPlayerIndex );
+	bool	IsPlayerDominatingMe( int iPlayerIndex );
+	void	SetPlayerDominatingMe( CTFPlayer *pPlayer, bool bDominated );
+
+	float	GetDisguiseCompleteTime( void ) { return m_flDisguiseCompleteTime; }
+	bool	IsSpyDisguisedAsMyTeam( CTFPlayer *pPlayer );
+
+	// Stuns
+	stun_struct_t *GetActiveStunInfo( void ) const;
+#ifdef GAME_DLL
+	void	StunPlayer( float flTime, float flReductionAmount, int iStunFlags = TF_STUN_MOVEMENT, CTFPlayer* pAttacker = NULL );
+#endif // GAME_DLL
+	float	GetAmountStunned( int iStunFlags );
+	bool	IsLoserStateStunned( void ) const;
+	bool	IsControlStunned( void );
+	bool	IsSnared( void );
+	CTFPlayer *GetStunner( void );
+	void	ControlStunFading( void );
+	int		GetStunFlags( void ) const		{ return GetActiveStunInfo() ? GetActiveStunInfo()->iStunFlags : 0; }
+	float	GetStunExpireTime( void ) const { return GetActiveStunInfo() ? GetActiveStunInfo()->flExpireTime : 0; }
+	void	SetStunExpireTime( float flTime );
+	void	UpdateLegacyStunSystem( void );
+
+	bool	IsFirstBloodBoosted( void ) const	{ return m_bArenaFirstBloodBoost; }
+	void	SetFirstBloodBoosted( bool bBoost ) { m_bArenaFirstBloodBoost = bBoost; }
+
+	CTFPlayer *GetAssist( void ) const			{ return m_hAssist; }
+	void	SetAssist( CTFPlayer* newAssist )	{ m_hAssist = newAssist; }
+
+	CTFPlayer *GetBurnAttacker( void ) const			{ return m_hBurnAttacker; }
+	CTFPlayer *GetOriginalBurnAttacker( void ) const	{ return m_hOriginalBurnAttacker; }
+
+	void SetCloakConsumeRate( float newCloakConsumeRate ) { m_fCloakConsumeRate = newCloakConsumeRate; }
+	void SetCloakRegenRate( float newCloakRegenRate ) { m_fCloakRegenRate = newCloakRegenRate; }
+
+	int		GetWeaponKnockbackID( void ) const	{ return m_iWeaponKnockbackID; }
+	void	SetWeaponKnockbackID( int iID )		{ m_iWeaponKnockbackID = iID; }
+
+	bool	IsLoadoutUnavailable( void ) { return m_bLoadoutUnavailable; }
+	void	SetLoadoutUnavailable( bool bUnavailable ) { m_bLoadoutUnavailable = bUnavailable; }
+
+	float GetInvulOffTime( void ) { return m_flInvulnerabilityRemoveTime; }
+
+	int		GetDisguiseBody( void ) const	{ return m_iDisguiseBody; }
+	void	SetDisguiseBody( int iVal )		{ m_iDisguiseBody = iVal; }
+
+	bool	IsCarryingObject( void )		const { return m_bCarryingObject; }
+	CBaseObject* GetCarriedObject( void )	const { return m_hCarriedObject.Get(); }
+	void	SetCarriedObject( CBaseObject* pObj );
+	void	StartBuildingObjectOfType( int iType, int iObjectMode=0 );
+
+	void	InterruptCharge( void );
+
+	void	PulseKingRuneBuff();
+
+public:
+	// Scoring
+	int	GetCaptures( int iIndex ) const				{ return m_ScoreData.m_iCaptures; }
+	int	GetDefenses( int iIndex ) const				{ return m_ScoreData.m_iDefenses; }
+	int	GetDominations( int iIndex ) const			{ return m_ScoreData.m_iDominations; }
+	int	GetRevenge( int iIndex ) const				{ return m_ScoreData.m_iRevenge; }
+	int	GetBuildingsDestroyed( int iIndex ) const	{ return m_ScoreData.m_iBuildingsDestroyed; }
+	int	GetHeadshots( int iIndex ) const			{ return m_ScoreData.m_iHeadshots; }
+	int	GetBackstabs( int iIndex ) const			{ return m_ScoreData.m_iBackstabs; }
+	int	GetHealPoints( int iIndex ) const			{ return m_ScoreData.m_iHealPoints; }
+	int	GetInvulns( int iIndex ) const				{ return m_ScoreData.m_iInvulns; }
+	int	GetTeleports( int iIndex ) const			{ return m_ScoreData.m_iTeleports; }
+	int	GetResupplyPoints( int iIndex ) const		{ return m_ScoreData.m_iResupplyPoints; }
+	int	GetKillAssists( int iIndex ) const			{ return m_ScoreData.m_iKillAssists; }
+	int GetBonusPoints( int iIndex ) const			{ return m_ScoreData.m_iBonusPoints; }
+
+	void ResetScores( void ) { m_ScoreData.Reset(); }
+	localplayerscoring_t *GetScoringData( void ) { return &m_ScoreData; }
+
+	// Per-round scoring data utilized by the steamworks stats system.
+	void ResetRoundScores( void ) { m_RoundScoreData.Reset(); }
+	localplayerscoring_t *GetRoundScoringData( void ) { return &m_RoundScoreData; }
+
+	void SetFeignDeathReady( bool bVal ) { m_bFeignDeathReady = bVal; }
+	bool IsFeignDeathReady( void ) const { return m_bFeignDeathReady; }
+	void ReduceFeignDeathDuration( float flAmount ) { m_flFeignDeathEnd -= flAmount; }
+
+	void SetShieldEquipped( bool bVal ) { m_bShieldEquipped = bVal; }
+	bool IsShieldEquipped() const		{ return m_bShieldEquipped; }
+
+	void SetParachuteEquipped( bool bVal ) { m_bParachuteEquipped = bVal; }
+	bool IsParachuteEquipped() const	{ return m_bParachuteEquipped; }
+
+	void SetNextMeleeCrit( int iVal )	{ m_iNextMeleeCrit = iVal; }
+	int	GetNextMeleeCrit( void ) const	{ return m_iNextMeleeCrit; }
+
+	void SetDecapitations( int iVal )	{ m_iDecapitations = iVal; }
+	int GetDecapitations( void ) const	{ return m_iDecapitations; }
+
+	void SetStreak( ETFStreak streak_type, int iVal )		{ m_nStreaks.Set( streak_type, iVal ); }
+	int GetStreak( ETFStreak streak_type ) const		{ return m_nStreaks[streak_type]; }
+	int IncrementStreak( ETFStreak streak_type, int iVal )
+	{
+		// Track duck streak steps so we can put deltas in the event
+		if ( streak_type == kTFStreak_Ducks )
+			m_nLastDuckStreakIncrement = iVal;
+		m_nStreaks.Set( streak_type, m_nStreaks[streak_type] + iVal );
+		return m_nStreaks[streak_type];
+	}
+	void ResetStreaks( void )	{ for ( int streak_type = 0; streak_type < kTFStreak_COUNT; streak_type++ ) { m_nStreaks.Set( streak_type, 0 ); } }
+
+	int GetLastDuckStreakIncrement( void ) const	{ return m_nLastDuckStreakIncrement; }
+
+	void SetRevengeCrits( int iVal );
+	int GetRevengeCrits( void ) const { return m_iRevengeCrits; }
+	void IncrementRevengeCrits( void );
+
+	int GetSequenceForDeath( CBaseAnimating* pRagdoll, bool bBurning, int nCustomDeath );
+
+	float GetNextNoiseMakerTime() const			{ return m_flNextNoiseMakerTime; }
+	void  SetNextNoiseMakerTime( float time )	{ m_flNextNoiseMakerTime = time; }
+
+	void	Heal_Radius ( bool bActive );
+
+	void IncrementRespawnTouchCount() { ++m_iSpawnRoomTouchCount; }
+	void DecrementRespawnTouchCount() { m_iSpawnRoomTouchCount = Max( m_iSpawnRoomTouchCount - 1, 0 ); }
+	int GetRespawnTouchCount() const { return m_iSpawnRoomTouchCount; }
+
+#ifdef CLIENT_DLL
+	void SetVehicleMoveAngles( const QAngle& angVehicleMoveAngles ) { m_angVehicleMovePitchLast = angVehicleMoveAngles[PITCH]; m_angVehicleMoveAngles = angVehicleMoveAngles; }
+#endif
+
+#ifdef STAGING_ONLY
+	void DoRocketPack();
+#endif // STAGING_ONLY
+
+#ifdef GAME_DLL
+	void SetBestOverhealDecayMult( float fValue )	{ m_flBestOverhealDecayMult = fValue; }
+	float GetBestOverhealDecayMult() const			{ return m_flBestOverhealDecayMult; }
+
+	void	SetPeeAttacker( CTFPlayer *pPlayer )	{ m_hPeeAttacker = pPlayer; }
+	CTFPlayer *GetPeeAttacker() const				{ return m_hPeeAttacker; }
+
+	void  SetChargeEffectOffTime( int iCondition, float flTime ) { m_flChargeEffectOffTime[iCondition] = flTime; }
+
+	void GetSpeedWatchersList( CUtlVector<CTFPlayer *> *out_pVecSpeedWatchers ) const;
+#endif
+
+	int GetTauntIndex( void ) const { return m_iTauntIndex; }
+	int GetTauntConcept( void ) const { return m_iTauntConcept; }
+	itemid_t GetTauntSourceItemID( void ) const { return ((uint64)m_unTauntSourceItemID_High << 32) | (uint64)m_unTauntSourceItemID_Low; }
+	void CreateVehicleMove( float flInputSampleTime, CUserCmd *pCmd );
+	void SetVehicleTurnAmount( float flTurnSpeed ) { m_flCurrentTauntTurnSpeed = flTurnSpeed; }
+	float GetVehicleTurnPoseAmount( void ) const { return m_flCurrentTauntTurnSpeed; }
+	void VehicleThink( void );
+
+	bool IsLoser( void );
+
+	int	GetItemFindBonus( void ) //{ return m_iItemFindBonus; }
+	{
+#ifdef GAME_DLL
+		if ( !m_iItemFindBonus )
+		{
+			m_iItemFindBonus = RandomInt( 1, 300 );
+		}
+#endif
+		return m_iItemFindBonus;
+	}
+	
+	void	RecalculatePlayerBodygroups( void );
+
+	void	FireGameEvent( IGameEvent *event );
+	
+	float	GetFlameBurnTime( void ) const { return m_flFlameBurnTime; }
+
+	void GetConditionsBits( CBitVec< TF_COND_LAST >& vbConditions ) const;
+
+#ifdef STAGING_ONLY
+	void	UpdateRocketPack( void );
+	void	ApplyRocketPackStun( float flStunDuration );
+	bool	CanBuildSpyTraps( void );
+#endif // STAGING_ONLY
+
+private:
+	CNetworkVarEmbedded( localplayerscoring_t,	m_ScoreData );
+	CNetworkVarEmbedded( localplayerscoring_t,	m_RoundScoreData );
+
+private:
+#ifdef CLIENT_DLL
+	typedef std::pair<const char *, float> taunt_particle_state_t;
+	taunt_particle_state_t GetClientTauntParticleDesiredState() const;
+	void FireClientTauntParticleEffects();
+#endif // CLIENT_DLL
+
+	void ImpactWaterTrace( trace_t &trace, const Vector &vecStart );
+
+	void OnAddZoomed( void );
+	void OnAddStealthed( void );
+	void OnAddInvulnerable( void );
+	void OnAddTeleported( void );
+	void OnAddBurning( void );
+	void OnAddDisguising( void );
+	void OnAddDisguised( void );
+	void OnAddDemoCharge( void );
+	void OnAddCritBoost( void );
+	void OnAddSodaPopperHype( void );
+	void OnAddOverhealed( void );
+	void OnAddFeignDeath( void );
+	void OnAddStunned( void );
+	void OnAddPhase( void );
+	void OnAddUrine( void );
+	void OnAddMarkedForDeath( void );
+	void OnAddBleeding( void );
+	void OnAddDefenseBuff( void );
+	void OnAddOffenseBuff( void );
+	void OnAddOffenseHealthRegenBuff( void );
+	const char* GetSoldierBuffEffectName( void );
+	void OnAddSoldierOffensiveBuff( void );
+	void OnAddSoldierDefensiveBuff( void );
+	void OnAddSoldierOffensiveHealthRegenBuff( void );
+	void OnAddSoldierNoHealingDamageBuff( void );
+	void OnAddShieldCharge( void );
+	void OnAddDemoBuff( void );
+	void OnAddEnergyDrinkBuff( void	);
+	void OnAddRadiusHeal( void );
+	void OnAddMegaHeal( void );
+	void OnAddMadMilk( void );
+	void OnAddTaunting( void );
+	void OnAddNoHealingDamageBuff( void );
+	void OnAddSpeedBoost( bool IsNonCombat );
+	void OnAddSapped( void );
+	void OnAddReprogrammed( void );
+	void OnAddMarkedForDeathSilent( void );
+	void OnAddDisguisedAsDispenser( void );
+	void OnAddHalloweenBombHead( void );
+	void OnAddHalloweenThriller( void );
+	void OnAddRadiusHealOnDamage( void );
+	void OnAddMedEffectUberBulletResist( void );
+	void OnAddMedEffectUberBlastResist( void );
+	void OnAddMedEffectUberFireResist( void );
+	void OnAddMedEffectSmallBulletResist( void );
+	void OnAddMedEffectSmallBlastResist( void );
+	void OnAddMedEffectSmallFireResist( void );
+	void OnAddStealthedUserBuffFade( void );
+	void OnAddBulletImmune( void );
+	void OnAddBlastImmune( void );
+	void OnAddFireImmune( void );
+	void OnAddMVMBotRadiowave( void );
+	void OnAddHalloweenSpeedBoost( void );
+	void OnAddHalloweenQuickHeal( void );
+	void OnAddHalloweenGiant( void );
+	void OnAddHalloweenTiny( void );
+	void OnAddHalloweenGhostMode( void );
+	void OnAddHalloweenKartDash( void );
+	void OnAddHalloweenKart( void );
+	void OnAddBalloonHead( void );
+	void OnAddMeleeOnly( void );
+	void OnAddSwimmingCurse( void );
+	void OnAddHalloweenKartCage( void );
+	void OnAddRuneResist( void );
+	void OnAddGrapplingHookLatched( void );
+	void OnAddPasstimeInterception( void );
+	void OnAddRunePlague( void );
+	void OnAddPlague( void );
+	void OnAddKingBuff( void );
+	void OnAddInPurgatory( void );
+	void OnAddCompetitiveWinner( void );
+	void OnAddCompetitiveLoser( void );
+
+#ifdef STAGING_ONLY
+	void OnAddTranqMark( void );
+	void OnAddSpaceGravity( void );
+	void OnAddSelfConc( void );
+	void OnAddRocketPack( void );
+	void OnAddStealthedPhase( void );
+	void OnAddClipOverload( void );
+	void OnAddCondSpyClassSteal( void );
+#endif // STAGING_ONLY
+
+	void OnRemoveZoomed( void );
+	void OnRemoveBurning( void );
+	void OnRemoveStealthed( void );
+	void OnRemoveDisguised( void );
+	void OnRemoveDisguising( void );
+	void OnRemoveInvulnerable( void );
+	void OnRemoveTeleported( void );
+	void OnRemoveDemoCharge( void );
+	void OnRemoveCritBoost( void );
+	void OnRemoveSodaPopperHype( void );
+	void OnRemoveTmpDamageBonus( void );
+	void OnRemoveOverhealed( void );
+	void OnRemoveFeignDeath( void );
+	void OnRemoveStunned( void );
+	void OnRemovePhase( void );
+	void OnRemoveUrine( void );
+	void OnRemoveMarkedForDeath( void );
+	void OnRemoveBleeding( void );
+	void OnRemoveInvulnerableWearingOff( void );
+	void OnRemoveDefenseBuff( void );
+	void OnRemoveOffenseBuff( void );
+	void OnRemoveOffenseHealthRegenBuff( void );
+	void OnRemoveSoldierOffensiveBuff( void );
+	void OnRemoveSoldierDefensiveBuff( void );
+	void OnRemoveSoldierOffensiveHealthRegenBuff( void );
+	void OnRemoveSoldierNoHealingDamageBuff( void );
+	void OnRemoveShieldCharge( void );
+	void OnRemoveDemoBuff( void );
+	void OnRemoveEnergyDrinkBuff( void );
+	void OnRemoveRadiusHeal( void );
+	void OnRemoveMegaHeal( void );
+	void OnRemoveMadMilk( void );
+	void OnRemoveTaunting( void );
+	void OnRemoveNoHealingDamageBuff( void );
+	void OnRemoveSpeedBoost( bool IsNonCombat );
+	void OnRemoveSapped( void );
+	void OnRemoveReprogrammed( void );
+	void OnRemoveMarkedForDeathSilent( void );
+	void OnRemoveDisguisedAsDispenser( void );
+	void OnRemoveHalloweenBombHead( void );
+	void OnRemoveHalloweenThriller( void );
+	void OnRemoveRadiusHealOnDamage( void );
+	void OnRemoveMedEffectUberBulletResist( void );
+	void OnRemoveMedEffectUberBlastResist( void );
+	void OnRemoveMedEffectUberFireResist( void );
+	void OnRemoveMedEffectSmallBulletResist( void );
+	void OnRemoveMedEffectSmallBlastResist( void );
+	void OnRemoveMedEffectSmallFireResist( void );
+	void OnRemoveStealthedUserBuffFade( void );
+	void OnRemoveBulletImmune( void );
+	void OnRemoveBlastImmune( void );
+	void OnRemoveFireImmune( void );
+	void OnRemoveMVMBotRadiowave( void );
+	void OnRemoveHalloweenSpeedBoost( void );
+	void OnRemoveHalloweenQuickHeal( void );
+	void OnRemoveHalloweenGiant( void );
+	void OnRemoveHalloweenTiny( void );
+	void OnRemoveHalloweenGhostMode( void );
+	void OnRemoveHalloweenKartDash( void );
+	void OnRemoveHalloweenKart( void );
+	void OnRemoveBalloonHead( void );
+	void OnRemoveMeleeOnly( void );
+	void OnRemoveSwimmingCurse( void );
+	void OnRemoveHalloweenKartCage( void );
+	void OnRemoveRuneResist( void );
+	void OnRemoveGrapplingHookLatched( void );
+	void OnRemovePasstimeInterception( void );
+	void OnRemoveRunePlague( void );
+	void OnRemovePlague( void );
+	void OnRemoveRuneKing( void );
+	void OnRemoveKingBuff( void );
+	void OnRemoveRuneSupernova( void );
+	void OnRemoveInPurgatory( void );
+	void OnRemoveCompetitiveWinner( void );
+	void OnRemoveCompetitiveLoser( void );
+	
+#ifdef STAGING_ONLY
+	void OnRemoveTranqMark( void );
+	void OnRemoveSpaceGravity( void );
+	void OnRemoveSelfConc( void );
+	void OnRemoveRocketPack( void );
+	void OnRemoveStealthedPhase( void );
+	void OnRemoveClipOverload( void );
+	void OnRemoveCondSpyClassSteal( void );
+#endif // STAGING_ONLY
+
+	// Starting a new trend, putting Add and Remove next to each other
+	void OnAddCondParachute( void );
+	void OnRemoveCondParachute( void );
+
+	float GetCritMult( void );
+
+#ifdef GAME_DLL
+	void  UpdateCritMult( void );
+	void  RecordDamageEvent( const CTakeDamageInfo &info, bool bKill, int nVictimPrevHealth );
+	void  AddTempCritBonus( float flAmount );
+	void  ClearDamageEvents( void ) { m_DamageEvents.Purge(); }
+	int	  GetNumKillsInTime( float flTime );
+
+	// Invulnerable.
+	void  SendNewInvulnGameEvent( void );
+	void  SetChargeEffect( medigun_charge_types iCharge, bool bState, bool bInstant, const struct MedigunEffects_t& effects, float flWearOffTime, CTFPlayer *pProvider = NULL );
+	void  SetCritBoosted( bool bState );
+
+	void RadiusCurrencyCollectionCheck( void );
+	void RadiusHealthkitCollectionCheck( void );
+	void RadiusSpyScan( void );
+
+	// Attr for Conditions
+	void ApplyAttributeToPlayer( const char* pszAttribName, float flValue );
+	void RemoveAttributeFromPlayer( const char* pszAttribName );
+#endif // GAME_DLL
+
+private:
+	// Vars that are networked.
+	CNetworkVar( int, m_nPlayerState );			// Player state.
+	CNetworkVar( int, m_nPlayerCond );			// Player condition flags.
+	CNetworkVar( int, m_nPlayerCondEx );		// Player condition flags (extended -- we overflowed 32 bits).
+	CNetworkVar( int, m_nPlayerCondEx2 );		// Player condition flags (extended -- we overflowed 64 bits).
+	CNetworkVar( int, m_nPlayerCondEx3 );		// Player condition flags (extended -- we overflowed 96 bits).
+
+	CNetworkVarEmbedded( CTFConditionList, m_ConditionList );
+
+//TFTODO: What if the player we're disguised as leaves the server?
+//...maybe store the name instead of the index?
+	CNetworkVar( int, m_nDisguiseTeam );		// Team spy is disguised as.
+	CNetworkVar( int, m_nDisguiseClass );		// Class spy is disguised as.
+	CNetworkVar( int, m_nDisguiseSkinOverride ); // skin override value of the player spy disguised as.
+	CNetworkVar( int, m_nMaskClass );
+#ifdef GAME_DLL
+	EHANDLE m_hDisguiseTarget;					// Playing the spy is using for name disguise.
+#endif // GAME_DLL
+	CNetworkVar( int, m_iDisguiseTargetIndex );
+	CNetworkVar( int, m_iDisguiseHealth );		// Health to show our enemies in player id
+	CNetworkVar( int, m_nDesiredDisguiseClass );
+	CNetworkVar( int, m_nDesiredDisguiseTeam );
+	CNetworkHandle( CTFWeaponBase, m_hDisguiseWeapon );
+	CNetworkVar( int, m_nTeamTeleporterUsed ); // for disguised spies using enemy teleporters
+	CHandle<CTFPlayer>	m_hDesiredDisguiseTarget;
+	int m_iDisguiseAmmo;
+
+	bool m_bEnableSeparation;		// Keeps separation forces on when player stops moving, but still penetrating
+	Vector m_vSeparationVelocity;	// Velocity used to keep player seperate from teammates
+
+	float m_flInvisibility;
+	float m_flPrevInvisibility;
+	CNetworkVar( float, m_flInvisChangeCompleteTime );		// when uncloaking, must be done by this time
+	float m_flLastStealthExposeTime;
+	float m_fCloakConsumeRate;
+	float m_fCloakRegenRate;
+	bool  m_bMotionCloak;
+#ifdef GAME_DLL
+	// Cloak Strange Tracking
+	float m_flCloakStartTime;
+#endif
+
+	float m_fEnergyDrinkConsumeRate;
+	float m_fEnergyDrinkRegenRate;
+
+
+	EHANDLE m_pPhaseTrail[TF_SCOUT_NUMBEROFPHASEATTACHMENTS];
+	bool m_bPhaseFXOn;
+	float m_fPhaseAlpha;
+
+	CNetworkVar( int, m_nNumHealers );
+
+	// Halloween silliness.
+	CNetworkVar( int, m_nHalloweenBombHeadStage );
+
+	// Vars that are not networked.
+	OuterClass			*m_pOuter;					// C_TFPlayer or CTFPlayer (client/server).
+
+#ifdef GAME_DLL
+	// Healer handling
+	struct healers_t
+	{
+		EHANDLE	pHealer;
+		float	flAmount;
+		float   flHealAccum;
+		float	flOverhealBonus;
+		float	flOverhealDecayMult;
+		bool	bDispenserHeal;
+		EHANDLE pHealScorer;
+		int		iKillsWhileBeingHealed; // for engineer achievement ACHIEVEMENT_TF_ENGINEER_TANK_DAMAGE
+		float	flHealedLastSecond;
+	};
+	CUtlVector< healers_t >	m_aHealers;	
+	float					m_flHealFraction;	// Store fractional health amounts
+	float					m_flDisguiseHealFraction;	// Same for disguised healing
+	float					m_flBestOverhealDecayMult;
+	float					m_flHealedPerSecondTimer;
+
+	float m_flChargeEffectOffTime[MEDIGUN_NUM_CHARGE_TYPES];
+	bool  m_bChargeSoundEffectsOn[MEDIGUN_NUM_CHARGE_TYPES];
+
+	// Heal_Radius handling
+	CUtlVector< int >		m_iRadiusHealTargets;
+	float					m_flRadiusHealCheckTime;
+
+#endif
+
+	// King Rune buff 
+	float		m_flKingRuneBuffCheckTime;
+	CNetworkVar( bool, m_bKingRuneBuffActive );
+
+	bool					m_bPulseRadiusHeal;
+
+	CNetworkVar( bool, m_bLastDisguisedAsOwnTeam );
+
+	// Burn handling
+	CHandle<CTFPlayer>		m_hBurnAttacker;
+	CHandle<CTFPlayer>		m_hOriginalBurnAttacker;		// Player who originally ignited this target
+	CHandle<CTFWeaponBase>	m_hBurnWeapon;
+	CNetworkVar( int,		m_nNumFlames );
+	float					m_flFlameBurnTime;
+	float					m_flFlameRemoveTime;
+
+	// Bleeding
+#ifdef GAME_DLL
+	struct bleed_struct_t
+	{
+		CHandle<CTFPlayer>		hBleedingAttacker;
+		CHandle<CTFWeaponBase>  hBleedingWeapon;
+		float					flBleedingTime;
+		float					flBleedingRemoveTime;
+		int						nBleedDmg;
+		bool					bPermanentBleeding;
+	};
+	CUtlVector <bleed_struct_t> m_PlayerBleeds;
+#endif // GAME_DLL
+
+	CNetworkVar( int, m_iTauntIndex );
+	CNetworkVar( int, m_iTauntConcept );
+	CNetworkVar( uint32, m_unTauntSourceItemID_Low );
+	CNetworkVar( uint32, m_unTauntSourceItemID_High );
+#ifdef CLIENT_DLL
+	float					m_flTauntParticleRefireTime;
+#endif // CLIENT_DLL
+
+	float					m_flDisguiseCompleteTime;
+	float					m_flTmpDamageBonusAmount;
+
+#ifdef CLIENT_DLL
+	bool m_bSyncingConditions;
+#endif
+	int	m_nOldConditions;
+	int m_nOldConditionsEx;
+	int m_nOldConditionsEx2;
+	int m_nOldConditionsEx3;
+	int	m_nOldDisguiseClass;
+	int	m_nOldDisguiseTeam;
+
+	int	m_nForceConditions;
+	int m_nForceConditionsEx;
+	int m_nForceConditionsEx2;
+	int m_nForceConditionsEx3;
+
+
+	// Feign Death
+	float					m_flFeignDeathEnd;
+	CNetworkVar( bool, m_bFeignDeathReady );
+
+	CNetworkVar( int, m_iDesiredPlayerClass );
+
+	float m_flNextBurningSound;
+
+	CNetworkVar( float, m_flCloakMeter );	// [0,100]
+
+	CNetworkVar( bool, m_bInUpgradeZone );
+
+	// Scout
+	CNetworkVar( float, m_flEnergyDrinkMeter );	// [0,100]
+	CNetworkVar( float, m_flHypeMeter );
+
+	// Demoman
+	CNetworkVar( float, m_flChargeMeter );
+
+	// Rage (Soldier, Pyro, Sniper)
+	CNetworkVar( float, m_flRageMeter );
+	CNetworkVar( bool, m_bRageDraining );
+	CNetworkVar( float, m_flNextRageEarnTime );
+
+	RageBuff m_RageBuffSlots[kBuffSlot_MAX];
+
+	// Movement.
+	CNetworkVar( bool, m_bJumping );
+	CNetworkVar( int,  m_iAirDash );
+	CNetworkVar( int, m_nAirDucked );
+	CNetworkVar( float, m_flDuckTimer );
+
+	CNetworkVar( float, m_flStealthNoAttackExpire );
+	CNetworkVar( float, m_flStealthNextChangeTime );
+
+	CNetworkVar( float, m_flRuneCharge );
+
+#ifdef STAGING_ONLY
+	// Space 
+	CNetworkVar( float, m_flSpaceJumpCharge );
+#endif
+
+	CNetworkVar( int, m_iCritMult );
+
+	CNetworkArray( bool, m_bPlayerDominated, MAX_PLAYERS+1 );		// array of state per other player whether player is dominating other players
+	CNetworkArray( bool, m_bPlayerDominatingMe, MAX_PLAYERS+1 );	// array of state per other player whether other players are dominating this player
+
+	CNetworkVar( float, m_flMovementStunTime );
+	CNetworkVar( int, m_iMovementStunAmount );
+	CNetworkVar( unsigned char, m_iMovementStunParity );
+	CNetworkHandle( CTFPlayer, m_hStunner );
+	CNetworkVar( int, m_iStunFlags );
+	CNetworkVar( int, m_iStunIndex );
+
+	CNetworkHandle( CBaseObject, m_hCarriedObject );
+	CNetworkVar( bool, m_bCarryingObject );
+
+	CHandle<CTFPlayer>	m_hAssist;
+
+	CNetworkVar( int, m_nArenaNumChanges );			// number of times a player has re-rolled their class
+
+	CNetworkVar( int, m_iWeaponKnockbackID );
+
+	CNetworkVar( bool, m_bLoadoutUnavailable );
+
+	CNetworkVar( int,	m_iItemFindBonus );
+
+	CNetworkVar( bool, m_bShieldEquipped );
+
+	CNetworkVar( bool, m_bParachuteEquipped );
+
+	CNetworkVar( int, m_iDecapitations );
+	int m_iOldDecapitations;
+
+	CNetworkArray( int, m_nStreaks, kTFStreak_COUNT );
+
+	int m_nLastDuckStreakIncrement;
+
+	int m_iOldKillStreak;
+	int m_iOldKillStreakWepSlot;
+
+	CNetworkVar( int, m_iRevengeCrits );
+
+	CNetworkVar( int,  m_iNextMeleeCrit );
+	bool m_bPostShieldCharge;
+	float m_flChargeEndTime;
+
+	CNetworkVar( int,  m_iDisguiseBody );
+
+	CNetworkVar( int,  m_iSpawnRoomTouchCount );
+
+	CNetworkVar( float, m_flNextNoiseMakerTime );
+
+	float m_flCurrentTauntTurnSpeed;
+#ifdef CLIENT_DLL
+	const WheelEffect_t *m_pWheelEffect;
+	QAngle m_angVehicleMoveAngles;
+	bool m_bPreKartPredictionState;
+	float m_angVehicleMovePitchLast;
+
+	CHandle<CBaseAnimating>		m_hKartParachuteEntity;
+
+#endif
+public:
+	CNetworkVar( int, m_iKillCountSinceLastDeploy );
+	CNetworkVar( float, m_flFirstPrimaryAttack );
+
+	CNetworkVar( float, m_flSpyTranqBuffDuration );
+private:
+
+#ifdef GAME_DLL
+	float	m_flNextCritUpdate;
+	CUtlVector<CTFDamageEvent> m_DamageEvents;
+
+	CHandle<CTFPlayer>	m_hPeeAttacker;
+
+	float m_flRadiusCurrencyCollectionTime;
+	float m_flRadiusSpyScanTime;
+
+	struct pulledcurrencypacks_t
+	{
+		CHandle<CCurrencyPack> hPack;
+		float flTime;
+	};
+	CUtlVector <pulledcurrencypacks_t> m_CurrencyPacks;
+
+#else
+	float	m_flGotTeleEffectAt;
+	unsigned char m_iOldMovementStunParity;
+	CSoundPatch	*m_pCritBoostSoundLoop;
+#endif
+
+public:
+	float	m_flStunFade;
+	float	m_flStunEnd;
+	float	m_flStunMid;
+	int		m_iStunAnimState;
+	int		m_iPhaseDamage;
+	
+	// Movement stun state.
+	bool		m_bStunNeedsFadeOut;
+	float		m_flStunLerpTarget;
+	float		m_flLastMovementStunChange;
+#ifdef GAME_DLL
+	CUtlVector <stun_struct_t> m_PlayerStuns;
+	CUtlVector< CHandle<CTFPlayer> >	m_hPlayersVisibleAtChargeStart; // ACHIEVEMENT_TF_DEMOMAN_KILL_PLAYER_YOU_DIDNT_SEE
+#else
+	stun_struct_t m_ActiveStunInfo;
+#endif // CLIENT_DLL
+
+	float	m_flInvulnerabilityRemoveTime;
+
+	/*
+	float	m_flShieldChargeStartTime;
+	*/
+
+	// Demoman charge weapon glow.
+	float	m_flLastChargeTime;
+	float	m_flLastNoChargeTime;
+	bool	m_bChargeGlowing;
+
+	bool	m_bChargeOffSounded;
+
+	bool	m_bBiteEffectWasApplied;
+
+	float	m_flNextRocketPackTime;
+	float	m_flLastNoMovementTime;
+
+	CNetworkVar( bool, m_bArenaFirstBloodBoost );
+
+// passtime
+public:
+	void SetHasPasstimeBall( bool has ) { m_bHasPasstimeBall = has; }
+	bool HasPasstimeBall() const { return m_bHasPasstimeBall; }
+	
+	bool IsTargetedForPasstimePass() const { return m_bIsTargetedForPasstimePass; }
+	void SetPasstimePassTarget( CTFPlayer *ent );
+	CTFPlayer *GetPasstimePassTarget() const;
+	
+	void SetAskForBallTime( float time ) { m_askForBallTime = time; }
+	float AskForBallTime() const { return m_askForBallTime; }
+
+	float   m_flPasstimeThrowAnimStateTime;
+	int     m_iPasstimeThrowAnimState;
+
+private:
+	CNetworkVar( bool, m_bHasPasstimeBall );
+	CNetworkVar( bool, m_bIsTargetedForPasstimePass );
+	CNetworkHandle( CTFPlayer, m_hPasstimePassTarget );
+	CNetworkVar( float, m_askForBallTime );
+};
+
+#define CONTROL_STUN_ANIM_TIME	1.5f
+#define STUN_ANIM_NONE	0
+#define STUN_ANIM_LOOP	1
+#define STUN_ANIM_END	2
+
+#define PASSTIME_THROW_ANIM_NONE   0
+#define PASSTIME_THROW_ANIM_LOOP   1
+#define PASSTIME_THROW_ANIM_END    2
+#define PASSTIME_THROW_ANIM_CANCEL  3
+
+extern const char *g_pszBDayGibs[22];
+
+class CTraceFilterIgnoreTeammatesAndTeamObjects : public CTraceFilterSimple
+{
+public:
+	DECLARE_CLASS( CTraceFilterIgnoreTeammatesAndTeamObjects, CTraceFilterSimple );
+
+	CTraceFilterIgnoreTeammatesAndTeamObjects( const IHandleEntity *passentity, int collisionGroup, int iIgnoreTeam )
+		: CTraceFilterSimple( passentity, collisionGroup ), m_iIgnoreTeam( iIgnoreTeam ) {}
+
+	virtual bool ShouldHitEntity( IHandleEntity *pServerEntity, int contentsMask );
+
+private:
+	int m_iIgnoreTeam;
+};
+
+enum { kSoldierBuffCount = 6 };
+extern ETFCond g_SoldierBuffAttributeIDToConditionMap[kSoldierBuffCount + 1];
+
+class CTFPlayerSharedUtils
+{
+public:
+	static CEconItemView *GetEconItemViewByLoadoutSlot( CTFPlayer *pTFPlayer, int iSlot, CEconEntity **pEntity = NULL );
+	static bool ConceptIsPartnerTaunt( int iConcept );
+	static CTFWeaponBuilder *GetBuilderForObjectType( CTFPlayer *pTFPlayer, int iObjectType );
+};
+
+class CTargetOnlyFilter : public CTraceFilterSimple
+{
+public:
+	CTargetOnlyFilter( CBaseEntity *pShooter, CBaseEntity *pTarget );
+	virtual bool ShouldHitEntity( IHandleEntity *pHandleEntity, int contentsMask );
+	CBaseEntity	*m_pShooter;
+	CBaseEntity	*m_pTarget;
+};
+
+#endif // TF_PLAYER_SHARED_H