BABA_YAGA/Assets/Scripts/Player Controller/PlayerRunState.cs

using UnityEngine;

namespace OnlyScove.Scripts
{
    public class PlayerRunState : PlayerBaseState
    {
        private readonly int speedHash = Animator.StringToHash("Speed");
        private readonly int speedXHash = Animator.StringToHash("Velocity X");
        private readonly int speedZHash = Animator.StringToHash("Velocity Z");

        public PlayerRunState(PlayerStateMachine stateMachine) : base(stateMachine) {}

        public override void Enter()
        {
            stateMachine.Input.OnJumpEvent += OnJump;
            stateMachine.Input.OnDodgeEvent += OnDodge;
            stateMachine.Input.OnCrouchEvent += OnCrouch;
        }

        public override void Tick(float deltaTime)
        {
            Vector2 input = stateMachine.Input.MoveInput;
            float moveAmount = Mathf.Clamp01(Mathf.Abs(input.x) + Mathf.Abs(input.y));

            if (moveAmount <= 0.01f)
            {
                stateMachine.SwitchState(new PlayerIdleState(stateMachine));
                return;
            }

            if (!stateMachine.Input.IsSprintHeld)
            {
                stateMachine.SwitchState(new PlayerMoveState(stateMachine));
                return;
            }

            Vector3 inputDir = new Vector3(input.x, 0, input.y).normalized;
            Vector3 moveDirection = stateMachine.Cam != null ? stateMachine.Cam.PlanarRotation * inputDir : inputDir;

            Vector3 velocity = moveDirection * stateMachine.SprintSpeed;

            if (stateMachine.IsGrounded && stateMachine.VelocityY < 0)
            {
                stateMachine.VelocityY = -2f;
            }
            else
            {
                stateMachine.VelocityY += Physics.gravity.y * deltaTime;
            }
            velocity.y = stateMachine.VelocityY;

            stateMachine.Controller.Move(velocity * deltaTime);

            if (moveDirection != Vector3.zero)
            {
                Quaternion targetRot = Quaternion.LookRotation(moveDirection);
                stateMachine.transform.rotation = Quaternion.RotateTowards(
                    stateMachine.transform.rotation, 
                    targetRot, 
                    stateMachine.RotationSpeed * deltaTime
                );
            }

            stateMachine.Anim.SetFloat(speedHash, 1f, stateMachine.AnimationDamping, deltaTime);
            stateMachine.Anim.SetFloat(speedXHash, input.x * 2f, stateMachine.AnimationDamping, deltaTime);
            stateMachine.Anim.SetFloat(speedZHash, input.y * 2f, stateMachine.AnimationDamping, deltaTime);
        }

        public override void PhysicsTick(float fixedDeltaTime) {}

        public override void Exit()
        {
            stateMachine.Input.OnJumpEvent -= OnJump;
            stateMachine.Input.OnDodgeEvent -= OnDodge;
            stateMachine.Input.OnCrouchEvent -= OnCrouch;
        }

        private void OnJump()
        {
            if (stateMachine.IsGrounded)
            {
                if (stateMachine.Scanner != null)
                {
                    var hitData = stateMachine.Scanner.ObstacleCheck();
                    if (hitData.forwardHitFound)
                    {
                        stateMachine.SwitchState(new PlayerParkourState(stateMachine));
                        return;
                    }
                }
                stateMachine.SwitchState(new PlayerJumpState(stateMachine, stateMachine.SprintSpeed));
            }
        }

        private void OnDodge() => stateMachine.SwitchState(new PlayerDodgeState(stateMachine));
        private void OnCrouch() => stateMachine.SwitchState(new PlayerCrouchState(stateMachine));
    }
}