1HEADmaster

1 files changed, 996 insertions, 0 deletions

diff --git a/game/client/tf/c_tf_player.h b/game/client/tf/c_tf_player.h
new file mode 100644
index 0000000..c6a7807
--- /dev/null
+++ b/game/client/tf/c_tf_player.h
@@ -0,0 +1,996 @@
+//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose: 
+//
+//=============================================================================
+
+#ifndef C_TF_PLAYER_H
+#define C_TF_PLAYER_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "tf_playeranimstate.h"
+#include "c_baseplayer.h"
+#include "tf_shareddefs.h"
+#include "baseparticleentity.h"
+#include "tf_player_shared.h"
+#include "c_tf_playerclass.h"
+#include "tf_item.h"
+#include "props_shared.h"
+#include "hintsystem.h"
+#include "c_playerattachedmodel.h"
+#include "c_playerrelativemodel.h"
+#include "iinput.h"
+#include "ihasattributes.h"
+#include "GameEventListener.h"
+#include "tf_item_inventory.h"
+#include "c_tf_mvm_boss_progress_user.h"
+#include "c_te_legacytempents.h"
+
+
+class C_MuzzleFlashModel;
+class C_BaseObject;
+class C_TFRagdoll;
+class C_TFWearable;
+class C_CaptureZone;
+class C_MerasmusBombEffect;
+class CTFReviveDialog;
+class C_TFDroppedWeapon;
+class C_PasstimePlayerReticle;
+class C_PasstimeAskForBallReticle;
+
+extern ConVar tf_medigun_autoheal;
+extern ConVar cl_autorezoom;
+extern ConVar cl_autoreload;
+
+enum EBonusEffectFilter_t
+{
+	kEffectFilter_AttackerOnly,
+	kEffectFilter_AttackerTeam,
+	kEffectFilter_VictimOnly,
+	kEffectFilter_VictimTeam,
+	kEffectFilter_AttackerAndVictimOnly,
+	kEffectFilter_BothTeams,
+};
+
+struct BonusEffect_t
+{
+	BonusEffect_t( const char* pszSoundName, const char* pszParticleName, EBonusEffectFilter_t eParticleFilter, EBonusEffectFilter_t eSoundFilter, bool bPlaySoundInAttackersEars )
+		: m_pszSoundName( pszSoundName )
+		, m_pszParticleName( pszParticleName )
+		, m_eParticleFilter( eParticleFilter )
+		, m_eSoundFilter( eSoundFilter )
+		, m_bPlaySoundInAttackersEars( bPlaySoundInAttackersEars )
+
+	{}
+
+	const char* m_pszSoundName;
+	const char* m_pszParticleName;
+	EBonusEffectFilter_t m_eParticleFilter;
+	EBonusEffectFilter_t m_eSoundFilter;
+	bool m_bPlaySoundInAttackersEars;
+};
+
+//-----------------------------------------------------------------------------
+// Purpose: 
+//-----------------------------------------------------------------------------
+class C_TFPlayer : public C_BasePlayer, public IHasAttributes, public IInventoryUpdateListener, public C_TFMvMBossProgressUser
+{
+public:
+
+	DECLARE_CLASS( C_TFPlayer, C_BasePlayer );
+	DECLARE_CLIENTCLASS();
+	DECLARE_PREDICTABLE();
+	DECLARE_INTERPOLATION();
+
+	C_TFPlayer();
+	~C_TFPlayer();
+
+	virtual void Spawn();
+
+	static C_TFPlayer* GetLocalTFPlayer();
+
+	virtual void UpdateOnRemove( void );
+
+	virtual const QAngle& GetRenderAngles();
+	virtual void UpdateClientSideAnimation();
+	virtual void SetDormant( bool bDormant );
+	virtual void OnPreDataChanged( DataUpdateType_t updateType );
+	virtual void OnDataChanged( DataUpdateType_t updateType );
+	virtual void ProcessMuzzleFlashEvent();
+	virtual void ValidateModelIndex( void );
+	void Touch( CBaseEntity *pOther );
+
+	virtual Vector GetObserverCamOrigin( void );
+	virtual int DrawModel( int flags );
+
+	virtual void ApplyBoneMatrixTransform( matrix3x4_t& transform );
+	virtual void BuildTransformations( CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed );
+
+	virtual bool CreateMove( float flInputSampleTime, CUserCmd *pCmd ) OVERRIDE;
+	void CreateVehicleMove( float flInputSampleTime, CUserCmd *pCmd );
+
+	virtual bool		IsAllowedToSwitchWeapons( void );
+
+	void    StopViewModelParticles( C_BaseEntity *pParticleEnt );
+
+	virtual void ClientThink();
+
+	// Deal with recording
+	virtual void GetToolRecordingState( KeyValues *msg );
+
+	CTFWeaponBase *GetActiveTFWeapon( void ) const;
+	bool IsActiveTFWeapon( CEconItemDefinition *weaponHandle ) const;
+	bool IsActiveTFWeapon( const CSchemaItemDefHandle &weaponHandle ) const;
+
+	virtual void Simulate( void );
+	virtual void FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options ) OVERRIDE;
+	virtual void UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity ) OVERRIDE;
+
+	CNewParticleEffect *SpawnHalloweenSpellFootsteps( ParticleAttachment_t eParticleAttachment, int iHalloweenFootstepType );
+
+	void FireBullet( CTFWeaponBase *pWpn, const FireBulletsInfo_t &info, bool bDoEffects, int nDamageType, int nCustomDamageType = TF_DMG_CUSTOM_NONE );
+
+	void ImpactWaterTrace( trace_t &trace, const Vector &vecStart );
+
+	bool CanAttack( int iCanAttackFlags = 0 );
+
+	const C_TFPlayerClass *GetPlayerClass( void ) const	{ return &m_PlayerClass; }
+	C_TFPlayerClass *GetPlayerClass( void )				{ return &m_PlayerClass; }
+	bool IsPlayerClass( int iClass ) const;
+	virtual int GetMaxHealth( void ) const;
+	int			GetMaxHealthForBuffing()  const;
+
+	virtual int GetRenderTeamNumber( void );
+
+	bool IsWeaponLowered( void );
+
+	void	AvoidPlayers( CUserCmd *pCmd );
+
+	bool	IsABot( void );
+
+	// Get the ID target entity index. The ID target is the player that is behind our crosshairs, used to
+	// display the player's name.
+	void UpdateIDTarget();
+	int GetIDTarget() const;
+	void SetForcedIDTarget( int iTarget );
+
+	void SetAnimation( PLAYER_ANIM playerAnim );
+
+	virtual float GetMinFOV() const;
+
+	virtual const QAngle& EyeAngles();
+
+	bool	ShouldDrawSpyAsDisguised();
+	virtual int GetBody( void );
+
+	int GetBuildResources( void );
+
+	// MATTTODO: object selection if necessary
+	void SetSelectedObject( C_BaseObject *pObject ) {}
+
+	void GetTeamColor( Color &color );
+	bool InSameDisguisedTeam( CBaseEntity *pEnt );
+
+	virtual void ComputeFxBlend( void );
+
+	// Taunts/VCDs
+	virtual bool	StartSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, C_BaseEntity *pTarget );
+	virtual	bool	ClearSceneEvent( CSceneEventInfo *info, bool fastKill, bool canceled );
+	virtual void	CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov );
+	bool			StartGestureSceneEvent( CSceneEventInfo *info, CChoreoScene *scene, CChoreoEvent *event, CChoreoActor *actor, CBaseEntity *pTarget );
+	bool			StopGestureSceneEvent( CSceneEventInfo *info, bool fastKill, bool canceled );
+	void			TurnOnTauntCam( void );
+	void			TurnOnTauntCam_Finish( void );
+	void			TurnOffTauntCam( void );
+	void			TurnOffTauntCam_Finish( void );
+	bool			IsTaunting( void ) const { return m_Shared.InCond( TF_COND_TAUNTING ); }
+
+	virtual void	InitPhonemeMappings();
+
+	// Gibs.
+	void InitPlayerGibs( void );
+	void CheckAndUpdateGibType( void );
+	void CreatePlayerGibs( const Vector &vecOrigin, const Vector &vecVelocity, float flImpactScale, bool bBurning, bool bWearableGibs=false, bool bOnlyHead=false, bool bDisguiseGibs=false );
+	void DropPartyHat( breakablepropparams_t &breakParams, Vector &vecBreakVelocity );
+	void DropWearable( C_TFWearable *pItem, const breakablepropparams_t &params );
+
+	int	GetObjectCount( void );
+	C_BaseObject *GetObject( int index );
+	C_BaseObject *GetObjectOfType( int iObjectType, int iObjectMode=0 ) const;
+	int GetNumObjects( int iObjectType, int iObjectMode=0 );
+
+	virtual bool ShouldCollide( int collisionGroup, int contentsMask ) const;
+
+	float GetPercentInvisible( void );
+	float GetEffectiveInvisibilityLevel( void );	// takes viewer into account
+	virtual bool IsTransparent( void ) OVERRIDE { return GetPercentInvisible() > 0.f; }
+
+	virtual void AddDecal( const Vector& rayStart, const Vector& rayEnd,
+		const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, int maxLODToDecal = ADDDECAL_TO_ALL_LODS );
+
+	virtual void CalcDeathCamView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov);
+	virtual Vector GetChaseCamViewOffset( CBaseEntity *target );
+	virtual Vector GetDeathViewPosition();
+
+	void ClientPlayerRespawn( void );
+
+	virtual bool	ShouldDraw();
+
+	virtual int		GetVisionFilterFlags( bool bWeaponsCheck = false );
+	virtual void	CalculateVisionUsingCurrentFlags( void );
+
+	void CreateSaveMeEffect( MedicCallerType nType = CALLER_TYPE_NORMAL );
+	void StopSaveMeEffect( bool bForceRemoveInstantly = false );
+
+	void CreateTauntWithMeEffect();
+	void StopTauntWithMeEffect();
+
+	void CreateKart();
+	void RemoveKart();
+	C_BaseAnimating *GetKart() const { return m_pKart; }
+	void CreateKartEffect( const char *pszEffectName );
+	void StopKartEffect();
+	void UpdateKartSounds();
+	void StartKartBrakeEffect();
+	void StopKartBrakeEffect();
+	CNetworkVar( int, m_iKartState );
+
+	bool IsAllowedToTaunt( void );
+	
+	virtual bool	IsOverridingViewmodel( void );
+	virtual int		DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags );
+
+	void			SetHealer( C_TFPlayer *pHealer, float flChargeLevel );
+	void			SetWasHealedByLocalPlayer( bool bState )	{ m_bWasHealedByLocalPlayer = bState; }
+	void			GetHealer( C_TFPlayer **pHealer, float *flChargeLevel ) { *pHealer = m_hHealer; *flChargeLevel = m_flHealerChargeLevel; }
+	bool			GetWasHealedByLocalPlayer() { return m_bWasHealedByLocalPlayer; }
+	float			MedicGetChargeLevel( CTFWeaponBase **pRetMedigun = NULL );
+	bool			MedicIsReleasingCharge( void );
+	CBaseEntity		*MedicGetHealTarget( void );
+
+	void			StartBurningSound( void );
+	void			StopBurningSound( void );
+
+	void			StopBlastJumpLoopSound( int iUserID );
+	
+	void			UpdateSpyStateChange( void );
+
+	void			UpdateRecentlyTeleportedEffect( void );
+	void			UpdateOverhealEffect( void );
+	void			UpdatedMarkedForDeathEffect( bool bFroceStop = false );
+	void			CreateOverhealEffect( int iTeam );
+	void			UpdateRuneIcon( bool bForceStop = false );
+
+	bool			CanShowClassMenu( void );
+	bool			CanShowTeamMenu( void );
+
+	void			InitializePoseParams( void );
+	void			UpdateLookAt( void );
+
+	bool			IsEnemyPlayer( void );
+	void			ShowNemesisIcon( bool bShow );
+	void			ShowDuelingIcon( bool bShow );
+	void			ShowIconForIT( bool bShow );
+
+#ifdef STAGING_ONLY
+	void			UpdateTranqMark( bool bShow, bool bForceStop = false );
+	void			UpdateSpyClassStealParticle( bool bShow );
+#endif // STAGING_ONLY
+	void			ShowBirthdayEffect( bool bShow );
+
+	CUtlVector<EHANDLE>		*GetSpawnedGibs( void ) { return &m_hSpawnedGibs; }
+
+	bool			HasBombinomiconEffectOnDeath( void );
+
+	Vector			GetClassEyeHeight( void );
+
+	void			ForceUpdateObjectHudState( void );
+
+	bool			GetMedigunAutoHeal( void ){ return tf_medigun_autoheal.GetBool(); }
+	bool			ShouldAutoRezoom( void ){ return cl_autorezoom.GetBool(); }
+	bool			ShouldAutoReload( void ){ return cl_autoreload.GetBool(); }
+
+	void			GetTargetIDDataString( bool bIsDisguised, OUT_Z_BYTECAP(iMaxLenInBytes) wchar_t *sDataString, int iMaxLenInBytes, bool &bIsAmmoData, bool &bIsKillStreakData );
+
+	void			RemoveDisguise( void );
+	bool			CanDisguise( void );
+	bool			CanDisguise_OnKill( void );
+
+	virtual void OnAchievementAchieved( int iAchievement );
+
+	virtual void OverrideView( CViewSetup *pSetup );
+
+	bool			CanAirDash( void ) const;
+	bool			CanGetWet() const;
+
+	void			CreateBoneAttachmentsFromWearables( C_TFRagdoll *pRagdoll, bool bDisguised );
+
+	bool			CanUseFirstPersonCommand( void );
+
+	bool			IsEffectRateLimited( EBonusEffectFilter_t effect, const C_TFPlayer* pAttacker ) const;
+	bool			ShouldPlayEffect( EBonusEffectFilter_t filter, const C_TFPlayer* pAttacker, const C_TFPlayer* pVictim ) const;
+	virtual void	FireGameEvent( IGameEvent *event );
+
+	virtual const char* ModifyEventParticles( const char* token );
+
+	// Set the distances the camera should use. 
+	void			SetTauntCameraTargets( float back, float up );
+
+	// TF-specific color values for GlowEffect
+	virtual void	GetGlowEffectColor( float *r, float *g, float *b );
+	void UpdateGlowColor( void );
+
+	virtual const Vector&	GetRenderOrigin( void );
+
+	RTime32			GetSpottedInPVSTime() const { return m_rtSpottedInPVSTime; }
+	RTime32			GetJoinedSpectatorTeamTime() const { return m_rtJoinedSpectatorTeam; }
+	RTime32			GetJoinedNormalTeamTime() const { return m_rtJoinedNormalTeam; }
+
+	// IHasAttributes
+	CAttributeManager		*GetAttributeManager( void ) { return &m_AttributeManager; }
+	CAttributeContainer		*GetAttributeContainer( void ) { return NULL; }
+	CBaseEntity				*GetAttributeOwner( void ) { return NULL; }
+	CAttributeList			*GetAttributeList( void ) { return &m_AttributeList; }
+	virtual void			ReapplyProvision( void ) { return; }
+
+	// ITFMvMBossProgressUser
+	virtual const char* GetBossProgressImageName() const OVERRIDE;
+	virtual float GetBossStatusProgress() const OVERRIDE;
+
+protected:
+	CNetworkVarEmbedded(	CAttributeContainerPlayer, m_AttributeManager );
+
+	// IClientNetworkable implementation.
+public:
+	virtual void	NotifyShouldTransmit( ShouldTransmitState_t state );
+
+public:
+	// Shared functions
+	float			GetMovementForwardPull( void ) const;
+	bool			CanPlayerMove() const;
+	float			TeamFortress_CalculateMaxSpeed( bool bIgnoreSpecialAbility = false ) const;
+	void			TeamFortress_SetSpeed();
+	bool			HasItem( void ) const;				// Currently can have only one item at a time.
+	void			SetItem( C_TFItem *pItem );
+	C_TFItem		*GetItem( void ) const;
+	bool			HasTheFlag( ETFFlagType exceptionTypes[] = NULL, int nNumExceptions = 0 ) const;
+	virtual bool	IsAllowedToPickUpFlag( void ) const;
+	float			GetCritMult( void ) { return m_Shared.GetCritMult(); }
+
+	virtual void	ItemPostFrame( void );
+
+	void			SetOffHandWeapon( CTFWeaponBase *pWeapon );
+	void			HolsterOffHandWeapon( void );
+	CTFWeaponBase*	GetOffHandWeapon( void ) { return m_hOffHandWeapon; }
+
+	void			GetActiveSets( CUtlVector<const CEconItemSetDefinition *> *pItemSets );
+
+	virtual int GetSkin();
+
+	float GetLastDamageTime( void ) const { return m_flLastDamageTime; }
+
+	virtual bool		Weapon_CanSwitchTo( CBaseCombatWeapon *pWeapon );
+
+	virtual bool		Weapon_ShouldSetLast( CBaseCombatWeapon *pOldWeapon, CBaseCombatWeapon *pNewWeapon ) OVERRIDE;
+	virtual	bool		Weapon_Switch( C_BaseCombatWeapon *pWeapon, int viewmodelindex = 0 ) OVERRIDE;
+	virtual void 		SelectItem( const char *pstr, int iSubType = 0 ) OVERRIDE;
+
+	virtual void		UpdateWearables() OVERRIDE;
+	CTFWearable			*GetEquippedWearableForLoadoutSlot( int iLoadoutSlot );
+	CBaseEntity			*GetEntityForLoadoutSlot( int iLoadoutSlot );			//Gets whatever entity is associated with the loadout slot (wearable or weapon)
+
+	CTFWeaponBase		*Weapon_OwnsThisID( int iWeaponID ) const;
+	CTFWeaponBase		*Weapon_GetWeaponByType( int iType );
+
+	virtual void		GetStepSoundVelocities( float *velwalk, float *velrun );
+	virtual void		SetStepSoundTime( stepsoundtimes_t iStepSoundTime, bool bWalking );
+	virtual const char *GetOverrideStepSound( const char *pszBaseStepSoundName );
+
+	virtual void		OnEmitFootstepSound( const CSoundParameters& params, const Vector& vecOrigin, float fVolume );
+
+	virtual void		ModifyEmitSoundParams( EmitSound_t &params );
+
+	virtual void		ThirdPersonSwitch( bool bThirdperson );
+
+	bool	DoClassSpecialSkill( void );
+	bool	EndClassSpecialSkill( void );
+	bool	CanGoInvisible( bool bAllowWhileCarryingFlag = false );
+	int		GetMaxAmmo( int iAmmoIndex, int iClassIndex = -1 );
+
+	//-----------------------------------------------------------------------------------------------------
+	// Return true if we are a "mini boss" in Mann Vs Machine mode
+	bool IsMiniBoss( void ) const;
+	bool ShouldTauntHintIconBeVisible() const;
+	virtual bool IsHealthBarVisible( void ) const OVERRIDE;
+
+	bool	CanStartPhase( void );
+
+	bool	CanPickupBuilding( CBaseObject *pPickupObject );
+	bool	TryToPickupBuilding( void );
+	void	StartBuildingObjectOfType( int iType, int iObjectMode=0 );
+
+	void			FeignDeath( CTakeDamageInfo& info );
+
+	C_CaptureZone *GetCaptureZoneStandingOn( void );
+	C_CaptureZone *GetClosestCaptureZone( void );
+
+	float			GetMetersRan( void )	{ return m_fMetersRan; }
+	void			SetMetersRan( float fMeters, int iFrame );
+
+	CEconItemView *GetInspectItem( int *iLastItem );
+
+	void			SetBodygroupsDirty( void );
+	void			RecalcBodygroupsIfDirty( void );
+
+	bool			CanMoveDuringTaunt();
+	bool			ShouldStopTaunting();
+	bool			IsTauntForceMovingForward() const { return m_bTauntForceMoveForward; }
+	float			GetTauntMoveAcceleration() const { return m_flTauntMoveAccelerationTime; }
+	float			GetTauntMoveSpeed() const { return m_flTauntForceMoveForwardSpeed; }
+	float			GetTauntTurnAccelerationTime() const { return m_flTauntTurnAccelerationTime; }
+	bool			IsReadyToTauntWithPartner( void ) const { return m_bIsReadyToHighFive; }
+	CTFPlayer *		GetTauntPartner( void )		{ return m_hHighFivePartner; }
+	float			GetTauntYaw( void )				{ return m_flTauntYaw; }
+	float			GetPrevTauntYaw( void )		{ return m_flPrevTauntYaw; }
+	void			SetTauntYaw( float flTauntYaw );
+	int				GetActiveTauntSlot() const { return m_nActiveTauntSlot; }
+	void			PlayTauntSoundLoop( const char *pszSoundLoopName );
+	void			StopTauntSoundLoop();
+	float			GetCurrentTauntMoveSpeed() const { return m_flCurrentTauntMoveSpeed; }
+	void			SetCurrentTauntMoveSpeed( float flSpeed ) { m_flCurrentTauntMoveSpeed = flSpeed; }
+	float			GetVehicleReverseTime() const { return m_flVehicleReverseTime; }
+	void			SetVehicleReverseTime( float flTime ) { m_flVehicleReverseTime = flTime; }
+
+	CEconItemView	*GetTauntEconItemView() { return m_TauntEconItemView.IsValid() ? &m_TauntEconItemView : NULL; }
+
+	float			GetHeadScale() const { return m_flHeadScale; }
+	float			GetTorsoScale() const { return m_flTorsoScale; }
+	float			GetHandScale() const { return m_flHandScale; }
+	float			GetLastResistTime()	const { return m_flLastResistTime; }
+	bool			BRenderAsZombie( bool bWeaponsCheck = false );
+	static void AdjustSkinIndexForZombie( int iClassIndex, int &iSkinIndex );
+
+	// Ragdolls.
+	virtual C_BaseAnimating *BecomeRagdollOnClient();
+	virtual IRagdoll		*GetRepresentativeRagdoll() const;
+	EHANDLE	m_hRagdoll;
+	Vector m_vecRagdollVelocity;
+
+	// Objects
+	int CanBuild( int iObjectType, int iObjectMode=0 );
+	CUtlVector< CHandle<C_BaseObject> > m_aObjects;
+
+	virtual CStudioHdr *OnNewModel( void );
+
+	void				DisplaysHintsForTarget( C_BaseEntity *pTarget );
+
+	// Shadows
+	virtual ShadowType_t ShadowCastType( void ) ;
+	virtual void GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType );
+	virtual void GetRenderBounds( Vector& theMins, Vector& theMaxs );
+	virtual bool GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const;
+
+	CMaterialReference *GetInvulnMaterialRef( void ) { return &m_InvulnerableMaterial; }
+	bool IsNemesisOfLocalPlayer();
+	bool ShouldShowDuelingIcon();
+	bool ShouldShowNemesisIcon();
+
+	virtual	IMaterial *GetHeadLabelMaterial( void );
+
+	// Spy Cigarette
+	bool CanLightCigarette( void );
+
+	void		UpdateDemomanEyeEffect( int iDecapitations );
+	const char* GetDemomanEyeEffectName( int iDecapitations );
+
+	int		GetCurrency( void ){ return m_nCurrency; }
+
+	virtual void UpdateMVMEyeGlowEffect( bool bVisible );
+
+	void	UpdateKillStreakEffects( int iCount, bool bKillScored = false );
+	const char *GetEyeGlowEffect() { return m_pszEyeGlowEffectName; }
+	Vector GetEyeGlowColor( bool bAlternate ) { return bAlternate? m_vEyeGlowColor1 : m_vEyeGlowColor2 ; }
+
+	// Bounty Mode
+	int	 GetExperienceLevel( void ) { return m_nExperienceLevel; }
+
+	// Matchmaking
+	bool	GetMatchSafeToLeave() { return m_bMatchSafeToLeave; }
+
+	// Halloween silliness.
+	void	HalloweenBombHeadUpdate( void );
+
+
+	bool	IsUsingVRHeadset( void ){ return m_bUsingVRHeadset; }
+
+	bool	ShouldPlayerDrawParticles( void );
+
+	bool	IsPlayerOnSteamFriendsList( C_BasePlayer *pPlayer );
+
+protected:
+
+	void ResetFlexWeights( CStudioHdr *pStudioHdr );
+
+	virtual void CalcInEyeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
+
+	virtual void UpdateGlowEffect( void );
+	virtual void DestroyGlowEffect( void );
+
+private:
+
+	bool ShouldShowPowerupGlowEffect();
+	void GetPowerupGlowEffectColor( float *r, float *g, float *b );
+
+	void HandleTaunting( void );
+	void TauntCamInterpolation( void );
+
+	void OnPlayerClassChange( void );
+	void UpdatePartyHat( void );
+
+	void InitInvulnerableMaterial( void );
+
+	void GetHorriblyHackedRailgunPosition( const Vector& vStart, Vector *out_pvStartPos );
+	void MaybeDrawRailgunBeam( IRecipientFilter *pFilter, CTFWeaponBase *pWeapon, const Vector& vStartPos, const Vector& vEndPos );
+
+	bool				m_bWasTaunting;
+	bool				m_bTauntInterpolating;
+	CameraThirdData_t	m_TauntCameraData;
+	float				m_flTauntCamCurrentDist;
+	float				m_flTauntCamTargetDist;
+	float				m_flTauntCamCurrentDistUp;
+	float				m_flTauntCamTargetDistUp;
+
+	QAngle				m_angTauntPredViewAngles;
+	QAngle				m_angTauntEngViewAngles;
+
+	CSoundPatch			*m_pTauntSoundLoop;
+
+	C_TFPlayerClass		m_PlayerClass;
+
+	// ID Target
+	int					m_iIDEntIndex;
+	int					m_iForcedIDTarget;
+
+	CNewParticleEffect	*m_pTeleporterEffect;
+	bool				m_bToolRecordingVisibility;
+
+	int					m_iOldSpawnCounter;
+
+	// Healer
+	CHandle<C_TFPlayer>	m_hHealer;
+	bool				m_bWasHealedByLocalPlayer;
+	float				m_flHealerChargeLevel;
+	int					m_iOldHealth;
+	int					m_nOldMaxHealth;
+
+	float				m_fMetersRan;
+	int					m_iLastRanFrame;
+
+	HPARTICLEFFECT		m_pEyeEffect;
+
+	bool				m_bOldCustomModelVisible;
+
+	CHandle< C_BaseCombatWeapon > m_hOldActiveWeapon;
+
+	// Look At
+	/*
+	int m_headYawPoseParam;
+	int m_headPitchPoseParam;
+	float m_headYawMin;
+	float m_headYawMax;
+	float m_headPitchMin;
+	float m_headPitchMax;
+	float m_flLastBodyYaw;
+	float m_flCurrentHeadYaw;
+	float m_flCurrentHeadPitch;
+	*/
+
+	// Spy cigarette smoke
+	bool m_bCigaretteSmokeActive;
+
+	// Medic callout particle effect
+	CNewParticleEffect	*m_pSaveMeEffect;
+	CNewParticleEffect	*m_pTauntWithMeEffect;
+
+	bool m_bUpdateObjectHudState;
+	bool	m_bBodygroupsDirty;
+
+	HPARTICLEFFECT	m_hKartDamageEffect;
+	CNetworkVar( float, m_flKartNextAvailableBoost );
+	CNetworkVar( int,	m_iKartHealth );
+	int			m_iOldKartHealth;
+	void		UpdateKartEffects();
+
+	void		UpdateKartState();
+	int			m_iOldKartState;
+
+	C_BaseAnimating *m_pKart;
+
+public:
+	float			GetKartSpeedBoost( void );
+	float			GetKartHealth( void )				{ return m_iKartHealth; }
+
+	CTFPlayerShared m_Shared;
+	friend class CTFPlayerShared;
+
+// Called by shared code.
+public:
+	float GetClassChangeTime() const { return m_flChangeClassTime; }
+	void SetFootStamps( int nFootStamps ) { m_nFootStamps = nFootStamps; }
+
+	void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 );
+	bool PlayAnimEventInPrediction( PlayerAnimEvent_t event );
+
+	bool							GetPredictable( void ) const;
+
+	// Halloween
+	void CreateBombonomiconHint();
+	void DestroyBombonomiconHint();
+
+	void CleanUpAnimationOnSpawn();
+	CTFPlayerAnimState *m_PlayerAnimState;
+
+	QAngle	m_angEyeAngles;
+	CInterpolatedVar< QAngle >	m_iv_angEyeAngles;
+
+	CNetworkHandle( C_TFItem, m_hItem );
+
+	CNetworkHandle( C_TFWeaponBase, m_hOffHandWeapon );
+	CNetworkHandle( C_TFPlayer, m_hCoach );
+	CNetworkHandle( C_TFPlayer, m_hStudent );
+
+	CGlowObject		*m_pStudentGlowEffect;
+	CGlowObject		*m_pPowerupGlowEffect;
+
+	int				m_iOldPlayerClass;	// Used to detect player class changes
+	bool			m_bIsDisplayingNemesisIcon;
+	bool			m_bIsDisplayingDuelingIcon;
+	bool			m_bIsDisplayingIconForIT;
+	bool			m_bIsDisplayingTranqMark;
+	bool			m_bShouldShowBirthdayEffect;
+
+	RuneTypes_t		m_eDisplayingRuneIcon;
+
+	float			m_flLastDamageTime;
+
+	bool			m_bInPowerPlay;
+
+	int				m_iSpawnCounter;
+	bool			m_bArenaSpectator;
+
+	bool			m_bIsMiniBoss;
+	bool			m_bIsABot;
+	int				m_nBotSkill;
+	int				m_nOldBotSkill;
+	bool			m_bSaveMeParity;
+	bool			m_bOldSaveMeParity;
+	bool			m_bIsCoaching;
+
+private:
+	void			UpdateTauntItem();
+	void			ParseSharedTauntDataFromEconItemView( CEconItemView *pEconItemView );
+
+	bool			m_bAllowMoveDuringTaunt;
+	bool			m_bTauntForceMoveForward;
+	float			m_flTauntForceMoveForwardSpeed;
+	float			m_flTauntMoveAccelerationTime;
+	float			m_flTauntTurnSpeed;
+	float			m_flTauntTurnAccelerationTime;
+	bool			m_bIsReadyToHighFive;
+	CNetworkHandle( C_TFPlayer, m_hHighFivePartner );
+	int				m_nForceTauntCam;
+	float			m_flTauntYaw;
+	float			m_flPrevTauntYaw;
+	int				m_nActiveTauntSlot;
+	int				m_nPrevTauntSlot;
+	item_definition_index_t	m_iTauntItemDefIndex;
+	item_definition_index_t m_iPrevTauntItemDefIndex;
+	float			m_flCurrentTauntMoveSpeed;
+	float			m_flVehicleReverseTime;
+
+	int				m_nTauntSequence;
+	float			m_flTauntStartTime;
+	float			m_flTauntDuration;
+
+	CEconItemView	m_TauntEconItemView;
+
+public:
+
+	int				m_nOldWaterLevel;
+	float			m_flWaterEntryTime;
+	bool			m_bWaterExitEffectActive;
+
+	bool			m_bDuckJumpInterp;
+	float			m_flFirstDuckJumpInterp;
+	float			m_flLastDuckJumpInterp;
+	float			m_flDuckJumpInterp;
+
+	CMaterialReference	m_InvulnerableMaterial;
+
+
+	// Burning
+	CSoundPatch			*m_pBurningSound;
+	HPARTICLEFFECT      m_pBurningEffect;
+	float				m_flBurnEffectStartTime;
+
+	// Urine
+	HPARTICLEFFECT		m_pUrineEffect;
+
+	// Milk
+	HPARTICLEFFECT		m_pMilkEffect;
+
+	// Soldier Buff
+	HPARTICLEFFECT		m_pSoldierOffensiveBuffEffect;
+	HPARTICLEFFECT		m_pSoldierDefensiveBuffEffect;
+	HPARTICLEFFECT		m_pSoldierOffensiveHealthRegenBuffEffect;
+	HPARTICLEFFECT		m_pSoldierNoHealingDamageBuffEffect;
+
+	// Speed boost
+	HPARTICLEFFECT		m_pSpeedBoostEffect;
+
+	// Taunt effects
+	HPARTICLEFFECT		m_pTauntEffect;
+
+	// Temp HACK for crit boost
+	HPARTICLEFFECT m_pCritBoostEffect;
+
+	HPARTICLEFFECT m_pOverHealedEffect;
+	HPARTICLEFFECT m_pPhaseStandingEffect;
+
+	HPARTICLEFFECT m_pStunnedEffect;
+
+	HPARTICLEFFECT m_pMegaHealEffect;
+	HPARTICLEFFECT m_pRadiusHealEffect;
+	HPARTICLEFFECT m_pKingRuneRadiusEffect;
+	HPARTICLEFFECT m_pKingBuffRadiusEffect;
+	HPARTICLEFFECT m_pRunePlagueEffect;
+	C_LocalTempEntity*	m_pTempShield;
+	float				m_flLastResistTime;
+
+	HPARTICLEFFECT m_pSappedPlayerEffect;
+	HPARTICLEFFECT m_pMVMEyeGlowEffect[ 2 ];
+
+	// KillStreak Weapons
+	char m_pszEyeGlowEffectName[MAX_PATH];
+	Vector m_vEyeGlowColor1;
+	Vector m_vEyeGlowColor2;
+	HPARTICLEFFECT m_pEyeGlowEffect[ 2 ];
+	float m_flNextSheenStartTime;
+	
+	HPARTICLEFFECT m_pMVMBotRadiowave;
+
+	HPARTICLEFFECT m_pRuneChargeReadyEffect;
+
+#ifdef STAGING_ONLY
+	HPARTICLEFFECT m_pRocketPackEffect;
+#endif // STAGING_ONLY
+
+	enum EKartParticles
+	{
+		KART_PARTICLE_LEFT_LIGHT = 0,
+		KART_PARTICLE_RIGHT_LIGHT,
+
+		KART_PARTICLE_LEFT_WHEEL,
+		KART_PARTICLE_RIGHT_WHEEL,
+		NUM_KART_PARTICLES
+	};
+	HPARTICLEFFECT m_pKartParticles[ NUM_KART_PARTICLES ];
+
+	enum EKartSounds
+	{
+		KART_SOUND_ENGINE_LOOP = 0,
+		KART_SOUND_BURNOUT_LOOP,
+
+		NUM_KART_SOUNDS,
+	};
+	CSoundPatch			*m_pKartSounds[ NUM_KART_SOUNDS ];
+
+	CNewParticleEffect	*m_pDisguisingEffect;
+	float m_flDisguiseEffectStartTime;
+	float m_flDisguiseEndEffectStartTime;
+
+	EHANDLE					m_hFirstGib;
+	EHANDLE					m_hHeadGib;
+	CUtlVector<EHANDLE>		m_hSpawnedGibs;
+
+	int				m_iOldTeam;
+	int				m_iOldClass;
+	int				m_iOldDisguiseTeam;
+	int				m_iOldDisguiseClass;
+	int				m_iOldObserverMode;
+	EHANDLE			m_hOldObserverTarget;
+
+	bool			m_bDisguised;
+	int				m_iPreviousMetal;
+
+	int GetNumActivePipebombs( void );
+
+	int				m_iSpyMaskBodygroup;
+	Vector			m_vecCustomModelOrigin;
+
+	// Halloween
+	CHandle<C_PlayerAttachedModel>	m_hHalloweenBombHat;
+	CHandle<C_MerasmusBombEffect>	m_hBombonomiconHint;
+	CHandle<C_PlayerAttachedModel>	m_hHalloweenKartCage;
+	float			m_flBombDelay;
+
+	// Achievements
+	float m_flSaveMeExpireTime;
+
+	//CountdownTimer m_LeaveServerTimer;
+
+	//----------------------------
+	// INVENTORY MANAGEMENT
+public:
+	// IInventoryUpdateListener
+	virtual void InventoryUpdated( CPlayerInventory *pInventory );
+	virtual void SOCacheUnsubscribed( const CSteamID & steamIDOwner ) { m_Shared.SetLoadoutUnavailable( true ); }
+	void		 UpdateInventory( bool bInit );
+
+	// Inventory access
+	CTFPlayerInventory	*Inventory( void ) { return &m_Inventory; }
+
+	bool		CanDisplayAllSeeEffect( EAttackBonusEffects_t effect ) const;
+	void		SetNextAllSeeEffectTime( EAttackBonusEffects_t effect, float flTime );
+
+private:
+	CTFPlayerInventory	m_Inventory;
+	bool				m_bInventoryReceived;
+
+private:
+	float			m_flChangeClassTime;
+
+	float m_flWaterImpactTime;
+	RTime32 m_rtSpottedInPVSTime;
+	RTime32 m_rtJoinedSpectatorTeam;
+	RTime32 m_rtJoinedNormalTeam;
+
+	// Gibs.
+	CUtlVector< int > m_aSillyGibs;
+	CUtlVector< char* > m_aNormalGibs;
+	CUtlVector<breakmodel_t>	m_aGibs;
+
+	C_TFPlayer( const C_TFPlayer & );
+
+	mutable char m_bIsCalculatingMaximumSpeed;
+
+	// In-game currency
+	int m_nCurrency;
+	int m_nOldCurrency;
+
+	// Bounty Mode
+	int m_nExperienceLevel;
+	int m_nExperienceLevelProgress;
+	int m_nPrevExperienceLevel;
+
+	// Matchmaking
+	// is this player bound to the match on penalty of abandon. Sync'd via local-player-only DT
+	bool m_bMatchSafeToLeave;
+
+	// Medic healtarget active weapon ammo/clip count
+	uint16	m_nActiveWpnClip;
+	
+	// Blast jump whistle
+	CSoundPatch		*m_pBlastJumpLoop;
+	float			m_flBlastJumpLaunchTime;
+
+	CNetworkVar( float, m_flHeadScale );
+	CNetworkVar( float, m_flTorsoScale );
+	CNetworkVar( float, m_flHandScale );
+
+	// Allseecrit throttle - other clients ask us if we can be the source of another particle+sound
+	float	m_flNextMiniCritEffectTime[ kBonusEffect_Count ];
+
+	CNetworkVar( bool, m_bUseBossHealthBar );
+
+	CNetworkVar( bool, m_bUsingVRHeadset );
+
+	CNetworkVar( bool, m_bForcedSkin );
+	CNetworkVar( int, m_nForcedSkin );
+
+	int m_nFootStamps;
+
+	vgui::DHANDLE< CTFReviveDialog > m_hRevivePrompt;
+
+public:
+	void SetShowHudMenuTauntSelection( bool bShow ) { m_bShowHudMenuTauntSelection = bShow; }
+	bool ShouldShowHudMenuTauntSelection() const { return m_bShowHudMenuTauntSelection; }
+
+private:
+	bool m_bShowHudMenuTauntSelection;
+
+public:
+	CBaseEntity *GetGrapplingHookTarget() const { return m_hGrapplingHookTarget; }
+
+	bool IsUsingActionSlot() const { return m_bUsingActionSlot; }
+	void SetUsingActionSlot( bool bUsingActionSlot ) { m_bUsingActionSlot = bUsingActionSlot; }
+	
+	void SetSecondaryLastWeapon( CBaseCombatWeapon *pSecondaryLastWeapon ) { m_hSecondaryLastWeapon = pSecondaryLastWeapon; }
+	CBaseCombatWeapon* GetSecondaryLastWeapon() const { return m_hSecondaryLastWeapon; }
+
+	bool CanPickupDroppedWeapon( const C_TFDroppedWeapon *pWeapon );
+	C_TFDroppedWeapon* GetDroppedWeaponInRange();
+
+	bool HasCampaignMedal( int iMedal );
+	CampaignMedalDisplayType_t GetCampaignMedalType( void );
+	const char *GetCampaignMedalImage( void );
+
+	void SetInspectTime( float flInspectTime ) { m_flInspectTime = flInspectTime; }
+	bool IsInspecting() const;
+	void HandleInspectHint();
+
+	bool AddOverheadEffect( const char *pszEffectName );
+	void RemoveOverheadEffect( const char *pszEffectName, bool bRemoveInstantly );
+	void UpdateOverheadEffects();
+	Vector GetOverheadEffectPosition();
+
+	int GetSkinOverride() const { return m_iPlayerSkinOverride; }
+
+private:
+	CNetworkHandle( CBaseEntity, m_hGrapplingHookTarget );
+	CNetworkHandle( CBaseCombatWeapon, m_hSecondaryLastWeapon );
+	CNetworkVar( bool, m_bUsingActionSlot );
+	CNetworkVar( int, m_iCampaignMedals );
+	CNetworkVar( float, m_flInspectTime );
+
+	bool m_bNotifiedWeaponInspectThisLife;
+
+	C_PasstimePlayerReticle *m_pPasstimePlayerReticle;
+	C_PasstimeAskForBallReticle *m_pPasstimeAskForBallReticle;
+
+	CUtlMap< const char *, HPARTICLEFFECT > m_mapOverheadEffects;
+	float m_flOverheadEffectStartTime;
+
+	CNetworkVar( int, m_iPlayerSkinOverride );
+};
+
+inline C_TFPlayer* ToTFPlayer( C_BaseEntity *pEntity )
+{
+	if ( !pEntity || !pEntity->IsPlayer() )
+		return NULL;
+
+	Assert( dynamic_cast<C_TFPlayer*>( pEntity ) != 0 );
+	return static_cast< C_TFPlayer* >( pEntity );
+}
+
+void SetAppropriateCamera( C_TFPlayer *pPlayer );
+
+class C_TFPlayerPreviewEffect
+{
+public:
+	// If you re-order this list, please update TF_ImportPreview_Effect* in tf_english.txt
+	enum PREVIEW_EFFECT
+	{
+		PREVIEW_EFFECT_NONE,
+		PREVIEW_EFFECT_UBER,
+		//PREVIEW_EFFECT_CRIT,	// Punting on particle effects for now
+		PREVIEW_EFFECT_URINE,
+		//PREVIEW_EFFECT_MILK,	// Punting on particle effects for now
+		//PREVIEW_EFFECT_INVIS,	// The CMDLPanel draw path doesn't handle transparency at the moment
+		PREVIEW_EFFECT_BURN,
+		NUM_PREVIEW_EFFECTS
+	};
+
+public:
+	C_TFPlayerPreviewEffect();
+
+	void SetEffect(PREVIEW_EFFECT nEffect) { m_nPreviewEffect = nEffect; }
+	PREVIEW_EFFECT GetEffect() const { return m_nPreviewEffect; }
+
+	void SetTeam(int nTeam);
+	int GetTeam() const { return m_nTeam; }
+
+	CMaterialReference *GetInvulnMaterialRef( void ) { return &m_InvulnerableMaterial; }
+
+	void Reset();
+
+protected:
+	PREVIEW_EFFECT m_nPreviewEffect;
+	int m_nTeam;
+	CMaterialReference	m_InvulnerableMaterial;
+};
+extern C_TFPlayerPreviewEffect g_PlayerPreviewEffect;
+
+#endif // C_TF_PLAYER_H