Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

996 lines
31 KiB

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