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

using System.Collections.Generic;
using UnityEngine;
using Fusion;

namespace OnlyScove.Scripts
{
    [RequireComponent(typeof(CharacterController), typeof(InputReader), typeof(Animator))]
    [RequireComponent(typeof(PlayerStats), typeof(PlayerInteraction), typeof(PlayerMovement))]
    [RequireComponent(typeof(PlayerAnimationHandler))]
    public class PlayerStateMachine : NetworkBehaviour
    {
        [field: Header("References")]
        [field: SerializeField] public CharacterController Controller { get; private set; }
        [field: SerializeField] public virtual InputReader Input { get; private set; }
        [field: SerializeField] public Animator Anim { get; private set; }
        [field: SerializeField] public EnvironmentScanner Scanner { get; private set; }
        public CameraController Cam { get; private set; }

        [Header("Modules")]
        public PlayerStats Stats;
        public PlayerInteraction Interaction;
        public PlayerMovement Movement;
        public PlayerAnimationHandler AnimationHandler;

        [Networked] public Quaternion NetworkedCameraRotation { get; set; }
        [Networked] public Vector2 NetworkedMoveInput { get; set; }
        [Networked] public float NetworkedSpeed { get; set; }

        // Pass-through properties for State Compatibility
        public Vector2 MoveInput { get; private set; }
        public bool IsSprintHeld { get; private set; }
        
        public float VelocityY 
        { 
            get => (Object != null && Object.IsValid && Movement != null) ? Movement.VelocityY : 0f; 
            set { if (Object != null && Object.IsValid && Movement != null) Movement.VelocityY = value; } 
        }

        public bool IsGrounded => (Object != null && Object.IsValid && Movement != null) ? Movement.IsGrounded : true;
        public bool WasGrounded => (Object != null && Object.IsValid && Movement != null) ? Movement.WasGrounded : true;
        
        public float WalkSpeed => Movement.WalkSpeed;
        public float RunSpeed => Movement.RunSpeed;
        public float SprintSpeed => Movement.SprintSpeed;
        public float SneakSpeed => Movement.SneakSpeed;
        public float DashForce => Movement.DashForce;
        public float JumpHeight => Movement.JumpHeight;
        public float ThrustDownwardForce => Movement.ThrustDownwardForce;
        public float Gravity => Movement.Gravity;

        public float InteractionRange => Interaction.InteractionRange;
        public LayerMask InteractionMask => Interaction.InteractionMask;

        public static PlayerStateMachine Local { get; private set; }
        public string CurrentStateName => currentState != null ? currentState.GetType().Name : "None";

        public Quaternion CameraRotation
        {
            get
            {
                if (Runner != null && Runner.IsRunning && Object != null && Object.IsValid) return NetworkedCameraRotation;
                return Cam != null ? Cam.PlanarRotation : transform.rotation;
            }
        }

        private PlayerBaseState currentState;
        private bool hasControl = true;
        private float localAnimatorSpeed;

        protected virtual void Awake()
        {
            Controller = GetComponent<CharacterController>();
            Input = GetComponent<InputReader>();
            Anim = GetComponentInChildren<Animator>();
            Scanner = GetComponent<EnvironmentScanner>();

            Stats = GetComponent<PlayerStats>();
            Interaction = GetComponent<PlayerInteraction>();
            Movement = GetComponent<PlayerMovement>();
            AnimationHandler = GetComponent<PlayerAnimationHandler>();

            AnimationHandler.Initialize(Anim);
            Movement.Initialize(Controller);
            Interaction.Initialize(Scanner);
        }

        private void Start()
        {
            if (Runner == null || !Runner.IsRunning) InitializePlayer();
        }

        public override void Spawned()
        {
            InitializePlayer();
        }

        private void InitializePlayer()
        {
            bool isLocal = (Object != null && Object.HasInputAuthority) || (Runner == null || !Runner.IsRunning);

            if (isLocal)
            {
                Local = this;
                CameraController cameraController = GameObject.FindAnyObjectByType<CameraController>();
                if (cameraController != null)
                {
                    Cam = cameraController;
                    Cam.followTarget = transform; 
                    Cam.inputReader = Input;
                }
                
                if (Input != null)
                {
                    Input.enabled = true; // Ensure local input is enabled
                    Input.OnNextInteractEvent -= Interaction.NextInteract;
                    Input.OnNextInteractEvent += Interaction.NextInteract;
                    Input.OnPreviousInteractEvent -= Interaction.PreviousInteract;
                    Input.OnPreviousInteractEvent += Interaction.PreviousInteract;
                }
                
                if (Controller != null) Controller.enabled = true;
            }
            else
            {
                // Disable input for proxies to prevent "Input Overlap"
                if (Input != null) Input.enabled = false;
                
                // On clients, proxies don't need CharacterController enabled
                if (Runner != null && Runner.IsClient && Controller != null) Controller.enabled = false;
            }

            if (currentState == null) SwitchState(new PlayerIdleState(this));
        }

        private void OnDestroy()
        {
            if (Input != null && Interaction != null)
            {
                Input.OnNextInteractEvent -= Interaction.NextInteract;
                Input.OnPreviousInteractEvent -= Interaction.PreviousInteract;
            }
        }

        public void Rotate(Vector3 moveDirection, float deltaTime)
        {
            Movement.Rotate(transform, moveDirection, deltaTime);
        }

        public void Move(Vector3 velocity, float animatorSpeed, float deltaTime)
        {
            bool canMove = (Runner == null || !Runner.IsRunning) || (Object != null && Object.IsValid && (Object.HasInputAuthority || Runner.IsServer));
            if (!canMove) return;

            Movement.Move(Controller, velocity, deltaTime);

            localAnimatorSpeed = animatorSpeed;
            if (Object != null && Object.IsValid && Object.HasStateAuthority)
            {
                NetworkedSpeed = animatorSpeed;
                NetworkedMoveInput = MoveInput;
            }
            UpdateAnimator(deltaTime);
        }

        private void UpdateAnimator(float deltaTime)
        {
            bool isNetworked = Runner != null && Runner.IsRunning && Object != null && Object.IsValid;
            float speedValue = (!isNetworked || Object.HasInputAuthority) ? localAnimatorSpeed : NetworkedSpeed;
            Vector2 inputVector = (!isNetworked || Object.HasInputAuthority) ? MoveInput : NetworkedMoveInput;
            AnimationHandler.UpdateAnimator(speedValue, inputVector, deltaTime);
        }

        public override void FixedUpdateNetwork()
        {
            bool isRunning = Runner != null && Runner.IsRunning;
            if (isRunning && (Object == null || !Object.IsValid)) return;

            if (GetInput(out PlayerInputData data))
            {
                MoveInput = data.Direction;
                IsSprintHeld = (bool)data.sprint;
                if (isRunning) NetworkedCameraRotation = data.rot;
            }
            else if (!isRunning)
            {
                MoveInput = new Vector2(UnityEngine.Input.GetAxisRaw("Horizontal"), UnityEngine.Input.GetAxisRaw("Vertical"));
                IsSprintHeld = UnityEngine.Input.GetKey(KeyCode.LeftShift);
            }

            // Only run logic if we have Input Authority (Local Player) or State Authority (Server simulating Player)
            if (!isRunning || (Object != null && Object.IsValid && (Object.HasInputAuthority || Runner.IsServer)))
            {
                if (hasControl)
                {
                    Movement.CheckGround(transform);
                    Interaction.UpdateInteractables();
                    currentState?.Tick(isRunning ? Runner.DeltaTime : Time.fixedDeltaTime);
                }
            }
        }

        public override void Render()
        {
            bool isRunning = Runner != null && Runner.IsRunning;
            if (isRunning && Object != null && Object.IsValid && !Object.HasInputAuthority)
            {
                // Note: We now rely on NetworkTransform component for position syncing
                UpdateAnimator(Runner.DeltaTime);
            }
            else if (!isRunning)
            {
                UpdateAnimator(Time.deltaTime);
            }
        }

        private void Update()
        {
            if (Runner == null || !Runner.IsRunning) FixedUpdateNetwork();
        }

        public IInteractable GetInteractable() => Interaction.GetInteractable();
        public void SetGroundCheck(float radius, Vector3 offset) => Movement.SetGroundCheck(radius, offset);

        public void SwitchState(PlayerBaseState newState)
        {
            currentState?.Exit();
            currentState = newState;
            currentState?.Enter();
        }

        public void SetControl(bool control)
        {
            hasControl = control;
            if (Controller != null) Controller.enabled = control;
            if (!control) AnimationHandler.SetSpeed(0f);
        }

        private void OnDrawGizmosSelected()
        {
            if (Movement == null) return;
            Gizmos.color = new Color(0, 1, 0, 0.5f);
            Gizmos.DrawSphere(transform.TransformPoint(Movement.GroundCheckOffset), Movement.GroundCheckRadius);
        }
    }
}