//========= 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