301 lines
9.5 KiB
C++
301 lines
9.5 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
// $Workfile: $
|
|
// $Date: $
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#if !defined(GAMEMOVEMENT_H)
|
|
#define GAMEMOVEMENT_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "cmodel.h"
|
|
#include "igamemovement.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
|