diff options
Diffstat (limited to 'mp/src/game/client/c_baseplayer.h')
| -rw-r--r-- | mp/src/game/client/c_baseplayer.h | 694 |
1 files changed, 694 insertions, 0 deletions
diff --git a/mp/src/game/client/c_baseplayer.h b/mp/src/game/client/c_baseplayer.h new file mode 100644 index 00000000..1e60f827 --- /dev/null +++ b/mp/src/game/client/c_baseplayer.h @@ -0,0 +1,694 @@ +//========= 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"
+
+#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:
+ 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 void GetRagdollInitBoneArrays( matrix3x4_t *pDeltaBones0, matrix3x4_t *pDeltaBones1, matrix3x4_t *pCurrentBones, float boneDt );
+
+ // 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 );
+
+ 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
+ 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();
+
+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; }
+ void 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
+
+#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
|