From cf5089ae50a7c46be7dbc2e425f821fd59ec40c8 Mon Sep 17 00:00:00 2001 From: dingo Date: Sat, 21 Mar 2026 06:54:33 -0400 Subject: [PATCH] Delta state system: replace full-push with game.state_delta MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit After any game action, push a structured GameStateDelta instead of the full GameStateDto to both players and spectators. Full state is preserved for: initial connect (game.ready), reconnect/get_state, spectate ACK, and turn-timer expiry. Server: - GameMessages.cs: add GameStateDeltaPush, GameStateDelta, TileDelta, UnitDelta, PlayerStatsDelta, GameMetaDelta record types - GameEngine.cs: make ToCardDto internal (used by differ) - GameStateDiffer.cs: new file — ComputeDelta (viewer-specific) and ComputeSpectatorDelta; diffs tiles, field units, hands, discards, archs, player stats, and game meta - GameHandlerBase.cs: PushStateToPlayersAsync gains optional prevState param; when provided pushes delta, else falls back to full push - All 10 action handlers: pass prev state to PushStateToPlayersAsync Client: - Game.gd: _state_version tracking, _apply_delta, _merge_unit_delta, request_sync, game.state_delta push handler with auto-resync on gap - in_game_settings.gd + InGameSettings.tscn: Request Sync button Generated with [Claude Code](https://claude.ai/code) via [Happy](https://happy.engineering) Co-Authored-By: Claude Co-Authored-By: Happy --- Client/origin-client/autoloads/Game.gd | 216 ++++++++++- .../scenes/game/InGameSettings.tscn | 8 + .../scenes/game/in_game_settings.gd | 11 + Server/src/SOR.Game/GameEngine.cs | 2 +- Server/src/SOR.Game/GameMessages.cs | 72 ++++ Server/src/SOR.Game/GameStateDiffer.cs | 366 ++++++++++++++++++ .../Handlers/GameActivateAbilityHandler.cs | 2 +- .../SOR.Game/Handlers/GameAscendHandler.cs | 2 +- .../SOR.Game/Handlers/GameAttackHandler.cs | 2 +- .../src/SOR.Game/Handlers/GameDrawHandler.cs | 2 +- .../SOR.Game/Handlers/GameEndTurnHandler.cs | 2 +- .../src/SOR.Game/Handlers/GameHandlerBase.cs | 83 ++-- .../SOR.Game/Handlers/GameMoveUnitHandler.cs | 2 +- .../Handlers/GamePlaceArchSpiritHandler.cs | 2 +- .../SOR.Game/Handlers/GamePlayCardHandler.cs | 2 +- .../SOR.Game/Handlers/GameSacrificeHandler.cs | 2 +- .../Handlers/GameTransitionHandler.cs | 2 +- 17 files changed, 735 insertions(+), 43 deletions(-) create mode 100644 Server/src/SOR.Game/GameStateDiffer.cs diff --git a/Client/origin-client/autoloads/Game.gd b/Client/origin-client/autoloads/Game.gd index d7aced0..6119c7e 100644 --- a/Client/origin-client/autoloads/Game.gd +++ b/Client/origin-client/autoloads/Game.gd @@ -39,10 +39,11 @@ signal both_idle_warning(session_id: String) # ── State ───────────────────────────────────────────────────────────────────── -var session_id : String = "" -var state : Dictionary = {} -var opponent_name : String = "" -var is_spectating : bool = false +var session_id : String = "" +var state : Dictionary = {} +var opponent_name : String = "" +var is_spectating : bool = false +var _state_version : int = -1 # ── Lifecycle ───────────────────────────────────────────────────────────────── @@ -52,10 +53,11 @@ func _ready() -> void: func _clear_state() -> void: - session_id = "" - state = {} - opponent_name = "" - is_spectating = false + session_id = "" + state = {} + opponent_name = "" + is_spectating = false + _state_version = -1 ## Start spectating a game session. State is applied from the server ack. @@ -282,13 +284,22 @@ func _apply_state_from_payload(p: Variant) -> void: if s.is_empty(): print("[Game] _apply_state_from_payload: no 'state' key in payload ", JSON.stringify(p)) return + _state_version = int(s.get("stateVersion", -1)) print("[Game] state applied phase=", s.get("phase","?"), " turn=", s.get("turnNumber","?"), + " ver=", _state_version, " activePlayer=", str(s.get("activePlayerAccountId","?")).substr(0,8)) state = s state_updated.emit(state) +## Request a full state resync from the server (e.g. from in-game settings, or auto on missed delta). +func request_sync() -> void: + if session_id.is_empty(): return + print("[Game] requesting full state sync") + _fetch_state() + + func _player_by_id(account_id: String) -> Dictionary: for p: Dictionary in state.get("players", []): if str(p.get("accountId", "")).to_lower() == account_id.to_lower(): @@ -296,6 +307,178 @@ func _player_by_id(account_id: String) -> Dictionary: return {} +func _apply_delta(delta: Dictionary) -> void: + # 1. Changed tiles + var changed_tiles: Array = delta.get("changedTiles", []) + if changed_tiles != null: + var tiles: Array = state.get("board", {}).get("tiles", []) + for td: Dictionary in changed_tiles: + var tx := int(td.get("x", -1)) + var ty := int(td.get("y", -1)) + for tile: Dictionary in tiles: + var c: Dictionary = tile.get("coord", {}) + if c.get("x", -1) == tx and c.get("y", -1) == ty: + if td.has("base1") and td["base1"] != null: tile["base1"] = td["base1"] + if td.has("base2") and td["base2"] != null: tile["base2"] = td["base2"] + if td.has("resolvedAffinity") and td["resolvedAffinity"] != null: tile["resolvedAffinity"] = td["resolvedAffinity"] + if td.has("occupantCleared") and bool(td["occupantCleared"]): tile["occupantId"] = null; tile["occupantOwner"] = null + elif td.has("occupantId") and td["occupantId"] != null: tile["occupantId"] = td["occupantId"] + if td.has("occupantOwner") and td["occupantOwner"] != null: tile["occupantOwner"] = td["occupantOwner"] + if td.has("ruinCleared") and bool(td["ruinCleared"]): tile["ruinId"] = null; tile["ruinOwner"] = null + elif td.has("ruinId") and td["ruinId"] != null: tile["ruinId"] = td["ruinId"] + if td.has("ruinOwner") and td["ruinOwner"] != null: tile["ruinOwner"] = td["ruinOwner"] + break + + # 2. Added units (new units entering the field) + var added_units: Array = delta.get("addedUnits", []) + if added_units != null: + for unit: Dictionary in added_units: + var owner_id := str(unit.get("ownerId", "")) # not on CardInstanceDto, use position to find by ownerId? + # CardInstanceDto doesn't carry ownerId; find the right player by checking which player + # doesn't already have this unit. We append to the player who owns the tile. + # Fallback: use the unit's position coord to find the tile's occupant owner. + var placed := false + for p: Dictionary in state.get("players", []): + var field: Array = p.get("field", []) + # Check if this player already has the unit (shouldn't happen) + var found := false + for u: Dictionary in field: + if u.get("instanceId", "") == unit.get("instanceId", ""): + found = true + break + if not found and not placed: + # Determine ownership from the tile's occupantOwner matching this player's accountId + var pos: Dictionary = unit.get("position", {}) + if not pos.is_empty(): + var tile := get_tile(int(pos.get("x", -1)), int(pos.get("y", -1))) + if str(tile.get("occupantOwner", "")).to_lower() == str(p.get("accountId", "")).to_lower(): + field.append(unit) + placed = true + # Fallback if we couldn't place via tile: append to active player's field + if not placed: + var my_p := get_my_player() + if not my_p.is_empty(): + my_p.get("field", []).append(unit) + + # 3. Removed unit IDs + var removed_ids: Array = delta.get("removedUnitIds", []) + if removed_ids != null: + for iid: String in removed_ids: + for p: Dictionary in state.get("players", []): + var field: Array = p.get("field", []) + for i in range(field.size() - 1, -1, -1): + if field[i].get("instanceId", "") == iid: + field.remove_at(i) + break + + # 4. Changed units (merge non-null UnitDelta fields) + var changed_units: Array = delta.get("changedUnits", []) + if changed_units != null: + for ud: Dictionary in changed_units: + var iid := str(ud.get("instanceId", "")) + var unit := get_unit_by_id(iid) + if not unit.is_empty(): + _merge_unit_delta(unit, ud) + + # 5. Hand added / removed (own player only) + var hand_added: Array = delta.get("handAdded", []) + if hand_added != null and not hand_added.is_empty(): + var my_hand: Array = get_my_player().get("hand", []) + for card: Dictionary in hand_added: + my_hand.append(card) + + var hand_removed: Array = delta.get("handRemovedIds", []) + if hand_removed != null: + var my_hand: Array = get_my_player().get("hand", []) + for iid: String in hand_removed: + for i in range(my_hand.size() - 1, -1, -1): + if my_hand[i].get("instanceId", "") == iid: + my_hand.remove_at(i) + break + + # 6. Discard added + var discard_added: Array = delta.get("discardAdded", []) + if discard_added != null and not discard_added.is_empty(): + var my_discard: Array = get_my_player().get("discard", []) + for card: Dictionary in discard_added: + my_discard.append(card) + + # 7. Opponent hand / deck counts + var opp_hand_count = delta.get("opponentHandCount", null) + var opp_deck_count = delta.get("opponentDeckCount", null) + var opp := get_opponent() + if not opp.is_empty(): + if opp_hand_count != null: opp["handCount"] = int(opp_hand_count) + if opp_deck_count != null: opp["deckCount"] = int(opp_deck_count) + + # 8. ArchSpirits + var own_arch_delta: Dictionary = delta.get("ownArchSpiritDelta", {}) + if own_arch_delta != null and not own_arch_delta.is_empty(): + var my_arch: Dictionary = get_my_player().get("archSpirit", {}) + if not my_arch.is_empty(): + _merge_unit_delta(my_arch, own_arch_delta) + + var opp_arch_delta: Dictionary = delta.get("opponentArchSpiritDelta", {}) + if opp_arch_delta != null and not opp_arch_delta.is_empty(): + var opp_arch: Dictionary = get_opponent().get("archSpirit", {}) + if not opp_arch.is_empty(): + _merge_unit_delta(opp_arch, opp_arch_delta) + + # 9. Player stats + var own_stats: Dictionary = delta.get("ownStatsDelta", {}) + if own_stats != null and not own_stats.is_empty(): + var my_p := get_my_player() + if not my_p.is_empty(): + if own_stats.has("currentSp") and own_stats["currentSp"] != null: my_p["currentSp"] = int(own_stats["currentSp"]) + if own_stats.has("currentSt") and own_stats["currentSt"] != null: my_p["currentSt"] = int(own_stats["currentSt"]) + if own_stats.has("deckCount") and own_stats["deckCount"] != null: my_p["deckCount"] = int(own_stats["deckCount"]) + if own_stats.has("handCount") and own_stats["handCount"] != null: my_p["handCount"] = int(own_stats["handCount"]) + if own_stats.has("discardCount") and own_stats["discardCount"] != null: my_p["discardCount"] = int(own_stats["discardCount"]) + + var opp_stats: Dictionary = delta.get("opponentStatsDelta", {}) + if opp_stats != null and not opp_stats.is_empty(): + var opp_p := get_opponent() + if not opp_p.is_empty(): + if opp_stats.has("currentSp") and opp_stats["currentSp"] != null: opp_p["currentSp"] = int(opp_stats["currentSp"]) + if opp_stats.has("currentSt") and opp_stats["currentSt"] != null: opp_p["currentSt"] = int(opp_stats["currentSt"]) + if opp_stats.has("deckCount") and opp_stats["deckCount"] != null: opp_p["deckCount"] = int(opp_stats["deckCount"]) + if opp_stats.has("handCount") and opp_stats["handCount"] != null: opp_p["handCount"] = int(opp_stats["handCount"]) + if opp_stats.has("discardCount") and opp_stats["discardCount"] != null: opp_p["discardCount"] = int(opp_stats["discardCount"]) + + # 10. Meta + var meta: Dictionary = delta.get("metaDelta", {}) + if meta != null and not meta.is_empty(): + if meta.has("phase") and meta["phase"] != null: state["phase"] = meta["phase"] + if meta.has("activePlayerAccountId") and meta["activePlayerAccountId"] != null: state["activePlayerAccountId"] = meta["activePlayerAccountId"] + if meta.has("turnNumber") and meta["turnNumber"] != null: state["turnNumber"] = int(meta["turnNumber"]) + + _state_version = int(delta.get("stateVersion", _state_version)) + print("[Game] delta applied ver=", _state_version, + " phase=", state.get("phase","?"), + " turn=", state.get("turnNumber","?")) + state_updated.emit(state) + + +func _merge_unit_delta(unit: Dictionary, ud: Dictionary) -> void: + if ud.has("currentHealth") and ud["currentHealth"] != null: unit["currentHealth"] = int(ud["currentHealth"]) + if ud.has("maxHealth") and ud["maxHealth"] != null: unit["maxHealth"] = int(ud["maxHealth"]) + if ud.has("currentDefense") and ud["currentDefense"] != null: unit["currentDefense"] = int(ud["currentDefense"]) + if ud.has("maxDefense") and ud["maxDefense"] != null: unit["maxDefense"] = int(ud["maxDefense"]) + if ud.has("damage") and ud["damage"] != null: unit["damage"] = int(ud["damage"]) + if ud.has("isExhausted") and ud["isExhausted"] != null: unit["isExhausted"] = bool(ud["isExhausted"]) + if ud.has("canMove") and ud["canMove"] != null: unit["canMove"] = bool(ud["canMove"]) + if ud.has("canAttack") and ud["canAttack"] != null: unit["canAttack"] = bool(ud["canAttack"]) + if ud.has("canBeAttacked") and ud["canBeAttacked"] != null: unit["canBeAttacked"] = bool(ud["canBeAttacked"]) + if ud.has("canUseAbility") and ud["canUseAbility"] != null: unit["canUseAbility"] = bool(ud["canUseAbility"]) + if ud.has("currentMp") and ud["currentMp"] != null: unit["currentMp"] = int(ud["currentMp"]) + if ud.has("maxMp") and ud["maxMp"] != null: unit["maxMp"] = int(ud["maxMp"]) + if ud.has("extraAttacksRemaining") and ud["extraAttacksRemaining"] != null: unit["extraAttacksRemaining"] = int(ud["extraAttacksRemaining"]) + if ud.has("position") and ud["position"] != null: unit["position"] = ud["position"] + if ud.has("effectsJson") and ud["effectsJson"] != null: unit["effectsJson"] = ud["effectsJson"] + if ud.has("abilitiesJson") and ud["abilitiesJson"] != null: unit["abilitiesJson"] = ud["abilitiesJson"] + if ud.has("abilityUsesJson") and ud["abilityUsesJson"] != null: unit["abilityUsesJson"] = ud["abilityUsesJson"] + + func _on_server_push(type: String, payload: Variant) -> void: if type.begins_with("game.") or type.begins_with("matchmaking."): print("[Game] PUSH ", type, " ", JSON.stringify(payload).substr(0, 200)) @@ -314,14 +497,31 @@ func _on_server_push(type: String, payload: Variant) -> void: var d := payload as Dictionary var s := d.get("state", {}) as Dictionary if not s.is_empty(): + _state_version = int(s.get("stateVersion", -1)) print("[Game] PUSH state_update phase=", s.get("phase","?"), " turn=", s.get("turnNumber","?"), + " ver=", _state_version, " activePlayer=", str(s.get("activePlayerAccountId","?")).substr(0,8)) state = s state_updated.emit(state) else: print("[Game] PUSH state_update: no 'state' key") + "game.state_delta": + var d := payload as Dictionary + var delta := d.get("delta", {}) as Dictionary + if delta.is_empty(): return + var v := int(delta.get("stateVersion", -1)) + if _state_version >= 0 and v <= _state_version: + # Already up to date — acting player received full state in ACK + return + if _state_version >= 0 and v > _state_version + 1: + print("[Game] WARN: missed delta (have %d, got %d) — requesting full sync" \ + % [_state_version, v]) + _fetch_state() + return + _apply_delta(delta) + "game.over": var d := payload as Dictionary var winner : String = str(d.get("winnerAccountId", "")) diff --git a/Client/origin-client/scenes/game/InGameSettings.tscn b/Client/origin-client/scenes/game/InGameSettings.tscn index 5260096..a309d8c 100644 --- a/Client/origin-client/scenes/game/InGameSettings.tscn +++ b/Client/origin-client/scenes/game/InGameSettings.tscn @@ -111,6 +111,14 @@ text = "Center camera on selected unit" [node name="HSeparator3" type="HSeparator" parent="MarginContainer/VBoxContainer"] layout_mode = 2 +[node name="SyncBtn" type="Button" parent="MarginContainer/VBoxContainer"] +unique_name_in_owner = true +layout_mode = 2 +text = "Request Sync" + +[node name="HSeparator4" type="HSeparator" parent="MarginContainer/VBoxContainer"] +layout_mode = 2 + [node name="ConcedeBtn" type="Button" parent="MarginContainer/VBoxContainer"] unique_name_in_owner = true layout_mode = 2 diff --git a/Client/origin-client/scenes/game/in_game_settings.gd b/Client/origin-client/scenes/game/in_game_settings.gd index 6e71df1..7be5ee4 100644 --- a/Client/origin-client/scenes/game/in_game_settings.gd +++ b/Client/origin-client/scenes/game/in_game_settings.gd @@ -7,6 +7,7 @@ extends PanelContainer @onready var _sfx_slider : HSlider = %SfxSlider @onready var _sfx_mute : CheckButton = %SfxMute @onready var _cam_follow : CheckButton = %CameraFollowUnit +@onready var _sync_btn : Button = %SyncBtn @onready var _concede_btn : Button = %ConcedeBtn @onready var _confirm_row : HBoxContainer = %ConcedeConfirmRow @onready var _confirm_yes : Button = %ConcedeYes @@ -25,6 +26,7 @@ func _ready() -> void: _sfx_mute.toggled.connect(_on_sfx_mute_toggled) _cam_follow.toggled.connect(func(v: bool) -> void: Settings.camera_follow_unit = v) + _sync_btn.pressed.connect(_on_sync_pressed) _concede_btn.pressed.connect(_on_concede_pressed) _confirm_yes.pressed.connect(_on_concede_confirmed) _confirm_no.pressed.connect(func() -> void: _confirm_row.visible = false; _concede_btn.visible = true) @@ -68,6 +70,15 @@ func _on_sfx_mute_toggled(v: bool) -> void: Settings.sfx_muted = v _sfx_slider.modulate.a = 0.4 if v else 1.0 +func _on_sync_pressed() -> void: + _sync_btn.text = "Syncing..." + _sync_btn.disabled = true + Game.request_sync() + get_tree().create_timer(1.5).timeout.connect(func() -> void: + if is_instance_valid(_sync_btn): + _sync_btn.text = "Request Sync" + _sync_btn.disabled = false) + func _on_concede_pressed() -> void: _concede_btn.visible = false _confirm_row.visible = true diff --git a/Server/src/SOR.Game/GameEngine.cs b/Server/src/SOR.Game/GameEngine.cs index 47578d3..6709735 100644 --- a/Server/src/SOR.Game/GameEngine.cs +++ b/Server/src/SOR.Game/GameEngine.cs @@ -1255,7 +1255,7 @@ public static class GameEngine throw new GameException($"INVALID_PHASE:{state.Phase}"); } - private static CardInstanceDto ToCardDto(CardInstance c) + internal static CardInstanceDto ToCardDto(CardInstance c) { var fc = c as FieldCard; return new( diff --git a/Server/src/SOR.Game/GameMessages.cs b/Server/src/SOR.Game/GameMessages.cs index 0ff6f17..c00ef66 100644 --- a/Server/src/SOR.Game/GameMessages.cs +++ b/Server/src/SOR.Game/GameMessages.cs @@ -389,6 +389,78 @@ public sealed record LobbyRuleSuggestionPush( /// Pushed to the guest when the host rejects their rule suggestion. public sealed record LobbyRuleSuggestionRejectedPush(Guid LobbyId); +/// +/// Pushed to each viewer after any game action that changes state. +/// Replaces the full for incremental updates. +/// +public sealed record GameStateDeltaPush(GameStateDelta Delta); + +/// +/// Viewer-specific state delta. Null collections mean no change for that category. +/// Own hand is shown in full; opponent hand = count only. +/// +public sealed record GameStateDelta( + int StateVersion, + IReadOnlyList? ChangedTiles, + IReadOnlyList? AddedUnits, + IReadOnlyList? RemovedUnitIds, + IReadOnlyList? ChangedUnits, + IReadOnlyList? HandAdded, + IReadOnlyList? HandRemovedIds, + IReadOnlyList? DiscardAdded, + int? OpponentHandCount, + int? OpponentDeckCount, + UnitDelta? OwnArchSpiritDelta, + UnitDelta? OpponentArchSpiritDelta, + PlayerStatsDelta? OwnStatsDelta, + PlayerStatsDelta? OpponentStatsDelta, + GameMetaDelta? MetaDelta); + +public sealed record TileDelta( + int X, + int Y, + string? Base1, + string? Base2, + string? ResolvedAffinity, + string? OccupantId, + bool OccupantCleared, + string? OccupantOwner, + string? RuinId, + bool RuinCleared, + string? RuinOwner); + +public sealed record UnitDelta( + string InstanceId, + int? CurrentHealth, + int? MaxHealth, + int? CurrentDefense, + int? MaxDefense, + int? Damage, + bool? IsExhausted, + bool? CanMove, + bool? CanAttack, + bool? CanBeAttacked, + bool? CanUseAbility, + int? CurrentMp, + int? MaxMp, + int? ExtraAttacksRemaining, + CoordDto? Position, + string? EffectsJson, + string? AbilitiesJson, + string? AbilityUsesJson); + +public sealed record PlayerStatsDelta( + int? CurrentSp, + int? CurrentSt, + int? DeckCount, + int? HandCount, + int? DiscardCount); + +public sealed record GameMetaDelta( + string? Phase, + string? ActivePlayerAccountId, + int? TurnNumber); + // ── DTOs ───────────────────────────────────────────────────────────────────── /// diff --git a/Server/src/SOR.Game/GameStateDiffer.cs b/Server/src/SOR.Game/GameStateDiffer.cs new file mode 100644 index 0000000..5ed89b1 --- /dev/null +++ b/Server/src/SOR.Game/GameStateDiffer.cs @@ -0,0 +1,366 @@ +namespace SOR.Game; + +using System.Text.Json; +using SOR.Game.Grid; + +/// +/// Computes a from two snapshots. +/// Used to send only changed data after each game action instead of the full state. +/// +internal static class GameStateDiffer +{ + private static readonly JsonSerializerOptions _json = new(JsonSerializerDefaults.Web) + { + WriteIndented = false, + }; + + /// + /// Compute a viewer-specific delta (own hand visible; opponent hand = count only). + /// + public static GameStateDelta ComputeDelta(GameState prev, GameState next, string viewerAccountId) + { + var changedTiles = DiffTiles(prev, next); + var (addedUnits, removedIds, changed) = DiffAllFieldUnits(prev, next); + + // Viewer's zones + prev.Players.TryGetValue(viewerAccountId, out var prevViewer); + next.Players.TryGetValue(viewerAccountId, out var nextViewer); + + List? handAdded = null; + List? handRemovedIds = null; + List? discardAdded = null; + + if (prevViewer != null && nextViewer != null) + { + var prevHandIds = new HashSet(prevViewer.Hand.Select(c => c.InstanceId)); + var nextHandIds = new HashSet(nextViewer.Hand.Select(c => c.InstanceId)); + + var added = nextHandIds.Except(prevHandIds).ToHashSet(); + if (added.Count > 0) + handAdded = nextViewer.Hand + .Where(c => added.Contains(c.InstanceId)) + .Select(GameEngine.ToCardDto) + .ToList(); + + var removed = prevHandIds.Except(nextHandIds).ToList(); + if (removed.Count > 0) + handRemovedIds = removed; + + // Discard: only appended; emit new tail entries + if (nextViewer.Discard.Count > prevViewer.Discard.Count) + discardAdded = nextViewer.Discard + .Skip(prevViewer.Discard.Count) + .Select(GameEngine.ToCardDto) + .ToList(); + } + + // Opponent's counts + var prevOpp = prev.Players.Values.FirstOrDefault(p => p.AccountId != viewerAccountId); + var nextOpp = next.Players.Values.FirstOrDefault(p => p.AccountId != viewerAccountId); + + int? oppHandCount = null; + int? oppDeckCount = null; + + if (prevOpp != null && nextOpp != null) + { + if (prevOpp.Hand.Count != nextOpp.Hand.Count) oppHandCount = nextOpp.Hand.Count; + if (prevOpp.Deck.Count != nextOpp.Deck.Count) oppDeckCount = nextOpp.Deck.Count; + } + + // ArchSpirits + UnitDelta? ownArchDelta = null; + UnitDelta? oppArchDelta = null; + + if (prevViewer?.ArchSpirit != null && nextViewer?.ArchSpirit != null) + ownArchDelta = DiffUnit(prevViewer.ArchSpirit, nextViewer.ArchSpirit); + if (prevOpp?.ArchSpirit != null && nextOpp?.ArchSpirit != null) + oppArchDelta = DiffUnit(prevOpp.ArchSpirit, nextOpp.ArchSpirit); + + // Player stats + PlayerStatsDelta? ownStats = null; + PlayerStatsDelta? oppStats = null; + + if (prevViewer != null && nextViewer != null) + ownStats = DiffPlayerStats(prevViewer, nextViewer); + if (prevOpp != null && nextOpp != null) + oppStats = DiffPlayerStats(prevOpp, nextOpp); + + var metaDelta = DiffMeta(prev, next); + + return new GameStateDelta( + StateVersion : next.NextActionSequence, + ChangedTiles : changedTiles, + AddedUnits : addedUnits, + RemovedUnitIds : removedIds, + ChangedUnits : changed, + HandAdded : handAdded, + HandRemovedIds : handRemovedIds, + DiscardAdded : discardAdded, + OpponentHandCount : oppHandCount, + OpponentDeckCount : oppDeckCount, + OwnArchSpiritDelta : ownArchDelta, + OpponentArchSpiritDelta : oppArchDelta, + OwnStatsDelta : ownStats, + OpponentStatsDelta : oppStats, + MetaDelta : metaDelta); + } + + /// + /// Compute a spectator delta: tile/unit/archspirit/meta changes visible to all; + /// hand card details suppressed. P1 mapped to "own", P2 to "opponent" in the result. + /// + public static GameStateDelta ComputeSpectatorDelta(GameState prev, GameState next) + { + var changedTiles = DiffTiles(prev, next); + var (addedUnits, removedIds, changed) = DiffAllFieldUnits(prev, next); + + // Map p1 → "own", p2 → "opponent" for archspirit and stats fields + prev.Players.TryGetValue(prev.PlayerOneAccountId, out var prevP1); + next.Players.TryGetValue(next.PlayerOneAccountId, out var nextP1); + var prevP2 = prev.Players.Values.FirstOrDefault(p => p.AccountId != prev.PlayerOneAccountId); + var nextP2 = next.Players.Values.FirstOrDefault(p => p.AccountId != next.PlayerOneAccountId); + + UnitDelta? ownArchDelta = null; + UnitDelta? oppArchDelta = null; + + if (prevP1?.ArchSpirit != null && nextP1?.ArchSpirit != null) + ownArchDelta = DiffUnit(prevP1.ArchSpirit, nextP1.ArchSpirit); + if (prevP2?.ArchSpirit != null && nextP2?.ArchSpirit != null) + oppArchDelta = DiffUnit(prevP2.ArchSpirit, nextP2.ArchSpirit); + + PlayerStatsDelta? ownStats = null; + PlayerStatsDelta? oppStats = null; + + if (prevP1 != null && nextP1 != null) ownStats = DiffPlayerStats(prevP1, nextP1); + if (prevP2 != null && nextP2 != null) oppStats = DiffPlayerStats(prevP2, nextP2); + + var metaDelta = DiffMeta(prev, next); + + return new GameStateDelta( + StateVersion : next.NextActionSequence, + ChangedTiles : changedTiles, + AddedUnits : addedUnits, + RemovedUnitIds : removedIds, + ChangedUnits : changed, + HandAdded : null, + HandRemovedIds : null, + DiscardAdded : null, + OpponentHandCount : null, + OpponentDeckCount : null, + OwnArchSpiritDelta : ownArchDelta, + OpponentArchSpiritDelta : oppArchDelta, + OwnStatsDelta : ownStats, + OpponentStatsDelta : oppStats, + MetaDelta : metaDelta); + } + + // ── Helpers ─────────────────────────────────────────────────────────────── + + private static List? DiffTiles(GameState prev, GameState next) + { + if (prev.Board == null || next.Board == null) return null; + + List? result = null; + + foreach (var nextTile in next.Board.Tiles.Values) + { + var key = nextTile.Coord.ToKey(); + + if (!prev.Board.Tiles.TryGetValue(key, out var prevTile)) + { + // New tile (board resize edge case — emit all fields) + result ??= new List(); + result.Add(new TileDelta( + X : nextTile.Coord.X, + Y : nextTile.Coord.Y, + Base1 : nextTile.Base1.ToString(), + Base2 : nextTile.Base2.ToString(), + ResolvedAffinity : AffinitySystem.Resolve(nextTile.Base1, nextTile.Base2).ToString(), + OccupantId : nextTile.OccupantId, + OccupantCleared : false, + OccupantOwner : nextTile.OccupantOwner, + RuinId : nextTile.RuinId, + RuinCleared : false, + RuinOwner : nextTile.RuinOwner)); + continue; + } + + bool base1Changed = prevTile.Base1 != nextTile.Base1; + bool base2Changed = prevTile.Base2 != nextTile.Base2; + bool occupantChanged = prevTile.OccupantId != nextTile.OccupantId; + bool occOwnerChanged = prevTile.OccupantOwner != nextTile.OccupantOwner; + bool ruinChanged = prevTile.RuinId != nextTile.RuinId; + bool ruinOwnerChanged = prevTile.RuinOwner != nextTile.RuinOwner; + + if (!base1Changed && !base2Changed && !occupantChanged && + !occOwnerChanged && !ruinChanged && !ruinOwnerChanged) + continue; + + result ??= new List(); + result.Add(new TileDelta( + X : nextTile.Coord.X, + Y : nextTile.Coord.Y, + Base1 : base1Changed ? nextTile.Base1.ToString() : null, + Base2 : base2Changed ? nextTile.Base2.ToString() : null, + ResolvedAffinity : (base1Changed || base2Changed) + ? AffinitySystem.Resolve(nextTile.Base1, nextTile.Base2).ToString() + : null, + OccupantId : occupantChanged && nextTile.OccupantId != null ? nextTile.OccupantId : null, + OccupantCleared : occupantChanged && nextTile.OccupantId == null, + OccupantOwner : occOwnerChanged ? nextTile.OccupantOwner : null, + RuinId : ruinChanged && nextTile.RuinId != null ? nextTile.RuinId : null, + RuinCleared : ruinChanged && nextTile.RuinId == null, + RuinOwner : ruinOwnerChanged ? nextTile.RuinOwner : null)); + } + + return result; + } + + private static (List? added, List? removed, List? changed) + DiffAllFieldUnits(GameState prev, GameState next) + { + var prevById = new Dictionary(); + var nextById = new Dictionary(); + + foreach (var ps in prev.Players.Values) + foreach (var u in ps.Field) + prevById[u.InstanceId] = u; + + foreach (var ps in next.Players.Values) + foreach (var u in ps.Field) + nextById[u.InstanceId] = u; + + List? added = null; + List? removed = null; + List? changed = null; + + foreach (var (id, nextUnit) in nextById) + { + if (!prevById.TryGetValue(id, out var prevUnit)) + { + added ??= new List(); + added.Add(GameEngine.ToCardDto(nextUnit)); + } + else + { + var delta = DiffUnit(prevUnit, nextUnit); + if (delta != null) + { + changed ??= new List(); + changed.Add(delta); + } + } + } + + foreach (var id in prevById.Keys) + { + if (!nextById.ContainsKey(id)) + { + removed ??= new List(); + removed.Add(id); + } + } + + return (added, removed, changed); + } + + private static UnitDelta? DiffUnit(CardInstance prevC, CardInstance nextC) + { + var prevFc = prevC as FieldCard; + var nextFc = nextC as FieldCard; + + bool abilityUsesChanged = !AbilityUsesEqual(prevC.AbilityUsesThisTurn, nextC.AbilityUsesThisTurn); + + bool anyChange = + prevC.CurrentHealth != nextC.CurrentHealth || + prevC.MaxHealth != nextC.MaxHealth || + prevC.CurrentDefense != nextC.CurrentDefense || + prevC.MaxDefense != nextC.MaxDefense || + prevC.Damage != nextC.Damage || + prevC.IsExhausted != nextC.IsExhausted || + prevC.CanMove != nextC.CanMove || + prevC.CanAttack != nextC.CanAttack || + prevC.CanBeAttacked != nextC.CanBeAttacked || + prevC.CanUseAbility != nextC.CanUseAbility || + (prevFc?.CurrentMp ?? 0) != (nextFc?.CurrentMp ?? 0) || + prevC.MaxMp != nextC.MaxMp || + prevC.ExtraAttacksRemaining != nextC.ExtraAttacksRemaining || + prevFc?.Position != nextFc?.Position || + prevC.EffectsJson != nextC.EffectsJson || + prevC.AbilitiesJson != nextC.AbilitiesJson || + abilityUsesChanged; + + if (!anyChange) return null; + + CoordDto? positionDelta = null; + if (prevFc?.Position != nextFc?.Position && nextFc?.Position is { } pos) + positionDelta = new CoordDto(pos.X, pos.Y); + + string? abilityUsesJson = abilityUsesChanged && nextC.AbilityUsesThisTurn != null + ? JsonSerializer.Serialize(nextC.AbilityUsesThisTurn, _json) + : null; + + return new UnitDelta( + InstanceId : nextC.InstanceId, + CurrentHealth : prevC.CurrentHealth != nextC.CurrentHealth ? nextC.CurrentHealth : null, + MaxHealth : prevC.MaxHealth != nextC.MaxHealth ? nextC.MaxHealth : null, + CurrentDefense : prevC.CurrentDefense != nextC.CurrentDefense ? nextC.CurrentDefense : null, + MaxDefense : prevC.MaxDefense != nextC.MaxDefense ? nextC.MaxDefense : null, + Damage : prevC.Damage != nextC.Damage ? nextC.Damage : null, + IsExhausted : prevC.IsExhausted != nextC.IsExhausted ? nextC.IsExhausted : null, + CanMove : prevC.CanMove != nextC.CanMove ? nextC.CanMove : null, + CanAttack : prevC.CanAttack != nextC.CanAttack ? nextC.CanAttack : null, + CanBeAttacked : prevC.CanBeAttacked != nextC.CanBeAttacked ? nextC.CanBeAttacked : null, + CanUseAbility : prevC.CanUseAbility != nextC.CanUseAbility ? nextC.CanUseAbility : null, + CurrentMp : (prevFc?.CurrentMp ?? 0) != (nextFc?.CurrentMp ?? 0) ? nextFc?.CurrentMp : null, + MaxMp : prevC.MaxMp != nextC.MaxMp ? nextC.MaxMp : null, + ExtraAttacksRemaining : prevC.ExtraAttacksRemaining != nextC.ExtraAttacksRemaining ? nextC.ExtraAttacksRemaining : null, + Position : positionDelta, + EffectsJson : prevC.EffectsJson != nextC.EffectsJson ? nextC.EffectsJson : null, + AbilitiesJson : prevC.AbilitiesJson != nextC.AbilitiesJson ? nextC.AbilitiesJson : null, + AbilityUsesJson : abilityUsesJson); + } + + private static PlayerStatsDelta? DiffPlayerStats(PlayerState prev, PlayerState next) + { + bool spChanged = prev.CurrentSp != next.CurrentSp; + bool stChanged = prev.CurrentSt != next.CurrentSt; + bool deckChanged = prev.Deck.Count != next.Deck.Count; + bool handChanged = prev.Hand.Count != next.Hand.Count; + bool discardChanged = prev.Discard.Count != next.Discard.Count; + + if (!spChanged && !stChanged && !deckChanged && !handChanged && !discardChanged) + return null; + + return new PlayerStatsDelta( + CurrentSp : spChanged ? next.CurrentSp : null, + CurrentSt : stChanged ? next.CurrentSt : null, + DeckCount : deckChanged ? next.Deck.Count : null, + HandCount : handChanged ? next.Hand.Count : null, + DiscardCount : discardChanged ? next.Discard.Count : null); + } + + private static GameMetaDelta? DiffMeta(GameState prev, GameState next) + { + bool phaseChanged = prev.Phase != next.Phase; + bool activeChanged = prev.ActivePlayerAccountId != next.ActivePlayerAccountId; + bool turnChanged = prev.TurnNumber != next.TurnNumber; + + if (!phaseChanged && !activeChanged && !turnChanged) return null; + + return new GameMetaDelta( + Phase : phaseChanged ? next.Phase.ToString() : null, + ActivePlayerAccountId : activeChanged ? next.ActivePlayerAccountId : null, + TurnNumber : turnChanged ? next.TurnNumber : null); + } + + private static bool AbilityUsesEqual(Dictionary? a, Dictionary? b) + { + if (a == null && b == null) return true; + if (a == null || b == null) return false; + if (a.Count != b.Count) return false; + foreach (var (k, v) in a) + if (!b.TryGetValue(k, out var bv) || bv != v) return false; + return true; + } +} diff --git a/Server/src/SOR.Game/Handlers/GameActivateAbilityHandler.cs b/Server/src/SOR.Game/Handlers/GameActivateAbilityHandler.cs index 0041c96..ae414d4 100644 --- a/Server/src/SOR.Game/Handlers/GameActivateAbilityHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameActivateAbilityHandler.cs @@ -48,7 +48,7 @@ internal sealed class GameActivateAbilityHandler : GameHandlerBase, IMessageHand await SaveStateAsync(_gameDb, session, newState, actorId, "game.activate_ability", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.activate_ability.ack", message.Seq, new GameActivateAbilityResponse(dto)); diff --git a/Server/src/SOR.Game/Handlers/GameAscendHandler.cs b/Server/src/SOR.Game/Handlers/GameAscendHandler.cs index 9231cd2..de4353d 100644 --- a/Server/src/SOR.Game/Handlers/GameAscendHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameAscendHandler.cs @@ -49,7 +49,7 @@ internal sealed class GameAscendHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.ascend", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.ascend.ack", message.Seq, new GameAscendResponse(dto)); diff --git a/Server/src/SOR.Game/Handlers/GameAttackHandler.cs b/Server/src/SOR.Game/Handlers/GameAttackHandler.cs index 4198118..0bd37bd 100644 --- a/Server/src/SOR.Game/Handlers/GameAttackHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameAttackHandler.cs @@ -86,7 +86,7 @@ internal sealed class GameAttackHandler : GameHandlerBase, IMessageHandler } else { - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); } return ServerMessage.Reply("game.attack.ack", message.Seq, diff --git a/Server/src/SOR.Game/Handlers/GameDrawHandler.cs b/Server/src/SOR.Game/Handlers/GameDrawHandler.cs index 4e13531..2d6aa28 100644 --- a/Server/src/SOR.Game/Handlers/GameDrawHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameDrawHandler.cs @@ -42,7 +42,7 @@ internal sealed class GameDrawHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.draw", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.draw.ack", message.Seq, new GameDrawResponse(dto)); diff --git a/Server/src/SOR.Game/Handlers/GameEndTurnHandler.cs b/Server/src/SOR.Game/Handlers/GameEndTurnHandler.cs index 3105502..3bc85f3 100644 --- a/Server/src/SOR.Game/Handlers/GameEndTurnHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameEndTurnHandler.cs @@ -82,7 +82,7 @@ internal sealed class GameEndTurnHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.end_turn", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(stateDto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); // Reset the turn timer for the new active player. _timerService.ResetTimer(session.Id, newState.Rules.TurnTimerSeconds, diff --git a/Server/src/SOR.Game/Handlers/GameHandlerBase.cs b/Server/src/SOR.Game/Handlers/GameHandlerBase.cs index b399d9e..57c9d4b 100644 --- a/Server/src/SOR.Game/Handlers/GameHandlerBase.cs +++ b/Server/src/SOR.Game/Handlers/GameHandlerBase.cs @@ -90,43 +90,78 @@ internal abstract class GameHandlerBase } /// - /// Push the updated (filtered) game state to both players and any current spectators. - /// Spectators receive a hand-hidden view via SpectatorRegistryService.Instance. + /// Push the updated game state to both players and any current spectators. + /// When is supplied a structured delta (game.state_delta) + /// is sent instead of the full state, reducing payload size. + /// Falls back to a full game.state_update push when prevState is null. /// internal static async Task PushStateToPlayersAsync( IClientPush clientPush, GameSession session, GameState state, - CancellationToken ct) + CancellationToken ct, + GameState? prevState = null) { var p1Id = session.PlayerOneAccountId.ToString(); var p2Id = session.PlayerTwoAccountId.ToString(); - var tasks = new List + if (prevState != null) { - clientPush.PushAsync(p1Id, - ServerMessage.Push("game.state_update", - new GameStateUpdatePush(GameEngine.ToDto(state, p1Id))), ct), - clientPush.PushAsync(p2Id, - ServerMessage.Push("game.state_update", - new GameStateUpdatePush(GameEngine.ToDto(state, p2Id))), ct), - }; + var d1 = GameStateDiffer.ComputeDelta(prevState, state, p1Id); + var d2 = GameStateDiffer.ComputeDelta(prevState, state, p2Id); - var registry = SpectatorRegistryService.Instance; - if (registry != null) - { - var spectators = registry.GetSpectators(session.Id); - if (spectators.Count > 0) + var tasks = new List { - var spectatorDto = GameEngine.ToDtoSpectator(state); - foreach (var specId in spectators) - tasks.Add(clientPush.PushAsync(specId.ToString(), - ServerMessage.Push("game.state_update", - new GameStateUpdatePush(spectatorDto)), ct)); - } - } + clientPush.PushAsync(p1Id, + ServerMessage.Push("game.state_delta", new GameStateDeltaPush(d1)), ct), + clientPush.PushAsync(p2Id, + ServerMessage.Push("game.state_delta", new GameStateDeltaPush(d2)), ct), + }; - await Task.WhenAll(tasks); + var registry = SpectatorRegistryService.Instance; + if (registry != null) + { + var spectators = registry.GetSpectators(session.Id); + if (spectators.Count > 0) + { + var sd = GameStateDiffer.ComputeSpectatorDelta(prevState, state); + foreach (var specId in spectators) + tasks.Add(clientPush.PushAsync(specId.ToString(), + ServerMessage.Push("game.state_delta", new GameStateDeltaPush(sd)), ct)); + } + } + + await Task.WhenAll(tasks); + } + else + { + // Fallback: no previous state — push full state (initial connect, reconnect, timer expiry) + var tasks = new List + { + clientPush.PushAsync(p1Id, + ServerMessage.Push("game.state_update", + new GameStateUpdatePush(GameEngine.ToDto(state, p1Id))), ct), + clientPush.PushAsync(p2Id, + ServerMessage.Push("game.state_update", + new GameStateUpdatePush(GameEngine.ToDto(state, p2Id))), ct), + }; + + var registry = SpectatorRegistryService.Instance; + if (registry != null) + { + var spectators = registry.GetSpectators(session.Id); + if (spectators.Count > 0) + { + var spectatorDto = GameEngine.ToDtoSpectator(state); + foreach (var specId in spectators) + tasks.Add(clientPush.PushAsync(specId.ToString(), + ServerMessage.Push("game.state_update", + new GameStateUpdatePush(spectatorDto)), ct)); + } + } + + await Task.WhenAll(tasks); + } } // OP config snapshot — read from RuleSnapshotJson at finalization time. diff --git a/Server/src/SOR.Game/Handlers/GameMoveUnitHandler.cs b/Server/src/SOR.Game/Handlers/GameMoveUnitHandler.cs index 8a99d30..b249d56 100644 --- a/Server/src/SOR.Game/Handlers/GameMoveUnitHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameMoveUnitHandler.cs @@ -49,7 +49,7 @@ internal sealed class GameMoveUnitHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.move_unit", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.move_unit.ack", message.Seq, new GameMoveUnitResponse(dto)); diff --git a/Server/src/SOR.Game/Handlers/GamePlaceArchSpiritHandler.cs b/Server/src/SOR.Game/Handlers/GamePlaceArchSpiritHandler.cs index 41dbd54..75ec2d7 100644 --- a/Server/src/SOR.Game/Handlers/GamePlaceArchSpiritHandler.cs +++ b/Server/src/SOR.Game/Handlers/GamePlaceArchSpiritHandler.cs @@ -56,7 +56,7 @@ internal sealed class GamePlaceArchSpiritHandler : GameHandlerBase, IMessageHand await SaveStateAsync(_gameDb, session, newState, actorId, "game.place_arch_spirit", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); // Start the turn timer once both players have placed and turn 1 begins. if (bothPlaced) diff --git a/Server/src/SOR.Game/Handlers/GamePlayCardHandler.cs b/Server/src/SOR.Game/Handlers/GamePlayCardHandler.cs index 5f3e7fc..d6bf258 100644 --- a/Server/src/SOR.Game/Handlers/GamePlayCardHandler.cs +++ b/Server/src/SOR.Game/Handlers/GamePlayCardHandler.cs @@ -55,7 +55,7 @@ internal sealed class GamePlayCardHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.play_card", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.play_card.ack", message.Seq, new GamePlayCardResponse(dto)); } diff --git a/Server/src/SOR.Game/Handlers/GameSacrificeHandler.cs b/Server/src/SOR.Game/Handlers/GameSacrificeHandler.cs index ebcc740..7be51c3 100644 --- a/Server/src/SOR.Game/Handlers/GameSacrificeHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameSacrificeHandler.cs @@ -48,7 +48,7 @@ internal sealed class GameSacrificeHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.sacrifice", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.sacrifice.ack", message.Seq, new GameSacrificeResponse(dto)); diff --git a/Server/src/SOR.Game/Handlers/GameTransitionHandler.cs b/Server/src/SOR.Game/Handlers/GameTransitionHandler.cs index 33588d9..8b4be9f 100644 --- a/Server/src/SOR.Game/Handlers/GameTransitionHandler.cs +++ b/Server/src/SOR.Game/Handlers/GameTransitionHandler.cs @@ -49,7 +49,7 @@ internal sealed class GameTransitionHandler : GameHandlerBase, IMessageHandler await SaveStateAsync(_gameDb, session, newState, actorId, "game.transition", JsonSerializer.Serialize(req), ct, JsonSerializer.Serialize(dto)); - await PushStateToPlayersAsync(_clientPush, session, newState, ct); + await PushStateToPlayersAsync(_clientPush, session, newState, ct, state); return ServerMessage.Reply("game.transition.ack", message.Seq, new GameTransitionResponse(dto));