435 lines
15 KiB
C#
435 lines
15 KiB
C#
using GeoSus.Client;
|
|
using System.Collections;
|
|
using System.Threading.Tasks;
|
|
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
using Subsystems;
|
|
using System.Linq;
|
|
using UnityEngine.SceneManagement;
|
|
|
|
namespace Subsystems
|
|
{
|
|
public class GameManager_Network
|
|
{
|
|
private const string _serverAddress = "geosus.honzuvkod.dev";
|
|
private const int _serverPort = 7777;
|
|
private GameClient _gameClient;
|
|
private GameManager _manager;
|
|
private bool _pendingMapBuild;
|
|
|
|
/// <summary>
|
|
/// Authoritative game state; written here, read by GameManager_UI.
|
|
/// </summary>
|
|
public GameState State { get; } = new GameState();
|
|
|
|
public GameManager_Network(GameClient gameClient, GameManager manager)
|
|
{
|
|
_gameClient = gameClient;
|
|
_manager = manager;
|
|
RegisterEventHandlers();
|
|
}
|
|
|
|
public async void OpenConnection()
|
|
{
|
|
int retries = 0;
|
|
int delayMs = 5000;
|
|
while (true)
|
|
{
|
|
Task<bool> state = _gameClient.ConnectAsync(_serverAddress, _serverPort);
|
|
await state;
|
|
if (state.Result)
|
|
{
|
|
Debug.Log("Connected to server.");
|
|
break;
|
|
}
|
|
retries++;
|
|
if (retries >= 10)
|
|
{
|
|
Debug.LogError("Failed to connect after 10 attempts. Giving up.");
|
|
break;
|
|
}
|
|
Debug.Log($"Failed to connect (attempt {retries}). Retrying in {delayMs / 1000}s...");
|
|
await Task.Delay(delayMs);
|
|
delayMs = Mathf.Min(delayMs * 2, 30000);
|
|
}
|
|
}
|
|
|
|
public void RegisterEventHandlers()
|
|
{
|
|
_gameClient.OnConnected += OnConnected;
|
|
_gameClient.OnDisconnected += OnDisconnected;
|
|
_gameClient.OnError += OnError;
|
|
_gameClient.OnMessage += OnMessage;
|
|
_gameClient.OnGameEvent += OnGameEvent;
|
|
}
|
|
|
|
private void OnConnected() => Debug.Log("Successfully connected to the server.");
|
|
private void OnError(string e) => Debug.LogError($"Network error: {e}");
|
|
|
|
private void OnDisconnected(string reason)
|
|
{
|
|
Debug.Log($"Disconnected: {reason}");
|
|
if (reason != "Disposed" && _manager != null)
|
|
_manager.StartCoroutine(ReconnectAfterDelay(3f));
|
|
}
|
|
|
|
private IEnumerator ReconnectAfterDelay(float seconds)
|
|
{
|
|
yield return new UnityEngine.WaitForSeconds(seconds);
|
|
Debug.Log("Attempting to reconnect...");
|
|
OpenConnection();
|
|
}
|
|
|
|
private void OnMessage(Message message)
|
|
{
|
|
switch (message.Type)
|
|
{
|
|
case "CreateLobbyResponse":
|
|
HandleCreateLobbyResponse(message as CreateLobbyResponse);
|
|
break;
|
|
case "JoinLobbyResponse":
|
|
HandleJoinLobbyResponse(message as JoinLobbyResponse);
|
|
break;
|
|
case "PositionBroadcast":
|
|
HandlePositionBroadcast(message as PositionBroadcast);
|
|
break;
|
|
case "Ack":
|
|
case "GameEvent":
|
|
break;
|
|
default:
|
|
Debug.Log("Received message of type: " + message.Type);
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void OnGameEvent(GameEvent gameEvent)
|
|
{
|
|
// Always sync player list from lobby state after any event
|
|
SyncPlayersFromLobby();
|
|
|
|
switch (gameEvent.EventType)
|
|
{
|
|
case "PlayerJoined":
|
|
case "PlayerLeft":
|
|
case "HostChanged":
|
|
_manager?.uiSubsystem?.NotifyLobbyChanged();
|
|
break;
|
|
|
|
case "GameStarting":
|
|
State.Phase = GamePhase.Loading;
|
|
HandleGameStarting();
|
|
break;
|
|
|
|
case "MapDataReady":
|
|
HandleMapDataReady();
|
|
break;
|
|
|
|
case "GameStarted":
|
|
State.Phase = GamePhase.Playing;
|
|
break;
|
|
|
|
case "RoleAssigned":
|
|
HandleRoleAssigned(gameEvent);
|
|
break;
|
|
|
|
case "TaskCompleted":
|
|
HandleTaskCompleted(gameEvent);
|
|
break;
|
|
|
|
case "PlayerKilled":
|
|
HandlePlayerKilled(gameEvent);
|
|
break;
|
|
|
|
case "BodyReported":
|
|
case "EmergencyMeetingCalled":
|
|
Toast("Meeting called! Head to the meeting point.");
|
|
break;
|
|
|
|
case "MeetingStarted":
|
|
HandleMeetingStarted(gameEvent);
|
|
break;
|
|
|
|
case "PlayerVoted":
|
|
HandlePlayerVoted(gameEvent);
|
|
break;
|
|
|
|
case "VotingClosed":
|
|
HandleVotingClosed(gameEvent);
|
|
break;
|
|
|
|
case "GameEnded":
|
|
HandleGameEnded(gameEvent);
|
|
break;
|
|
|
|
case "ReturnedToLobby":
|
|
HandleReturnedToLobby();
|
|
break;
|
|
|
|
case "SabotageStarted":
|
|
HandleSabotageStarted(gameEvent);
|
|
break;
|
|
|
|
case "SabotageRepaired":
|
|
case "SabotageMeltdown":
|
|
State.ActiveSabotage = null;
|
|
_manager?.uiSubsystem?.HideSabotageTimer();
|
|
_manager?.mapSubsystem?.ClearSabotageMarkers();
|
|
break;
|
|
|
|
case "MapDataError":
|
|
Debug.LogError("Server could not generate map data.");
|
|
break;
|
|
|
|
default:
|
|
Debug.Log("GameEvent: " + gameEvent.EventType);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// ── Lobby responses ───────────────────────────────────────────────────
|
|
|
|
private void HandleCreateLobbyResponse(CreateLobbyResponse message)
|
|
{
|
|
if (message == null) return;
|
|
if (message.Success)
|
|
{
|
|
Debug.Log($"Lobby created. Code: {message.JoinCode}");
|
|
SceneManager.LoadScene("create", LoadSceneMode.Single);
|
|
_manager?.uiSubsystem?.NotifyLobbyChanged();
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Failed to create lobby: " + message.Error);
|
|
}
|
|
}
|
|
|
|
private void HandleJoinLobbyResponse(JoinLobbyResponse message)
|
|
{
|
|
if (message == null) return;
|
|
if (message.Success)
|
|
{
|
|
Debug.Log($"Joined lobby: {message.LobbyId}");
|
|
SceneManager.LoadScene("join loading", LoadSceneMode.Single);
|
|
_manager?.uiSubsystem?.NotifyLobbyChanged();
|
|
}
|
|
else
|
|
{
|
|
Debug.LogError("Failed to join lobby: " + message.Error);
|
|
}
|
|
}
|
|
|
|
// ── Game flow ─────────────────────────────────────────────────────────
|
|
|
|
private void HandleGameStarting()
|
|
{
|
|
_pendingMapBuild = false;
|
|
// Reset per-game state
|
|
State.MyRole = null;
|
|
State.IsDead = false;
|
|
State.MyTasks = new List<GameTask>();
|
|
State.MyCompletedTaskIds = new HashSet<string>();
|
|
State.TotalCompleted = 0;
|
|
State.TotalRequired = 0;
|
|
State.ActiveMeeting = null;
|
|
State.LastVoteResult = null;
|
|
State.VotedPlayerIds = new HashSet<string>();
|
|
State.ActiveSabotage = null;
|
|
State.GameEndData = null;
|
|
State.KillCooldownRemaining = 0;
|
|
SceneManager.LoadScene("Client", LoadSceneMode.Single);
|
|
}
|
|
|
|
private void HandleMapDataReady()
|
|
{
|
|
_pendingMapBuild = true;
|
|
TryBuildMapAndMarkers();
|
|
}
|
|
|
|
public void OnClientSceneReady()
|
|
{
|
|
TryBuildMapAndMarkers();
|
|
}
|
|
|
|
private void TryBuildMapAndMarkers()
|
|
{
|
|
if (!_pendingMapBuild) return;
|
|
if (_manager?.mapSubsystem == null || !_manager.mapSubsystem.IsSceneReady) return;
|
|
if (_gameClient?.CurrentLobbyState?.MapData == null) return;
|
|
|
|
_manager.mapSubsystem.BuildMap();
|
|
_manager.mapSubsystem.CreateTaskMarkers(_gameClient.MyTasks);
|
|
_pendingMapBuild = false;
|
|
Debug.Log("[Network] Map built.");
|
|
}
|
|
|
|
private void HandleRoleAssigned(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<RoleAssignedPayload>();
|
|
if (payload == null || payload.ClientUuid != _gameClient.ClientUuid) return;
|
|
|
|
State.MyRole = payload.Role;
|
|
State.MyTasks = payload.Tasks ?? new List<GameTask>();
|
|
State.MyCompletedTaskIds.Clear();
|
|
|
|
Debug.Log($"Role: {payload.Role}, Tasks: {State.MyTasks.Count}");
|
|
_manager?.taskSubsystem?.Initialize(State.MyTasks);
|
|
}
|
|
|
|
private void HandleTaskCompleted(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<TaskCompletedPayload>();
|
|
if (payload == null) return;
|
|
|
|
// Track if it's our task
|
|
if (payload.ClientUuid == _gameClient.ClientUuid)
|
|
State.MyCompletedTaskIds.Add(payload.TaskId);
|
|
|
|
State.TotalCompleted = payload.TotalCompleted;
|
|
State.TotalRequired = payload.TotalTasks;
|
|
|
|
_manager?.uiSubsystem?.UpdateTaskProgress(payload.TotalCompleted, payload.TotalTasks);
|
|
_manager?.mapSubsystem?.RemoveTaskMarker(payload.TaskId);
|
|
}
|
|
|
|
private void HandlePlayerKilled(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<PlayerKilledPayload>();
|
|
if (payload == null) return;
|
|
|
|
_manager?.mapSubsystem?.CreateBodyMarker(payload.BodyId, payload.Location);
|
|
|
|
if (payload.VictimId == _gameClient.ClientUuid)
|
|
{
|
|
State.IsDead = true;
|
|
_manager?.uiSubsystem?.OnLocalPlayerDied();
|
|
}
|
|
|
|
// Update player state in our list
|
|
var p = State.Players.Find(x => x.ClientUuid == payload.VictimId);
|
|
if (p != null) p.State = PlayerState.Dead;
|
|
}
|
|
|
|
private void HandleMeetingStarted(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<MeetingStartedPayload>();
|
|
if (payload == null) return;
|
|
|
|
State.Phase = GamePhase.Meeting;
|
|
State.ActiveMeeting = payload;
|
|
State.VotedPlayerIds = new HashSet<string>();
|
|
State.LastVoteResult = null;
|
|
|
|
SyncPlayersFromLobby();
|
|
_manager?.uiSubsystem?.ShowMeetingPanel(State.Players, payload);
|
|
}
|
|
|
|
private void HandlePlayerVoted(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<PlayerVotedPayload>();
|
|
if (payload == null) return;
|
|
State.VotedPlayerIds.Add(payload.VoterId);
|
|
}
|
|
|
|
private void HandleVotingClosed(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<VotingClosedPayload>();
|
|
if (payload == null) return;
|
|
|
|
State.Phase = GamePhase.Playing;
|
|
State.ActiveMeeting = null;
|
|
State.LastVoteResult = payload;
|
|
|
|
// Mark ejected player dead in our list
|
|
if (!string.IsNullOrEmpty(payload.EjectedPlayerId))
|
|
{
|
|
var p = State.Players.Find(x => x.ClientUuid == payload.EjectedPlayerId);
|
|
if (p != null) p.State = PlayerState.Dead;
|
|
}
|
|
|
|
_manager?.uiSubsystem?.ShowVoteResult(payload, State.Players);
|
|
_manager?.mapSubsystem?.ClearBodyMarkers();
|
|
}
|
|
|
|
private void HandleGameEnded(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<GameEndedPayload>();
|
|
if (payload == null) return;
|
|
|
|
State.Phase = GamePhase.Ended;
|
|
State.GameEndData = payload;
|
|
|
|
_manager?.uiSubsystem?.ShowGameEndPanel(payload, _gameClient.ClientUuid);
|
|
}
|
|
|
|
private void HandleReturnedToLobby()
|
|
{
|
|
State.Phase = GamePhase.Lobby;
|
|
if (_gameClient.IsOwner)
|
|
SceneManager.LoadScene("create", LoadSceneMode.Single);
|
|
else
|
|
SceneManager.LoadScene("join loading", LoadSceneMode.Single);
|
|
}
|
|
|
|
private void HandleSabotageStarted(GameEvent evt)
|
|
{
|
|
var payload = evt.GetPayload<SabotageStartedPayload>();
|
|
if (payload == null) return;
|
|
|
|
State.ActiveSabotage = payload;
|
|
|
|
_manager?.mapSubsystem?.CreateSabotageMarkers(payload.RepairStations);
|
|
if (payload.Type == SabotageType.CriticalMeltdown && payload.Deadline.HasValue)
|
|
_manager?.uiSubsystem?.ShowSabotageTimer(payload.Deadline.Value);
|
|
if (payload.Type == SabotageType.CommsBlackout)
|
|
_manager?.uiSubsystem?.SetCommsBlackout(true);
|
|
}
|
|
|
|
private void HandlePositionBroadcast(PositionBroadcast broadcast)
|
|
{
|
|
if (broadcast == null) return;
|
|
_manager?.mapSubsystem?.UpdatePlayerAvatars(_gameClient.PlayerPositions, _gameClient.ClientUuid);
|
|
}
|
|
|
|
// ── Helpers ───────────────────────────────────────────────────────────
|
|
|
|
private void SyncPlayersFromLobby()
|
|
{
|
|
var lobby = _gameClient.CurrentLobbyState;
|
|
if (lobby?.Players != null)
|
|
State.Players = lobby.Players;
|
|
}
|
|
|
|
private void Toast(string message)
|
|
{
|
|
State.ToastMessage = message;
|
|
State.ToastExpiry = UnityEngine.Time.time + 4f;
|
|
}
|
|
|
|
// ── Send helpers ──────────────────────────────────────────────────────
|
|
|
|
public void CreateLobby(double lat, double lon, double radius = 500, int impostorCount = 1, int taskCount = 5)
|
|
{
|
|
_gameClient.CreateLobby(new Position(lat, lon), impostorCount, taskCount, null, radius);
|
|
}
|
|
|
|
public void JoinLobby(string joinCode)
|
|
{
|
|
try { _gameClient.JoinLobby(joinCode); }
|
|
catch (System.Exception ex) { Debug.LogError("JoinLobby error: " + ex.Message); }
|
|
}
|
|
|
|
public void LeaveLobby()
|
|
{
|
|
_gameClient.LeaveLobby();
|
|
State.Phase = GamePhase.Lobby;
|
|
SceneManager.LoadScene(_manager?.firstMenuScene ?? "main menu asi idk lol", LoadSceneMode.Single);
|
|
}
|
|
|
|
public void StartGame()
|
|
{
|
|
_gameClient.StartGame();
|
|
}
|
|
}
|
|
}
|
|
|