diff options
Diffstat (limited to 'mp/src/game/shared/gamemovement.h')
| -rw-r--r-- | mp/src/game/shared/gamemovement.h | 291 |
1 files changed, 291 insertions, 0 deletions
diff --git a/mp/src/game/shared/gamemovement.h b/mp/src/game/shared/gamemovement.h new file mode 100644 index 00000000..e1b6f88c --- /dev/null +++ b/mp/src/game/shared/gamemovement.h @@ -0,0 +1,291 @@ +//========= Copyright Valve Corporation, All rights reserved. ============//
+//
+// Purpose:
+//
+// $Workfile: $
+// $Date: $
+// $NoKeywords: $
+//=============================================================================//
+#if !defined( GAMEMOVEMENT_H )
+#define GAMEMOVEMENT_H
+#ifdef _WIN32
+#pragma once
+#endif
+
+#include "igamemovement.h"
+#include "cmodel.h"
+#include "tier0/vprof.h"
+
+#define CTEXTURESMAX 512 // max number of textures loaded
+#define CBTEXTURENAMEMAX 13 // only load first n chars of name
+
+#define GAMEMOVEMENT_DUCK_TIME 1000.0f // ms
+#define GAMEMOVEMENT_JUMP_TIME 510.0f // ms approx - based on the 21 unit height jump
+#define GAMEMOVEMENT_JUMP_HEIGHT 21.0f // units
+#define GAMEMOVEMENT_TIME_TO_UNDUCK ( TIME_TO_UNDUCK * 1000.0f ) // ms
+#define GAMEMOVEMENT_TIME_TO_UNDUCK_INV ( GAMEMOVEMENT_DUCK_TIME - GAMEMOVEMENT_TIME_TO_UNDUCK )
+
+enum
+{
+ SPEED_CROPPED_RESET = 0,
+ SPEED_CROPPED_DUCK = 1,
+ SPEED_CROPPED_WEAPON = 2,
+};
+
+struct surfacedata_t;
+
+class CBasePlayer;
+
+class CGameMovement : public IGameMovement
+{
+public:
+ DECLARE_CLASS_NOBASE( CGameMovement );
+
+ CGameMovement( void );
+ virtual ~CGameMovement( void );
+
+ virtual void ProcessMovement( CBasePlayer *pPlayer, CMoveData *pMove );
+
+ virtual void StartTrackPredictionErrors( CBasePlayer *pPlayer );
+ virtual void FinishTrackPredictionErrors( CBasePlayer *pPlayer );
+ virtual void DiffPrint( PRINTF_FORMAT_STRING char const *fmt, ... );
+ virtual Vector GetPlayerMins( bool ducked ) const;
+ virtual Vector GetPlayerMaxs( bool ducked ) const;
+ virtual Vector GetPlayerViewOffset( bool ducked ) const;
+
+// For sanity checking getting stuck on CMoveData::SetAbsOrigin
+ virtual void TracePlayerBBox( const Vector& start, const Vector& end, unsigned int fMask, int collisionGroup, trace_t& pm );
+
+ // allows derived classes to exclude entities from trace
+ virtual void TryTouchGround( const Vector& start, const Vector& end, const Vector& mins, const Vector& maxs, unsigned int fMask, int collisionGroup, trace_t& pm );
+
+
+#define BRUSH_ONLY true
+ virtual unsigned int PlayerSolidMask( bool brushOnly = false ); ///< returns the solid mask for the given player, so bots can have a more-restrictive set
+ CBasePlayer *player;
+ CMoveData *GetMoveData() { return mv; }
+protected:
+ // Input/Output for this movement
+ CMoveData *mv;
+
+ int m_nOldWaterLevel;
+ float m_flWaterEntryTime;
+ int m_nOnLadder;
+
+ Vector m_vecForward;
+ Vector m_vecRight;
+ Vector m_vecUp;
+
+
+ // Does most of the player movement logic.
+ // Returns with origin, angles, and velocity modified in place.
+ // were contacted during the move.
+ virtual void PlayerMove( void );
+
+ // Set ground data, etc.
+ void FinishMove( void );
+
+ virtual float CalcRoll( const QAngle &angles, const Vector &velocity, float rollangle, float rollspeed );
+
+ virtual void DecayPunchAngle( void );
+
+ virtual void CheckWaterJump(void );
+
+ virtual void WaterMove( void );
+
+ void WaterJump( void );
+
+ // Handles both ground friction and water friction
+ void Friction( void );
+
+ virtual void AirAccelerate( Vector& wishdir, float wishspeed, float accel );
+
+ virtual void AirMove( void );
+ virtual float GetAirSpeedCap( void ) { return 30.f; }
+
+ virtual bool CanAccelerate();
+ virtual void Accelerate( Vector& wishdir, float wishspeed, float accel);
+
+ // Only used by players. Moves along the ground when player is a MOVETYPE_WALK.
+ virtual void WalkMove( void );
+
+ // Try to keep a walking player on the ground when running down slopes etc
+ void StayOnGround( void );
+
+ // Handle MOVETYPE_WALK.
+ virtual void FullWalkMove();
+
+ // allow overridden versions to respond to jumping
+ virtual void OnJump( float fImpulse ) {}
+ virtual void OnLand( float fVelocity ) {}
+
+ // Implement this if you want to know when the player collides during OnPlayerMove
+ virtual void OnTryPlayerMoveCollision( trace_t &tr ) {}
+
+ virtual Vector GetPlayerMins( void ) const; // uses local player
+ virtual Vector GetPlayerMaxs( void ) const; // uses local player
+
+ typedef enum
+ {
+ GROUND = 0,
+ STUCK,
+ LADDER
+ } IntervalType_t;
+
+ virtual int GetCheckInterval( IntervalType_t type );
+
+ // Useful for things that happen periodically. This lets things happen on the specified interval, but
+ // spaces the events onto different frames for different players so they don't all hit their spikes
+ // simultaneously.
+ bool CheckInterval( IntervalType_t type );
+
+
+ // Decompoosed gravity
+ void StartGravity( void );
+ void FinishGravity( void );
+
+ // Apply normal ( undecomposed ) gravity
+ void AddGravity( void );
+
+ // Handle movement in noclip mode.
+ void FullNoClipMove( float factor, float maxacceleration );
+
+ // Returns true if he started a jump (ie: should he play the jump animation)?
+ virtual bool CheckJumpButton( void ); // Overridden by each game.
+
+ // Dead player flying through air., e.g.
+ virtual void FullTossMove( void );
+
+ // Player is a Observer chasing another player
+ void FullObserverMove( void );
+
+ // Handle movement when in MOVETYPE_LADDER mode.
+ virtual void FullLadderMove();
+
+ // The basic solid body movement clip that slides along multiple planes
+ virtual int TryPlayerMove( Vector *pFirstDest=NULL, trace_t *pFirstTrace=NULL );
+
+ virtual bool LadderMove( void );
+ virtual bool OnLadder( trace_t &trace );
+ virtual float LadderDistance( void ) const { return 2.0f; } ///< Returns the distance a player can be from a ladder and still attach to it
+ virtual unsigned int LadderMask( void ) const { return MASK_PLAYERSOLID; }
+ virtual float ClimbSpeed( void ) const { return MAX_CLIMB_SPEED; }
+ virtual float LadderLateralMultiplier( void ) const { return 1.0f; }
+
+ // See if the player has a bogus velocity value.
+ void CheckVelocity( void );
+
+ // Does not change the entities velocity at all
+ void PushEntity( Vector& push, trace_t *pTrace );
+
+ // Slide off of the impacting object
+ // returns the blocked flags:
+ // 0x01 == floor
+ // 0x02 == step / wall
+ int ClipVelocity( Vector& in, Vector& normal, Vector& out, float overbounce );
+
+ // If pmove.origin is in a solid position,
+ // try nudging slightly on all axis to
+ // allow for the cut precision of the net coordinates
+ virtual int CheckStuck( void );
+
+ // Check if the point is in water.
+ // Sets refWaterLevel and refWaterType appropriately.
+ // If in water, applies current to baseVelocity, and returns true.
+ virtual bool CheckWater( void );
+
+ // Determine if player is in water, on ground, etc.
+ virtual void CategorizePosition( void );
+
+ virtual void CheckParameters( void );
+
+ virtual void ReduceTimers( void );
+
+ virtual void CheckFalling( void );
+
+ virtual void PlayerRoughLandingEffects( float fvol );
+
+ void PlayerWaterSounds( void );
+
+ void ResetGetPointContentsCache();
+ int GetPointContentsCached( const Vector &point, int slot );
+
+ // Ducking
+ virtual void Duck( void );
+ virtual void HandleDuckingSpeedCrop();
+ virtual void FinishUnDuck( void );
+ virtual void FinishDuck( void );
+ virtual bool CanUnduck();
+ void UpdateDuckJumpEyeOffset( void );
+ bool CanUnDuckJump( trace_t &trace );
+ void StartUnDuckJump( void );
+ void FinishUnDuckJump( trace_t &trace );
+ void SetDuckedEyeOffset( float duckFraction );
+ void FixPlayerCrouchStuck( bool moveup );
+
+ float SplineFraction( float value, float scale );
+
+ void CategorizeGroundSurface( trace_t &pm );
+
+ bool InWater( void );
+
+ // Commander view movement
+ void IsometricMove( void );
+
+ // Traces the player bbox as it is swept from start to end
+ virtual CBaseHandle TestPlayerPosition( const Vector& pos, int collisionGroup, trace_t& pm );
+
+ // Checks to see if we should actually jump
+ void PlaySwimSound();
+
+ bool IsDead( void ) const;
+
+ // Figures out how the constraint should slow us down
+ float ComputeConstraintSpeedFactor( void );
+
+ virtual void SetGroundEntity( trace_t *pm );
+
+ virtual void StepMove( Vector &vecDestination, trace_t &trace );
+
+ // when we step on ground that's too steep, search to see if there's any ground nearby that isn't too steep
+ void TryTouchGroundInQuadrants( const Vector& start, const Vector& end, unsigned int fMask, int collisionGroup, trace_t& pm );
+
+
+protected:
+
+ // Performs the collision resolution for fliers.
+ void PerformFlyCollisionResolution( trace_t &pm, Vector &move );
+
+ virtual bool GameHasLadders() const;
+
+ enum
+ {
+ // eyes, waist, feet points (since they are all deterministic
+ MAX_PC_CACHE_SLOTS = 3,
+ };
+
+ // Cache used to remove redundant calls to GetPointContents().
+ int m_CachedGetPointContents[ MAX_PLAYERS ][ MAX_PC_CACHE_SLOTS ];
+ Vector m_CachedGetPointContentsPoint[ MAX_PLAYERS ][ MAX_PC_CACHE_SLOTS ];
+
+ Vector m_vecProximityMins; // Used to be globals in sv_user.cpp.
+ Vector m_vecProximityMaxs;
+
+ float m_fFrameTime;
+
+//private:
+ int m_iSpeedCropped;
+
+ float m_flStuckCheckTime[MAX_PLAYERS+1][2]; // Last time we did a full test
+
+ // special function for teleport-with-duck for episodic
+#ifdef HL2_EPISODIC
+public:
+ void ForceDuck( void );
+
+#endif
+};
+
+
+
+#endif // GAMEMOVEMENT_H
|