diff options
Diffstat (limited to 'game/client/c_baseplayer.h')
| -rw-r--r-- | game/client/c_baseplayer.h | 700 |
1 files changed, 700 insertions, 0 deletions
diff --git a/game/client/c_baseplayer.h b/game/client/c_baseplayer.h new file mode 100644 index 0000000..12eacf5 --- /dev/null +++ b/game/client/c_baseplayer.h @@ -0,0 +1,700 @@ +//========= Copyright Valve Corporation, All rights reserved. ============// +// +// Purpose: Client-side CBasePlayer. +// +// - Manages the player's flashlight effect. +// +//=============================================================================// + +#ifndef C_BASEPLAYER_H +#define C_BASEPLAYER_H +#ifdef _WIN32 +#pragma once +#endif + +#include "c_playerlocaldata.h" +#include "c_basecombatcharacter.h" +#include "PlayerState.h" +#include "usercmd.h" +#include "shareddefs.h" +#include "timedevent.h" +#include "smartptr.h" +#include "fx_water.h" +#include "hintsystem.h" +#include "SoundEmitterSystem/isoundemittersystembase.h" +#include "c_env_fog_controller.h" +#include "igameevents.h" +#include "GameEventListener.h" + +#if defined USES_ECON_ITEMS +#include "econ_item.h" +#include "game_item_schema.h" +#include "econ_item_view.h" +#endif + +class C_BaseCombatWeapon; +class C_BaseViewModel; +class C_FuncLadder; +class CFlashlightEffect; +class C_EconWearable; + +extern int g_nKillCamMode; +extern int g_nKillCamTarget1; +extern int g_nKillCamTarget2; + +class C_CommandContext +{ +public: + bool needsprocessing; + + CUserCmd cmd; + int command_number; +}; + +class C_PredictionError +{ +public: + float time; + Vector error; +}; + +#define CHASE_CAM_DISTANCE_MIN 16.0f +#define CHASE_CAM_DISTANCE_MAX 96.0f +#define WALL_OFFSET 6.0f + + +bool IsInFreezeCam( void ); + +//----------------------------------------------------------------------------- +// Purpose: Base Player class +//----------------------------------------------------------------------------- +class C_BasePlayer : public C_BaseCombatCharacter, public CGameEventListener +{ +public: + DECLARE_CLASS( C_BasePlayer, C_BaseCombatCharacter ); + DECLARE_CLIENTCLASS(); + DECLARE_PREDICTABLE(); + DECLARE_INTERPOLATION(); + + C_BasePlayer(); + virtual ~C_BasePlayer(); + + virtual void Spawn( void ); + virtual void SharedSpawn(); // Shared between client and server. + virtual bool GetSteamID( CSteamID *pID ); + + // IClientEntity overrides. + virtual void OnPreDataChanged( DataUpdateType_t updateType ); + virtual void OnDataChanged( DataUpdateType_t updateType ); + + virtual void PreDataUpdate( DataUpdateType_t updateType ); + virtual void PostDataUpdate( DataUpdateType_t updateType ); + + virtual void ReceiveMessage( int classID, bf_read &msg ); + + virtual void OnRestore(); + + virtual void AddEntity( void ); + + virtual void MakeTracer( const Vector &vecTracerSrc, const trace_t &tr, int iTracerType ); + + virtual void GetToolRecordingState( KeyValues *msg ); + + virtual float GetPlayerMaxSpeed(); + + void SetAnimationExtension( const char *pExtension ); + + C_BaseViewModel *GetViewModel( int viewmodelindex = 0, bool bObserverOK=true ); + C_BaseCombatWeapon *GetActiveWeapon( void ) const; + const char *GetTracerType( void ); + + // View model prediction setup + virtual void CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov ); + virtual void CalcViewModelView( const Vector& eyeOrigin, const QAngle& eyeAngles); + + + // Handle view smoothing when going up stairs + void SmoothViewOnStairs( Vector& eyeOrigin ); + virtual float CalcRoll (const QAngle& angles, const Vector& velocity, float rollangle, float rollspeed); + void CalcViewRoll( QAngle& eyeAngles ); + void CreateWaterEffects( void ); + + virtual void SetPlayerUnderwater( bool state ); + void UpdateUnderwaterState( void ); + bool IsPlayerUnderwater( void ) { return m_bPlayerUnderwater; } + + virtual Vector Weapon_ShootPosition(); + virtual void Weapon_DropPrimary( void ) {} + + virtual Vector GetAutoaimVector( float flScale ); + void SetSuitUpdate(const char *name, int fgroup, int iNoRepeat); + + // Input handling + virtual bool CreateMove( float flInputSampleTime, CUserCmd *pCmd ); + virtual void AvoidPhysicsProps( CUserCmd *pCmd ); + + virtual void PlayerUse( void ); + CBaseEntity *FindUseEntity( void ); + virtual bool IsUseableEntity( CBaseEntity *pEntity, unsigned int requiredCaps ); + + // Data handlers + virtual bool IsPlayer( void ) const { return true; } + virtual int GetHealth() const { return m_iHealth; } + + int GetBonusProgress() const { return m_iBonusProgress; } + int GetBonusChallenge() const { return m_iBonusChallenge; } + + // observer mode + virtual int GetObserverMode() const; + void SetObserverMode ( int iNewMode ); + virtual CBaseEntity *GetObserverTarget() const; + void SetObserverTarget( EHANDLE hObserverTarget ); + + bool AudioStateIsUnderwater( Vector vecMainViewOrigin ); + + bool IsObserver() const; + bool IsHLTV() const; + bool IsReplay() const; + void ResetObserverMode(); + bool IsBot( void ) const { return false; } + + // Eye position.. + virtual Vector EyePosition(); + virtual const QAngle &EyeAngles(); // Direction of eyes + void EyePositionAndVectors( Vector *pPosition, Vector *pForward, Vector *pRight, Vector *pUp ); + virtual const QAngle &LocalEyeAngles(); // Direction of eyes + + // This can be overridden to return something other than m_pRagdoll if the mod uses separate + // entities for ragdolls. + virtual IRagdoll* GetRepresentativeRagdoll() const; + + // override the initial bone position for ragdolls + virtual bool GetRagdollInitBoneArrays( matrix3x4_t *pDeltaBones0, matrix3x4_t *pDeltaBones1, matrix3x4_t *pCurrentBones, float boneDt ) OVERRIDE; + + // Returns eye vectors + void EyeVectors( Vector *pForward, Vector *pRight = NULL, Vector *pUp = NULL ); + void CacheVehicleView( void ); // Calculate and cache the position of the player in the vehicle + + + bool IsSuitEquipped( void ) { return m_Local.m_bWearingSuit; }; + + // Team handlers + virtual void TeamChange( int iNewTeam ); + + // Flashlight + void Flashlight( void ); + void UpdateFlashlight( void ); + + // Weapon selection code + virtual bool IsAllowedToSwitchWeapons( void ) { return !IsObserver(); } + virtual C_BaseCombatWeapon *GetActiveWeaponForSelection( void ); + + // Returns the view model if this is the local player. If you're in third person or + // this is a remote player, it returns the active weapon + // (and its appropriate left/right weapon if this is TF2). + virtual C_BaseAnimating* GetRenderedWeaponModel(); + + virtual bool IsOverridingViewmodel( void ) { return false; }; + virtual int DrawOverriddenViewmodel( C_BaseViewModel *pViewmodel, int flags ) { return 0; }; + + virtual float GetDefaultAnimSpeed( void ) { return 1.0; } + + void SetMaxSpeed( float flMaxSpeed ) { m_flMaxspeed = flMaxSpeed; } + float MaxSpeed() const { return m_flMaxspeed; } + + // Should this object cast shadows? + virtual ShadowType_t ShadowCastType() { return SHADOWS_NONE; } + + virtual bool ShouldReceiveProjectedTextures( int flags ) + { + return false; + } + + + bool IsLocalPlayer( void ) const; + + // Global/static methods + virtual void ThirdPersonSwitch( bool bThirdperson ); + static bool LocalPlayerInFirstPersonView(); + static bool ShouldDrawLocalPlayer(); + static C_BasePlayer *GetLocalPlayer( void ); + int GetUserID( void ); + virtual bool CanSetSoundMixer( void ); + virtual int GetVisionFilterFlags( bool bWeaponsCheck = false ) { return 0x00; } + bool HasVisionFilterFlags( int nFlags, bool bWeaponsCheck = false ) { return ( GetVisionFilterFlags( bWeaponsCheck ) & nFlags ) == nFlags; } + virtual void CalculateVisionUsingCurrentFlags( void ) {} + void BuildFirstPersonMeathookTransformations( CStudioHdr *hdr, Vector *pos, Quaternion q[], const matrix3x4_t& cameraTransform, int boneMask, CBoneBitList &boneComputed, const char *pchHeadBoneName ); + + // Specific queries about this player. + bool InFirstPersonView(); + bool ShouldDrawThisPlayer(); + + // Called by the view model if its rendering is being overridden. + virtual bool ViewModel_IsTransparent( void ); + virtual bool ViewModel_IsUsingFBTexture( void ); + +#if !defined( NO_ENTITY_PREDICTION ) + void AddToPlayerSimulationList( C_BaseEntity *other ); + void SimulatePlayerSimulatedEntities( void ); + void RemoveFromPlayerSimulationList( C_BaseEntity *ent ); + void ClearPlayerSimulationList( void ); +#endif + + virtual void PhysicsSimulate( void ); + virtual unsigned int PhysicsSolidMaskForEntity( void ) const { return MASK_PLAYERSOLID; } + + // Prediction stuff + virtual bool ShouldPredict( void ); + + virtual void PreThink( void ); + virtual void PostThink( void ); + + virtual void ItemPreFrame( void ); + virtual void ItemPostFrame( void ); + virtual void AbortReload( void ); + + virtual void SelectLastItem(void); + virtual void Weapon_SetLast( C_BaseCombatWeapon *pWeapon ); + virtual bool Weapon_ShouldSetLast( C_BaseCombatWeapon *pOldWeapon, C_BaseCombatWeapon *pNewWeapon ) { return true; } + virtual bool Weapon_ShouldSelectItem( C_BaseCombatWeapon *pWeapon ); + virtual bool Weapon_Switch( C_BaseCombatWeapon *pWeapon, int viewmodelindex = 0 ); // Switch to given weapon if has ammo (false if failed) + virtual C_BaseCombatWeapon *GetLastWeapon( void ) { return m_hLastWeapon.Get(); } + void ResetAutoaim( void ); + virtual void SelectItem( const char *pstr, int iSubType = 0 ); + + virtual void UpdateClientData( void ); + + bool IsLerpingFOV( void ) const; + virtual float GetFOV( void ); + int GetDefaultFOV( void ) const; + virtual bool IsZoomed( void ) { return false; } + bool SetFOV( CBaseEntity *pRequester, int FOV, float zoomRate = 0.0f, int iZoomStart = 0 ); + void ClearZoomOwner( void ); + + float GetFOVDistanceAdjustFactor(); + + virtual void ViewPunch( const QAngle &angleOffset ); + void ViewPunchReset( float tolerance = 0 ); + + void UpdateButtonState( int nUserCmdButtonMask ); + int GetImpulse( void ) const; + + virtual void Simulate(); + + virtual bool ShouldInterpolate(); + + virtual bool ShouldDraw(); + virtual int DrawModel( int flags ); + + // Called when not in tactical mode. Allows view to be overriden for things like driving a tank. + virtual void OverrideView( CViewSetup *pSetup ); + + // returns the player name + const char * GetPlayerName(); + virtual const Vector GetPlayerMins( void ) const; // uses local player + virtual const Vector GetPlayerMaxs( void ) const; // uses local player + + // Is the player dead? + bool IsPlayerDead(); + bool IsPoisoned( void ) { return m_Local.m_bPoisoned; } + + C_BaseEntity *GetUseEntity(); + + // Vehicles... + IClientVehicle *GetVehicle(); + + bool IsInAVehicle() const { return ( NULL != m_hVehicle.Get() ) ? true : false; } + virtual void SetVehicleRole( int nRole ); + void LeaveVehicle( void ); + + bool UsingStandardWeaponsInVehicle( void ); + + virtual void SetAnimation( PLAYER_ANIM playerAnim ); + + float GetTimeBase( void ) const; + float GetFinalPredictedTime() const; + + bool IsInVGuiInputMode() const; + bool IsInViewModelVGuiInputMode() const; + + C_CommandContext *GetCommandContext(); + + // Get the command number associated with the current usercmd we're running (if in predicted code). + int CurrentCommandNumber() const; + const CUserCmd *GetCurrentUserCommand() const; + + const QAngle& GetPunchAngle(); + void SetPunchAngle( const QAngle &angle ); + + float GetWaterJumpTime() const; + void SetWaterJumpTime( float flWaterJumpTime ); + float GetSwimSoundTime( void ) const; + void SetSwimSoundTime( float flSwimSoundTime ); + + float GetDeathTime( void ) { return m_flDeathTime; } + + void SetPreviouslyPredictedOrigin( const Vector &vecAbsOrigin ); + const Vector &GetPreviouslyPredictedOrigin() const; + + // CS wants to allow small FOVs for zoomed-in AWPs. + virtual float GetMinFOV() const; + + virtual void DoMuzzleFlash(); + virtual void PlayPlayerJingle(); + + virtual void UpdateStepSound( surfacedata_t *psurface, const Vector &vecOrigin, const Vector &vecVelocity ); + virtual void PlayStepSound( Vector &vecOrigin, surfacedata_t *psurface, float fvol, bool force ); + virtual surfacedata_t * GetFootstepSurface( const Vector &origin, const char *surfaceName ); + virtual void GetStepSoundVelocities( float *velwalk, float *velrun ); + virtual void SetStepSoundTime( stepsoundtimes_t iStepSoundTime, bool bWalking ); + virtual const char *GetOverrideStepSound( const char *pszBaseStepSoundName ) { return pszBaseStepSoundName; } + + virtual void OnEmitFootstepSound( const CSoundParameters& params, const Vector& vecOrigin, float fVolume ) {} + + // Called by prediction when it detects a prediction correction. + // vDelta is the line from where the client had predicted the player to at the usercmd in question, + // to where the server says the client should be at said usercmd. + void NotePredictionError( const Vector &vDelta ); + + // Called by the renderer to apply the prediction error smoothing. + void GetPredictionErrorSmoothingVector( Vector &vOffset ); + + virtual void ExitLadder() {} + surfacedata_t *GetLadderSurface( const Vector &origin ); + + surfacedata_t *GetSurfaceData( void ) { return m_pSurfaceData; } + + void SetLadderNormal( Vector vecLadderNormal ) { m_vecLadderNormal = vecLadderNormal; } + + // Hints + virtual CHintSystem *Hints( void ) { return NULL; } + bool ShouldShowHints( void ) { return Hints() ? Hints()->ShouldShowHints() : false; } + bool HintMessage( int hint, bool bForce = false, bool bOnlyIfClear = false ) { return Hints() ? Hints()->HintMessage( hint, bForce, bOnlyIfClear ) : false; } + void HintMessage( const char *pMessage ) { if (Hints()) Hints()->HintMessage( pMessage ); } + + virtual IMaterial *GetHeadLabelMaterial( void ); + + // Fog + fogparams_t *GetFogParams( void ) { return &m_CurrentFog; } + void FogControllerChanged( bool bSnap ); + void UpdateFogController( void ); + void UpdateFogBlend( void ); + + float GetFOVTime( void ){ return m_flFOVTime; } + + virtual void OnAchievementAchieved( int iAchievement ) {} + + bool ShouldAnnounceAchievement( void ){ return m_flNextAchievementAnnounceTime < gpGlobals->curtime; } + void SetNextAchievementAnnounceTime( float flTime ){ m_flNextAchievementAnnounceTime = flTime; } + +#if defined USES_ECON_ITEMS + // Wearables + virtual void UpdateWearables(); + C_EconWearable *GetWearable( int i ) { return m_hMyWearables[i]; } + int GetNumWearables( void ) { return m_hMyWearables.Count(); } +#endif + + bool HasFiredWeapon( void ) { return m_bFiredWeapon; } + void SetFiredWeapon( bool bFlag ) { m_bFiredWeapon = bFlag; } + + virtual bool CanUseFirstPersonCommand( void ){ return true; } + +protected: + fogparams_t m_CurrentFog; + EHANDLE m_hOldFogController; + +public: + int m_StuckLast; + + // Data for only the local player + CNetworkVarEmbedded( CPlayerLocalData, m_Local ); + +#if defined USES_ECON_ITEMS + CNetworkVarEmbedded( CAttributeList, m_AttributeList ); +#endif + + // Data common to all other players, too + CPlayerState pl; + + // Player FOV values + int m_iFOV; // field of view + int m_iFOVStart; // starting value of the FOV changing over time (client only) + float m_flFOVTime; // starting time of the FOV zoom + int m_iDefaultFOV; // default FOV if no other zooms are occurring + EHANDLE m_hZoomOwner; // This is a pointer to the entity currently controlling the player's zoom + // Only this entity can change the zoom state once it has ownership + + // For weapon prediction + bool m_fOnTarget; //Is the crosshair on a target? + + char m_szAnimExtension[32]; + + int m_afButtonLast; + int m_afButtonPressed; + int m_afButtonReleased; + + int m_nButtons; + + CUserCmd *m_pCurrentCommand; + + // Movement constraints + EHANDLE m_hConstraintEntity; + Vector m_vecConstraintCenter; + float m_flConstraintRadius; + float m_flConstraintWidth; + float m_flConstraintSpeedFactor; + +protected: + + void CalcPlayerView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov ); + void CalcVehicleView(IClientVehicle *pVehicle, Vector& eyeOrigin, QAngle& eyeAngles, + float& zNear, float& zFar, float& fov ); + virtual void CalcObserverView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov ); + virtual Vector GetChaseCamViewOffset( CBaseEntity *target ); + void CalcChaseCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov ); + virtual void CalcInEyeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov ); + + virtual float GetDeathCamInterpolationTime(); + + virtual void CalcDeathCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov ); + void CalcRoamingView(Vector& eyeOrigin, QAngle& eyeAngles, float& fov); + virtual void CalcFreezeCamView( Vector& eyeOrigin, QAngle& eyeAngles, float& fov ); + + // Check to see if we're in vgui input mode... + void DetermineVguiInputMode( CUserCmd *pCmd ); + + // Used by prediction, sets the view angles for the player + virtual void SetLocalViewAngles( const QAngle &viewAngles ); + virtual void SetViewAngles( const QAngle& ang ); + + // used by client side player footsteps + surfacedata_t* GetGroundSurface(); + + virtual void FireGameEvent( IGameEvent *event ); + +protected: + // Did we just enter a vehicle this frame? + bool JustEnteredVehicle(); + +// DATA + int m_iObserverMode; // if in spectator mode != 0 + EHANDLE m_hObserverTarget; // current observer target + float m_flObserverChaseDistance; // last distance to observer traget + Vector m_vecFreezeFrameStart; + float m_flFreezeFrameStartTime; // Time at which we entered freeze frame observer mode + float m_flFreezeFrameDistance; + bool m_bWasFreezeFraming; + float m_flDeathTime; // last time player died + + float m_flStepSoundTime; + bool m_IsFootprintOnLeft; + +private: + // Make sure no one calls this... + C_BasePlayer& operator=( const C_BasePlayer& src ); + C_BasePlayer( const C_BasePlayer & ); // not defined, not accessible + + // Vehicle stuff. + EHANDLE m_hVehicle; + EHANDLE m_hOldVehicle; + EHANDLE m_hUseEntity; + + float m_flMaxspeed; + + int m_iBonusProgress; + int m_iBonusChallenge; + + CInterpolatedVar< Vector > m_iv_vecViewOffset; + + // Not replicated + Vector m_vecWaterJumpVel; + float m_flWaterJumpTime; // used to be called teleport_time + int m_nImpulse; + + float m_flSwimSoundTime; + Vector m_vecLadderNormal; + + QAngle m_vecOldViewAngles; + + bool m_bWasFrozen; + int m_flPhysics; + + int m_nTickBase; + int m_nFinalPredictedTick; + + EHANDLE m_pCurrentVguiScreen; + + bool m_bFiredWeapon; + + + // Player flashlight dynamic light pointers + CFlashlightEffect *m_pFlashlight; + + typedef CHandle<C_BaseCombatWeapon> CBaseCombatWeaponHandle; + CNetworkVar( CBaseCombatWeaponHandle, m_hLastWeapon ); + +#if !defined( NO_ENTITY_PREDICTION ) + CUtlVector< CHandle< C_BaseEntity > > m_SimulatedByThisPlayer; +#endif + + // players own view models, left & right hand + CHandle< C_BaseViewModel > m_hViewModel[ MAX_VIEWMODELS ]; + + float m_flOldPlayerZ; + float m_flOldPlayerViewOffsetZ; + + Vector m_vecVehicleViewOrigin; // Used to store the calculated view of the player while riding in a vehicle + QAngle m_vecVehicleViewAngles; // Vehicle angles + float m_flVehicleViewFOV; + int m_nVehicleViewSavedFrame; // Used to mark which frame was the last one the view was calculated for + + // For UI purposes... + int m_iOldAmmo[ MAX_AMMO_TYPES ]; + + C_CommandContext m_CommandContext; + + // For underwater effects + float m_flWaterSurfaceZ; + bool m_bResampleWaterSurface; + TimedEvent m_tWaterParticleTimer; + CSmartPtr<WaterDebrisEffect> m_pWaterEmitter; + + bool m_bPlayerUnderwater; + + friend class CPrediction; + + // HACK FOR TF2 Prediction + friend class CTFGameMovementRecon; + friend class CGameMovement; + friend class CTFGameMovement; + friend class CHL1GameMovement; + friend class CCSGameMovement; + friend class CHL2GameMovement; + friend class CDODGameMovement; + friend class CPortalGameMovement; + + // Accessors for gamemovement + float GetStepSize( void ) const { return m_Local.m_flStepSize; } + + float m_flNextAvoidanceTime; + float m_flAvoidanceRight; + float m_flAvoidanceForward; + float m_flAvoidanceDotForward; + float m_flAvoidanceDotRight; + +protected: + virtual bool IsDucked( void ) const { return m_Local.m_bDucked; } + virtual bool IsDucking( void ) const { return m_Local.m_bDucking; } + virtual float GetFallVelocity( void ) { return m_Local.m_flFallVelocity; } + bool ForceSetupBonesAtTimeFakeInterpolation( matrix3x4_t *pBonesOut, float curtimeOffset ); + + float m_flLaggedMovementValue; + + // These are used to smooth out prediction corrections. They're most useful when colliding with + // vphysics objects. The server will be sending constant prediction corrections, and these can help + // the errors not be so jerky. + Vector m_vecPredictionError; + float m_flPredictionErrorTime; + + Vector m_vecPreviouslyPredictedOrigin; // Used to determine if non-gamemovement game code has teleported, or tweaked the player's origin + + char m_szLastPlaceName[MAX_PLACE_NAME_LENGTH]; // received from the server + + // Texture names and surface data, used by CGameMovement + int m_surfaceProps; + surfacedata_t* m_pSurfaceData; + float m_surfaceFriction; + char m_chTextureType; + + bool m_bSentFreezeFrame; + float m_flFreezeZOffset; + + float m_flNextAchievementAnnounceTime; + + int m_nForceVisionFilterFlags; // Force our vision filter to a specific setting + int m_nLocalPlayerVisionFlags; + +#if defined USES_ECON_ITEMS + // Wearables + CUtlVector<CHandle<C_EconWearable > > m_hMyWearables; +#endif + +private: + + struct StepSoundCache_t + { + StepSoundCache_t() : m_usSoundNameIndex( 0 ) {} + CSoundParameters m_SoundParameters; + unsigned short m_usSoundNameIndex; + }; + // One for left and one for right side of step + StepSoundCache_t m_StepSoundCache[ 2 ]; + +public: + + const char *GetLastKnownPlaceName( void ) const { return m_szLastPlaceName; } // return the last nav place name the player occupied + + float GetLaggedMovementValue( void ){ return m_flLaggedMovementValue; } + bool ShouldGoSouth( Vector vNPCForward, Vector vNPCRight ); //Such a bad name. + + void SetOldPlayerZ( float flOld ) { m_flOldPlayerZ = flOld; } +}; + +EXTERN_RECV_TABLE(DT_BasePlayer); + +//----------------------------------------------------------------------------- +// Inline methods +//----------------------------------------------------------------------------- +inline C_BasePlayer *ToBasePlayer( C_BaseEntity *pEntity ) +{ + if ( !pEntity || !pEntity->IsPlayer() ) + return NULL; + +#if _DEBUG + Assert( dynamic_cast<C_BasePlayer *>( pEntity ) != NULL ); +#endif + + return static_cast<C_BasePlayer *>( pEntity ); +} + +inline C_BaseEntity *C_BasePlayer::GetUseEntity() +{ + return m_hUseEntity; +} + + +inline IClientVehicle *C_BasePlayer::GetVehicle() +{ + C_BaseEntity *pVehicleEnt = m_hVehicle.Get(); + return pVehicleEnt ? pVehicleEnt->GetClientVehicle() : NULL; +} + +inline bool C_BasePlayer::IsObserver() const +{ + return (GetObserverMode() != OBS_MODE_NONE); +} + +inline int C_BasePlayer::GetImpulse( void ) const +{ + return m_nImpulse; +} + + +inline C_CommandContext* C_BasePlayer::GetCommandContext() +{ + return &m_CommandContext; +} + +inline int CBasePlayer::CurrentCommandNumber() const +{ + Assert( m_pCurrentCommand ); + return m_pCurrentCommand->command_number; +} + +inline const CUserCmd *CBasePlayer::GetCurrentUserCommand() const +{ + Assert( m_pCurrentCommand ); + return m_pCurrentCommand; +} + +#endif // C_BASEPLAYER_H |