62251482e4
Close the two generated-token gaps that desynced PvP live test #3 (the Forestcraft Fairy), both sourced from the 2026-06-03 decomp-validation table. - MineAddOps now returns (idx, cardId, isSelf) and no longer drops isSelf:0. isSelf is the sender's perspective tag on CardObj.IsPlayer (RegisterToken.cs:22) and a card has one CardObj.Index, so an isSelf:0 add is the opponent's card. - New shared BattleSessionState.RecordTokensFrom routes isSelf:1 -> sender, isSelf:0 -> opponent (the gift lives in the recipient's map, consulted when they play it). PlayActionsHandler delegates to it. - EchoHandler now mines via the same helper but still returns no routes. An Echo's orderList carries the same add-op shape as a send (MakeEchoData -> MakeCommonSendAndEchoCardData), so MineAddOps applies verbatim; mining != relaying. Choice/copy/private-group adds stay skipped (no concrete cardId). Full solution 963/963 green. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
60 lines
3.5 KiB
C#
60 lines
3.5 KiB
C#
using SVSim.BattleNode.Sessions;
|
|
|
|
namespace SVSim.BattleNode.Sessions.Dispatch;
|
|
|
|
/// <summary>Mutable per-session state shared across frame handlers. The mulligan barrier's
|
|
/// post-swap hands, plus (PvP-equivalency, vanilla slice) the per-side idx->cardId map used to
|
|
/// synthesize the opponent-facing <c>knownList</c>. Generated tokens (cardIds mined from
|
|
/// orderList <c>add</c> ops) are recorded into the SAME
|
|
/// <see cref="IdxToCardId"/> map via <see cref="RecordToken"/>; a reveal-gate set is still future.</summary>
|
|
internal sealed class BattleSessionState
|
|
{
|
|
public BattleSessionPhase SessionPhase { get; set; } = BattleSessionPhase.AwaitingInitNetwork;
|
|
public Dictionary<IBattleParticipant, long[]> PostSwapHands { get; } = new();
|
|
|
|
/// <summary>Per-side idx->cardId, seeded lazily from <see cref="MatchContext.SelfDeckCardIds"/>.
|
|
/// Holds deck cards (idx 1..deckCount, seeded) and generated tokens (idx>deckCount, recorded
|
|
/// from add ops via <see cref="RecordToken"/>).</summary>
|
|
public Dictionary<IBattleParticipant, Dictionary<int, long>> IdxToCardId { get; } = new();
|
|
|
|
/// <summary>The sender's idx->cardId map, seeding it from its <see cref="MatchContext"/> on first
|
|
/// use. <c>BuildPlayerDeck</c> assigns deck idx = position+1, so entry (i+1) -> cardIds[i].</summary>
|
|
public IReadOnlyDictionary<int, long> GetOrSeedDeckMap(IBattleParticipant side)
|
|
{
|
|
if (!IdxToCardId.TryGetValue(side, out var map))
|
|
{
|
|
map = new Dictionary<int, long>();
|
|
var deck = side.Context.SelfDeckCardIds;
|
|
for (var i = 0; i < deck.Count; i++) map[i + 1] = deck[i];
|
|
IdxToCardId[side] = map;
|
|
}
|
|
return map;
|
|
}
|
|
|
|
/// <summary>Record a generated token's identity into the side's idx->cardId map (the same map
|
|
/// that holds deck cards). Mined from the sender's <c>orderList</c> <c>add</c> ops by
|
|
/// <see cref="KnownListBuilder.MineAddOps"/>; surfaced later by <c>BuildPlayedCard</c> when the
|
|
/// token is the played card. Deck idxs (1..deckCount) and token idxs (>deckCount) don't
|
|
/// collide — the client allocates token idxs after the deck.</summary>
|
|
public void RecordToken(IBattleParticipant side, int idx, long cardId)
|
|
{
|
|
GetOrSeedDeckMap(side); // ensure the per-side map exists (deck-seeded)
|
|
IdxToCardId[side][idx] = cardId; // overwrite-on-conflict: latest identity wins
|
|
}
|
|
|
|
/// <summary>Mine generated-token identities from a sender's <c>orderList</c> <c>add</c> ops and
|
|
/// record each into the correct side's map. <c>isSelf:1</c> → the sender's own token (<paramref
|
|
/// name="from"/>); <c>isSelf:0</c> → a cross-side gift living at that idx in the OPPONENT's index
|
|
/// space (<paramref name="other"/>) — <c>isSelf</c> is the sender's perspective tag on
|
|
/// <c>CardObj.IsPlayer</c> (RegisterToken.cs:22), and a card has a single <c>CardObj.Index</c>, so
|
|
/// the gifted idx is the same slot in the recipient's own map (the one consulted when the recipient
|
|
/// later plays it). Shared by <c>PlayActionsHandler</c> and <c>EchoHandler</c> — an Echo's orderList
|
|
/// carries the same add-op shape (<c>SendCardDataMaker.MakeEchoData</c>), so both mine identically;
|
|
/// Echo is mined but never relayed.</summary>
|
|
public void RecordTokensFrom(IBattleParticipant from, IBattleParticipant other, object? orderList)
|
|
{
|
|
foreach (var (idx, cardId, isSelf) in KnownListBuilder.MineAddOps(orderList))
|
|
RecordToken(isSelf == 1 ? from : other, idx, cardId);
|
|
}
|
|
}
|