297 lines
11 KiB
C#
297 lines
11 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Threading.Tasks;
|
|
using Fusion;
|
|
using Fusion.Sockets;
|
|
using UnityEngine;
|
|
using OnlyScove.Scripts;
|
|
|
|
namespace Hallucinate.UI
|
|
{
|
|
public class BasicSpawner : MonoBehaviour, INetworkRunnerCallbacks
|
|
{
|
|
public static BasicSpawner Instance { get; private set; }
|
|
private NetworkRunner _runner;
|
|
|
|
public event Action<List<SessionInfo>> OnSessionListUpdatedEvent;
|
|
public event Action<string> OnShutdownEvent;
|
|
public event Action OnJoinStartedEvent;
|
|
public event Action OnJoinFailedEvent;
|
|
|
|
[Header("Prefabs")]
|
|
[SerializeField] private NetworkPrefabRef _playerPrefab;
|
|
[SerializeField] private NetworkPrefabRef _playerDataManagerPrefab;
|
|
|
|
private void Awake()
|
|
{
|
|
if (Instance != null && Instance != this)
|
|
{
|
|
Destroy(gameObject);
|
|
return;
|
|
}
|
|
Instance = this;
|
|
DontDestroyOnLoad(gameObject);
|
|
}
|
|
|
|
public PlayerProfile LocalPlayerProfile { get; private set; }
|
|
public void SetLocalPlayerProfile(PlayerProfile _profile)
|
|
{
|
|
LocalPlayerProfile = _profile;
|
|
}
|
|
|
|
private async Task EnsureRunnerExists()
|
|
{
|
|
if (_runner == null)
|
|
{
|
|
_runner = GetComponent<NetworkRunner>();
|
|
}
|
|
|
|
if (_runner != null && _runner.IsRunning)
|
|
{
|
|
await _runner.Shutdown();
|
|
}
|
|
|
|
if (_runner == null)
|
|
{
|
|
_runner = gameObject.AddComponent<NetworkRunner>();
|
|
}
|
|
|
|
_runner.ProvideInput = true;
|
|
_runner.RemoveCallbacks(this);
|
|
_runner.AddCallbacks(this);
|
|
}
|
|
|
|
public async Task StartLobby()
|
|
{
|
|
await EnsureRunnerExists();
|
|
|
|
if (_runner.SessionInfo.IsValid) return;
|
|
|
|
var result = await _runner.JoinSessionLobby(SessionLobby.ClientServer);
|
|
if (!result.Ok)
|
|
{
|
|
Debug.LogWarning($"Join lobby result: {result.ShutdownReason}. This is often normal on first run if already connecting.");
|
|
}
|
|
}
|
|
|
|
public async Task<bool> StartHost(string sessionName, string displayName, string password = null)
|
|
{
|
|
OnJoinStartedEvent?.Invoke();
|
|
|
|
bool sceneExists = false;
|
|
for (int i = 0; i < UnityEngine.SceneManagement.SceneManager.sceneCountInBuildSettings; i++)
|
|
{
|
|
if (UnityEngine.SceneManagement.SceneUtility.GetScenePathByBuildIndex(i).Contains("Main Scene"))
|
|
{
|
|
sceneExists = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!sceneExists)
|
|
{
|
|
Debug.LogError("CRITICAL: 'Main Scene' is NOT in Build Settings!");
|
|
return false;
|
|
}
|
|
|
|
await EnsureRunnerExists();
|
|
|
|
var customProps = new Dictionary<string, SessionProperty>();
|
|
if (!string.IsNullOrEmpty(password))
|
|
{
|
|
customProps.Add("pw", password);
|
|
}
|
|
customProps.Add("rn", displayName);
|
|
|
|
var result = await _runner.StartGame(new StartGameArgs()
|
|
{
|
|
GameMode = GameMode.Host,
|
|
SessionName = sessionName,
|
|
SessionProperties = customProps,
|
|
PlayerCount = 2,
|
|
SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>() ?? gameObject.AddComponent<NetworkSceneManagerDefault>()
|
|
});
|
|
|
|
if (result.Ok)
|
|
{
|
|
if (_runner.IsServer && _playerDataManagerPrefab.IsValid)
|
|
{
|
|
if (FindFirstObjectByType<PlayerDataManager>() == null)
|
|
{
|
|
_runner.Spawn(_playerDataManagerPrefab, Vector3.zero, Quaternion.identity, null);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError($"Fusion StartHost Failed: {result.ShutdownReason}.");
|
|
OnJoinFailedEvent?.Invoke();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public async Task<bool> StartClient(string sessionName, string password = null)
|
|
{
|
|
OnJoinStartedEvent?.Invoke();
|
|
await EnsureRunnerExists();
|
|
|
|
var result = await _runner.StartGame(new StartGameArgs()
|
|
{
|
|
GameMode = GameMode.Client,
|
|
SessionName = sessionName,
|
|
SceneManager = gameObject.GetComponent<NetworkSceneManagerDefault>() ?? gameObject.AddComponent<NetworkSceneManagerDefault>()
|
|
});
|
|
|
|
if (result.Ok)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError($"Fusion StartClient Failed: {result.ShutdownReason}");
|
|
OnJoinFailedEvent?.Invoke();
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private Dictionary<PlayerRef, NetworkObject> _spawnedCharacters = new Dictionary<PlayerRef, NetworkObject>();
|
|
|
|
public void OnPlayerJoined(NetworkRunner runner, PlayerRef player)
|
|
{
|
|
if (player == runner.LocalPlayer)
|
|
{
|
|
SendLocalMetaData(player);
|
|
}
|
|
}
|
|
|
|
private async void SendLocalMetaData(PlayerRef player)
|
|
{
|
|
PlayerDataManager pdm = null;
|
|
int retries = 0;
|
|
while (pdm == null && retries < 20)
|
|
{
|
|
pdm = FindFirstObjectByType<PlayerDataManager>();
|
|
if (pdm != null) break;
|
|
await Task.Delay(500);
|
|
retries++;
|
|
}
|
|
|
|
if (pdm != null)
|
|
{
|
|
string playerName = LocalPlayerProfile != null ? LocalPlayerProfile.Name : "Player " + player.PlayerId;
|
|
|
|
// Thêm hậu tố (HOST) nếu là server để dễ phân biệt
|
|
if (_runner.IsServer) playerName += " (HOST)";
|
|
|
|
_Role playerRole = _Role.Seeker;
|
|
|
|
var metaData = new _PlayerMetaData()
|
|
{
|
|
Name = playerName,
|
|
Role = playerRole,
|
|
IsReady = false
|
|
};
|
|
pdm.RPC_UpdatePlayerMetaData(player, metaData);
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("[BasicSpawner] Could not find PlayerDataManager after retries. Data will not sync.");
|
|
}
|
|
}
|
|
|
|
public void StartGame()
|
|
{
|
|
if (_runner != null && _runner.IsServer)
|
|
{
|
|
_runner.LoadScene("Main Scene");
|
|
}
|
|
}
|
|
|
|
public void OnPlayerLeft(NetworkRunner runner, PlayerRef player)
|
|
{
|
|
if (_spawnedCharacters.TryGetValue(player, out NetworkObject networkObject))
|
|
{
|
|
runner.Despawn(networkObject);
|
|
_spawnedCharacters.Remove(player);
|
|
}
|
|
|
|
if (runner.IsServer && player == runner.LocalPlayer)
|
|
{
|
|
runner.Shutdown();
|
|
}
|
|
}
|
|
|
|
public void OnShutdown(NetworkRunner runner, ShutdownReason shutdownReason)
|
|
{
|
|
Debug.LogWarning($"[Fusion] Shutdown occurred. Reason: {shutdownReason}");
|
|
OnShutdownEvent?.Invoke(shutdownReason.ToString());
|
|
|
|
if (UIManager.Instance != null)
|
|
{
|
|
UIManager.Instance.OnBackToMenu();
|
|
}
|
|
}
|
|
|
|
public void OnSessionListUpdated(NetworkRunner runner, List<SessionInfo> sessionList)
|
|
{
|
|
OnSessionListUpdatedEvent?.Invoke(sessionList);
|
|
}
|
|
|
|
public void OnInput(NetworkRunner runner, NetworkInput input)
|
|
{
|
|
var data = new PlayerInputData();
|
|
if (PlayerStateMachine.Local != null && PlayerStateMachine.Local.Input != null)
|
|
{
|
|
data.Direction = PlayerStateMachine.Local.Input.MoveInput;
|
|
data.sprint = PlayerStateMachine.Local.Input.IsSprintHeld;
|
|
if (PlayerStateMachine.Local.Cam != null)
|
|
data.rot = PlayerStateMachine.Local.Cam.PlanarRotation;
|
|
}
|
|
input.Set(data);
|
|
}
|
|
|
|
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 OnReliableDataReceived(NetworkRunner runner, PlayerRef player, ReliableKey key, ArraySegment<byte> data) { }
|
|
public void OnReliableDataProgress(NetworkRunner runner, PlayerRef player, ReliableKey key, float progress) { }
|
|
public void OnInputMissing(NetworkRunner runner, PlayerRef player, NetworkInput input) { }
|
|
public void OnObjectExitAOI(NetworkRunner runner, NetworkObject obj, PlayerRef player) { }
|
|
public void OnObjectEnterAOI(NetworkRunner runner, NetworkObject obj, PlayerRef player) { }
|
|
public void OnCustomAuthenticationResponse(NetworkRunner runner, Dictionary<string, object> data) { }
|
|
public void OnHostMigration(NetworkRunner runner, HostMigrationToken hostMigrationToken) { }
|
|
|
|
public void OnSceneLoadDone(NetworkRunner runner)
|
|
{
|
|
string currentSceneName = UnityEngine.SceneManagement.SceneManager.GetActiveScene().name;
|
|
if (runner.IsServer && currentSceneName == "Main Scene")
|
|
{
|
|
foreach (var player in runner.ActivePlayers)
|
|
{
|
|
Vector2 spawnPosition = (player == runner.LocalPlayer) ? new Vector2(-8, 0) : new Vector2(8, 0);
|
|
var networkPlayerObject = runner.Spawn(_playerPrefab, spawnPosition, Quaternion.identity, player);
|
|
_spawnedCharacters.Add(player, networkPlayerObject);
|
|
}
|
|
}
|
|
// Removed incorrect UI transition for Lobby/Menu scenes to allow LobbyController to manage its state.
|
|
// The original logic incorrectly called UIManager.OnBackToMenu() when entering the Lobby scene,
|
|
// causing the redirect to the Main Menu after creating a room.
|
|
// This block ensures that only the Main Scene triggers a specific UI transition (OnGameStarted).
|
|
// If other scenes like "Lobby" or "Menu" are loaded, no automatic transition is forced from here,
|
|
// letting scene-specific controllers (like LobbyController) manage their UI.
|
|
if (currentSceneName == "Main Scene")
|
|
{
|
|
UIManager.Instance?.OnGameStarted();
|
|
}
|
|
// Removed the problematic else-if block that would incorrectly call OnBackToMenu for "Lobby" or "Menu" scenes.
|
|
}
|
|
|
|
|
|
public void OnSceneLoadStart(NetworkRunner runner) { }
|
|
}
|
|
}
|