c0309061fa
Verbatim uList relay shape + transform (deck-sourced summons/fetches), mirroring RenameTargets. Not yet wired into the handler. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
509 lines
21 KiB
C#
509 lines
21 KiB
C#
using NUnit.Framework;
|
|
using SVSim.BattleNode.Protocol.Bodies;
|
|
using SVSim.BattleNode.Sessions.Dispatch;
|
|
|
|
namespace SVSim.UnitTests.BattleNode.Sessions;
|
|
|
|
[TestFixture]
|
|
public class KnownListBuilderTests
|
|
{
|
|
// orderList as it arrives in a RawBody: a list of single-key op dicts.
|
|
private static List<object?> OrderListMove(int idx, int from, int to) => new()
|
|
{
|
|
new Dictionary<string, object?>
|
|
{
|
|
["move"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = new List<object?> { (long)idx },
|
|
["isSelf"] = 1L, ["from"] = (long)from, ["to"] = (long)to,
|
|
}
|
|
}
|
|
};
|
|
|
|
[Test]
|
|
public void ExtractMoveTo_returns_to_for_matching_idx()
|
|
{
|
|
var to = KnownListBuilder.ExtractMoveTo(OrderListMove(3, 10, 20), playIdx: 3);
|
|
Assert.That(to, Is.EqualTo(20));
|
|
}
|
|
|
|
[Test]
|
|
public void ExtractMoveTo_returns_null_when_no_move_op_matches()
|
|
{
|
|
Assert.That(KnownListBuilder.ExtractMoveTo(OrderListMove(3, 10, 20), playIdx: 99), Is.Null);
|
|
Assert.That(KnownListBuilder.ExtractMoveTo(null, playIdx: 3), Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void ExtractMoveTo_returns_first_matching_move_op()
|
|
{
|
|
// A real PlayActions can carry several move ops; the played card's move comes first,
|
|
// later ops (token add/alter) target other idxs. Confirm first-match-wins, not last.
|
|
var orderList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?>
|
|
{
|
|
["move"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = new List<object?> { 3L }, ["isSelf"] = 1L, ["from"] = 10L, ["to"] = 30L,
|
|
}
|
|
},
|
|
new Dictionary<string, object?>
|
|
{
|
|
["move"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = new List<object?> { 31L, 32L }, ["isSelf"] = 1L, ["from"] = 0L, ["to"] = 40L,
|
|
}
|
|
},
|
|
};
|
|
Assert.That(KnownListBuilder.ExtractMoveTo(orderList, playIdx: 3), Is.EqualTo(30));
|
|
Assert.That(KnownListBuilder.ExtractMoveTo(orderList, playIdx: 31), Is.EqualTo(40));
|
|
}
|
|
|
|
[Test]
|
|
public void BuildPlayedCard_returns_null_for_deck_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));
|
|
Assert.That(entry, Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void BuildPlayedCard_synthesizes_entry_for_deck_card()
|
|
{
|
|
var deckMap = new Dictionary<int, long> { [3] = 128821011L };
|
|
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 3, orderList: OrderListMove(3, 10, 20));
|
|
|
|
Assert.That(entry, Is.Not.Null);
|
|
Assert.That(entry!.Idx, Is.EqualTo(3));
|
|
Assert.That(entry.CardId, Is.EqualTo(128821011L));
|
|
Assert.That(entry.To, Is.EqualTo(20));
|
|
Assert.That(entry.Spellboost, Is.EqualTo(0));
|
|
Assert.That(entry.AttachTarget, Is.EqualTo(""));
|
|
}
|
|
|
|
[Test]
|
|
public void BuildPlayedCard_returns_null_for_token_idx_not_in_deck()
|
|
{
|
|
var deckMap = new Dictionary<int, long> { [3] = 128821011L };
|
|
var entry = KnownListBuilder.BuildPlayedCard(deckMap, playIdx: 31, orderList: OrderListMove(31, 10, 20));
|
|
Assert.That(entry, Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void RenameTargets_passes_isSelf_through_verbatim()
|
|
{
|
|
var targetList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?> { ["targetIdx"] = 8L, ["isSelf"] = 0L },
|
|
};
|
|
var renamed = KnownListBuilder.RenameTargets(targetList);
|
|
|
|
Assert.That(renamed, Is.Not.Null);
|
|
Assert.That(renamed!.Count, Is.EqualTo(1));
|
|
Assert.That(renamed[0].TargetIdx, Is.EqualTo(8));
|
|
Assert.That(renamed[0].IsSelf, Is.EqualTo(0));
|
|
}
|
|
|
|
[Test]
|
|
public void RenameTargets_returns_null_for_missing_or_empty()
|
|
{
|
|
Assert.That(KnownListBuilder.RenameTargets(null), Is.Null);
|
|
Assert.That(KnownListBuilder.RenameTargets(new List<object?>()), Is.Null);
|
|
}
|
|
|
|
// An add op as it arrives in a RawBody: { "add": { "idx": [..], "isSelf": n, "card": { "cardId": n } } }
|
|
private static Dictionary<string, object?> AddOp(long[] idxs, long cardId, long isSelf = 1) => new()
|
|
{
|
|
["add"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = idxs.Select(i => (object?)i).ToList(),
|
|
["isSelf"] = isSelf,
|
|
["card"] = new Dictionary<string, object?> { ["cardId"] = cardId },
|
|
}
|
|
};
|
|
|
|
[Test]
|
|
public void MineAddOps_yields_idx_to_cardId_for_every_idx_in_an_add_op()
|
|
{
|
|
var orderList = new List<object?> { AddOp(new[] { 31L, 32L }, 900111010L) };
|
|
var mined = KnownListBuilder.MineAddOps(orderList).ToList();
|
|
|
|
Assert.That(mined, Is.EquivalentTo(new[] { (31, 900111010L, 1), (32, 900111010L, 1) }));
|
|
}
|
|
|
|
[Test]
|
|
public void MineAddOps_yields_cross_side_gifts_with_isSelf_0()
|
|
{
|
|
// A card gifted to the opponent (isSelf:0) is the opponent's card at this idx (isSelf is the
|
|
// sender's perspective tag on CardObj.IsPlayer — RegisterToken.cs:22). The extractor surfaces
|
|
// it; the caller routes it into the OTHER side's map.
|
|
var orderList = new List<object?> { AddOp(new[] { 31L }, 900111010L, isSelf: 0) };
|
|
Assert.That(KnownListBuilder.MineAddOps(orderList),
|
|
Is.EquivalentTo(new[] { (31, 900111010L, 0) }));
|
|
}
|
|
|
|
[Test]
|
|
public void MineAddOps_skips_choice_adds_with_no_concrete_cardId()
|
|
{
|
|
// { "add": { "idx":[46], "card": { "candidates":[...] }, "isChoice":"1" } } — identity undetermined.
|
|
var orderList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?>
|
|
{
|
|
["add"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = new List<object?> { 46L },
|
|
["isSelf"] = 1L,
|
|
["card"] = new Dictionary<string, object?>
|
|
{
|
|
["candidates"] = new List<object?> { 810041260L, 101041020L },
|
|
},
|
|
["isChoice"] = "1",
|
|
}
|
|
}
|
|
};
|
|
Assert.That(KnownListBuilder.MineAddOps(orderList), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineAddOps_skips_copy_token_adds_with_baseIdx_and_no_cardId()
|
|
{
|
|
// RegisterCopyToken.MakeCardData → { "baseIdx": N, "isPremium": 0 } — no cardId, deferred.
|
|
var orderList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?>
|
|
{
|
|
["add"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = new List<object?> { 33L },
|
|
["isSelf"] = 1L,
|
|
["card"] = new Dictionary<string, object?> { ["baseIdx"] = 12L, ["isPremium"] = 0L },
|
|
}
|
|
}
|
|
};
|
|
Assert.That(KnownListBuilder.MineAddOps(orderList), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineAddOps_ignores_non_add_ops_and_null()
|
|
{
|
|
Assert.That(KnownListBuilder.MineAddOps(OrderListMove(3, 10, 20)), Is.Empty);
|
|
Assert.That(KnownListBuilder.MineAddOps(null), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineAddOps_yields_from_multiple_add_ops_in_one_orderList()
|
|
{
|
|
var orderList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?> { ["move"] = new Dictionary<string, object?>
|
|
{ ["idx"] = new List<object?> { 3L }, ["isSelf"] = 1L, ["from"] = 10L, ["to"] = 30L } },
|
|
AddOp(new[] { 31L }, 900111010L),
|
|
AddOp(new[] { 32L }, 900811090L),
|
|
};
|
|
var mined = KnownListBuilder.MineAddOps(orderList).ToList();
|
|
Assert.That(mined, Is.EquivalentTo(new[] { (31, 900111010L, 1), (32, 900811090L, 1) }));
|
|
}
|
|
|
|
// A choice/Discover add op as it arrives in a RawBody: candidates-only (no concrete cardId —
|
|
// RegisterChoiceAdd strips it), with isChoice present. Capture battle-traffic_tk2_regular line 152.
|
|
private static Dictionary<string, object?> ChoiceAddOp(long idx, long[] candidates, long isSelf = 1) => new()
|
|
{
|
|
["add"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = new List<object?> { idx },
|
|
["isSelf"] = isSelf,
|
|
["card"] = new Dictionary<string, object?>
|
|
{
|
|
["candidates"] = candidates.Select(c => (object?)c).ToList(),
|
|
},
|
|
["isChoice"] = "1",
|
|
}
|
|
};
|
|
|
|
// A keyAction entry: { type, cardId (the GENERATING card), selectCard:{ cardId:[chosen...], open } }.
|
|
private static List<object?> KeyActionChoice(long generatingCardId, long[] chosen, long open) => new()
|
|
{
|
|
new Dictionary<string, object?>
|
|
{
|
|
["type"] = 1L,
|
|
["cardId"] = generatingCardId,
|
|
["selectCard"] = new Dictionary<string, object?>
|
|
{
|
|
["cardId"] = chosen.Select(c => (object?)c).ToList(),
|
|
["open"] = open,
|
|
},
|
|
}
|
|
};
|
|
|
|
[Test]
|
|
public void MineChoicePicks_resolves_idx_to_chosen_cardId_from_selectCard()
|
|
{
|
|
// The choiceAdd carries only candidates; the pick rides keyAction.selectCard.cardId. The node
|
|
// joins them by candidate membership. Capture lines 151/152/193: chosen = candidates[0].
|
|
var orderList = new List<object?> { ChoiceAddOp(46, new[] { 810041260L, 101041020L }) };
|
|
var keyAction = KeyActionChoice(generatingCardId: 810014030L, chosen: new[] { 810041260L }, open: 0);
|
|
|
|
Assert.That(KnownListBuilder.MineChoicePicks(orderList, keyAction),
|
|
Is.EquivalentTo(new[] { (46, 810041260L, 1) }));
|
|
}
|
|
|
|
[Test]
|
|
public void MineChoicePicks_routes_cross_side_choice_by_isSelf()
|
|
{
|
|
// A choiceAdd with isSelf:0 (a gifted choice in the opponent's index space) surfaces isSelf:0
|
|
// so the caller routes it into the OTHER side's map (same rule as MineAddOps).
|
|
var orderList = new List<object?> { ChoiceAddOp(46, new[] { 810041260L, 101041020L }, isSelf: 0) };
|
|
var keyAction = KeyActionChoice(810014030L, new[] { 101041020L }, open: 0);
|
|
|
|
Assert.That(KnownListBuilder.MineChoicePicks(orderList, keyAction),
|
|
Is.EquivalentTo(new[] { (46, 101041020L, 0) }));
|
|
}
|
|
|
|
[Test]
|
|
public void MineChoicePicks_yields_nothing_when_no_pick_matches_candidates()
|
|
{
|
|
var orderList = new List<object?> { ChoiceAddOp(46, new[] { 810041260L, 101041020L }) };
|
|
var keyAction = KeyActionChoice(810014030L, new[] { 999999999L }, open: 0);
|
|
|
|
Assert.That(KnownListBuilder.MineChoicePicks(orderList, keyAction), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineChoicePicks_ignores_non_choice_add_ops()
|
|
{
|
|
// A concrete-token add (cardId, no candidates) is MineAddOps' job — even if its cardId happens
|
|
// to equal a selectCard pick, MineChoicePicks only mines isChoice/candidates adds.
|
|
var orderList = new List<object?> { AddOp(new[] { 31L }, 900111010L) };
|
|
var keyAction = KeyActionChoice(810014030L, new[] { 900111010L }, open: 0);
|
|
|
|
Assert.That(KnownListBuilder.MineChoicePicks(orderList, keyAction), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineChoicePicks_yields_nothing_when_keyAction_absent()
|
|
{
|
|
// Echo carries orderList but no keyAction; choice mining keys on keyAction, so Echo yields
|
|
// nothing here and stays mining-only via MineAddOps (§3.5).
|
|
var orderList = new List<object?> { ChoiceAddOp(46, new[] { 810041260L, 101041020L }) };
|
|
|
|
Assert.That(KnownListBuilder.MineChoicePicks(orderList, null), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void StripKeyActionForOpponent_drops_selectCard_when_open_0()
|
|
{
|
|
// Hidden draw-to-hand choice: opponent gets {type,cardId} only; the pick stays secret.
|
|
// Capture line 151: keyAction:[{type:1, cardId:810014030}].
|
|
var keyAction = KeyActionChoice(810014030L, new[] { 810041260L }, open: 0);
|
|
var stripped = KnownListBuilder.StripKeyActionForOpponent(keyAction);
|
|
|
|
Assert.That(stripped, Is.Not.Null);
|
|
Assert.That(stripped!.Count, Is.EqualTo(1));
|
|
Assert.That(stripped[0].Type, Is.EqualTo(1));
|
|
Assert.That(stripped[0].CardId, Is.EqualTo(810014030L));
|
|
Assert.That(stripped[0].SelectCard, Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void StripKeyActionForOpponent_passes_selectCard_through_when_open_1()
|
|
{
|
|
// Visible board choice — provisional reveal-immediately behavior (§6, flagged for the live run).
|
|
var keyAction = KeyActionChoice(810014030L, new[] { 810041260L }, open: 1);
|
|
var stripped = KnownListBuilder.StripKeyActionForOpponent(keyAction);
|
|
|
|
Assert.That(stripped![0].SelectCard, Is.Not.Null);
|
|
Assert.That(stripped[0].SelectCard!.CardId, Is.EqualTo(new[] { 810041260L }));
|
|
Assert.That(stripped[0].SelectCard.Open, Is.EqualTo(1));
|
|
}
|
|
|
|
[Test]
|
|
public void StripKeyActionForOpponent_drops_non_choice_types()
|
|
{
|
|
// Only Choice(1)/HaveBeforeSkillChoice(5) are handled; other KeyActionTypes are dropped
|
|
// (current behavior) until their own specs (§6).
|
|
var keyAction = new List<object?>
|
|
{
|
|
new Dictionary<string, object?> { ["type"] = 2L, ["cardId"] = 123L },
|
|
};
|
|
Assert.That(KnownListBuilder.StripKeyActionForOpponent(keyAction), Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void StripKeyActionForOpponent_returns_null_for_absent_keyAction()
|
|
{
|
|
Assert.That(KnownListBuilder.StripKeyActionForOpponent(null), Is.Null);
|
|
Assert.That(KnownListBuilder.StripKeyActionForOpponent(new List<object?>()), Is.Null);
|
|
}
|
|
|
|
// A copy add op as it arrives in a RawBody: { "add": { "idx":[..], "isSelf":n, "card":{ "baseIdx":m, "isPremium":0 } } }
|
|
private static Dictionary<string, object?> CopyOp(long[] idxs, long baseIdx, long isSelf = 1) => new()
|
|
{
|
|
["add"] = new Dictionary<string, object?>
|
|
{
|
|
["idx"] = idxs.Select(i => (object?)i).ToList(),
|
|
["isSelf"] = isSelf,
|
|
["card"] = new Dictionary<string, object?> { ["baseIdx"] = baseIdx, ["isPremium"] = 0L },
|
|
}
|
|
};
|
|
|
|
[Test]
|
|
public void MineCopyTokens_resolves_baseIdx_against_selfMap_for_isSelf_1()
|
|
{
|
|
var orderList = new List<object?> { CopyOp(new[] { 31L }, baseIdx: 5L, isSelf: 1) };
|
|
var selfMap = new Dictionary<int, long> { [5] = 100_011_010L };
|
|
var otherMap = new Dictionary<int, long>();
|
|
var mined = KnownListBuilder.MineCopyTokens(orderList, selfMap, otherMap).ToList();
|
|
Assert.That(mined, Is.EquivalentTo(new[] { (31, 100_011_010L, 1) }));
|
|
}
|
|
|
|
[Test]
|
|
public void MineCopyTokens_resolves_baseIdx_against_otherMap_for_isSelf_0()
|
|
{
|
|
// Cross-side copy shape (battle-traffic_tk2_regular.ndjson:196 is an isSelf:0 Echo, baseIdx 21):
|
|
// the source lives in the OPPONENT's index space, so resolve against otherMap and record there.
|
|
var orderList = new List<object?> { CopyOp(new[] { 49L }, baseIdx: 21L, isSelf: 0) };
|
|
var selfMap = new Dictionary<int, long>();
|
|
var otherMap = new Dictionary<int, long> { [21] = 900_841_330L };
|
|
var mined = KnownListBuilder.MineCopyTokens(orderList, selfMap, otherMap).ToList();
|
|
Assert.That(mined, Is.EquivalentTo(new[] { (49, 900_841_330L, 0) }));
|
|
}
|
|
|
|
[Test]
|
|
public void MineCopyTokens_skips_copy_when_baseIdx_absent_from_map()
|
|
{
|
|
// Unknown source (e.g. a card the node never recorded) → no record, no desync, the play degrades.
|
|
var orderList = new List<object?> { CopyOp(new[] { 31L }, baseIdx: 99L, isSelf: 1) };
|
|
Assert.That(
|
|
KnownListBuilder.MineCopyTokens(orderList, new Dictionary<int, long>(), new Dictionary<int, long>()),
|
|
Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineCopyTokens_ignores_concrete_and_choice_adds()
|
|
{
|
|
// A concrete-cardId add is MineAddOps' job; a candidates add is MineChoicePicks' — both skipped here.
|
|
var orderList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?> { ["add"] = new Dictionary<string, object?>
|
|
{ ["idx"] = new List<object?> { 31L }, ["isSelf"] = 1L,
|
|
["card"] = new Dictionary<string, object?> { ["cardId"] = 900_111_010L } } },
|
|
new Dictionary<string, object?> { ["add"] = new Dictionary<string, object?>
|
|
{ ["idx"] = new List<object?> { 32L }, ["isSelf"] = 1L,
|
|
["card"] = new Dictionary<string, object?> { ["candidates"] = new List<object?> { 1L, 2L } },
|
|
["isChoice"] = "1" } },
|
|
};
|
|
var map = new Dictionary<int, long> { [1] = 5L };
|
|
Assert.That(KnownListBuilder.MineCopyTokens(orderList, map, map), Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineCopyTokens_skips_string_baseIdx_private_group()
|
|
{
|
|
// PrivateGroupIndexMsg != "" makes baseIdx a STRING (RegisterCopyToken.cs:19-22) — the hidden
|
|
// private-card path; skipped just like private-group idx in MineAddOps.
|
|
var orderList = new List<object?>
|
|
{
|
|
new Dictionary<string, object?> { ["add"] = new Dictionary<string, object?>
|
|
{ ["idx"] = new List<object?> { 31L }, ["isSelf"] = 1L,
|
|
["card"] = new Dictionary<string, object?> { ["baseIdx"] = "g1", ["isPremium"] = 0L } } },
|
|
};
|
|
Assert.That(
|
|
KnownListBuilder.MineCopyTokens(orderList, new Dictionary<int, long>(), new Dictionary<int, long>()),
|
|
Is.Empty);
|
|
}
|
|
|
|
[Test]
|
|
public void MineCopyTokens_yields_for_every_idx_in_a_multi_idx_copy_op()
|
|
{
|
|
var orderList = new List<object?> { CopyOp(new[] { 31L, 32L }, baseIdx: 5L, isSelf: 1) };
|
|
var selfMap = new Dictionary<int, long> { [5] = 700L };
|
|
var mined = KnownListBuilder.MineCopyTokens(orderList, selfMap, new Dictionary<int, long>()).ToList();
|
|
Assert.That(mined, Is.EquivalentTo(new[] { (31, 700L, 1), (32, 700L, 1) }));
|
|
}
|
|
|
|
// A uList entry as it arrives in a RawBody. Minimal = the 5 always-present fields
|
|
// (capture battle-traffic_tk2_regular.ndjson:75). Optional fields added per-test.
|
|
private static Dictionary<string, object?> UListEntry(
|
|
long[] idxList, int from, int to, int isSelf, string skill) => new()
|
|
{
|
|
["idxList"] = idxList.Select(i => (object?)i).ToList(),
|
|
["from"] = (long)from, ["to"] = (long)to, ["isSelf"] = (long)isSelf, ["skill"] = skill,
|
|
};
|
|
|
|
[Test]
|
|
public void RelayUList_maps_the_minimal_capture_entry_shape()
|
|
{
|
|
// battle-traffic_tk2_regular.ndjson:75 — a hidden deck-fetch (no cardId), the only uList shape
|
|
// in any capture. The 5 always-present fields map; conditionals stay null.
|
|
var uList = new List<object?> { UListEntry(new[] { 16L, 22L }, from: 0, to: 10, isSelf: 1, skill: "37|36|0") };
|
|
var relayed = KnownListBuilder.RelayUList(uList);
|
|
|
|
Assert.That(relayed, Is.Not.Null);
|
|
Assert.That(relayed!.Count, Is.EqualTo(1));
|
|
var e = relayed[0];
|
|
Assert.That(e.IdxList, Is.EqualTo(new[] { 16, 22 }));
|
|
Assert.That(e.From, Is.EqualTo(0));
|
|
Assert.That(e.To, Is.EqualTo(10));
|
|
Assert.That(e.IsSelf, Is.EqualTo(1));
|
|
Assert.That(e.Skill, Is.EqualTo("37|36|0"));
|
|
Assert.That(e.CardId, Is.Null);
|
|
Assert.That(e.Clan, Is.Null);
|
|
Assert.That(e.Cost, Is.Null);
|
|
Assert.That(e.SkillKeyCardIdx, Is.Null);
|
|
Assert.That(e.RandomTargetIdx, Is.Null);
|
|
Assert.That(e.IsInvoke, Is.Null);
|
|
Assert.That(e.AttachTarget, Is.Null);
|
|
}
|
|
|
|
[Test]
|
|
public void RelayUList_maps_a_revealed_summon_with_all_conditional_fields()
|
|
{
|
|
// Decomp-grounded (no capture): a revealed summon-to-field carries cardId + clan + cost etc.
|
|
var entry = UListEntry(new[] { 40L }, from: 0, to: 20, isSelf: 1, skill: "5|3|0");
|
|
entry["cardId"] = 900111010L;
|
|
entry["clan"] = 8L;
|
|
entry["cost"] = 2L;
|
|
entry["skillKeyCardIdx"] = new List<object?> { 7L };
|
|
entry["randomTargetIdx"] = new List<object?> { 2L, 3L };
|
|
entry["isInvoke"] = 1L;
|
|
entry["attachTarget"] = "12,13";
|
|
var relayed = KnownListBuilder.RelayUList(new List<object?> { entry });
|
|
|
|
var e = relayed![0];
|
|
Assert.That(e.To, Is.EqualTo(20));
|
|
Assert.That(e.CardId, Is.EqualTo(900111010L));
|
|
Assert.That(e.Clan, Is.EqualTo(8));
|
|
Assert.That(e.Cost, Is.EqualTo(2));
|
|
Assert.That(e.SkillKeyCardIdx, Is.EqualTo(new[] { 7 }));
|
|
Assert.That(e.RandomTargetIdx, Is.EqualTo(new[] { 2, 3 }));
|
|
Assert.That(e.IsInvoke, Is.EqualTo(1));
|
|
Assert.That(e.AttachTarget, Is.EqualTo("12,13"));
|
|
}
|
|
|
|
[Test]
|
|
public void RelayUList_preserves_multiple_entries_in_order()
|
|
{
|
|
var uList = new List<object?>
|
|
{
|
|
UListEntry(new[] { 16L }, 0, 10, 1, "a"),
|
|
UListEntry(new[] { 22L }, 0, 20, 0, "b"),
|
|
};
|
|
var relayed = KnownListBuilder.RelayUList(uList);
|
|
|
|
Assert.That(relayed!.Count, Is.EqualTo(2));
|
|
Assert.That(relayed[0].Skill, Is.EqualTo("a"));
|
|
Assert.That(relayed[1].Skill, Is.EqualTo("b"));
|
|
Assert.That(relayed[1].IsSelf, Is.EqualTo(0));
|
|
}
|
|
|
|
[Test]
|
|
public void RelayUList_returns_null_for_missing_or_empty()
|
|
{
|
|
Assert.That(KnownListBuilder.RelayUList(null), Is.Null);
|
|
Assert.That(KnownListBuilder.RelayUList(new List<object?>()), Is.Null);
|
|
}
|
|
}
|