BABA_YAGA/Assets/Scripts/Fusion/BasicSpawner.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using System.Linq;
using Fusion;
using Fusion.Sockets;
using UnityEngine;
using UnityEngine.SceneManagement;
using Random = UnityEngine.Random;

// Struct input đồng bộ giữa Spawner, Movement và StateMachine
public struct PlayerInputData : INetworkInput
{
    public Vector2 Direction;
    public Quaternion rot;
    public bool sprint;
}

public class BasicSpawner : MonoBehaviour, INetworkRunnerCallbacks
{
    private NetworkRunner _runner;

    public LobbyManager LobbyManager;
    [SerializeField] private NetworkPrefabRef _playerPrefab;
    private Dictionary<PlayerRef, NetworkObject> _spawnedCharacters = new Dictionary<PlayerRef, NetworkObject>();

    // Thông tin profile local
    public PlayerProfile LocalPlayerProfile { get; private set; }
    public void SetLocalPlayerProfile(PlayerProfile profile)
    {
        LocalPlayerProfile = profile;
    }

    private void Awake()
    {
        if (_runner == null) _runner = gameObject.AddComponent<NetworkRunner>();
        DontDestroyOnLoad(gameObject);
    }

    // Khởi tạo Game (Host/Client)
    public async Task StartGame(GameMode mode, string sessionName = "TestRoom")
    {
        Debug.Log($"<color=yellow>Fusion:</color> Đang khởi tạo kết nối với Mode: {mode} | Phòng: {sessionName}");
        
        if (_runner == null) _runner = gameObject.AddComponent<NetworkRunner>();
        _runner.ProvideInput = true;

        var sceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>();
        if (sceneManager == null) sceneManager = gameObject.AddComponent<NetworkSceneManagerDefault>();

        var result = await _runner.StartGame(new StartGameArgs()
        {
            GameMode = mode,
            SessionName = sessionName,
            Scene = SceneRef.FromIndex(1),
            SceneManager = sceneManager
        });

        if (result.Ok)
        {
            Debug.Log($"<color=green>Fusion thành công:</color> Đã vào phòng {sessionName}");
        }
        else
        {
            Debug.LogError($"<color=red>Fusion thất bại:</color> Lý do: {result.ShutdownReason}");
            if (_runner != null)
            {
                Destroy(_runner);
                _runner = null;
            }
        }
    }

    private void OnGUI()
    {
        if (_runner == null || !_runner.IsRunning)
        {
            if (GUI.Button(new Rect(10, 10, 250, 40), "Bắt đầu (Auto Host/Client)")) 
            {
                _ = StartGame(GameMode.AutoHostOrClient);
            }
            GUI.Label(new Rect(10, 60, 300, 20), "Gợi ý: Mở bản Build trước, sau đó mở Unity bấm nút trên.");
        }
        else
        {
            string region = (_runner.SessionInfo != null && _runner.SessionInfo.IsValid) ? _runner.SessionInfo.Region : "Connecting...";
            int playerCount = 0;
            foreach (var p in _runner.ActivePlayers) playerCount++;
            
            string info = $"Mode: {_runner.GameMode} | Region: {region} | Players: {playerCount}";
            GUI.Box(new Rect(10, 10, 400, 30), info);
            
            if (GUI.Button(new Rect(10, 50, 100, 30), "Thoát"))
            {
                _runner.Shutdown();
            }
        }
    }

    public void OnPlayerJoined(NetworkRunner runner, PlayerRef player)
    {
        if (runner.IsServer)
        {
            Vector3 spawnPosition = new Vector3(Random.Range(-10f, 10f), 2f, Random.Range(-10f, 10f));
            spawnPosition += new Vector3(player.RawEncoded % 3, 0, player.RawEncoded % 3);

            var networkPlayerObject = runner.Spawn(_playerPrefab, spawnPosition, Quaternion.identity, player);
            runner.SetPlayerObject(player, networkPlayerObject);
            _spawnedCharacters.Add(player, networkPlayerObject);
        }
    }

    public void OnPlayerLeft(NetworkRunner runner, PlayerRef player)
    {
        if (_spawnedCharacters.TryGetValue(player, out NetworkObject networkObject))
        {
            if (networkObject != null) runner.Despawn(networkObject);
            _spawnedCharacters.Remove(player);
        }
    }

    public void OnInput(NetworkRunner runner, NetworkInput input)
    {
        var data = new PlayerInputData();
        
        // ĐỌC TRỰC TIẾP: Không dùng Buffer để tránh bị trôi phím
        data.Direction = new Vector2(Input.GetAxisRaw("Horizontal"), Input.GetAxisRaw("Vertical"));
        data.sprint = Input.GetKey(KeyCode.LeftShift);

        if (OnlyScove.Scripts.PlayerStateMachine.Local != null)
        {
            var sm = OnlyScove.Scripts.PlayerStateMachine.Local;
            if (sm.Cam != null) data.rot = sm.Cam.PlanarRotation;
            else data.rot = sm.NetworkedCameraRotation;
        }
        
        input.Set(data);
    }

    public void OnSessionListUpdated(NetworkRunner runner, List<SessionInfo> sessionList)
    {
        if (LobbyManager != null) LobbyManager.DisplayRoomList(sessionList);
    }

    public void OnInputMissing(NetworkRunner runner, PlayerRef player, NetworkInput input) { }
    public void OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason) { }
    public void OnConnectedToServer(NetworkRunner runner) { }
    public void OnDisconnectedFromServer(NetworkRunner runner, NetDisconnectReason reason) { }
    public void OnConnectRequest(NetworkRunner runner, NetworkRunnerCallbackArgs.ConnectRequest request, byte[] token) { }
    public void OnConnectFailed(NetworkRunner runner, NetAddress remoteAddress, NetConnectFailedReason reason) { }
    public void OnUserSimulationMessage(NetworkRunner runner, SimulationMessagePtr message) { }
    public void OnCustomAuthenticationResponse(NetworkRunner runner, Dictionary<string, object> data) { }
    public void OnHostMigration(NetworkRunner runner, HostMigrationToken hostMigrationToken) { }
    public void OnSceneLoadDone(NetworkRunner runner) { }
    public void OnSceneLoadStart(NetworkRunner runner) { }
    public void OnObjectExitAOI(NetworkRunner runner, NetworkObject obj, PlayerRef player) { }
    public void OnObjectEnterAOI(NetworkRunner runner, NetworkObject obj, PlayerRef player) { }
    public void OnReliableDataReceived(NetworkRunner runner, PlayerRef player, ReliableKey key, ArraySegment<byte> data) { }
    public void OnReliableDataProgress(NetworkRunner runner, PlayerRef player, ReliableKey key, float progress) { }
}