d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
82 Commits
25 Branches
6 Tags
221 MiB
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/shared/tf/tf_player_shared.h

1298 lines
42 KiB
Raw Normal View History Unescape

1
5 years ago
//========= 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