Files
sor/Server/src/SOR.Game/Handlers/GameReadyHandler.cs
T
7b1e7e346a Show display names everywhere accountId was shown in GameScreen
Server:
- PlayerState: add DisplayName property (populated from identity DB)
- PlayerStateDto: add DisplayName field (falls back to truncated ID)
- GameEngine.ToDto: include DisplayName in player DTO
- GameReadyHandler: resolve display names from identity DB after state
  initialization so every subsequent state push carries them

Client:
- Game.gd: add get_display_name(account_id) helper — reads displayName
  from player state, falls back to substr(0,8)
- game_screen.gd: replace all 5 pid/eid/elim_id.substr(0,8) UI sites
  with Game.get_display_name() — HUD opp name, turn order strip,
  game-over outcome list, discard scope selector, elimination dialog
- Turn order strip chips: use resolved display name; add mouse_filter
  STOP + tooltip_text showing SP/ST/Hand/Deck for opponent chips on hover

Generated with [Claude Code](https://claude.ai/code)
via [Happy](https://happy.engineering)

Co-Authored-By: Claude <noreply@anthropic.com>
Co-Authored-By: Happy <yesreply@happy.engineering>
2026-03-26 10:52:08 -04:00

280 lines
12 KiB
C#

namespace SOR.Game.Handlers;
using System.Text.Json;
using Microsoft.EntityFrameworkCore;
using SOR.Database.Contexts;
using SOR.Database.Entities.Catalog;
using SOR.Database.Entities.Collection;
using SOR.Database.Enums;
using SOR.Networking.Abstractions.Messaging;
using SOR.Networking.Abstractions.Push;
using SOR.Networking.Abstractions.Transport;
using SOR.Shared.Networking;
/// <summary>
/// game.ready — player signals they are on the game screen and ready to start.
///
/// When BOTH players have sent ready, the game state is initialized and
/// pushed to both clients.
/// </summary>
internal sealed class GameReadyHandler : GameHandlerBase, IMessageHandler
{
private readonly IMessageSerializer _serializer;
private readonly GameDbContext _gameDb;
private readonly SorIdentityDbContext _identityDb;
private readonly CollectionDbContext _collectionDb;
private readonly CatalogDbContext _catalogDb;
private readonly IClientPush _clientPush;
public GameReadyHandler(
IMessageSerializer serializer,
GameDbContext gameDb,
SorIdentityDbContext identityDb,
CollectionDbContext collectionDb,
CatalogDbContext catalogDb,
IClientPush clientPush)
{
_serializer = serializer;
_gameDb = gameDb;
_identityDb = identityDb;
_collectionDb = collectionDb;
_catalogDb = catalogDb;
_clientPush = clientPush;
}
public string MessageType => "game.ready";
public async Task<IServerMessage?> HandleAsync(
IClientMessage message,
AuthenticatedConnection connection,
CancellationToken ct)
{
var req = _serializer.DeserializePayload<GameReadyRequest>(message.Payload);
var accountId = Guid.Parse(connection.UserId);
// Serialize concurrent game.ready requests with a row-level lock so that
// exactly one request performs initialization when both players are ready.
// Without this, both players send game.ready at nearly the same time (both
// clients navigate to the game screen after match_found), each reads the
// other's ready flag as false, and neither triggers initialization.
await _gameDb.Database.BeginTransactionAsync(ct);
var session = await _gameDb.GameSessions
.FromSqlInterpolated(
$"""
SELECT * FROM game.game_sessions
WHERE "Id" = {req.SessionId}
FOR UPDATE
""")
.SingleOrDefaultAsync(ct)
?? throw new GameException("SESSION_NOT_FOUND");
bool isP1orP2 = session.PlayerOneAccountId == accountId || session.PlayerTwoAccountId == accountId;
bool isAdditional = !isP1orP2 && session.AdditionalPlayersJson != null &&
session.AdditionalPlayersJson.Contains(accountId.ToString());
if (!isP1orP2 && !isAdditional)
throw new GameException("NOT_IN_SESSION");
if (session.Status == GameSessionStatus.Active)
{
await _gameDb.Database.CommitTransactionAsync(ct);
// Fetch the opponent's display name so the client can show it correctly on rejoin.
var opponentId = session.PlayerOneAccountId == accountId
? session.PlayerTwoAccountId
: session.PlayerOneAccountId;
var oppName = await _identityDb.Users
.AsNoTracking()
.Where(a => a.Id == opponentId)
.Select(a => a.DisplayName ?? a.UserName ?? a.Id.ToString().Substring(0, 8))
.FirstOrDefaultAsync(ct);
return ServerMessage.Reply("game.ready.ack", message.Seq,
new GameReadyResponse(session.Id, "AlreadyStarted", oppName));
}
if (session.Status != GameSessionStatus.Initializing)
throw new GameException("SESSION_NOT_INITIALIZING");
// Mark this player ready.
if (session.PlayerOneAccountId == accountId)
session.PlayerOneReady = true;
else if (session.PlayerTwoAccountId == accountId)
session.PlayerTwoReady = true;
else if (isAdditional && session.AdditionalPlayersJson != null)
{
// Additional players (seat 2+): track readiness in AdditionalPlayersJson.
var addl = JsonSerializer.Deserialize<List<SessionAdditionalPlayer>>(
session.AdditionalPlayersJson,
new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
?? new();
var entry = addl.FirstOrDefault(p => p.AccountId == accountId);
if (entry != null) entry.IsReady = true;
session.AdditionalPlayersJson = JsonSerializer.Serialize(addl);
}
await _gameDb.SaveChangesAsync(ct);
bool allReady = session.PlayerOneReady && session.PlayerTwoReady;
if (allReady && !string.IsNullOrEmpty(session.AdditionalPlayersJson))
{
var addl = JsonSerializer.Deserialize<List<SessionAdditionalPlayer>>(
session.AdditionalPlayersJson,
new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
?? new();
allReady = addl.All(p => p.IsReady);
}
if (!allReady)
{
await _gameDb.Database.CommitTransactionAsync(ct);
return ServerMessage.Reply("game.ready.ack", message.Seq,
new GameReadyResponse(session.Id, "WaitingForOpponent"));
}
// Both ready — initialize game state.
// Deserialize rule snapshot (falls back to default if none stored).
var rules = session.RuleSnapshotJson is not null
? GameEngine.DeserializeRules(session.RuleSnapshotJson)
: null;
GameState state;
if (session.PlayerCount <= 2 || string.IsNullOrEmpty(session.AdditionalPlayersJson))
{
// Standard 2-player path.
var p1DeckCards = await LoadDeckCardsAsync(session.PlayerOneDeckId, ct);
var p2DeckCards = await LoadDeckCardsAsync(session.PlayerTwoDeckId, ct);
var p1ArchSpirit = await LoadDeckArchSpiritAsync(session.PlayerOneDeckId, ct);
var p2ArchSpirit = await LoadDeckArchSpiritAsync(session.PlayerTwoDeckId, ct);
state = GameEngine.Initialize(
session.Id,
session.PlayerOneAccountId, p1DeckCards, p1ArchSpirit,
session.PlayerTwoAccountId, p2DeckCards, p2ArchSpirit,
rules);
}
else
{
// N-player path: read additional players from session JSON.
var additionalEntries = JsonSerializer.Deserialize<List<SessionAdditionalPlayer>>(
session.AdditionalPlayersJson,
new JsonSerializerOptions { PropertyNameCaseInsensitive = true })
?? new();
// Build player list with seat/team indices.
// P1 and P2 always have seatIndex 0 and 1; teamIndex from GameMode.
int teamCount = 1; // FFA default
static int TeamIdx(string gameMode, int seat, int tc) =>
gameMode == "FFA" ? seat : seat % tc;
var playerList = new List<(Guid, IEnumerable<(SOR.Database.Entities.Catalog.CardDefinition, int)>,
SOR.Database.Entities.Catalog.CardDefinition, int, int)>
{
(session.PlayerOneAccountId,
await LoadDeckCardsAsync(session.PlayerOneDeckId, ct),
await LoadDeckArchSpiritAsync(session.PlayerOneDeckId, ct),
0,
TeamIdx(session.GameMode, 0, teamCount)),
(session.PlayerTwoAccountId,
await LoadDeckCardsAsync(session.PlayerTwoDeckId, ct),
await LoadDeckArchSpiritAsync(session.PlayerTwoDeckId, ct),
1,
TeamIdx(session.GameMode, 1, teamCount)),
};
foreach (var entry in additionalEntries)
{
playerList.Add((
entry.AccountId,
await LoadDeckCardsAsync(entry.DeckId, ct),
await LoadDeckArchSpiritAsync(entry.DeckId, ct),
entry.SeatIndex,
entry.TeamIndex));
}
state = GameEngine.Initialize(
session.Id,
playerList.AsReadOnly(),
session.GameMode,
rules?.BoardShape ?? "Rectangle",
rules);
}
// Resolve display names for all players so every client can show real names.
var pidGuids = state.Players.Keys
.Select(k => Guid.TryParse(k, out var g) ? g : Guid.Empty)
.Where(g => g != Guid.Empty)
.ToArray();
var nameMap = await _identityDb.Users
.AsNoTracking()
.Where(u => pidGuids.Contains(u.Id))
.Select(u => new { u.Id, Name = u.DisplayName ?? u.UserName ?? u.Id.ToString().Substring(0, 8) })
.ToDictionaryAsync(u => u.Id.ToString(), u => u.Name, ct);
foreach (var (pid, ps) in state.Players)
if (nameMap.TryGetValue(pid, out var dn))
ps.DisplayName = dn;
session.StateJson = GameEngine.Serialize(state);
session.Status = GameSessionStatus.Active;
session.StartedAt = DateTimeOffset.UtcNow;
await _gameDb.SaveChangesAsync(ct);
await _gameDb.Database.CommitTransactionAsync(ct);
// Push initial state to both players.
await PushStateToPlayersAsync(_clientPush, session, state, ct);
return ServerMessage.Reply("game.ready.ack", message.Seq,
new GameReadyResponse(session.Id, "Started"));
}
// ── Helpers ───────────────────────────────────────────────────────────────
/// <summary>JSON shape for AdditionalPlayersJson entries on a GameSession.</summary>
private sealed class SessionAdditionalPlayer
{
public Guid AccountId { get; set; }
public Guid DeckId { get; set; }
public int SeatIndex { get; set; }
public int TeamIndex { get; set; }
public bool IsReady { get; set; }
}
private async Task<IEnumerable<(CardDefinition, int)>> LoadDeckCardsAsync(Guid deckId, CancellationToken ct)
{
var deck = await _collectionDb.Decks
.AsNoTracking()
.Include(d => d.Cards)
.FirstOrDefaultAsync(d => d.Id == deckId, ct)
?? throw new GameException("DECK_NOT_FOUND");
var defIds = deck.Cards.Select(c => c.CardDefinitionId).ToList();
var defs = await _catalogDb.Set<CardDefinition>()
.AsNoTracking()
.Where(d => defIds.Contains(d.Id))
.ToDictionaryAsync(d => d.Id, ct);
return deck.Cards
.Where(c => defs.ContainsKey(c.CardDefinitionId))
.Select(c => (defs[c.CardDefinitionId], c.Quantity));
}
private async Task<CardDefinition> LoadDeckArchSpiritAsync(Guid deckId, CancellationToken ct)
{
var deck = await _collectionDb.Decks
.AsNoTracking()
.FirstOrDefaultAsync(d => d.Id == deckId, ct)
?? throw new GameException("DECK_NOT_FOUND");
if (deck.ArchSpiritCardDefinitionId == Guid.Empty)
throw new GameException("DECK_HAS_NO_ARCH_SPIRIT");
return await _catalogDb.Set<CardDefinition>()
.AsNoTracking()
.FirstOrDefaultAsync(d => d.Id == deck.ArchSpiritCardDefinitionId, ct)
?? throw new GameException("ARCH_SPIRIT_DEFINITION_NOT_FOUND");
}
}