SVSim/SVSimServer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

refactor(battlenode): engine-first token identity (cardId); keep wire-mining fallback (M-HC-4f, partial)

Browse Source 
Source the played card's opponent-facing knownList[].cardId off the shadow engine
(SessionBattleEngine.PlayedCardId -> BattleCardBase.CardId), engine-first with the
wire-mined idx->cardId map as the fallback. PROVEN engine-resolved (each backed by a
HeadlessConductorTests PlayedCardId_* test): deck cards and receive-path substituted/
revealed tokens (engine seats the wire id at the wire idx).

PARTIAL retirement: the wire-mining bookkeeping (MineAddOps/MineChoicePicks/MineCopyTokens
+ Record*From) is KEPT as the load-bearing fallback. The choice/Discover, copy/clone and
cross-side (isSelf:0) token cases are NOT proven to resolve at a wire idx headless — the
autonomous token_draw path seats a chosen token at engine Index 0 (would collide with the
leader), and copy/cross-side aren't cheaply fixturable. Deleting their mining on faith
would silently corrupt opponent reveals, so it stays behind a TODO(M-HC-4f) gate.

- SessionBattleEngine.PlayedCardId: new accessor mirroring PlayedCardClan/Tribe.
- BuildPlayedCard: signature deckMap->explicit cardId; null on cardId==0 (no engine id AND
  no mined/deck-map fallback).
- PlayActionsHandler: cardId = engine.PlayedCardId(seat, idx, fallback: mapped) ; mining retained.
- Tests: PlayedCardId_* (deck/substituted/degrade pass; choice-gap [Explicit] documents the
  Index-0 finding). KnownListBuilder + CaptureConformance call-sites updated to new signature.

Full BattleNode suite 263/263 green; HeadlessConductorTests 27/27; drift clean; no Engine edits.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
gamer147
2026-06-07 00:36:49 -04:00
parent d3508d7bd4
commit a30a496265
8 changed files with 219 additions and 52 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
SVSim.UnitTests/BattleNode/Integration/CaptureConformanceTests.cs
View File

@@ -282,7 +282,7 @@ public class CaptureConformanceTests
}
}
};
var entry = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(deckMap, 17, orderList);
var entry = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(17, deckMap[17], orderList);
Assert.That(entry, Is.Not.Null);
var body = new SVSim.BattleNode.Protocol.Bodies.PlayActionsBroadcastBody(
@@ -333,7 +333,7 @@ public class CaptureConformanceTests
new Dictionary<string, object?> { ["move"] = new Dictionary<string, object?>
{ ["idx"] = new List<object?> { 38L }, ["isSelf"] = 1L, ["from"] = 10L, ["to"] = 20L } },
};
var entry = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(map, 38, playOrderList);
var entry = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(38, map[38], playOrderList);
Assert.That(entry, Is.Not.Null, "the mined token resolves to a knownList entry");
var body = new SVSim.BattleNode.Protocol.Bodies.PlayActionsBroadcastBody(
@@ -456,7 +456,7 @@ public class CaptureConformanceTests
}
};
var played = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(deckMap, 18, orderList);
var played = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(18, deckMap[18], orderList);
var keyActionOut = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.StripKeyActionForOpponent(keyActionIn);
var body = new SVSim.BattleNode.Protocol.Bodies.PlayActionsBroadcastBody(
PlayIdx: 18, Type: 30, KnownList: new[] { played! }, OppoTargetList: null, KeyAction: keyActionOut);
@@ -520,7 +520,7 @@ public class CaptureConformanceTests
new Dictionary<string, object?> { ["move"] = new Dictionary<string, object?>
{ ["idx"] = new List<object?> { 46L }, ["isSelf"] = 1L, ["from"] = 10L, ["to"] = 20L } },
};
var entry = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(map, 46, playOrderList);
var entry = SVSim.BattleNode.Sessions.Dispatch.KnownListBuilder.BuildPlayedCard(46, map[46], playOrderList);
Assert.That(entry, Is.Not.Null, "the mined choice pick resolves to a knownList entry");
var body = new SVSim.BattleNode.Protocol.Bodies.PlayActionsBroadcastBody(

111
SVSim.UnitTests/BattleNode/Integration/HeadlessConductorTests.cs
View File

@@ -1285,6 +1285,117 @@ public class HeadlessConductorTests
Assert.That(body.KnownList[0].Tribe, Is.Not.EqualTo("0"), "non-vacuity: tribe must not be the \"0\" default");
}
// === M-HC-4f: engine-resolved token identity (cardId) on the knownList =========================
//
// The opponent-facing knownList[].cardId is now ENGINE-sourced (PlayActionsHandler reads
// SessionBattleEngine.PlayedCardId off the resolved card). These tests prove the engine carries the TRUE
// id for each token case the retired wire-mining used to handle — deck card, generated/substituted token,
// and choice/Discover token — so the wire-mined idx→cardId bookkeeping for the PLAYED card is redundant.
// (The deck-map remains as the non-engine-session fallback.)
[Test]
public void PlayedCardId_reads_engine_resolved_deck_card_id()
{
// BASELINE (proves the read mechanism): a plain DECK card. Play it and assert PlayedCardId returns the
// seeded deck id — the same value the deck-map fallback would have supplied, read off the engine.
var deck = new List<long> { NodeNativeBattleHarness.VanillaFollowerId };
deck.AddRange(NodeNativeBattleHarness.DefaultDeck());
deck = deck.GetRange(0, 30);
using var harness = NodeNativeBattleHarness.Create(seatADeck: deck);
Assert.That(harness.Push(NetworkBattleUri.Deal, DealBody(), isPlayerSeat: true).Accepted, Is.True, "Deal");
int playIdx = harness.PlayerHandCardIndex(0);
long dealtId = harness.HandCardId(playerSeat: true, handPos: 0); // the engine-seated deck identity at this idx
Assert.That(harness.Push(NetworkBattleUri.PlayActions, PlayBody(playIdx), isPlayerSeat: true).Accepted,
Is.True, "deck-card play");
Assert.That(harness.PlayedCardId(playerSeat: true, idx: playIdx), Is.EqualTo(dealtId),
"PlayedCardId must return the engine-resolved deck card identity");
// Cross-check against the deck-map (the retired path's source) so we KNOW the engine read is equivalent
// for a deck card — the behavior-preserving guarantee for the common case.
Assert.That(dealtId, Is.EqualTo(harness.SeatADeck[playIdx - 1]),
"the dealt id equals the node's shuffled deck-map id at this idx (engine read == deck-map fallback)");
}
[Test]
public void PlayedCardId_degrades_to_fallback_for_unknown_idx()
{
// Graceful degradation (mirrors PlayedCardCost_degrades_*): a non-engine session / unmapped idx returns
// the caller's fallback — the deck-map id the handler hands in — never crashing.
using var harness = NodeNativeBattleHarness.Create();
Assert.That(harness.PlayedCardId(playerSeat: true, idx: 9999, fallback: 424242L), Is.EqualTo(424242L));
}
[Test]
public void PlayedCardId_reads_substituted_token_identity_off_the_board()
{
// GENERATED/SUBSTITUTED TOKEN: M-HC-2 proved a reveal seats the WIRE cardId (overriding the seeded id)
// via CreateActualCard. This proves PlayedCardId then reads that TRUE id off the resolved card — so a
// later play of a generated token reveals its real identity engine-sourced, NOT the wire-mined map.
// Reuse the substitution fixture: seat B's deck is uniformly Z; the reveal substitutes W at idx 1.
const long Z = NodeNativeBattleHarness.VanillaFollowerId; // seeded identity
const long W = NodeNativeBattleHarness.AltVanillaFollowerId; // the wire (revealed) identity
var seatBDeck = Enumerable.Repeat(Z, 30).ToList();
using var harness = NodeNativeBattleHarness.Create(seatBDeck: seatBDeck);
Assert.That(harness.Push(NetworkBattleUri.Deal, DealBody(), isPlayerSeat: true).Accepted, Is.True, "Deal");
Assert.That(harness.Push(NetworkBattleUri.Swap, SwapBody(), isPlayerSeat: true).Accepted, Is.True, "Swap");
Assert.That(harness.Push(NetworkBattleUri.Ready, ReadyBody(), isPlayerSeat: true).Accepted, Is.True, "Ready");
Assert.That(harness.Push(NetworkBattleUri.TurnStart, TurnStartBody(), isPlayerSeat: true).Accepted, Is.True, "turn1 TurnStart");
Assert.That(harness.Push(NetworkBattleUri.TurnEnd, TurnEndBody(), isPlayerSeat: true).Accepted, Is.True, "turn1 TurnEnd");
Assert.That(harness.Push(NetworkBattleUri.TurnStart, TurnStartBody(), isPlayerSeat: false).Accepted, Is.True, "turn2 TurnStart (B)");
Assert.That(harness.Push(NetworkBattleUri.PlayActions, RevealPlayBody(idx: 1, cardId: W), isPlayerSeat: false).Accepted,
Is.True, "seat B reveal-play");
int boardIdx = harness.InPlayCardIndex(playerSeat: false, boardPos: 0);
// THE assertion: PlayedCardId reads the SUBSTITUTED wire id W off the resolved board card, not the seeded Z.
Assert.That(harness.PlayedCardId(playerSeat: false, idx: boardIdx), Is.EqualTo(W),
"PlayedCardId must read the engine-seated (substituted) wire cardId, not the seeded deck id");
Assert.That(harness.PlayedCardId(playerSeat: false, idx: boardIdx), Is.Not.EqualTo(Z),
"non-vacuity: the read is the wire id, NOT the seeded identity at that idx");
}
[Test]
[Explicit("M-HC-4f UNPROVEN case: the engine's autonomous token_draw seats the chosen token at engine " +
"Index 0 headless (NOT a wire idx past the deck), so PlayedCardId cannot address it by idx — it " +
"would collide with the leader (also Index 0). This test DOCUMENTS the gap that keeps " +
"MineChoicePicks wire-mining alive (see TODO(M-HC-4f) in PlayActionsHandler). Run explicitly to " +
"re-verify the gap; it asserts the FINDING (Index 0), not a passing engine read.")]
public void PlayedCardId_choice_token_seats_at_index_zero_headless_GAP()
{
// CHOICE/Discover TOKEN — the case the engine does NOT resolve at a wire idx headless. Playing the choice
// card (127011010) and choosing token B (120011010) lands it in hand with the correct IDENTITY, but at
// engine Index 0 (the autonomous token_draw skill path, not the wire add-op/replace path the relay uses).
// PlayedCardId(seat, 0) would therefore read the LEADER (Index 0), not the token — so the engine cannot
// replace MineChoicePicks for this case. (In a real relay the token rides a wire add op that seats a dummy
// at a non-zero idx, then a replace substitutes the real id there — a path not reproducible cheaply here.)
var seatADeck = Enumerable.Repeat(NodeNativeBattleHarness.ChoiceCardId, 30).ToList();
using var harness = NodeNativeBattleHarness.Create(seatADeck: seatADeck);
Assert.That(harness.Push(NetworkBattleUri.Deal, DealBody(), isPlayerSeat: true).Accepted, Is.True, "Deal");
Assert.That(harness.Push(NetworkBattleUri.Swap, SwapBody(), isPlayerSeat: true).Accepted, Is.True, "Swap");
Assert.That(harness.Push(NetworkBattleUri.Ready, ReadyBody(), isPlayerSeat: true).Accepted, Is.True, "Ready");
Assert.That(harness.Push(NetworkBattleUri.TurnStart, TurnStartBody(), isPlayerSeat: true).Accepted, Is.True, "turn1 TurnStart");
int choiceIdx = harness.HandCardIndex(playerSeat: true, handPos: 0);
const long chosen = NodeNativeBattleHarness.ChoiceTokenB; // 120011010
Assert.That(harness.Push(NetworkBattleUri.PlayActions,
NodeNativeBattleHarness.ChoicePlayBody(choiceIdx, NodeNativeBattleHarness.ChoiceCardId, chosen),
isPlayerSeat: true).Accepted,
Is.True, "choice play (chose token B)");
// The chosen token IS in hand with the right identity (M-HC-4c proved this) ...
int tokenIdx = -1;
for (int i = 0; i < harness.HandCount(playerSeat: true); i++)
if (harness.HandCardId(playerSeat: true, i) == (int)chosen) { tokenIdx = harness.HandCardIndex(playerSeat: true, i); break; }
Assert.That(tokenIdx, Is.GreaterThanOrEqualTo(0), "the chosen token (B) must be in seat A's hand");
// ... but its engine Index is 0 — the documented gap. PlayedCardId(seat, 0) reads the leader, not the token.
Assert.That(tokenIdx, Is.EqualTo(0),
"FINDING: the autonomous token_draw seats the chosen token at engine Index 0 headless — not addressable by a wire idx");
}
// The hand POSITION (0-based) of the seat-A hand card with the given engine Index, or -1. Lets a test
// re-derive a HandCardId(seat, pos) lookup from an engine Index it already located by identity.
private static int FindHandPosByEngineIdx(NodeNativeBattleHarness harness, int engineIdx)

6
SVSim.UnitTests/BattleNode/Integration/NodeNativeBattleHarness.cs
View File

@@ -242,6 +242,12 @@ internal sealed class NodeNativeBattleHarness : IDisposable
public int DeckCount(bool playerSeat) => Engine.DeckCount(playerSeat);
public int Turn(bool playerSeat) => Engine.Turn(playerSeat);
/// <summary>The engine-resolved wire <c>cardId</c> of the card at engine <paramref name="idx"/> on the
/// given seat (M-HC-4f). Pass-through to <c>SessionBattleEngine.PlayedCardId</c> — the TRUE id the engine
/// seated (deck id / token id / chosen-token id / copied id), the value the handler now sources for the
/// opponent-facing knownList instead of the wire-mined map.</summary>
public long PlayedCardId(bool playerSeat, int idx, long fallback = 0) => Engine.PlayedCardId(playerSeat, idx, fallback);
/// <summary>The engine Index of seat A's hand card at <paramref name="handPos"/> (the playIdx a
/// Play frame would carry to play it).</summary>
public int PlayerHandCardIndex(int handPos) => Engine.HandCardIndex(playerSeat: true, handPos);

36
SVSim.UnitTests/BattleNode/Sessions/KnownListBuilderTests.cs
View File

@@ -62,19 +62,19 @@ public class KnownListBuilderTests
}
[Test]
public void BuildPlayedCard_returns_null_for_deck_card_with_no_matching_move_op()
public void BuildPlayedCard_returns_null_for_card_with_no_matching_move_op()
{
// idx is in the deck, but the orderList has no move op for it → can't synthesize.
var deckMap = new Dictionary<int, long> { [3] = 128821011L };
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 3, orderList: OrderListMove(7, 10, 20));
// A resolved cardId, but the orderList has no move op for the played idx → can't synthesize.
var entry = KnownListBuilder.BuildPlayedCard(playIdx: 3, cardId: 128821011L, orderList: OrderListMove(7, 10, 20));
Assert.That(entry, Is.Null);
}
[Test]
public void BuildPlayedCard_synthesizes_entry_for_deck_card()
public void BuildPlayedCard_synthesizes_entry_from_engine_sourced_cardId()
{
var deckMap = new Dictionary<int, long> { [3] = 128821011L };
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 3, orderList: OrderListMove(3, 10, 20));
// M-HC-4f: the handler resolves the cardId engine-first (PlayedCardId, deck-map/mined fallback) and passes
// it in; BuildPlayedCard lands it on the entry verbatim.
var entry = KnownListBuilder.BuildPlayedCard(playIdx: 3, cardId: 128821011L, orderList: OrderListMove(3, 10, 20));
Assert.That(entry, Is.Not.Null);
Assert.That(entry!.Idx, Is.EqualTo(3));
@@ -90,8 +90,7 @@ public class KnownListBuilderTests
{
// M-HC-3a: the handler reads the engine-resolved play-time cost and passes it in; BuildPlayedCard
// lands it on the entry verbatim. (A wrong cost yields a different field — non-vacuity.)
var deckMap = new Dictionary<int, long> { [3] = 101314020L };
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 3, orderList: OrderListMove(3, 10, 20), cost: 3);
var entry = KnownListBuilder.BuildPlayedCard(playIdx: 3, cardId: 101314020L, orderList: OrderListMove(3, 10, 20), cost: 3);
Assert.That(entry, Is.Not.Null);
Assert.That(entry!.Cost, Is.EqualTo(3));
}
@@ -102,17 +101,17 @@ public class KnownListBuilderTests
// M-HC-3b: the handler reads the engine-resolved spell-charge count
// (SessionBattleEngine.PlayedCardSpellboost) and passes it in; BuildPlayedCard lands it on the
// entry verbatim. (Default 0 vs a non-zero value is the non-vacuity.)
var deckMap = new Dictionary<int, long> { [3] = 101314020L };
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 3, orderList: OrderListMove(3, 10, 20), cost: 3, spellboost: 2);
var entry = KnownListBuilder.BuildPlayedCard(playIdx: 3, cardId: 101314020L, orderList: OrderListMove(3, 10, 20), cost: 3, spellboost: 2);
Assert.That(entry, Is.Not.Null);
Assert.That(entry!.Spellboost, Is.EqualTo(2));
}
[Test]
public void BuildPlayedCard_returns_null_for_token_idx_not_in_deck()
public void BuildPlayedCard_returns_null_for_zero_cardId()
{
var deckMap = new Dictionary<int, long> { [3] = 128821011L };
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 31, orderList: OrderListMove(31, 10, 20));
// M-HC-4f: cardId 0 means the engine resolved no id AND the deck-map/mined fallback had no entry for the
// idx → un-synthesizable identity → null (the play degrades to {playIdx,type}, no knownList).
var entry = KnownListBuilder.BuildPlayedCard(playIdx: 31, cardId: 0L, orderList: OrderListMove(31, 10, 20));
Assert.That(entry, Is.Null);
}
@@ -121,8 +120,7 @@ public class KnownListBuilderTests
{
// A vanilla play emits spellboost 0 (the engine resolves no spell-charge for a non-boosted card,
// so the handler's PlayedCardSpellboost read is 0 and the param defaults to 0).
var deckMap = new Dictionary<int, long> { [3] = 101311010L };
Assert.That(KnownListBuilder.BuildPlayedCard(deckMap, 3, OrderListMove(3, 10, 20))!.Spellboost, Is.EqualTo(0));
Assert.That(KnownListBuilder.BuildPlayedCard(playIdx: 3, cardId: 101311010L, orderList: OrderListMove(3, 10, 20))!.Spellboost, Is.EqualTo(0));
}
[Test]
@@ -131,9 +129,8 @@ public class KnownListBuilderTests
// M-HC-4e: the handler reads the engine-resolved clan/tribe
// (SessionBattleEngine.PlayedCardClan / PlayedCardTribe) and passes them in; BuildPlayedCard lands
// them on the entry verbatim. (A wrong clan/tribe yields a different field — non-vacuity.)
var deckMap = new Dictionary<int, long> { [3] = 101314020L };
var entry = KnownListBuilder.BuildPlayedCard(
deckMap, playIdx: 3, orderList: OrderListMove(3, 10, 20), cost: 3, spellboost: 2, clan: 8, tribe: "7,16");
playIdx: 3, cardId: 101314020L, orderList: OrderListMove(3, 10, 20), cost: 3, spellboost: 2, clan: 8, tribe: "7,16");
Assert.That(entry, Is.Not.Null);
Assert.That(entry!.Clan, Is.EqualTo(8));
Assert.That(entry.Tribe, Is.EqualTo("7,16"));
@@ -145,8 +142,7 @@ public class KnownListBuilderTests
// A play whose engine read degraded (single-active-engine gate: _mgr null → the accessor fallback)
// emits clan 0 (ClanType.ALL ordinal) and tribe "0" (the prod no-tribe form, NEVER empty —
// empty is wire-illegal). The param defaults match the accessor fallbacks.
var deckMap = new Dictionary<int, long> { [3] = 101311010L };
var entry = KnownListBuilder.BuildPlayedCard(deckMap, 3, OrderListMove(3, 10, 20));
var entry = KnownListBuilder.BuildPlayedCard(playIdx: 3, cardId: 101311010L, orderList: OrderListMove(3, 10, 20));
Assert.That(entry, Is.Not.Null);
Assert.That(entry!.Clan, Is.EqualTo(0));
Assert.That(entry.Tribe, Is.EqualTo("0"));