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));