PlayerMovement.cs

using System.Collections;
using UnityEngine;
using DG.Tweening;
using FishNet.Connection;
using FishNet.Object;
using FishNet.Managing.Timing;
using FishNet.Object.Prediction;
using FishNet.Transporting;

/*
*
* See TransformPrediction.cs for more detailed notes.
*
*/

[RequireComponent(typeof(Rigidbody))]
public class PlayerMovement : NetworkBehaviour
{
    #region delegates
    public delegate void OnLand();
    public static event OnLand onLand;

    public delegate void OnAirborne();
    public static event OnAirborne onAirborne;

    public delegate void OnCrouch();
    public static event OnCrouch onCrouch;

    public delegate void OnUncrouch();
    public static event OnUncrouch onUncrouch;

    public delegate void OnJump();
    public static event OnJump onJump;
    #endregion

    #region values
    [ReadOnlyInspector] public bool isSliding;
    [ReadOnlyInspector] public bool isVaulting;
    [ReadOnlyInspector] public bool isCrouching;
    [ReadOnlyInspector] public bool isStepping;

    [Header("Input")]
    [SerializeField] private KeyCode _jumpKey = KeyCode.Space;
    [SerializeField] private KeyCode _sprintKey = KeyCode.LeftShift;
    [SerializeField] private KeyCode _crouchKey = KeyCode.C;
    [SerializeField] private KeyCode _vaultKey = KeyCode.Space;

    [Header("References")]
    [SerializeField] private StaminaSystem _staminaSystem;
    [SerializeField] private PlayerStateManager _playerStateManager;
    [SerializeField] private Transform _orientation;

    [Header("Movement")]
    [SerializeField] private float _walkSpeed = 1.75f;
    [SerializeField] private float _sprintSpeed = 5f;
    [SerializeField] private float _crouchSpeed = 0.75f;
    [SerializeField] private float _groundDrag = 5f;
    [SerializeField] private float _airSpeed = 3.5f;
    [SerializeField] private float _lerpGroundSpeedRate = 3f;
    [SerializeField] private float _lerpCrouchSpeedRate = 10f;
    [SerializeField] private float _lerpSprintSpeedRate = 10f;
    [HideInInspector] public Vector3 moveDirection;

    [Header("Sliding")]
    [SerializeField] private float _slideSpeed = 20f;
    [SerializeField] private float _slideSpeedMultiplier = 0.15f;
    [SerializeField] private float _speedIncreaseSlideTimeMultiplier = 1.5f;
    [SerializeField] private float _slopeIncreaseSlideTimeMultiplier = 2.75f;

    [Header("Ground Check")]
    [SerializeField] private LayerMask _groundMask;
    [SerializeField] private float _groundCheckRadius = 0.2f;
    [HideInInspector] public bool isGrounded;

    [Header("Slopes")]
    [SerializeField] private float _maxSlopeAngle = 40f;
    [SerializeField] private float _exitSlopeDownwardForce = 2f;
    [SerializeField] private float _minYVelocityToApplyDownwardForce = 0.1f;

    [Header("Jump/Airborne")]
    [SerializeField] private float _jumpForce = 8f;
    [SerializeField] private float _jumpCooldown = 0.25f;
    [SerializeField] private float _airControlMultiplier = 0.05f;
    [SerializeField] private float _fallDistanceRequiredToShake = 0.525f;
    [SerializeField] private float _jumpKeyStayPressedTime = 0.05f;
    [SerializeField] private float _minAirMagnitude = 1.5f;
    [HideInInspector] public bool readyToJump;

    [Header("Crouch")]
    [SerializeField] private HeadCheck _headCheck;
    [SerializeField] private float _crouchHeight = 0.6f;
    [SerializeField, Range(0f, 0.5f)] private float _crouchDownDuration = 0.35f;
    [SerializeField, Range(0f, 0.5f)] private float _crouchUpDuration = 0.25f;
    [HideInInspector] public Tween crouchTween;


    #endregion

    #region private
    private Rigidbody _rigidbody;
    private RaycastHit _slopeHit;

    private float _desiredMoveSpeed;
    private float _lastDesiredMoveSpeed;
    private float _speedMultiplier;
    private float _startYPosition;
    private float _moveSpeed;
    private float _currentWalkSpeed;
    private float _currentCrouchSpeed;
    private float _currentSprintSpeed;
    private float _airborneYPosition;
    private float _airborneHighestYPosition;
    private float _velocityWhenLeftGround;
    private float _startHeight;

    private bool _exitingSlope;
    private bool _boostedSlowDown;
    private bool _sprintFOVEnabled;
    private bool _downwardForceApplied = true;
    private bool _keepMomentum;
    private bool _canSprint = true;

    private Vaulting _vaultingReference;
    private Sliding _slidingReference;
    private CameraLook _cameraLookReference;
    #endregion

    #region movestate
    [ReadOnlyInspector] public MovementState _movementState;
    public enum MovementState
    {
        walking,
        sprinting,
        sliding,
        vaulting,
        airborne,
        crouching
    }
    #endregion


    #region network data
    public struct MoveData : IReplicateData
    {
        public float Horizontal;
        public float Vertical;
        public bool VaultHeld;
        public bool Jumped;
        public bool CrouchPressed;
        public bool CrouchHeld;
        public bool CrouchReleased;
        public bool SprintPressed;
        public bool SprintReleased;
        public bool SprintHeld;
        public Quaternion OrientationRotation;
        public MoveData(float horizontal, float vertical, bool vaultHeld, bool jump, bool crouchPressed, bool crouchHeld, bool crouchReleased, bool sprintPressed, bool sprintReleased, bool sprintHeld, Quaternion orientationRotation)
        {
            Horizontal = horizontal;
            Vertical = vertical;
            VaultHeld = vaultHeld;
            Jumped = jump;
            CrouchPressed = crouchPressed;
            CrouchHeld = crouchHeld;
            CrouchReleased = crouchReleased;
            SprintPressed = sprintPressed;
            SprintReleased = sprintReleased;
            SprintHeld = sprintHeld;
            OrientationRotation = orientationRotation;
            _tick = 0;
        }
        public void Dispose() { }
        private uint _tick;

        public uint GetTick() => _tick;
        public void SetTick(uint value) => _tick = value;

    }
    public struct ReconcileData : IReconcileData
    {
        public Vector3 Position;
        public Quaternion Rotation;
        public Quaternion OrientationRotation;
        public Vector3 Velocity;
        public Vector3 AngularVelocity;
        public MovementState MoveState;
        public bool IsVaulting;
        public bool IsSliding;
        public bool IsCrouching;
        public bool IsStepping;
        public bool IsGrounded;
        public bool ReadyToJump;
        public ReconcileData(Vector3 position, Quaternion rotation, Quaternion orientationRotation, Vector3 velocity, Vector3 angularVelocity,
            MovementState moveState, bool isVaulting, bool isSliding, bool isCrouching, bool isStepping, bool isGrounded, bool readyToJump)
        {
            Position = position;
            Rotation = rotation;
            OrientationRotation = orientationRotation;
            Velocity = velocity;
            AngularVelocity = angularVelocity;
            MoveState = moveState;
            IsVaulting = isVaulting;
            IsSliding = isSliding;
            IsCrouching = isCrouching;
            IsStepping = isStepping;
            IsGrounded = isGrounded;
            ReadyToJump = readyToJump;
            _tick = 0;
        }

        private uint _tick;
        public void Dispose() { }
        public uint GetTick() => _tick;
        public void SetTick(uint value) => _tick = value;

    }
    private bool _vaultHeld = false;
    private bool _jumpQueued = false;
    private bool _crouchPressed = false;
    private bool _crouchHeld = false;
    private bool _crouchReleased = false;
    private bool _sprintPressed = false;
    private bool _sprintReleased = false;
    private bool _sprintHeld = false;

    #endregion

    [SerializeField]
    private float _moveRate = 15f;

    #region unity methods
    private void OnEnable()
    {
        PlayerLifeSystem.onKillPlayer += KillPlayer;
    }
    private void OnDisable()
    {
        PlayerLifeSystem.onKillPlayer -= KillPlayer;
    }
    private void Start()
    {
        _rigidbody.freezeRotation = true;
        _startHeight = transform.localScale.y;
        _startYPosition = transform.position.y;
        readyToJump = true;
        //We need to do this in start as well
        _rigidbody.isKinematic = false;
    }

    private void LateUpdate()
    {
        //if player movement not locked, update look direction
        if (_playerStateManager.playerState != PlayerStateManager.PlayerState.MovementDisabled && base.IsOwner)
            _cameraLookReference.Look();
    }
    private void Update()
    {

        SpeedControl();
        LerpGroundSpeed();
        LerpCrouchSpeed();
        LerpSprintSpeed();
        //set drag when on ground to make it grippier
        if (isGrounded)
            _rigidbody.drag = _groundDrag;
        else
            _rigidbody.drag = 0f;

        if (base.IsOwner)
        {
            _vaultHeld = Input.GetKey(_vaultKey);
            _crouchHeld = Input.GetKey(_crouchKey);
            _sprintHeld = Input.GetKey(_sprintKey);

            if (Input.GetKeyDown(_jumpKey))
            {
                _jumpQueued = true;
            }
            if (Input.GetKeyDown(_crouchKey))
            {
                _crouchPressed = true;
                _crouchReleased = false;
            }
            if (Input.GetKeyUp(_crouchKey))
            {
                _crouchReleased = true;
                _crouchPressed = false;
                _crouchHeld = false;
            }
            if (Input.GetKeyDown(_sprintKey))
            {
                _sprintPressed = true;
                _sprintReleased = false;
            }
            if (Input.GetKeyUp(_sprintKey))
            {
                _sprintReleased = true;
                _sprintPressed = false;
                _sprintHeld = false;
            }
        }

    }
    #endregion

    #region network methods
    public override void OnStopNetwork()
    {
        if (base.TimeManager != null)
        {
            base.TimeManager.OnTick -= TimeManager_OnTick;
            base.TimeManager.OnPostTick -= TimeManager_OnPostTick;
        }
    }
    public override void OnStartNetwork()
    {
        _playerStateManager = GetComponent<PlayerStateManager>();
        _rigidbody = GetComponent<Rigidbody>();
        _rigidbody.isKinematic = false;
        _vaultingReference = GetComponent<Vaulting>();
        _slidingReference = GetComponent<Sliding>();
        _cameraLookReference = GetComponent<CameraLook>();
        base.TimeManager.OnTick += TimeManager_OnTick;
        base.TimeManager.OnPostTick += TimeManager_OnPostTick;
    }
    #endregion


    private void TimeManager_OnTick()
    {


        //update highest point reached in air
        if (!isGrounded && transform.position.y > _airborneHighestYPosition)
            _airborneHighestYPosition = transform.position.y;

        GroundCheck();

        if (_playerStateManager.playerState != PlayerStateManager.PlayerState.MovementDisabled)
        {
            Move(BuildMoveData());
        }
        else
        {
            _jumpQueued = false; //prevents unwanted jumping after disabling/reenabling movement (ie: after vaulting)
        }
    }

    private MoveData BuildMoveData()
    {
        if (!base.IsOwner)
            return default;
        float _horizontal = Input.GetAxisRaw("Horizontal");
        float _vertical = Input.GetAxisRaw("Vertical");
        Quaternion _orientationRotation = _cameraLookReference.GetOrientationRotation();
        MoveData md = new MoveData
        {
            Horizontal = _horizontal,
            Vertical = _vertical,
            VaultHeld = _vaultHeld,
            Jumped = _jumpQueued,
            CrouchPressed = _crouchPressed,
            CrouchHeld = _crouchHeld,
            CrouchReleased = _crouchReleased,
            SprintPressed = _sprintPressed,
            SprintReleased = _sprintReleased,
            SprintHeld = _sprintHeld,
            OrientationRotation = _orientationRotation
        };

        _jumpQueued = false;
        _sprintPressed = false;
        _sprintReleased = false;
        _crouchPressed = false;
        //_crouchHeld = false;
        _crouchReleased = false;
        //_sprintHeld = false;
        //_vaultHeld = false;
        return md;
    }

    private MoveData? _lastMoveData;

    [ReplicateV2]
    private void Move(MoveData data, ReplicateState state = ReplicateState.Invalid, Channel channel = Channel.Unreliable)
    {

        #region fishnet magic
        if (state == ReplicateState.Predicted && _lastMoveData.HasValue)
        {
            MoveData lastMd = _lastMoveData.Value;
            lastMd.Horizontal *= 0.9f;
            /* The tick will increase even if the data is unset.
             * Cache the tick, set md to last data, then reapply the tick. */
            uint tick = data.GetTick();
            data = lastMd;
            data.SetTick(tick);
            _lastMoveData = lastMd;
        }
        else if (state == ReplicateState.UserCreated && !base.IsOwner && !base.IsServer)
        {
            _lastMoveData = data;
        }
        #endregion

        #region look syncing for server
        if (base.IsServer)
        {
            _cameraLookReference.SetOrientationRotation(data.OrientationRotation);
        }
        #endregion

        #region movement
        _vaultingReference.SetVaultingKeyInput(data.VaultHeld);
        _slidingReference.SetValuesFromMoveData(data.CrouchPressed, data.CrouchHeld, data.Horizontal, data.Vertical);
        //get movement vector
        moveDirection = _orientation.forward * data.Vertical + _orientation.right * data.Horizontal;

        if (data.SprintReleased)
            _canSprint = true;
        if (data.SprintPressed && !isSliding)
            _canSprint = true;

        //allows for player to jump if they pressed key right before hitting ground
        //keeps key pressed for certain amount of time

        if (data.Jumped)
        {
            if (isCrouching && _headCheck.canStand)
                EndCrouch();

            else if(CanJump())
            {
                readyToJump = false;

                Jump();
                Invoke(nameof(ResetJump), _jumpCooldown);
            }
        }
        if (data.CrouchPressed)
        {
           if (CanCrouch() && !isCrouching)
            {
                StartCrouch();
                _currentCrouchSpeed = _crouchSpeed;
            }

            else if (_headCheck.canStand && isCrouching)
                EndCrouch();
        }
        #endregion

        #region non-input movement
        //adjust speed to give player less control when sliding
        if (isSliding && _rigidbody.velocity.y < 0.1f)
            _speedMultiplier = _slideSpeedMultiplier;
        else if (isSliding && _rigidbody.velocity.y >= 0.1f)
            _speedMultiplier = 0f;
        else
            _speedMultiplier = 1f;

        //if on slope, move along slope
        if (isGrounded && OnSlope() && !_exitingSlope)
        {
            _downwardForceApplied = false;
            _rigidbody.AddForce(GetSlopeMoveDirection(moveDirection) * _moveSpeed * 10f * _speedMultiplier, ForceMode.Force);

            //apply downforce to keep player on ground if traveling down slope
            if (moveDirection != Vector3.zero && !isStepping && _rigidbody.velocity.y < -_minYVelocityToApplyDownwardForce)
                _rigidbody.AddForce(Vector3.down * 50f, ForceMode.Force);
        }
        //if going from uphill to not uphill surface, push player down to prevent unwanted ungrounding
        if (!OnSlope() && isGrounded && _rigidbody.velocity.y > 0.01f && _rigidbody.velocity.y < 5f && !_exitingSlope && !_downwardForceApplied && !isStepping)
        {
            _downwardForceApplied = true;
            _rigidbody.AddForce(Vector3.down * _exitSlopeDownwardForce, ForceMode.VelocityChange);
        }
        //if on normal ground, move normally
        else if (isGrounded && !OnSteepSlope())
            _rigidbody.AddForce(moveDirection.normalized * _moveSpeed * 10f * _speedMultiplier, ForceMode.Force);

        //if in air or on too steep of surface
        else if (!isGrounded || OnSteepSlope())
        {
            //move normally but with lower amount of control
            _rigidbody.AddForce(moveDirection.normalized * _moveSpeed * 10f * _airControlMultiplier, ForceMode.Force);

            //limit max speed to speed player was at when they went airborne
            Vector3 flatVel = new Vector3(_rigidbody.velocity.x, 0f, _rigidbody.velocity.z);
            _rigidbody.velocity = Vector3.ClampMagnitude(flatVel, _velocityWhenLeftGround < _minAirMagnitude ? _minAirMagnitude : _velocityWhenLeftGround) + Vector3.up * _rigidbody.velocity.y;

            //push player down steep slopes
            if (OnSteepSlope())
                _rigidbody.AddForce(Vector3.down * 50f, ForceMode.Force);
        }

        //disable gravity if on slope (prevents sliding down) or grounded or not stepping
        if ((!isGrounded || !OnSlope()) && !isStepping)
            _rigidbody.useGravity = true;
        else
            _rigidbody.useGravity = false;


        #endregion

        #region state handling
        if (isVaulting)
            _movementState = MovementState.vaulting;
        else if (isSliding)
        {
            _movementState = MovementState.sliding;
            _currentCrouchSpeed = _slideSpeed;
            _canSprint = false;

            //if sliding down slope
            if (OnSlope() && _rigidbody.velocity.y < -0.1f)
            {
                _desiredMoveSpeed = _slideSpeed;
                _keepMomentum = true;
            }
            else
                _desiredMoveSpeed = _slideSpeed;
        }
        //if crouching and not trying to sprint and grounded
        else if (isCrouching && (!(data.SprintHeld && data.Vertical > 0.1f && _headCheck.canStand) || !_canSprint) && isGrounded)
        {
            _movementState = MovementState.crouching;
            //only change to crouch speed if not jumping (helps keep momentum from slide jump)
            if (readyToJump)
                _desiredMoveSpeed = _currentCrouchSpeed;
        }
        else if (isGrounded && data.SprintHeld && CanSprint(data))
        {
            if (isCrouching)
                EndCrouch();

            _movementState = MovementState.sprinting;
            _desiredMoveSpeed = _currentSprintSpeed;
        }
        else if (isGrounded)
        {
            _movementState = MovementState.walking;
            //set sprint speed to walk so we can lerp to it
            _currentSprintSpeed = _walkSpeed;
            //only update walk speed if not jumping (helps keep momentum from slide jump)
            if (readyToJump)
                _desiredMoveSpeed = _currentWalkSpeed;
        }
        else
        {
            if (isCrouching && _headCheck.canStand)
                EndCrouch();

            else if (!isCrouching)
            {
                _movementState = MovementState.airborne;

                if (_moveSpeed < _airSpeed)
                    _desiredMoveSpeed = _airSpeed;
            }
        }

        bool desiredMoveSpeedChanged = _desiredMoveSpeed != _lastDesiredMoveSpeed;

        //decide to keep momentum or instantly change desired move speed
        if (desiredMoveSpeedChanged)
        {
            if (_keepMomentum)
            {
                StopAllCoroutines();
                StartCoroutine(SmoothLerpMoveSpeed());
            }
            else
                _moveSpeed = _desiredMoveSpeed;
        }

        _lastDesiredMoveSpeed = _desiredMoveSpeed;

        //don't keep momentum if desired move speed is close to move speed
        if (Mathf.Abs(_desiredMoveSpeed - _moveSpeed) < 0.1f)
            _keepMomentum = false;
        #endregion

    }

    private void TimeManager_OnPostTick()
    {
        /* The base.IsServer check is not required but does save a little
        * performance by not building the reconcileData if not server. */
        if (IsServer)
        {
            ReconcileData rd = new ReconcileData(_rigidbody.position, transform.rotation, _cameraLookReference.GetOrientationRotation(), _rigidbody.velocity,
                _rigidbody.angularVelocity.normalized, _movementState, isVaulting, isSliding, isCrouching, isStepping, isGrounded,
                readyToJump);
            Reconciliation(rd);
        }
    }

    /// <summary>
    /// Method that resets the player based on the servers values
    /// </summary>
    /// <param name="data">ReconcileData reference</param>
    /// <param name="channel">Channel which data is sent or recieved</param>
    [ReconcileV2]
    private void Reconciliation(ReconcileData data, Channel channel = Channel.Unreliable)
    {
        _rigidbody.position = data.Position;
        transform.rotation = data.Rotation;
        _cameraLookReference.SetOrientationRotation(data.OrientationRotation);
        _rigidbody.velocity = data.Velocity;
        _rigidbody.angularVelocity = data.AngularVelocity;
        _movementState = data.MoveState;
        isVaulting = data.IsVaulting;
        isSliding = data.IsSliding;
        isCrouching = data.IsCrouching;
        isStepping = data.IsStepping;
        isGrounded = data.IsGrounded;
        readyToJump = data.ReadyToJump;
    }


    #region movement functions
    //keep momentum, usually done after coming out of a downward slide
    private IEnumerator SmoothLerpMoveSpeed()
    {
        float time = 0;
        float difference = _desiredMoveSpeed - _moveSpeed;

        if (difference < 0f)
            difference = 0f;

        float startValue = _moveSpeed;
        float boostFactor = 1f;

        //if not sliding, add boost factor to end momentum shift faster
        if (_boostedSlowDown && !isSliding)
            boostFactor = 10f;

        while (time < difference)
        {
            //lerp move speed from current to desired move speed
            _moveSpeed = Mathf.Lerp(startValue, _desiredMoveSpeed, time / difference);

            //change lerp speed based on speed and slope angle if on slope
            if (OnSlope())
            {
                float slopeAngle = Vector3.Angle(Vector3.up, _slopeHit.normal);
                float slopeAngleIncrease = 1 + (slopeAngle / 90f);

                time += Time.fixedDeltaTime * _speedIncreaseSlideTimeMultiplier * _slopeIncreaseSlideTimeMultiplier * slopeAngleIncrease * boostFactor;
            }
            else
                time += Time.fixedDeltaTime * _speedIncreaseSlideTimeMultiplier * boostFactor;

            yield return null;
        }

        //instantly change move speed after lerp done
        _moveSpeed = _desiredMoveSpeed;

        if (_boostedSlowDown)
            _boostedSlowDown = false;
    }

    private void Jump()
    {
        _exitingSlope = true;

        //Set y vel to 0
        _rigidbody.velocity = new Vector3(_rigidbody.velocity.x, _rigidbody.velocity.y / 2f, _rigidbody.velocity.z);

        if (onJump != null)
            onJump();

        _rigidbody.AddForce(new Vector3(0f, _jumpForce, 0f), ForceMode.Impulse);
    }

    /// <summary>
    /// Method that resets the player on death
    /// </summary>
    /// <param name="spawnPoint">The transform to spawn the player at</param>
    public void Respawn(Vector3 spawnPoint)
    {
        //reset player
        _rigidbody.isKinematic = false;
        _rigidbody.velocity = Vector3.zero;
        isGrounded = true;
        transform.position = spawnPoint;
    }

    /// <summary>
    /// Method that checks if the player is currently on a slope by raycasting and checking the hit normal
    /// </summary>
    /// <returns>True if a player is on a slope, otherwise false</returns>
    public bool OnSlope()
    {
        //check ground slope angle to determine if on slope
        if (Physics.Raycast(transform.position, Vector3.down, out _slopeHit, 0.25f, _groundMask))
        {
            float angle = Vector3.Angle(Vector3.up, _slopeHit.normal);
            return angle < _maxSlopeAngle && angle != 0f;
        }

        return false;
    }
    /// <summary>
    /// Method that checks the direction of a slope
    /// </summary>
    /// <param name="direction"></param>
    /// <returns>The direction a slope is facing</returns>
    public Vector3 GetSlopeMoveDirection(Vector3 direction)
    {
        return Vector3.ProjectOnPlane(direction, _slopeHit.normal).normalized;
    }
    public void SlideToCrouch()
    {
        if (onCrouch != null)
            onCrouch();
    }
    private void ResetJump()
    {
        readyToJump = true;
        _exitingSlope = false;
    }
    private bool OnSteepSlope()
    {
        //check ground slope angle to determine if on slope
        if (Physics.Raycast(transform.position, Vector3.down, out _slopeHit, 0.25f, _groundMask))
        {
            float angle = Vector3.Angle(Vector3.up, _slopeHit.normal);
            return angle >= _maxSlopeAngle && angle != 0f;
        }

        return false;
    }
    private bool CanCrouch()
    {
        return _movementState != MovementState.airborne && _movementState != MovementState.crouching && _movementState != MovementState.sprinting && !isVaulting && !isSliding;
    }
    private void StartCrouch()
    {
        if (onCrouch != null)
            onCrouch();

        isCrouching = true;

        if (crouchTween != null)
            crouchTween.Kill();

        crouchTween = transform.DOScaleY(_crouchHeight, _crouchDownDuration);
    }
    private void EndCrouch()
    {
        if (onUncrouch != null)
            onUncrouch();

        isCrouching = false;

        if (crouchTween != null)
            crouchTween.Kill();

        crouchTween = transform.DOScaleY(_startHeight, _crouchUpDuration);
    }
    private void KillPlayer()
    {
        //_playerCamera.fieldOfView = PlayerPrefs.GetInt("FieldOfView");
        transform.localScale = Vector3.one;
        _movementState = MovementState.walking;

        isSliding = false;
        isVaulting = false;
        isCrouching = false;
    }

    /// <summary>
    /// Method that assigns the TimeManager
    /// </summary>
    /// <param name="manager">TimeManager reference</param>
    //lerp ground walk speed to retain some x/z velocity when hopping
    private void LerpGroundSpeed()
    {
        if (isGrounded && _movementState == MovementState.walking)
            _currentWalkSpeed = Mathf.Lerp(_currentWalkSpeed, _walkSpeed, _lerpGroundSpeedRate * Time.fixedDeltaTime);
    }
    //lerp crouch speed when exiting slide so you don't lose all momentum
    private void LerpCrouchSpeed()
    {
        Vector3 flatVel = new Vector3(_rigidbody.velocity.x, 0f, _rigidbody.velocity.z);
        if (isCrouching)
        {
            if (Vector3.Dot(moveDirection, flatVel.normalized) > 0.5f || moveDirection.magnitude < 0.1f)
                _currentCrouchSpeed = Mathf.Lerp(_currentCrouchSpeed, _crouchSpeed, _lerpCrouchSpeedRate * Time.fixedDeltaTime);
            else
                _currentCrouchSpeed = Mathf.Lerp(_currentCrouchSpeed, _crouchSpeed, _lerpCrouchSpeedRate * 3f * Time.fixedDeltaTime);
        }
    }
    //lerp sprint speed when going from walk to sprint
    //lerp to either slope sprint speed or normal sprint speed
    private void LerpSprintSpeed()
    {
        if (isGrounded && _movementState == MovementState.sprinting)
            _currentSprintSpeed = Mathf.Lerp(_currentSprintSpeed, OnSlope() ? GetSlopeSprintSpeed() : _sprintSpeed, _lerpSprintSpeedRate * Time.fixedDeltaTime);
    }
    //get slope sprint speed using linear equation to calculate how much we want the player to be slowed by steeper slopes
    private float GetSlopeSprintSpeed()
    {
        if (Vector3.Dot(GetSlopeMoveDirection(moveDirection), Vector3.up) > -0.01f)
            return _sprintSpeed * (Vector3.Dot(GetSlopeMoveDirection(moveDirection), Vector3.up) * -0.3f + 1f);
        else
            return _sprintSpeed;
    }
    //clamp velocity to match current state, only clamp x/z when on slopes
    private void SpeedControl()
    {
        //change full velocity if on slope
        if (OnSlope() && !_exitingSlope)
        {
            if (_rigidbody.velocity.magnitude > _moveSpeed)
                _rigidbody.velocity = _rigidbody.velocity.normalized * _moveSpeed;
        }
        //only change x/z if not on slope
        else
        {
            Vector3 flatVel = new Vector3(_rigidbody.velocity.x, 0f, _rigidbody.velocity.z);

            if (flatVel.magnitude > _moveSpeed)
            {
                Vector3 limitedVel = flatVel.normalized * _moveSpeed;
                _rigidbody.velocity = new Vector3(limitedVel.x, _rigidbody.velocity.y, limitedVel.z);
            }
        }
    }
    private void GroundCheck()
    {
        if (Physics.CheckSphere(transform.position + transform.up * (_groundCheckRadius / 2f), _groundCheckRadius, _groundMask) && !isGrounded)
        {
            if (onLand != null && !isVaulting)
            {
                //onLand();

                //if player fallen far enough to land with enough force
                if (_airborneHighestYPosition - transform.position.y >= _fallDistanceRequiredToShake)
                {
                    //ScreenShake.instance.Shake(1);
                    onLand();
                }
                else
                    _currentWalkSpeed = _walkSpeed;
            }

            isGrounded = true;
        }
        else if (!Physics.CheckSphere(transform.position, _groundCheckRadius, _groundMask) && isGrounded && !isStepping)
        {
            //start checking for highest y position reached in air
            isGrounded = false;
            _airborneYPosition = transform.position.y;
            _airborneHighestYPosition = _startYPosition;

            //get x/z velocity when airborne so we can clamp airborne maximum speed to that speed
            _velocityWhenLeftGround = new Vector3(_rigidbody.velocity.x, 0f, _rigidbody.velocity.z).magnitude;
            _currentWalkSpeed = _airSpeed;

            if (onAirborne != null)
                onAirborne();
        }
    }
    private bool CanSprint(MoveData data)
    {
        return data.Vertical > 0.1f && _staminaSystem.GetStamina() > 0f;
    }
    private bool CanJump()
    {
         return (!isCrouching && readyToJump && isGrounded && !OnSteepSlope()) && !isVaulting && !(!OnSlope() && _rigidbody.velocity.y > 4f);
    }
    #endregion
}