using System.Collections.Concurrent;
using System.Numerics;
using System.Text.Json;
using Microsoft.Extensions.Logging;
using Server.Networking;
using Server.Networking.Handling;
using Server.Networking.Messages;
using Server.Services.Auth;
namespace VoidScavengers.Game;
///
/// Handles all game-related messages and manages match instances.
/// Integrates with the existing SystemRevival server architecture.
///
public sealed class GameHandler : IClientMessageHandler
{
private readonly ILogger _log;
private readonly ISessionRegistry _sessions;
private readonly IMessageSerializer _ser;
private readonly MatchManager _matchManager;
public GameHandler(
ILogger log,
ISessionRegistry sessions,
IMessageSerializer ser,
MatchManager matchManager)
{
_log = log;
_sessions = sessions;
_ser = ser;
_matchManager = matchManager;
}
public IReadOnlyCollection SupportedOpCodes => new[]
{
// Lobby
GameOpCodes.LOBBY_JOIN,
GameOpCodes.LOBBY_READY,
GameOpCodes.LOBBY_LEAVE,
// Game Input
GameOpCodes.INPUT_MOVE,
GameOpCodes.INPUT_ACTION,
GameOpCodes.INPUT_SHOOT,
GameOpCodes.INPUT_DROP,
GameOpCodes.INPUT_CRAFT,
// Chat
GameOpCodes.CHAT_SEND
};
public async Task HandleAsync(int opCode, IConnection connection, ReadOnlyMemory payload, CancellationToken ct)
{
// All game operations require authentication
if (!_sessions.TryGet(connection.Id, out var accountId, out _))
{
await SendErrorAsync(connection, "auth_required", ct);
return;
}
try
{
switch (opCode)
{
case GameOpCodes.LOBBY_JOIN:
await HandleLobbyJoinAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.LOBBY_READY:
await HandleLobbyReadyAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.LOBBY_LEAVE:
await HandleLobbyLeaveAsync(connection, accountId, ct);
break;
case GameOpCodes.INPUT_MOVE:
await HandleMoveInputAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.INPUT_SHOOT:
await HandleShootInputAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.INPUT_ACTION:
await HandleActionInputAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.INPUT_CRAFT:
await HandleCraftInputAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.INPUT_DROP:
await HandleDropInputAsync(connection, accountId, payload, ct);
break;
case GameOpCodes.CHAT_SEND:
await HandleChatAsync(connection, accountId, payload, ct);
break;
}
}
catch (Exception ex)
{
_log.LogError(ex, "Error handling opcode {OpCode} from account {AccountId}", opCode, accountId);
await SendErrorAsync(connection, "internal_error", ct);
}
}
private async Task HandleLobbyJoinAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var request = _ser.Deserialize(payload);
// Get or create player name (in production, fetch from database)
string playerName = request?.PlayerName ?? $"Player{accountId % 10000}";
var (ok, lobbyId, error) = await _matchManager.JoinLobbyAsync(accountId, conn, playerName);
var result = new LobbyJoinResult(ok, error, lobbyId, ok ? _matchManager.GetLobbyPlayerCount(lobbyId!) : 0);
await SendAsync(conn, GameOpCodes.LOBBY_JOIN_RESULT, result, ct);
}
private async Task HandleLobbyReadyAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var request = _ser.Deserialize(payload);
await _matchManager.SetPlayerReadyAsync(accountId, request?.Ready ?? true);
}
private async Task HandleLobbyLeaveAsync(IConnection conn, ulong accountId, CancellationToken ct)
{
await _matchManager.LeaveLobbyAsync(accountId);
}
private Task HandleMoveInputAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var input = _ser.Deserialize(payload);
if (input == null) return Task.CompletedTask;
_matchManager.EnqueueInput(accountId, new PlayerInput
{
PlayerId = accountId,
Type = InputType.Move,
Dx = input.Dx,
Dy = input.Dy,
AimAngle = input.AimAngle,
Seq = input.Seq
});
return Task.CompletedTask;
}
private Task HandleShootInputAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var input = _ser.Deserialize(payload);
if (input == null) return Task.CompletedTask;
_matchManager.EnqueueInput(accountId, new PlayerInput
{
PlayerId = accountId,
Type = InputType.Shoot,
AimAngle = input.AimAngle,
Seq = input.Seq
});
return Task.CompletedTask;
}
private Task HandleActionInputAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var input = _ser.Deserialize(payload);
_matchManager.EnqueueInput(accountId, new PlayerInput
{
PlayerId = accountId,
Type = InputType.Action,
TargetId = input?.TargetId
});
return Task.CompletedTask;
}
private Task HandleCraftInputAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var input = _ser.Deserialize(payload);
if (input == null) return Task.CompletedTask;
_matchManager.EnqueueInput(accountId, new PlayerInput
{
PlayerId = accountId,
Type = InputType.Craft,
TargetId = input.RecipeId
});
return Task.CompletedTask;
}
private Task HandleDropInputAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var input = _ser.Deserialize(payload);
if (input == null) return Task.CompletedTask;
_matchManager.EnqueueInput(accountId, new PlayerInput
{
PlayerId = accountId,
Type = InputType.Drop,
TargetId = input.SlotIndex
});
return Task.CompletedTask;
}
private async Task HandleChatAsync(IConnection conn, ulong accountId, ReadOnlyMemory payload, CancellationToken ct)
{
var msg = _ser.Deserialize(payload);
if (string.IsNullOrWhiteSpace(msg?.Text)) return;
// Sanitize and limit message
string text = msg.Text.Trim();
if (text.Length > 200) text = text[..200];
await _matchManager.BroadcastChatAsync(accountId, text);
}
private async Task SendAsync(IConnection conn, int opCode, T data, CancellationToken ct)
{
var payload = _ser.Serialize(data);
var wire = _ser.Serialize(new ServerMessage(opCode, payload));
await conn.SendAsync(wire, ct);
}
private async Task SendErrorAsync(IConnection conn, string error, CancellationToken ct)
{
await SendAsync(conn, OpCodes.ERROR, new { error }, ct);
}
}
// ===== Input message types for deserialization =====
public sealed record LobbyJoinRequest(string? PlayerName);
public sealed record LobbyReadyRequest(bool Ready);
public sealed record LobbyJoinResult(bool Ok, string? Error, string? LobbyId, int PlayerCount);
public sealed record MoveInputMsg(float Dx, float Dy, float AimAngle, uint Seq);
public sealed record ShootInputMsg(float AimAngle, uint Seq);
public sealed record ActionInputMsg(int? TargetId);
public sealed record CraftInputMsg(int RecipeId);
public sealed record DropInputMsg(int SlotIndex);
public sealed record ChatMsg(string Text);
///
/// Static OpCodes class for game-specific operations
///
public static class GameOpCodes
{
// Lobby
public const int LOBBY_JOIN = 400;
public const int LOBBY_JOIN_RESULT = 401;
public const int LOBBY_STATE = 402;
public const int LOBBY_READY = 403;
public const int LOBBY_COUNTDOWN = 404;
public const int LOBBY_LEAVE = 405;
// Game State
public const int GAME_START = 420;
public const int GAME_STATE = 421;
public const int GAME_TICK = 422;
public const int GAME_END = 423;
// Input
public const int INPUT_MOVE = 450;
public const int INPUT_ACTION = 451;
public const int INPUT_SHOOT = 452;
public const int INPUT_DROP = 453;
public const int INPUT_CRAFT = 454;
// Events
public const int EVENT_SPAWN = 470;
public const int EVENT_DESPAWN = 471;
public const int EVENT_DAMAGE = 472;
public const int EVENT_DEATH = 473;
public const int EVENT_PICKUP = 474;
public const int EVENT_PROJECTILE = 475;
public const int EVENT_EXPLOSION = 476;
// Chat
public const int CHAT_SEND = 500;
public const int CHAT_RECEIVE = 501;
}
///
/// Manages lobbies, matchmaking, and active game instances
///
public sealed class MatchManager : IDisposable
{
private readonly ILogger _log;
private readonly IMessageSerializer _ser;
private readonly ConcurrentDictionary _lobbies = new();
private readonly ConcurrentDictionary _matches = new();
private readonly ConcurrentDictionary _playerToLobby = new();
private readonly ConcurrentDictionary _playerToMatch = new();
private readonly ConcurrentDictionary _playerConnections = new();
private readonly Timer _tickTimer;
private readonly Timer _lobbyTimer;
private const int MinPlayersToStart = 2;
private const int MaxPlayersPerLobby = 8;
private const int LobbyCountdownSeconds = 10;
public MatchManager(ILogger log, IMessageSerializer ser)
{
_log = log;
_ser = ser;
// Game tick timer (20 Hz)
_tickTimer = new Timer(OnGameTick, null, 50, 50);
// Lobby update timer (1 Hz)
_lobbyTimer = new Timer(OnLobbyTick, null, 1000, 1000);
}
public async Task<(bool ok, string? lobbyId, string? error)> JoinLobbyAsync(ulong accountId, IConnection conn, string playerName)
{
// Remove from any existing lobby
await LeaveLobbyAsync(accountId);
// Find or create lobby
Lobby? lobby = null;
foreach (var l in _lobbies.Values)
{
if (l.Phase == LobbyPhase.Waiting && l.Players.Count < MaxPlayersPerLobby)
{
lobby = l;
break;
}
}
if (lobby == null)
{
lobby = new Lobby
{
Id = Guid.NewGuid().ToString("N")[..8],
CreatedAt = DateTime.UtcNow
};
_lobbies[lobby.Id] = lobby;
_log.LogInformation("Created new lobby {LobbyId}", lobby.Id);
}
var player = new LobbyPlayer
{
AccountId = accountId,
Name = playerName,
Ready = false,
Connection = conn
};
lobby.Players[accountId] = player;
_playerToLobby[accountId] = lobby.Id;
_playerConnections[accountId] = conn;
_log.LogInformation("Player {AccountId} ({Name}) joined lobby {LobbyId}", accountId, playerName, lobby.Id);
// Broadcast updated lobby state
await BroadcastLobbyStateAsync(lobby);
return (true, lobby.Id, null);
}
public async Task LeaveLobbyAsync(ulong accountId)
{
if (_playerToLobby.TryRemove(accountId, out var lobbyId))
{
if (_lobbies.TryGetValue(lobbyId, out var lobby))
{
lobby.Players.Remove(accountId);
// Clean up empty lobbies
if (lobby.Players.Count == 0)
{
_lobbies.TryRemove(lobbyId, out _);
_log.LogInformation("Removed empty lobby {LobbyId}", lobbyId);
}
else
{
// Reset countdown if in progress
if (lobby.Phase == LobbyPhase.Countdown)
{
lobby.Phase = LobbyPhase.Waiting;
lobby.CountdownSeconds = 0;
}
await BroadcastLobbyStateAsync(lobby);
}
}
}
_playerConnections.TryRemove(accountId, out _);
}
public async Task SetPlayerReadyAsync(ulong accountId, bool ready)
{
if (!_playerToLobby.TryGetValue(accountId, out var lobbyId)) return;
if (!_lobbies.TryGetValue(lobbyId, out var lobby)) return;
if (!lobby.Players.TryGetValue(accountId, out var player)) return;
player.Ready = ready;
await BroadcastLobbyStateAsync(lobby);
// Check if all players ready
if (lobby.Players.Count >= MinPlayersToStart &&
lobby.Players.Values.All(p => p.Ready) &&
lobby.Phase == LobbyPhase.Waiting)
{
lobby.Phase = LobbyPhase.Countdown;
lobby.CountdownSeconds = LobbyCountdownSeconds;
_log.LogInformation("Lobby {LobbyId} starting countdown", lobbyId);
}
}
public int GetLobbyPlayerCount(string lobbyId)
{
return _lobbies.TryGetValue(lobbyId, out var lobby) ? lobby.Players.Count : 0;
}
public void EnqueueInput(ulong accountId, PlayerInput input)
{
if (!_playerToMatch.TryGetValue(accountId, out var matchId)) return;
if (!_matches.TryGetValue(matchId, out var match)) return;
match.Simulation.EnqueueInput(accountId, input);
}
public async Task BroadcastChatAsync(ulong senderId, string text)
{
// Find which match/lobby the sender is in
string? targetId = null;
Dictionary? targets = null;
string? senderName = null;
if (_playerToMatch.TryGetValue(senderId, out var matchId) &&
_matches.TryGetValue(matchId, out var match))
{
targets = match.Connections;
senderName = match.Simulation.Players.TryGetValue(senderId, out var p) ? p.Name : "Unknown";
}
else if (_playerToLobby.TryGetValue(senderId, out var lobbyId) &&
_lobbies.TryGetValue(lobbyId, out var lobby))
{
targets = lobby.Players.ToDictionary(kv => kv.Key, kv => kv.Value.Connection);
senderName = lobby.Players.TryGetValue(senderId, out var p) ? p.Name : "Unknown";
}
if (targets == null) return;
var chatMsg = new
{
senderId,
senderName,
text,
timestamp = DateTimeOffset.UtcNow.ToUnixTimeMilliseconds()
};
var payload = _ser.Serialize(chatMsg);
var wire = _ser.Serialize(new ServerMessage(GameOpCodes.CHAT_RECEIVE, payload));
foreach (var (_, conn) in targets)
{
try
{
await conn.SendAsync(wire);
}
catch { /* ignore failed sends */ }
}
}
private async void OnLobbyTick(object? state)
{
foreach (var lobby in _lobbies.Values.ToList())
{
if (lobby.Phase == LobbyPhase.Countdown)
{
lobby.CountdownSeconds--;
// Broadcast countdown
await BroadcastToLobbyAsync(lobby, GameOpCodes.LOBBY_COUNTDOWN,
new { seconds = lobby.CountdownSeconds });
if (lobby.CountdownSeconds <= 0)
{
// Start the match!
await StartMatchAsync(lobby);
}
}
}
}
private async Task StartMatchAsync(Lobby lobby)
{
lobby.Phase = LobbyPhase.Starting;
var matchId = Guid.NewGuid().ToString("N")[..12];
var seed = (int)(DateTime.UtcNow.Ticks % int.MaxValue);
var simulation = new GameSimulation(matchId, seed);
var match = new MatchInstance
{
Id = matchId,
Simulation = simulation,
StartedAt = DateTime.UtcNow
};
// Add players to match
int playerIndex = 0;
foreach (var (accountId, lobbyPlayer) in lobby.Players)
{
var spawnPos = simulation.GetSpawnPosition(playerIndex, lobby.Players.Count);
simulation.AddPlayer(accountId, lobbyPlayer.Name, spawnPos);
match.Connections[accountId] = lobbyPlayer.Connection;
_playerToMatch[accountId] = matchId;
_playerToLobby.TryRemove(accountId, out _);
playerIndex++;
}
_matches[matchId] = match;
_lobbies.TryRemove(lobby.Id, out _);
// Start simulation
simulation.StartGame();
// Send GAME_START to all players
foreach (var (accountId, conn) in match.Connections)
{
var startInfo = BuildGameStartInfo(simulation, accountId);
var payload = _ser.Serialize(startInfo);
var wire = _ser.Serialize(new ServerMessage(GameOpCodes.GAME_START, payload));
try
{
await conn.SendAsync(wire);
}
catch (Exception ex)
{
_log.LogWarning(ex, "Failed to send GAME_START to {AccountId}", accountId);
}
}
_log.LogInformation("Match {MatchId} started with {PlayerCount} players", matchId, match.Connections.Count);
}
private object BuildGameStartInfo(GameSimulation sim, ulong forPlayerId)
{
var self = sim.Players[forPlayerId];
var others = sim.Players.Values.Where(p => p.Id != forPlayerId).ToArray();
return new
{
matchId = sim.MatchId,
mapSeed = sim.MapSeed,
mapWidth = sim.MapWidth,
mapHeight = sim.MapHeight,
self = new
{
playerId = self.Id,
name = self.Name,
x = self.X,
y = self.Y,
rotation = self.Rotation,
health = self.Health,
maxHealth = self.MaxHealth
},
otherPlayers = others.Select(p => new
{
playerId = p.Id,
name = p.Name,
x = p.X,
y = p.Y,
rotation = p.Rotation,
health = p.Health,
maxHealth = p.MaxHealth
}).ToArray(),
asteroids = sim.Asteroids.Values.Select(a => new
{
id = a.Id,
x = a.X,
y = a.Y,
radius = a.Radius,
type = a.Type
}).ToArray(),
resources = sim.Resources.Values.Select(r => new
{
id = r.Id,
x = r.X,
y = r.Y,
resourceType = r.ResourceType,
amount = r.Amount
}).ToArray(),
extractionZones = sim.ExtractionZones.Values.Select(z => new
{
id = z.Id,
x = z.X,
y = z.Y,
radius = z.Radius,
active = z.Active,
activatesAtTick = z.ActivatesAtTick
}).ToArray()
};
}
private async void OnGameTick(object? state)
{
foreach (var match in _matches.Values.ToList())
{
if (match.Simulation.Phase != GamePhase.InProgress) continue;
// Advance simulation
var events = match.Simulation.Tick();
// Broadcast state snapshot every tick
await BroadcastGameStateAsync(match);
// Broadcast events
foreach (var evt in events)
{
await BroadcastEventAsync(match, evt);
// Handle game end
if (evt.Type == EventType.GameEnd)
{
await EndMatchAsync(match);
}
}
}
}
private async Task BroadcastGameStateAsync(MatchInstance match)
{
var sim = match.Simulation;
var state = new
{
tick = sim.CurrentTick,
timeRemaining = sim.TimeRemaining,
playersAlive = sim.Players.Values.Count(p => p.Alive),
entities = sim.Players.Values.Where(p => p.Alive).Select(p => new
{
id = p.Id,
type = 0, // player
x = p.X,
y = p.Y,
rotation = p.Rotation,
health = p.Health,
scrap = p.Scrap,
energy = p.Energy,
rare = p.Rare
}).ToArray(),
projectiles = sim.Projectiles.Values.Select(p => new
{
id = p.Id,
x = p.X,
y = p.Y,
velX = p.VelX,
velY = p.VelY,
ownerId = p.OwnerId
}).ToArray(),
droppedItems = sim.DroppedItems.Values.Select(d => new
{
id = d.Id,
x = d.X,
y = d.Y,
itemId = d.ItemId,
quantity = d.Quantity
}).ToArray(),
resources = sim.Resources.Values.Where(r => r.Amount > 0).Select(r => new
{
id = r.Id,
amount = r.Amount
}).ToArray()
};
var payload = _ser.Serialize(state);
var wire = _ser.Serialize(new ServerMessage(GameOpCodes.GAME_STATE, payload));
foreach (var (_, conn) in match.Connections)
{
try
{
await conn.SendAsync(wire);
}
catch { /* ignore */ }
}
}
private async Task BroadcastEventAsync(MatchInstance match, GameEvent evt)
{
int opCode = evt.Type switch
{
EventType.Spawn => GameOpCodes.EVENT_SPAWN,
EventType.Despawn => GameOpCodes.EVENT_DESPAWN,
EventType.Damage => GameOpCodes.EVENT_DAMAGE,
EventType.Death => GameOpCodes.EVENT_DEATH,
EventType.Pickup => GameOpCodes.EVENT_PICKUP,
EventType.Projectile => GameOpCodes.EVENT_PROJECTILE,
EventType.Explosion => GameOpCodes.EVENT_EXPLOSION,
EventType.GameEnd => GameOpCodes.GAME_END,
_ => 0
};
if (opCode == 0) return;
var payload = _ser.Serialize(evt.Data);
var wire = _ser.Serialize(new ServerMessage(opCode, payload));
foreach (var (_, conn) in match.Connections)
{
try
{
await conn.SendAsync(wire);
}
catch { /* ignore */ }
}
}
private async Task EndMatchAsync(MatchInstance match)
{
// Remove players from match tracking
foreach (var accountId in match.Connections.Keys)
{
_playerToMatch.TryRemove(accountId, out _);
}
_matches.TryRemove(match.Id, out _);
_log.LogInformation("Match {MatchId} ended", match.Id);
}
private async Task BroadcastLobbyStateAsync(Lobby lobby)
{
var state = new
{
lobbyId = lobby.Id,
phase = lobby.Phase.ToString(),
countdownSeconds = lobby.CountdownSeconds,
players = lobby.Players.Values.Select(p => new
{
accountId = p.AccountId,
name = p.Name,
ready = p.Ready
}).ToArray()
};
await BroadcastToLobbyAsync(lobby, GameOpCodes.LOBBY_STATE, state);
}
private async Task BroadcastToLobbyAsync(Lobby lobby, int opCode, T data)
{
var payload = _ser.Serialize(data);
var wire = _ser.Serialize(new ServerMessage(opCode, payload));
foreach (var player in lobby.Players.Values)
{
try
{
await player.Connection.SendAsync(wire);
}
catch { /* ignore */ }
}
}
public void Dispose()
{
_tickTimer.Dispose();
_lobbyTimer.Dispose();
}
}
// ===== Lobby & Match Data Structures =====
public sealed class Lobby
{
public string Id { get; set; } = "";
public LobbyPhase Phase { get; set; } = LobbyPhase.Waiting;
public int CountdownSeconds { get; set; }
public DateTime CreatedAt { get; set; }
public Dictionary Players { get; } = new();
}
public sealed class LobbyPlayer
{
public ulong AccountId { get; set; }
public string Name { get; set; } = "";
public bool Ready { get; set; }
public IConnection Connection { get; set; } = null!;
}
public enum LobbyPhase
{
Waiting,
Countdown,
Starting
}
public sealed class MatchInstance
{
public string Id { get; set; } = "";
public GameSimulation Simulation { get; set; } = null!;
public DateTime StartedAt { get; set; }
public Dictionary Connections { get; } = new();
}