From 63cb3248b4595f10eb9a115a9142443e7d671714 Mon Sep 17 00:00:00 2001 From: gamer147 Date: Thu, 4 Jun 2026 15:13:47 -0400 Subject: [PATCH] =?UTF-8?q?feat(battle-node):=20CountHiddenDraws=20?= =?UTF-8?q?=E2=80=94=20hidden=20shared-RNG=20draw=20tally=20for=20real=20s?= =?UTF-8?q?pin?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Co-Authored-By: Claude Opus 4.8 --- .../Sessions/Dispatch/KnownListBuilder.cs | 35 +++++++++ .../Sessions/KnownListBuilderTests.cs | 72 +++++++++++++++++++ 2 files changed, 107 insertions(+) diff --git a/SVSim.BattleNode/Sessions/Dispatch/KnownListBuilder.cs b/SVSim.BattleNode/Sessions/Dispatch/KnownListBuilder.cs index 9ec92c0..2df5637 100644 --- a/SVSim.BattleNode/Sessions/Dispatch/KnownListBuilder.cs +++ b/SVSim.BattleNode/Sessions/Dispatch/KnownListBuilder.cs @@ -42,6 +42,41 @@ internal static class KnownListBuilder return null; } + /// Count hidden, non-reproduced shared-RNG draws implied by an orderList: move ops + /// from Deck(0) to Hand(10) for a non-played, unrevealed card (a random fetch the opponent can't + /// reproduce — it can't enumerate the active player's deck). Each such moved card = one crank the + /// receiver must apply (spin += 1). Skips: the played card's own move (idx == playIdx); + /// any idx in (its identity is already on the wire — a revealed uList + /// fetch); and lot-based randoms (a move op carrying a rand array — the receiver + /// reproduces those by re-rolling, so counting would double-crank). An ordinary card DRAW also + /// surfaces as a hidden move(0→10) but is a deterministic top-of-deck pop (no shared-stream + /// roll) and must NOT be counted — distinguishing it from a random fetch on the wire is the open + /// capture (real-spin design §3.1; the spec's Task 0). Base 0; see the real-spin design doc. + public static int CountHiddenDraws(object? orderList, int playIdx, IReadOnlySet revealed) + { + if (orderList is not IEnumerable ops) return 0; + var count = 0; + foreach (var op in ops) + { + if (op is not IDictionary opDict) continue; + if (!opDict.TryGetValue("move", out var moveRaw) || moveRaw is not IDictionary move) continue; + + if (move.ContainsKey("rand")) continue; // lot random → receiver re-rolls + if (!move.TryGetValue("from", out var fromRaw) || (int)AsLong(fromRaw) != 0) continue; // not from Deck + if (!move.TryGetValue("to", out var toRaw) || (int)AsLong(toRaw) != 10) continue; // not to Hand + if (!move.TryGetValue("idx", out var idxRaw) || idxRaw is not IEnumerable idxList) continue; + + foreach (var i in idxList) + { + var idx = (int)AsLong(i); + if (idx == playIdx) continue; // the played card's own move + if (revealed.Contains(idx)) continue; // opponent already knows this card's identity + count++; + } + } + return count; + } + /// Mine generated-token identities from a sender's add ops: yields /// (idx, cardId, isSelf) for every idx in each {add:{idx:[...], isSelf, card:{cardId}}} /// op. isSelf is surfaced verbatim (the sender's perspective tag on CardObj.IsPlayer, diff --git a/SVSim.UnitTests/BattleNode/Sessions/KnownListBuilderTests.cs b/SVSim.UnitTests/BattleNode/Sessions/KnownListBuilderTests.cs index 3133844..a7381a0 100644 --- a/SVSim.UnitTests/BattleNode/Sessions/KnownListBuilderTests.cs +++ b/SVSim.UnitTests/BattleNode/Sessions/KnownListBuilderTests.cs @@ -20,6 +20,78 @@ public class KnownListBuilderTests } }; + // A move op dict allowing extra keys (e.g. "rand") for CountHiddenDraws fixtures. + private static Dictionary MoveOp(long[] idxs, int from, int to, + IDictionary? extra = null) + { + var move = new Dictionary + { + ["idx"] = idxs.Select(i => (object?)i).ToList(), + ["isSelf"] = 1L, ["from"] = (long)from, ["to"] = (long)to, + }; + if (extra is not null) foreach (var kv in extra) move[kv.Key] = kv.Value; + return new Dictionary { ["move"] = move }; + } + + private static readonly IReadOnlySet NoneRevealed = new HashSet(); + + [Test] + public void CountHiddenDraws_counts_a_hidden_deck_to_hand_fetch() + { + // Hoverboard-shaped: move(0->10) for a non-played, unrevealed token idx. + var orderList = new List { MoveOp(new[] { 31L }, from: 0, to: 10) }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, NoneRevealed), Is.EqualTo(1)); + } + + [Test] + public void CountHiddenDraws_ignores_the_played_cards_own_move() + { + // The played card moving hand(10)->field(20) is not a draw. + var orderList = new List { MoveOp(new[] { 3L }, from: 10, to: 20) }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, NoneRevealed), Is.EqualTo(0)); + } + + [Test] + public void CountHiddenDraws_ignores_a_visible_destroy() + { + // A visible field(20)->cemetery(30) destroy is reproduced by the receiver → 0. + var orderList = new List { MoveOp(new[] { 8L }, from: 20, to: 30) }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, NoneRevealed), Is.EqualTo(0)); + } + + [Test] + public void CountHiddenDraws_ignores_a_revealed_fetch() + { + // The fetched idx's identity was revealed to the opponent (in `revealed`) → 0. + var orderList = new List { MoveOp(new[] { 31L }, from: 0, to: 10) }; + var revealed = new HashSet { 31 }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, revealed), Is.EqualTo(0)); + } + + [Test] + public void CountHiddenDraws_ignores_a_lot_based_random() + { + // A move op carrying a `rand` array is reproduced (re-rolled) by the receiver → 0. + var rand = new Dictionary { ["rand"] = new List { 0.5d } }; + var orderList = new List { MoveOp(new[] { 31L }, from: 0, to: 10, extra: rand) }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, NoneRevealed), Is.EqualTo(0)); + } + + [Test] + public void CountHiddenDraws_counts_each_hidden_card_in_a_multi_fetch() + { + var orderList = new List { MoveOp(new[] { 31L, 32L }, from: 0, to: 10) }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, NoneRevealed), Is.EqualTo(2)); + } + + [Test] + public void CountHiddenDraws_returns_zero_for_a_vanilla_play() + { + var orderList = new List { MoveOp(new[] { 3L }, from: 10, to: 20) }; + Assert.That(KnownListBuilder.CountHiddenDraws(orderList, playIdx: 3, NoneRevealed), Is.EqualTo(0)); + Assert.That(KnownListBuilder.CountHiddenDraws(null, playIdx: 3, NoneRevealed), Is.EqualTo(0)); + } + [Test] public void ExtractMoveTo_returns_to_for_matching_idx() {