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.
1256 lines
42 KiB
1256 lines
42 KiB
//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================//
|
|
|
|
#ifndef C_CS_PLAYER_H
|
|
#define C_CS_PLAYER_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
|
|
#include "cs_playeranimstate.h"
|
|
#include "c_baseplayer.h"
|
|
#include "cs_shareddefs.h"
|
|
#include "weapon_csbase.h"
|
|
#include "baseparticleentity.h"
|
|
#include "beamdraw.h"
|
|
#include "glow_outline_effect.h"
|
|
|
|
#include "cs_player_rank_shared.h"
|
|
#include "GameEventListener.h"
|
|
|
|
#include "cstrike15_item_inventory.h"
|
|
|
|
#include "cs_custom_weapon_visualsdata_processor.h"
|
|
|
|
#include "cs_player_shared.h"
|
|
|
|
#include "iinput.h"
|
|
|
|
#include "cstrike15_item_inventory.h"
|
|
|
|
#include "csgo_playeranimstate.h"
|
|
|
|
#include "cs_gamerules.h"
|
|
|
|
#include "basecsgrenade_projectile.h"
|
|
|
|
#define SPEECH_VOIP_PARTICLE_EFFECT_NAME "speech_voice"
|
|
#define RADIO_VOICE_PARTICLE_EFFECT_NAME "radio_voice"
|
|
|
|
enum CStrikeScreenSpaceEffect
|
|
{
|
|
AR_LEADER_SCREEN_SPACE_EFFECT,
|
|
|
|
CSTRIKE_SCREEN_SPACE_EFFECT_COUNT
|
|
};
|
|
|
|
//#define CHARACTER_SPAWN_CAM_ZOOM_IN
|
|
extern const char *musicTypeStrings[];
|
|
|
|
class C_PhysicsProp;
|
|
|
|
extern ConVar cl_disablefreezecam;
|
|
|
|
struct clientSmokeGrenadeRecord_t
|
|
{
|
|
Vector m_vecPosition;
|
|
float m_flInceptionTime;
|
|
int m_iEntityId;
|
|
};
|
|
|
|
struct clientHitVerify_t
|
|
{
|
|
|
|
clientHitVerify_t()
|
|
{
|
|
vecPosition = Vector(0, 0, 0);
|
|
flTimestamp = 0;
|
|
flExpireTime = -1;
|
|
}
|
|
|
|
clientHitVerify_t( Vector inPos, float flTimestamp, float flExpireTime )
|
|
{
|
|
vecPosition = inPos;
|
|
flTimestamp = flTimestamp;
|
|
flExpireTime = flExpireTime;
|
|
}
|
|
|
|
Vector vecPosition;
|
|
float flTimestamp;
|
|
float flExpireTime;
|
|
};
|
|
|
|
class C_BulletHitModel : public C_BaseAnimating
|
|
{
|
|
DECLARE_CLASS( C_BulletHitModel, C_BaseAnimating );
|
|
|
|
public:
|
|
//C_BulletHitModel() : m_pPlayerParent(NULL), m_iBoneIndex( 0 ), m_bIsHit( false ), m_flTimeCreated( 0 ){}
|
|
void AttachToPlayer( C_CSPlayer *pTargetPlayer, int nBoneIndex, matrix3x4_t matLocalOffset, bool bIsHit, Vector vecStartPos );
|
|
virtual int DrawModel( int flags, const RenderableInstance_t &instance );
|
|
bool UpdatePosition( void );
|
|
CCSPlayer *GetPlayerParent();
|
|
private:
|
|
matrix3x4_t m_matLocal;
|
|
int m_iBoneIndex;
|
|
EHANDLE m_hPlayerParent;
|
|
bool m_bIsHit;
|
|
float m_flTimeCreated;
|
|
Vector m_vecStartPos;
|
|
};
|
|
|
|
|
|
#define BONESNAPSHOT_ENTIRE_BODY 0
|
|
#define BONESNAPSHOT_UPPER_BODY 1
|
|
|
|
#define BONESNAPSHOT_DECAYDURATION_MIN 0
|
|
#define BONESNAPSHOT_DECAYDURATION_MAX 0.4f
|
|
|
|
class CBoneSnapshot
|
|
{
|
|
public:
|
|
void Update( CBaseAnimating* pEnt, bool bReadOnly = false );
|
|
inline void UpdateReadOnly( void ) { Update( m_pEnt, true ); }
|
|
|
|
void SetShouldCapture( void ) { m_bCapturePending = true; }
|
|
|
|
void SetShouldCapture( float flNewDecayDuration )
|
|
{
|
|
m_bCapturePending = true;
|
|
m_flDecayIdealDuration = clamp( flNewDecayDuration, BONESNAPSHOT_DECAYDURATION_MIN, BONESNAPSHOT_DECAYDURATION_MAX );
|
|
m_flDecayStartTime = gpGlobals->curtime;
|
|
m_flDecayEndTime = m_flDecayStartTime + m_flDecayIdealDuration;
|
|
}
|
|
|
|
bool IsCapturePending( void ) { return (m_bEnabled && m_bCapturePending); }
|
|
|
|
void Enable( void ) { if ( !m_bEnabled ) { AbandonAnyPending(); } m_bEnabled = true; }
|
|
void Disable( void ) { if ( m_bEnabled ) { AbandonAnyPending(); } m_bEnabled = false; }
|
|
|
|
float GetCurrentWeight( void ) { return m_flWeight; }
|
|
|
|
void SetLastBoneSetupTimeIndex( void ) { m_flLastBoneSetupTimeIndex = gpGlobals->curtime; }
|
|
|
|
void Init( void )
|
|
{
|
|
m_pEnt = NULL;
|
|
m_flWeight = 0;
|
|
memset( m_Weightlist, 0, ARRAYSIZE(m_Weightlist) );
|
|
m_bWeightlistInitialized = false;
|
|
m_bEnabled = false;
|
|
m_bCapturePending = false;
|
|
m_vecSubordinateSnapshots.RemoveAll();
|
|
m_flDecayIdealDuration = 0.25f;
|
|
m_flDecayStartTime = 0;
|
|
m_flDecayEndTime = 0;
|
|
m_vecWorldCapturePos.Init();
|
|
m_flLastBoneSetupTimeIndex = 0;
|
|
m_nStudioRenderHdrId = -1;
|
|
}
|
|
|
|
void Init( CBaseAnimating* pEnt ) { Init(); m_pEnt = pEnt; }
|
|
CBoneSnapshot() { Init(); }
|
|
|
|
void AddSubordinate( CBoneSnapshot* pSnapshot )
|
|
{
|
|
if ( !m_vecSubordinateSnapshots.HasElement(pSnapshot) )
|
|
{
|
|
m_vecSubordinateSnapshots[ m_vecSubordinateSnapshots.AddToTail() ] = pSnapshot;
|
|
}
|
|
}
|
|
|
|
void AbandonAnyPending( void )
|
|
{
|
|
m_flWeight = 0;
|
|
m_bCapturePending = false;
|
|
}
|
|
|
|
void SetWeightListName( const char* szWeightListName ) { m_szWeightlistName = szWeightListName; }
|
|
|
|
private:
|
|
|
|
CBaseAnimating* m_pEnt;
|
|
float m_flWeight;
|
|
matrix3x4a_t m_Cache[ MAXSTUDIOBONES ];
|
|
const char* m_szWeightlistName;
|
|
float m_Weightlist[ MAXSTUDIOBONES ];
|
|
bool m_bWeightlistInitialized;
|
|
bool m_bEnabled;
|
|
bool m_bCapturePending;
|
|
float m_flDecayIdealDuration;
|
|
float m_flDecayStartTime;
|
|
float m_flDecayEndTime;
|
|
Vector m_vecWorldCapturePos;
|
|
float m_flLastBoneSetupTimeIndex;
|
|
int m_nStudioRenderHdrId;
|
|
|
|
CUtlVector<CBoneSnapshot*> m_vecSubordinateSnapshots;
|
|
|
|
void CaptureSnapshot( void );
|
|
void PlaybackSnapshot( void );
|
|
void InitWeightList( void );
|
|
bool IsBoneSetupTimeIndexRecent( void ) { return (gpGlobals->curtime - m_flLastBoneSetupTimeIndex) <= 0.25f; }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CAddonModel
|
|
{
|
|
public:
|
|
CHandle<C_BaseAnimating> m_hEnt; // The model for the addon.
|
|
int m_iAddon; // One of the ADDON_ bits telling which model this is.
|
|
int m_iAttachmentPoint; // Which attachment point on the player model this guy is on.
|
|
};
|
|
|
|
// Class that handles the playback of a sound instance during round start
|
|
class RoundStartSoundPlaybackData
|
|
{
|
|
public:
|
|
RoundStartSoundPlaybackData() { m_pEntityPlayingSound = NULL; m_SoundName[0] = 0; m_fPlaybackTime = 0.0f; m_bHasBeenPlayed = false; }
|
|
|
|
CBaseEntity* m_pEntityPlayingSound; // Entity playing the sound event
|
|
char m_SoundName[64]; // Name of sound event to play
|
|
float m_fPlaybackTime; // Length of time for sound event to play
|
|
bool m_bHasBeenPlayed; // true = event has been played
|
|
};
|
|
|
|
class CStartOfRoundAudioPlayback
|
|
{
|
|
public:
|
|
CStartOfRoundAudioPlayback() { m_NextAvailableTime = 1.0f; m_bPlaybackEnabled = false; }
|
|
|
|
// Adds a sound event to be played at the next round restart
|
|
void AddSound( CBaseEntity* pEntityPlayingSound, char* pName, float fDelayTime );
|
|
|
|
// Play all the queued sounds
|
|
void PlaySounds( void );
|
|
|
|
// Clear all the queued sounds
|
|
void ClearSounds( void );
|
|
|
|
// Updates the playback when m_bPlaybackEnabled is valid
|
|
void Update( void );
|
|
|
|
void RemoveSoundByName( char* pName );
|
|
|
|
protected:
|
|
// List of sounds to play at start of round
|
|
CUtlVector<RoundStartSoundPlaybackData> m_SoundEvents;
|
|
|
|
// Time from start of round when the next added sound event can play
|
|
float m_NextAvailableTime;
|
|
|
|
// Allows Update() to be called so sounds can play
|
|
bool m_bPlaybackEnabled;
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class C_CSPlayer : public C_BasePlayer, public CGameEventListener, public ICSPlayerAnimStateHelpers
|
|
#if !defined( NO_STEAM ) && !defined( NO_STEAM_GAMECOORDINATOR )
|
|
, public IHasAttributes
|
|
#endif
|
|
{
|
|
public:
|
|
DECLARE_CLASS( C_CSPlayer, C_BasePlayer );
|
|
DECLARE_CLIENTCLASS();
|
|
DECLARE_PREDICTABLE();
|
|
DECLARE_INTERPOLATION();
|
|
|
|
C_CSPlayer();
|
|
~C_CSPlayer();
|
|
|
|
float * GetRenderClipPlane( void );
|
|
float m_fRenderingClipPlane[4];
|
|
int m_nLastClipPlaneSetupFrame;
|
|
int m_nClipPlaneProximityLimitAttachmentIndex;
|
|
Vector m_vecLastClipCameraPos;
|
|
Vector m_vecLastClipCameraForward;
|
|
bool m_bClipHitStaticWorld;
|
|
bool m_bCachedPlaneIsValid;
|
|
CBaseWeaponWorldModel *m_pClippingWeaponWorldModel;
|
|
|
|
virtual void SetSequence(int nSequence) OVERRIDE;
|
|
|
|
virtual bool Simulate();
|
|
virtual void Spawn( void );
|
|
virtual void UpdateOnRemove( void );
|
|
virtual void OnSetDormant( bool bDormant );
|
|
|
|
//EHANDLE GetCarriedHostage() const;
|
|
void GiveCarriedHostage( EHANDLE hHostage );
|
|
void RefreshCarriedHostage( bool bForceCreate );
|
|
void RemoveCarriedHostage();
|
|
|
|
bool HasDefuser() const;
|
|
|
|
void GiveDefuser();
|
|
void RemoveDefuser();
|
|
|
|
bool HasNightVision() const;
|
|
|
|
static C_CSPlayer* GetLocalCSPlayer();
|
|
CSPlayerState State_Get() const;
|
|
CSPlayerState m_previousPlayerState;
|
|
|
|
virtual float GetMinFOV() const;
|
|
|
|
// Get how much $$$ this guy has.
|
|
int GetAccount() const;
|
|
|
|
// Returns one of the CS_CLASS_ enums.
|
|
int PlayerClass() const;
|
|
|
|
bool IsInBuyZone();
|
|
bool IsInBuyPeriod();
|
|
bool CanBuyDuringImmunity();
|
|
bool CanPlayerBuy( bool display );
|
|
|
|
bool CanShowTeamMenu() const; // Returns true if we're allowed to show the team menu right now.
|
|
|
|
// Get the amount of armor the player has.
|
|
int ArmorValue() const;
|
|
bool HasHelmet() const;
|
|
bool HasHeavyArmor() const;
|
|
|
|
// create tracers
|
|
void CreateWeaponTracer( Vector vecStart, Vector vecEnd );
|
|
|
|
virtual const QAngle& EyeAngles();
|
|
virtual void CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
|
|
|
|
// observer mode
|
|
void SetSpecWatchingGrenade( C_BaseEntity *pGrenade, bool bWatching );
|
|
virtual int GetObserverMode() const;
|
|
virtual CBaseEntity *GetObserverTarget() const;
|
|
bool IsSpecFollowingGrenade( void ) {return m_bIsSpecFollowingGrenade; }
|
|
bool IsHoldingSpecGrenadeKey( void );
|
|
bool m_bIsSpecFollowingGrenade;
|
|
EHANDLE m_hOldGrenadeObserverTarget;
|
|
|
|
virtual void GetRenderBounds( Vector& theMins, Vector& theMaxs );
|
|
virtual void GetShadowRenderBounds( Vector &mins, Vector &maxs, ShadowType_t shadowType );
|
|
virtual bool GetShadowCastDirection( Vector *pDirection, ShadowType_t shadowType ) const;
|
|
|
|
virtual void VPhysicsUpdate( IPhysicsObject *pPhysics );
|
|
|
|
// Get the ID target entity index. The ID target is the player that is behind our crosshairs, used to
|
|
// display the player's name.
|
|
int GetIDTarget() const;
|
|
int GetTargetedWeapon( void ) const;
|
|
|
|
virtual void NotifyShouldTransmit( ShouldTransmitState_t state );
|
|
virtual void ClientThink();
|
|
virtual void OnTimeJump() OVERRIDE;
|
|
|
|
virtual void OnDataChanged( DataUpdateType_t type );
|
|
virtual void PostDataUpdate( DataUpdateType_t updateType );
|
|
virtual bool Interpolate( float currentTime );
|
|
virtual void UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity );
|
|
virtual surfacedata_t * GetFootstepSurface( const Vector &origin, const char *surfaceName );
|
|
virtual void PlayClientJumpSound( void );
|
|
virtual void ValidateModelIndex( void );
|
|
|
|
static bool RenderLocalScreenSpaceEffect( CStrikeScreenSpaceEffect effect, IMatRenderContext *pRenderContext, int x, int y, int w, int h );
|
|
bool AreScreenSpaceVomitParticlesActive( void ) const;
|
|
bool DrawScreenSpaceVomitParticles( IMatRenderContext *pRenderContext );
|
|
|
|
int GetHealth() const { return m_iHealth; }
|
|
virtual int GetMaxHealth() const;
|
|
|
|
bool Weapon_CanSwitchTo(C_BaseCombatWeapon *pWeapon);
|
|
|
|
virtual void UpdateClientSideAnimation();
|
|
virtual void ProcessMuzzleFlashEvent();
|
|
void HandleTaserAnimation();
|
|
|
|
virtual const Vector& GetRenderOrigin( void );
|
|
|
|
bool CreateMove( float flInputSampleTime, CUserCmd *pCmd );
|
|
|
|
CUtlVector< C_BaseParticleEntity* > m_SmokeGrenades;
|
|
|
|
virtual bool ShouldDraw( void );
|
|
virtual bool UpdateDispatchLayer( CAnimationLayer *pLayer, CStudioHdr *pWeaponStudioHdr, int iSequence ) OVERRIDE;
|
|
virtual void AccumulateLayers( IBoneSetup &boneSetup, BoneVector pos[], BoneQuaternion q[], float currentTime );
|
|
bool UpdateLayerWeaponDispatch( C_AnimationLayer *pLayer, int iSequence );
|
|
virtual float GetLayerSequenceCycleRate( C_AnimationLayer *pLayer, int iSequence );
|
|
virtual void BuildTransformations( CStudioHdr *pStudioHdr, BoneVector *pos, BoneQuaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed );
|
|
|
|
virtual void DoExtraBoneProcessing( CStudioHdr *pStudioHdr, BoneVector pos[], BoneQuaternion q[], matrix3x4a_t boneToWorld[], CBoneBitList &boneComputed, CIKContext *pIKContext ) OVERRIDE;
|
|
|
|
virtual bool SetupBones( matrix3x4a_t *pBoneToWorldOut, int nMaxBones, int boneMask, float currentTime );
|
|
|
|
void ReevauluateAnimLOD( int boneMask = 0 );
|
|
|
|
virtual C_BaseAnimating * BecomeRagdollOnClient();
|
|
virtual IRagdoll* GetRepresentativeRagdoll() const;
|
|
|
|
virtual void TeamChange( int iNewTeam );
|
|
|
|
void ImpactTrace( trace_t *pTrace, int iDamageType, char *pCustomImpactName );
|
|
|
|
// Have this player play the sounds from his view model's reload animation.
|
|
void PlayReloadEffect( int iActAnimID, const Vector *pOrigin = NULL );
|
|
|
|
virtual void FireEvent( const Vector& origin, const QAngle& angles, int event, const char *options );
|
|
|
|
virtual void DropPhysicsMag( const char *options ) OVERRIDE;
|
|
|
|
bool HasC4( void );
|
|
bool HasWeaponOfType( int nWeaponID ) const;
|
|
|
|
virtual bool CreateLightEffects( void ) { return false; } //no dimlight effects
|
|
|
|
// Sometimes the server wants to update the client's cycle to get the two to run in sync (for proper hit detection)
|
|
virtual void SetServerIntendedCycle( float intended ) { m_serverIntendedCycle = intended; }
|
|
virtual float GetServerIntendedCycle( void ) { return m_serverIntendedCycle; }
|
|
|
|
virtual bool IsTaunting( void ) const { return m_bIsTaunting; }
|
|
virtual bool IsThirdPersonTaunt( void ) const { return m_bIsThirdPersonTaunt; }
|
|
virtual bool IsHoldingTaunt( void ) const { return m_bIsHoldingTaunt; }
|
|
|
|
virtual bool IsLookingAtWeapon( void ) const { return m_bIsLookingAtWeapon; }
|
|
virtual bool IsHoldingLookAtWeapon( void ) const { return m_bIsHoldingLookAtWeapon; }
|
|
|
|
virtual float GetTauntYaw( void ) const { return m_flTauntYaw; }
|
|
|
|
virtual const char *GetVOIPParticleEffectName() const { return SPEECH_VOIP_PARTICLE_EFFECT_NAME; }
|
|
virtual const char *GetRadioHeadParticleEffectName() const { return RADIO_VOICE_PARTICLE_EFFECT_NAME; }
|
|
virtual void UpdateRadioHeadIcon( bool bVoice );
|
|
virtual bool ShouldShowRadioHeadIcon() const;
|
|
virtual CNewParticleEffect *GetRadioHeadParticleEffect( void );
|
|
virtual CNewParticleEffect *GetVOIPParticleEffect( void );
|
|
virtual Vector GetParticleHeadLabelOffset( void );
|
|
virtual bool HasSpeechVOIPParticleIconActive( void ) { return (m_speechVOIPParticleEffect && m_speechVOIPParticleEffect.IsValid()); }
|
|
|
|
virtual void AddDecal( const Vector& rayStart, const Vector& rayEnd, const Vector& decalCenter, int hitbox, int decalIndex, bool doTrace, trace_t& tr, int maxLODToDecal );
|
|
|
|
virtual void SetRenderAlpha( byte a );
|
|
virtual void SetRenderMode( RenderMode_t nRenderMode, bool bForceUpdate = false );
|
|
|
|
virtual int DrawModel( int flags, const RenderableInstance_t &instance );
|
|
|
|
virtual bool ShouldReceiveProjectedTextures( int flags )
|
|
{
|
|
return ( this != C_BasePlayer::GetLocalPlayer() || IsTaunting() || ShouldDraw() );
|
|
}
|
|
|
|
void ClearSoundEvents()
|
|
{
|
|
m_SoundEvents.RemoveAll();
|
|
}
|
|
|
|
CsMusicType_t GetCurrentMusic() { return m_nCurrentMusic; } const
|
|
void SetCurrentMusic( CsMusicType_t nMusicType )
|
|
{
|
|
m_nCurrentMusic = nMusicType;
|
|
if( nMusicType == CSMUSIC_START )
|
|
{
|
|
m_flMusicRoundStartTime = gpGlobals->curtime;
|
|
}
|
|
m_flCurrentMusicStartTime = gpGlobals->curtime;
|
|
}
|
|
float GetCurrentMusicElapsed()
|
|
{
|
|
return gpGlobals->curtime - m_flCurrentMusicStartTime;
|
|
}
|
|
|
|
float GetMusicStartRoundElapsed()
|
|
{
|
|
return gpGlobals->curtime - m_flMusicRoundStartTime;
|
|
}
|
|
|
|
bool IsPlayerDominated( int iPlayerIndex );
|
|
bool IsPlayerDominatingMe( int iPlayerIndex );
|
|
|
|
virtual float GetFOV( void ) const;
|
|
|
|
virtual void CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
|
|
virtual void CalcDeathCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov );
|
|
|
|
void UpdateFreezeCamFlashlightEffect( C_BaseEntity *pTarget, float flAmount );
|
|
void CancelFreezeCamFlashlightEffect();
|
|
bool m_bFreezeCamFlashlightActive;
|
|
CTextureReference m_freezeCamSpotLightTexture;
|
|
|
|
virtual float GetDeathCamInterpolationTime();
|
|
float GetFreezeFrameInterpolant( void );
|
|
float GetFreezeFrameTilt( void ) { return m_flFreezeFrameTilt; }
|
|
|
|
// check autoaim
|
|
bool IsCursorOnAutoAimTarget();
|
|
|
|
AcquireResult::Type CanAcquire( CSWeaponID weaponId, AcquireMethod::Type acquireMethod, CEconItemView *pItem = NULL );
|
|
int GetCarryLimit( CSWeaponID weaponId );
|
|
int GetWeaponPrice( CSWeaponID weaponId, const CEconItemView *pWepView = NULL ) const;
|
|
CWeaponCSBase* CSWeapon_OwnsThisType( CEconItemView *pItem ) const;
|
|
|
|
virtual bool ShouldRegenerateOriginFromCellBits() const;
|
|
|
|
bool IsOtherSameTeam( int nTeam );
|
|
bool IsOtherEnemy( CCSPlayer *pPlayer );
|
|
bool IsOtherEnemy( int nEntIndex );
|
|
bool IsOtherEnemyAndPlaying( int nEntIndex );
|
|
|
|
virtual void SetModelPointer( const model_t *pModel );
|
|
|
|
protected:
|
|
CUtlReference< CNewParticleEffect > m_radioHeadIconParticleEffect;
|
|
|
|
// Called by shared code.
|
|
public:
|
|
|
|
// ICSPlayerAnimState overrides.
|
|
virtual CWeaponCSBase* CSAnim_GetActiveWeapon();
|
|
virtual bool CSAnim_CanMove();
|
|
|
|
|
|
void DoAnimationEvent( PlayerAnimEvent_t event, int nData = 0 );
|
|
|
|
|
|
// Implemented in shared code.
|
|
public:
|
|
virtual float GetPlayerMaxSpeed();
|
|
bool IsPrimaryOrSecondaryWeapon( CSWeaponType nType );
|
|
|
|
bool GetUseConfigurationForHighPriorityUseEntity( CBaseEntity *pEntity, CConfigurationForHighPriorityUseEntity_t &cfg );
|
|
CBaseEntity *GetUsableHighPriorityEntity( void );
|
|
|
|
void GetBulletTypeParameters(
|
|
int iBulletType,
|
|
float &fPenetrationPower,
|
|
float &flPenetrationDistance );
|
|
|
|
void FireBullet(
|
|
Vector vecSrc,
|
|
const QAngle &shootAngles,
|
|
float flDistance,
|
|
float flPenetration,
|
|
int nPenetrationCount,
|
|
int iBulletType,
|
|
int iDamage,
|
|
float flRangeModifier,
|
|
CBaseEntity *pevAttacker,
|
|
bool bDoEffects,
|
|
float xSpread, float ySpread );
|
|
|
|
bool HandleBulletPenetration(
|
|
float &flPenetration,
|
|
int &iEnterMaterial,
|
|
bool &hitGrate,
|
|
trace_t &tr,
|
|
Vector &vecDir,
|
|
surfacedata_t *pSurfaceData,
|
|
float flPenetrationModifier,
|
|
float flDamageModifier,
|
|
bool bDoEffects,
|
|
int iDamageType,
|
|
float flPenetrationPower,
|
|
int &nPenetrationCount,
|
|
Vector &vecSrc,
|
|
float flDistance,
|
|
float flCurrentDistance,
|
|
float &fCurrentDamage );
|
|
|
|
virtual QAngle GetAimPunchAngle( void );
|
|
QAngle GetRawAimPunchAngle( void ) const;
|
|
|
|
void KickBack(
|
|
float fAngle,
|
|
float fMagnitude );
|
|
|
|
int GetDefaultCrouchedFOV( void ) const;
|
|
|
|
void DisplayPenetrationDebug( Vector vecEnter, Vector vecExit, float flDistance, float flInitialDamage, float flDamageLostImpact, float flTotalLostDamage, short nEnterSurf, short nExitSurf );
|
|
|
|
// Returns true if the player is allowed to move.
|
|
bool CanMove() const;
|
|
|
|
// Returns the player mask which includes the solid mask plus the team mask.
|
|
virtual unsigned int PhysicsSolidMaskForEntity( void ) const;
|
|
|
|
void OnJump( float fImpulse );
|
|
void OnLand( float fVelocity );
|
|
|
|
bool HasC4() const; // Is this player carrying a C4 bomb?
|
|
bool IsVIP() const; // Is this player the VIP?
|
|
|
|
virtual void SetAnimation( PLAYER_ANIM playerAnim );
|
|
|
|
virtual bool ShouldInterpolate( void );
|
|
|
|
public:
|
|
|
|
void UpdateIDTarget( void );
|
|
void UpdateTargetedWeapon( void );
|
|
void RemoveAddonModels( void );
|
|
void UpdateMinModels( void );
|
|
|
|
void CreateC4Effect( CBaseEntity *pEnt, bool bIsWeaponModel );
|
|
void RemoveC4Effect( bool bIsWeaponModel );
|
|
|
|
void SetActivity( Activity eActivity );
|
|
Activity GetActivity( void ) const;
|
|
|
|
void DoAnimStateEvent( PlayerAnimEvent_t evt );
|
|
|
|
// Global/static methods
|
|
virtual void ThirdPersonSwitch( bool bThirdperson );
|
|
virtual void CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov );
|
|
|
|
public:
|
|
|
|
IPlayerAnimState *m_PlayerAnimState;
|
|
CCSGOPlayerAnimState *m_PlayerAnimStateCSGO;
|
|
|
|
virtual Vector Weapon_ShootPosition();
|
|
|
|
// Used to control animation state.
|
|
Activity m_Activity;
|
|
|
|
CNetworkVar( bool, m_bIsScoped );
|
|
CNetworkVar( bool, m_bIsWalking );
|
|
// Predicted variables.
|
|
CNetworkVar( bool, m_bResumeZoom );
|
|
CNetworkVar( CSPlayerState, m_iPlayerState ); // SupraFiend: this gives the current state in the joining process, the states are listed above
|
|
CNetworkVar( bool, m_bIsDefusing ); // tracks whether this player is currently defusing a bomb
|
|
CNetworkVar( bool, m_bIsGrabbingHostage ); // tracks whether this player is currently defusing a bomb
|
|
CNetworkVar( bool, m_bIsRescuing ); // tracks whether this player is currently rescuing a hostage
|
|
CNetworkVar( float, m_fImmuneToGunGameDamageTime ); // When gun game spawn damage immunity will expire
|
|
float m_fImmuneToGunGameDamageTimeLast;
|
|
CNetworkVar( bool, m_bGunGameImmunity ); // tracks whether this player is currently immune in gun game
|
|
CNetworkVar( bool, m_bHasMovedSinceSpawn ); // Whether player has moved from spawn position
|
|
CNetworkVar( bool, m_bMadeFinalGunGameProgressiveKill );
|
|
CNetworkVar( int, m_iGunGameProgressiveWeaponIndex ); // index of current gun game weapon
|
|
CNetworkVar( int, m_iNumGunGameTRKillPoints ); // number of kill points accumulated so far in TR Gun Game mode (resets to 0 when weapon is upgraded)
|
|
CNetworkVar( int, m_iNumGunGameKillsWithCurrentWeapon );
|
|
CNetworkVar( int, m_iNumRoundKills ); // number of kills a player has gotten in a round
|
|
CNetworkVar( int, m_iNumRoundKillsHeadshots ); // number of headshot kills a player has gotten in a round
|
|
CNetworkVar( float, m_fMolotovUseTime ); // Molotov can be used if current time is after this time
|
|
CNetworkVar( float, m_fMolotovDamageTime ); // Last time when this player was burnt by Molotov damage
|
|
CNetworkVar( bool, m_bInBombZone );
|
|
CNetworkVar( bool, m_bInBuyZone );
|
|
CNetworkVar( bool, m_bInNoDefuseArea );
|
|
CNetworkVar( int, m_iThrowGrenadeCounter ); // used to trigger grenade throw animations.
|
|
CNetworkVar( bool, m_bWaitForNoAttack ); // flag to indicate player cannot attack until the attack button is released
|
|
CNetworkVar( bool, m_bIsRespawningForDMBonus ); // flag to indicate player wants to spawn with the deathmatch bonus weapons
|
|
CNetworkVar( float, m_flGuardianTooFarDistFrac );
|
|
CNetworkVar( float, m_flDetectedByEnemySensorTime );
|
|
float m_flNextGuardianTooFarWarning;
|
|
|
|
CNetworkVar( bool, m_bKilledByTaser );
|
|
CNetworkVar( int, m_iMoveState ); // Is the player trying to run or walk or idle? Tells us what the player is "trying" to do.
|
|
|
|
CNetworkVar( bool, m_bCanMoveDuringFreezePeriod );
|
|
|
|
CNetworkVar( bool, m_isCurrentGunGameLeader );
|
|
CNetworkVar( bool, m_isCurrentGunGameTeamLeader );
|
|
|
|
CNetworkString( m_szArmsModel, MAX_MODEL_STRING_SIZE ); // Which arms we're using for the view model.
|
|
|
|
const PlayerViewmodelArmConfig *m_pViewmodelArmConfig;
|
|
|
|
CNetworkVar( float, m_flLowerBodyYawTarget );
|
|
CNetworkVar( bool, m_bStrafing );
|
|
|
|
bool m_bUseNewAnimstate;
|
|
|
|
CBoneSnapshot m_boneSnapshots[2];
|
|
bool IsAnyBoneSnapshotPending( void );
|
|
|
|
float m_flLastSpawnTimeIndex;
|
|
|
|
virtual void NotifyOnLayerChangeSequence( const CAnimationLayer* pLayer, const int nNewSequence ) OVERRIDE;
|
|
virtual void NotifyOnLayerChangeWeight( const CAnimationLayer* pLayer, const float flNewWeight ) OVERRIDE;
|
|
virtual void NotifyOnLayerChangeCycle( const CAnimationLayer* pLayer, const float flNewCycle ) OVERRIDE;
|
|
|
|
bool IsInHostageRescueZone( void );
|
|
|
|
// This is a combination of the ADDON_ flags in cs_shareddefs.h.
|
|
CNetworkVar( int, m_iAddonBits );
|
|
|
|
// Clients don't know about holstered weapons, so we need to be told about them here
|
|
CNetworkVar( int, m_iPrimaryAddon );
|
|
CNetworkVar( int, m_iSecondaryAddon );
|
|
|
|
// How long the progress bar takes to get to the end. If this is 0, then the progress bar
|
|
// should not be drawn.
|
|
CNetworkVar( int, m_iProgressBarDuration );
|
|
|
|
// When the progress bar should start.
|
|
CNetworkVar( float, m_flProgressBarStartTime );
|
|
|
|
CNetworkVar( float, m_flStamina );
|
|
CNetworkVar( int, m_iDirection ); // The current lateral kicking direction; 1 = right, 0 = left
|
|
CNetworkVar( int, m_iShotsFired ); // number of shots fired recently
|
|
CNetworkVar( int, m_nNumFastDucks ); // UNUSED. Kept for backwards demo compatibility. $$$REI TODO: Investigate safely removing variables
|
|
CNetworkVar( bool, m_bDuckOverride ); // force the player to duck regardless of if they're holding crouch
|
|
|
|
CNetworkVar( bool, m_bNightVisionOn );
|
|
CNetworkVar( bool, m_bHasNightVision );
|
|
CNetworkVar( float, m_flVelocityModifier );
|
|
CNetworkVar( float, m_flGroundAccelLinearFracLastTime );
|
|
|
|
CNetworkVar( int, m_iStartAccount ); // how much cash the player started the round with
|
|
|
|
CNetworkVar( int, m_totalHitsOnServer );
|
|
|
|
CNetworkVar( bool, m_bIsBuyMenuOpen );
|
|
bool IsBuyMenuOpen( void ) { return m_bIsBuyMenuOpen; }
|
|
void SetBuyMenuOpen( bool bOpen );
|
|
|
|
EHANDLE m_hRagdoll;
|
|
|
|
EHANDLE m_hCarriedHostage;
|
|
EHANDLE m_hCarriedHostageProp;
|
|
bool m_bPlayingHostageCarrySound;
|
|
|
|
CWeaponCSBase* GetActiveCSWeapon() const;
|
|
CWeaponCSBase* GetCSWeapon( CSWeaponID id ) const;
|
|
|
|
virtual ShadowType_t ShadowCastType();
|
|
|
|
#ifdef CS_SHIELD_ENABLED
|
|
bool HasShield( void ) { return m_bHasShield; }
|
|
bool IsShieldDrawn( void ) { return m_bShieldDrawn; }
|
|
void SetShieldDrawnState( bool bState ) { m_bShieldDrawn = bState; }
|
|
#else
|
|
bool HasShield( void ) { return false; }
|
|
bool IsShieldDrawn( void ) { return false; }
|
|
void SetShieldDrawnState( bool bState ) {}
|
|
#endif
|
|
|
|
bool IsMiniScoreHidden( void ) { return m_bHud_MiniScoreHidden; }
|
|
bool IsRadarHidden( void ) { return m_bHud_RadarHidden; }
|
|
|
|
|
|
virtual int GetLastKillerIndex( void ) { return m_nLastKillerIndex; }
|
|
int GetLastConcurrentKilled( void ) { return m_nLastConcurrentKilled; }
|
|
int GetDeathCamMusicIndex( void ) { return m_nDeathCamMusic; }
|
|
|
|
float m_flNightVisionAlpha;
|
|
|
|
float m_flFlashBangTime; // end time
|
|
float m_flFlashScreenshotAlpha;
|
|
float m_flFlashOverlayAlpha;
|
|
bool m_bFlashBuildUp;
|
|
bool m_bFlashDspHasBeenCleared;
|
|
bool m_bFlashScreenshotHasBeenGrabbed;
|
|
|
|
bool IsFlashBangActive( void ) { return ( m_flFlashDuration > 0.0f ) && ( gpGlobals->curtime < m_flFlashBangTime ); }
|
|
bool IsFlashBangBuildUpActive( void ) { return m_bFlashBuildUp && IsFlashBangActive(); }
|
|
float GetFlashStartTime( void ) { return (m_flFlashBangTime - m_flFlashDuration); }
|
|
float GetFlashTimeElapsed( void ) { return MAX( gpGlobals->curtime - GetFlashStartTime(), 0.0f ); }
|
|
|
|
bool IsBlinded( void ) { return (m_flFlashBangTime - 1.0f) > gpGlobals->curtime; }
|
|
CNetworkVar( float, m_flFlashMaxAlpha );
|
|
CNetworkVar( float, m_flFlashDuration );
|
|
|
|
float GetLastFiredWeaponTime( void ) { return m_flLastFiredWeaponTime; }
|
|
float m_flLastFiredWeaponTime;
|
|
|
|
// Having the RecvProxy in the player allows us to keep the var private
|
|
static void RecvProxy_CycleLatch( const CRecvProxyData *pData, void *pStruct, void *pOut );
|
|
|
|
// Bots and hostages auto-duck during jumps
|
|
bool m_duckUntilOnGround;
|
|
|
|
Vector m_lastStandingPos; // used by the gamemovement code for finding ladders
|
|
|
|
void SurpressLadderChecks( const Vector& pos, const Vector& normal );
|
|
bool CanGrabLadder( const Vector& pos, const Vector& normal );
|
|
|
|
// [tj] checks if this player has another given player on their Steam friends list.
|
|
bool HasPlayerAsFriend( C_CSPlayer* player );
|
|
|
|
bool MadeFinalGunGameProgressiveKill( void ) { return m_bMadeFinalGunGameProgressiveKill; }
|
|
int GetPlayerGunGameWeaponIndex( void ) { return m_iGunGameProgressiveWeaponIndex; }
|
|
int GetNumGunGameTRKillPoints( void ) { return m_iNumGunGameTRKillPoints; }
|
|
int GetNumGunGameKillsWithCurrentWeapon( void ) { return m_iNumGunGameKillsWithCurrentWeapon; }
|
|
|
|
int GetNumRoundKills( void ) { return m_iNumRoundKills; }
|
|
int GetNumRoundKillsHeadshots( void ) { return m_iNumRoundKillsHeadshots; }
|
|
|
|
void DisplayInventory(bool showPistol);
|
|
|
|
bool CanUseGrenade( CSWeaponID );
|
|
|
|
MedalRank_t GetRank( MedalCategory_t category );
|
|
|
|
uint32 GetMusicID( void );
|
|
|
|
void ToggleRandomWeapons( void );
|
|
|
|
bool ShouldShowTeamPlayerColors( int nOtherTeamNum );
|
|
bool ShouldShowTeamPlayerColorLetters( void );
|
|
|
|
static void UpdateGlowsForAllPlayers( void );
|
|
CGlowObject m_GlowObject;
|
|
|
|
uint16 GetCurrentEquipmentValue ( void ) const { return m_unCurrentEquipmentValue; }
|
|
uint16 GetRoundStartEquipmentValue ( void ) const { return m_unRoundStartEquipmentValue; }
|
|
uint16 GetFreezetimeEndEquipmentValue ( void ) const { return m_unFreezetimeEndEquipmentValue; }
|
|
|
|
bool IsAbleToInstantRespawn( void );
|
|
char const * IsAbleToApplySpray( trace_t *ptr, Vector *pvecForward, Vector *pvecRight );
|
|
|
|
float GetLastSmokeOverlayAlpha( void ) const { return m_flLastSmokeOverlayAlpha; }
|
|
|
|
char *GetHalloweenMaskModelAddon( C_CSPlayer *pPlayer );
|
|
|
|
uint32 GetActiveQuestID( void ) const;
|
|
QuestProgress::Reason GetQuestProgressReason( void ) const;
|
|
|
|
Vector m_vecLastMuzzleFlashPos;
|
|
QAngle m_angLastMuzzleFlashAngle;
|
|
EHANDLE m_hMuzzleFlashShape;
|
|
int m_iHealthBarRenderMaskIndex;
|
|
float m_flHealthFadeValue;
|
|
float m_flHealthFadeAlpha;
|
|
|
|
// Match Stats data
|
|
int m_iMatchStats_Kills[ MAX_MATCH_STATS_ROUNDS ]; //kills, per round
|
|
int m_iMatchStats_Damage[ MAX_MATCH_STATS_ROUNDS ]; //damage, per round
|
|
int m_iMatchStats_EquipmentValue[ MAX_MATCH_STATS_ROUNDS ]; //Equipment value, per round
|
|
int m_iMatchStats_MoneySaved[ MAX_MATCH_STATS_ROUNDS ]; //Saved money, per round
|
|
int m_iMatchStats_KillReward[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_LiveTime[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_Deaths[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_Assists[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_HeadShotKills[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_Objective[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_CashEarned[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_UtilityDamage[ MAX_MATCH_STATS_ROUNDS ];
|
|
int m_iMatchStats_EnemiesFlashed[ MAX_MATCH_STATS_ROUNDS ];
|
|
|
|
CUtlReference<CNewParticleEffect> m_ARScreenGlowEffect;
|
|
|
|
private:
|
|
void AnimateGlows( void );
|
|
void UpdateGlows( void );
|
|
void UpdateFlashBangEffect( void );
|
|
|
|
CountdownTimer m_ladderSurpressionTimer;
|
|
Vector m_lastLadderNormal;
|
|
Vector m_lastLadderPos;
|
|
|
|
ClientCCHandle_t m_CCDeathHandle; // handle to death cc effect
|
|
float m_flDeathCCWeight; // for fading in cc effect
|
|
|
|
bool m_bFreezeFrameCloseOnKiller;
|
|
int m_nFreezeFrameShiftSideDist;
|
|
Vector m_vecFreezeFrameEnd;
|
|
QAngle m_vecFreezeFrameAnglesStart;
|
|
float m_flFreezeFrameTilt;
|
|
|
|
bool m_bOldIsScoped;
|
|
|
|
CNetworkVar( QuestProgress::Reason, m_nQuestProgressReason );
|
|
|
|
CNetworkVar( uint16, m_unCurrentEquipmentValue );
|
|
CNetworkVar( uint16, m_unRoundStartEquipmentValue );
|
|
CNetworkVar( uint16, m_unFreezetimeEndEquipmentValue );
|
|
|
|
CNetworkArray( MedalRank_t, m_rank, MEDAL_CATEGORY_COUNT );
|
|
|
|
CNetworkVar( uint16, m_unMusicID );
|
|
|
|
void ProcessSpottedEntityUpdate( void );
|
|
void UpdateSoundEvents( void );
|
|
// void HandleTauntSound( void );
|
|
|
|
void CreateNewCustomClothingModels( void );
|
|
void UpdateCustomClothingModels( void );
|
|
|
|
private:
|
|
|
|
bool ApplyCompositeMaterialsToCustomClothingModel( C_BaseAnimating* pTargetEntity, CEconItemView *pItem, int nSlotId, bool bForceRegenerate /*= false */ ) const;
|
|
|
|
void CreateAddonModel( int i );
|
|
void UpdateAddonModels( bool bForce = false );
|
|
bool m_bAddonModelsAreOutOfDate;
|
|
void UpdateHostageCarryModels();
|
|
|
|
void PushawayThink();
|
|
|
|
Vector m_vecThirdPersonViewPositionOverride;
|
|
virtual Vector GetThirdPersonViewPosition( void );
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [dwenger] Added for auto-buy functionality
|
|
//=============================================================================
|
|
void FireGameEvent( IGameEvent *event );
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
|
|
int m_iAccount;
|
|
bool m_bHasHelmet;
|
|
bool m_bHasHeavyArmor;
|
|
int m_iClass;
|
|
int m_ArmorValue;
|
|
QAngle m_angEyeAngles;
|
|
bool m_bHasDefuser;
|
|
bool m_bInHostageRescueZone;
|
|
float m_fNextThinkPushAway;
|
|
|
|
// Glow stuff
|
|
float m_fNextGlowCheckUpdate;
|
|
float m_fNextGlowCheckInterval;
|
|
float m_fGlowAlpha;
|
|
float m_fGlowAlphaTarget;
|
|
float m_fGlowAlphaUpdateTime;
|
|
float m_fGlowAlphaTargetTime;
|
|
|
|
static bool s_bPlayingFreezeCamSound;
|
|
bool m_bShouldAutobuyDMWeapons;
|
|
|
|
//=============================================================================
|
|
// HPE_BEGIN:
|
|
// [dwenger] Added for auto-buy functionality
|
|
//=============================================================================
|
|
bool m_bShouldAutobuyNow;
|
|
//=============================================================================
|
|
// HPE_END
|
|
//=============================================================================
|
|
|
|
#ifdef CS_SHIELD_ENABLED
|
|
bool m_bHasShield;
|
|
bool m_bShieldDrawn;
|
|
#endif
|
|
|
|
bool m_bHud_MiniScoreHidden;
|
|
bool m_bHud_RadarHidden;
|
|
|
|
int m_nLastKillerIndex;
|
|
int m_nLastConcurrentKilled;
|
|
int m_nDeathCamMusic;
|
|
|
|
CInterpolatedVar< QAngle > m_iv_angEyeAngles;
|
|
|
|
// ID Target
|
|
int m_iIDEntIndex;
|
|
CountdownTimer m_delayTargetIDTimer;
|
|
|
|
int m_iTargetedWeaponEntIndex;
|
|
|
|
// Show the ID target after the cursor leaves the entity
|
|
int m_iOldIDEntIndex;
|
|
CountdownTimer m_holdTargetIDTimer;
|
|
|
|
void ReleaseFlashlight( void );
|
|
Beam_t *m_pFlashlightBeam;
|
|
|
|
class CCSSoundEvent
|
|
{
|
|
public:
|
|
CCSSoundEvent() : m_bHasSoundOrigin(false) {}
|
|
string_t m_SoundName;
|
|
float m_flEventTime; // Play the event when gpGlobals->curtime goes past this.
|
|
Vector m_SoundOrigin;
|
|
bool m_bHasSoundOrigin;
|
|
};
|
|
CUtlLinkedList<CCSSoundEvent,int> m_SoundEvents;
|
|
|
|
// List of sounds to play at start of round
|
|
CStartOfRoundAudioPlayback m_StartOfRoundSoundEvents;
|
|
|
|
// manage per play music
|
|
CsMusicType_t m_nCurrentMusic;
|
|
float m_flCurrentMusicStartTime;
|
|
float m_flMusicRoundStartTime;
|
|
|
|
// This is the list of addons hanging off the guy (grenades, C4, nightvision, etc).
|
|
CUtlLinkedList<CAddonModel, int> m_AddonModels;
|
|
int m_iLastAddonBits;
|
|
int m_iLastPrimaryAddon;
|
|
int m_iLastSecondaryAddon;
|
|
|
|
CUtlReference<CNewParticleEffect> m_hC4AddonLED;
|
|
CUtlReference<CNewParticleEffect> m_hC4WeaponLED;
|
|
|
|
int m_cycleLatch; // server periodically updates this to fix up our anims, here it is a 4 bit fixed point
|
|
float m_serverIntendedCycle; // server periodically updates this to fix up our anims, here it is the float we want, or -1 for no override
|
|
|
|
// [tj] Network variables that track who are dominating and being dominated by
|
|
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
|
|
|
|
CNetworkArray( int, m_iWeaponPurchasesThisRound, MAX_WEAPONS ); // number of times each weapon purchased this round; used to limit repurchases
|
|
|
|
CNetworkVar( bool, m_bIsTaunting );
|
|
CNetworkVar( bool, m_bIsThirdPersonTaunt );
|
|
CNetworkVar( bool, m_bIsHoldingTaunt );
|
|
CNetworkVar( float, m_flTauntYaw );
|
|
|
|
CNetworkVar( bool, m_bIsLookingAtWeapon );
|
|
CNetworkVar( bool, m_bIsHoldingLookAtWeapon );
|
|
|
|
bool m_bWasTaunting;
|
|
bool m_bTauntInterpolating;
|
|
CameraThirdData_t m_TauntCameraData;
|
|
float m_flTauntCamCurrentDist;
|
|
float m_flTauntCamTargetDist;
|
|
QAngle m_angTauntPredViewAngles;
|
|
QAngle m_angTauntEngViewAngles;
|
|
|
|
public:
|
|
float m_flThirdpersonRecoil;
|
|
|
|
// taser items
|
|
float m_nextTaserShakeTime;
|
|
float m_firstTaserShakeTime;
|
|
|
|
float m_flLastSmokeOverlayAlpha;
|
|
|
|
C_CSPlayer( const C_CSPlayer & );
|
|
|
|
// For interpolating between observer targets
|
|
protected:
|
|
void UpdateObserverTargetVisibility( void ) const;
|
|
Vector m_vecObserverInterpolateOffset; // Offset vec applied to the view which decays over time
|
|
Vector m_vecObserverInterpStartPos;
|
|
float m_flObsInterp_PathLength; // Full path lenght being interpolated
|
|
Quaternion m_qObsInterp_OrientationStart;
|
|
Quaternion m_qObsInterp_OrientationTravelDir;
|
|
eObserverInterpState m_obsInterpState;
|
|
bool m_bObserverInterpolationNeedsDeferredSetup;
|
|
|
|
public:
|
|
bool ShouldInterpolateObserverChanges() const;
|
|
void StartObserverInterpolation( const QAngle &startAngles );
|
|
virtual eObserverInterpState GetObserverInterpState( void ) const OVERRIDE;
|
|
virtual bool IsInObserverInterpolation( void ) const OVERRIDE { return ShouldInterpolateObserverChanges() && m_obsInterpState != OBSERVER_INTERP_NONE; }
|
|
virtual void SetObserverTarget( EHANDLE hObserverTarget ) OVERRIDE;
|
|
void InterpolateObserverView( Vector& vOrigin, QAngle& vAngles );
|
|
Vector GetObserverInterpolatedOffsetVector( void ) { return m_vecObserverInterpolateOffset; }
|
|
|
|
bool IsAssassinationTarget( void ) const;
|
|
|
|
private:
|
|
CNetworkVar( bool, m_bIsAssassinationTarget ); // This player is an assassination target for an active mission
|
|
|
|
#if CS_CONTROLLABLE_BOTS_ENABLED
|
|
|
|
public:
|
|
bool IsControllingBot() const { return m_bIsControllingBot; }
|
|
bool CanControlObservedBot() const { return m_bCanControlObservedBot; }
|
|
|
|
int GetControlledBotIndex() const { return m_iControlledBotEntIndex; }
|
|
|
|
virtual bool GetAttachment( int number, matrix3x4_t &matrix );
|
|
virtual bool GetAttachment( int number, Vector &origin );
|
|
virtual bool GetAttachment( int number, Vector &origin, QAngle &angles );
|
|
|
|
private:
|
|
bool m_bIsControllingBot; // Are we controlling a bot?
|
|
// Note that this can be TRUE even if GetControlledPlayer() returns NULL, IFF we started controlling a bot and then the bot was deleted for some reason.
|
|
bool m_bCanControlObservedBot; // True if the player can control the bot s/he is observing
|
|
int m_iControlledBotEntIndex;
|
|
|
|
|
|
void UpdateFirstPersonShadowCasters( void );
|
|
|
|
float m_flNextMagDropTime;
|
|
int m_nLastMagDropAttachmentIndex;
|
|
CNetworkVar( bool, m_bHasControlledBotThisRound );
|
|
|
|
#endif
|
|
|
|
public:
|
|
int GetEloBracket( void ) const;
|
|
void SetEloBracket ( int bracket );
|
|
|
|
#if !defined( NO_STEAM ) && !defined( NO_STEAM_GAMECOORDINATOR )
|
|
|
|
public:
|
|
// IHasAttributes
|
|
CAttributeManager *GetAttributeManager( void ) {
|
|
#if defined( USE_PLAYER_ATTRIBUTE_MANAGER )
|
|
return &m_AttributeManager;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
CAttributeContainer *GetAttributeContainer( void ) { return NULL; }
|
|
CBaseEntity *GetAttributeOwner( void ) { return NULL; }
|
|
CAttributeList *GetAttributeList( void ) {
|
|
#if defined( USE_PLAYER_ATTRIBUTE_MANAGER )
|
|
return &m_AttributeList;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
virtual void ReapplyProvision( void ) { return; }
|
|
|
|
#if defined( USE_PLAYER_ATTRIBUTE_MANAGER )
|
|
protected:
|
|
CNetworkVarEmbedded( CAttributeContainerPlayer, m_AttributeManager );
|
|
#endif
|
|
|
|
//----------------------------
|
|
// INVENTORY MANAGEMENT
|
|
public:
|
|
// Inventory access
|
|
#if defined ENABLE_CLIENT_INVENTORIES_FOR_OTHER_PLAYERS
|
|
CCSPlayerInventory *Inventory( void );
|
|
CEconItemView *GetEquippedItemInLoadoutSlot( int iLoadoutSlot ) { return Inventory()->GetInventoryItemByItemID( m_EquippedLoadoutItemIndices[iLoadoutSlot] ); }
|
|
CEconItemView *GetEquippedItemInLoadoutSlotOrBaseItem( int iLoadoutSlot );
|
|
#endif
|
|
|
|
private:
|
|
// Items that have been equipped on this player instance (the inventory loadout may have changed)
|
|
itemid_t m_EquippedLoadoutItemIndices[LOADOUT_POSITION_COUNT];
|
|
|
|
#endif //!defined( NO_STEAM ) && !defined( NO_STEAM_GAMECOORDINATOR )
|
|
|
|
public:
|
|
void ClearAllBulletHitModels( void );
|
|
void UpdateAllBulletHitModels( void );
|
|
CUtlVector< C_BulletHitModel* > m_vecBulletHitModels;
|
|
|
|
// This code allowed us to measure discrepency between client and server bullet hits.
|
|
// It became obsolete when we started using a separate seed for client and server
|
|
// to eliminate 'rage' hacks.
|
|
//
|
|
CUtlVector< clientHitVerify_t > m_vecBulletVerifyListClient;
|
|
CUtlVector< clientHitVerify_t > m_vecBulletVerifyListServer;
|
|
|
|
void CompareClientServerBulletHits( void );
|
|
|
|
CUserMessageBinder m_UMCMsgReportHit;
|
|
|
|
uint8 m_ui8ClientServerHitDifference;
|
|
|
|
// Ammo count at death OGS data
|
|
struct roundEndAmmoCount_t
|
|
{
|
|
roundEndAmmoCount_t()
|
|
{
|
|
V_memset( this, 0, sizeof( *this ) );
|
|
}
|
|
|
|
int nPrimaryWeaponDefIndex;
|
|
int nPrimaryWeaponAmmoCount;
|
|
|
|
int nSecondaryWeaponDefIndex;
|
|
int nSecondaryWeaponAmmoCount;
|
|
|
|
};
|
|
|
|
roundEndAmmoCount_t m_roundEndAmmoCount;
|
|
|
|
Vector m_vecLastAliveLocalVelocity;
|
|
|
|
private:
|
|
void RecordAmmoForRound( void );
|
|
|
|
Vector m_vecLastContactShadowTraceOriginLeft;
|
|
Vector m_vecLastContactShadowTraceOriginRight;
|
|
float m_flLastContactShadowGroundHeightLeft;
|
|
float m_flLastContactShadowGroundHeightRight;
|
|
|
|
public:
|
|
|
|
EHANDLE m_hContactShadowLeft;
|
|
EHANDLE m_hContactShadowRight;
|
|
|
|
void CreateClientEffectModels( void );
|
|
void RemoveClientEffectModels( void );
|
|
|
|
};
|
|
|
|
C_CSPlayer* GetLocalOrInEyeCSPlayer( void );
|
|
C_CSPlayer* GetHudPlayer( void ); // get the player we should show the HUD for (local or observed)
|
|
|
|
inline C_CSPlayer *ToCSPlayer( CBaseEntity *pEntity )
|
|
{
|
|
if ( !pEntity || !pEntity->IsPlayer() )
|
|
return NULL;
|
|
|
|
return assert_cast<C_CSPlayer*>( pEntity );
|
|
}
|
|
|
|
namespace vgui
|
|
{
|
|
class IImage;
|
|
}
|
|
vgui::IImage* GetDefaultAvatarImage( C_BasePlayer *pPlayer );
|
|
|
|
|
|
void AddSmokeGrenade( Vector location, int iEntityId );
|
|
void AddSmokeGrenadeHandle( EHANDLE hGrenade );
|
|
void RemoveSmokeGrenade( Vector location, int iEntityId );
|
|
void RemoveSmokeGrenadeHandle( EHANDLE hGrenade );
|
|
void RemoveAllSmokeGrenades( void );
|
|
void RemoveSmokeGrenadeHandle( EHANDLE hGrenade );
|
|
bool LineGoesThroughSmoke( Vector from, Vector to, bool grenadeBloat );
|
|
void TruncatePlayerName( wchar_t *pCleanedHTMLName, int destLen, int nTruncateAt, bool bSkipHTML = false );
|
|
|
|
class C_CSRagdoll : public C_BaseAnimatingOverlay
|
|
{
|
|
public:
|
|
DECLARE_CLASS( C_CSRagdoll, C_BaseAnimatingOverlay );
|
|
DECLARE_CLIENTCLASS();
|
|
|
|
C_CSRagdoll();
|
|
~C_CSRagdoll();
|
|
|
|
virtual void OnDataChanged( DataUpdateType_t type );
|
|
|
|
int GetPlayerEntIndex() const;
|
|
IRagdoll* GetIRagdoll() const;
|
|
void GetRagdollInitBoneArrays( matrix3x4a_t *pDeltaBones0, matrix3x4a_t *pDeltaBones1, matrix3x4a_t *pCurrentBones, float boneDt );
|
|
void GetRagdollInitBoneArraysYawMode( matrix3x4a_t *pDeltaBones0, matrix3x4a_t *pDeltaBones1, matrix3x4a_t *pCurrentBones, float boneDt );
|
|
|
|
void ApplyRandomTaserForce( void );
|
|
void ImpactTrace( trace_t *pTrace, int iDamageType, char *pCustomImpactName );
|
|
bool IsInitialized() { return m_bInitialized; }
|
|
virtual void ValidateModelIndex( void );
|
|
|
|
void SetRagdollClientSideAddon( uint32 uiAddonMask );
|
|
|
|
int BloodColor(){ return BLOOD_COLOR_RED; }
|
|
|
|
void ApplySemiRandomDirectionalForce( Vector vecDir, float flStrength );
|
|
|
|
void AttachWearableGibsFromPlayer( C_CSPlayer *pParentPlayer );
|
|
void DestroyAttachedWearableGibs( void );
|
|
|
|
int GetDeathPose( void ) { return m_iDeathPose; }
|
|
|
|
private:
|
|
|
|
C_CSRagdoll( const C_CSRagdoll & ) :m_nGlowObjectHandle( -1) { }
|
|
void DestroyGlowObject();
|
|
|
|
void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );
|
|
|
|
void CreateLowViolenceRagdoll( void );
|
|
void CreateCSRagdoll( void );
|
|
|
|
private:
|
|
|
|
EHANDLE m_hPlayer;
|
|
CHandle<C_BaseAnimating> m_hHolidayHatAddon;
|
|
CHandle<C_BaseAnimating> m_hHolidayGhostAddon;
|
|
CHandle<C_BaseAnimating> m_hAssassinationTargetAddon;
|
|
CNetworkVector( m_vecRagdollVelocity );
|
|
CNetworkVector( m_vecRagdollOrigin );
|
|
CNetworkVar(int, m_iDeathPose );
|
|
CNetworkVar(int, m_iDeathFrame );
|
|
CNetworkVar(float, m_flDeathYaw );
|
|
CNetworkVar(float, m_flAbsYaw );
|
|
bool m_bInitialized;
|
|
|
|
int m_nGlowObjectHandle;
|
|
};
|
|
|
|
|
|
#endif // C_CS_PLAYER_H
|