From 9fc97abee7af39d14ed12ffbb4735137477d3138 Mon Sep 17 00:00:00 2001 From: gamer147 Date: Sat, 6 Jun 2026 08:23:53 -0400 Subject: [PATCH] =?UTF-8?q?feat(battle-engine-port):=20M7=20COMPLETE=20?= =?UTF-8?q?=E2=80=94=20targeted=20destroy=20resolves=20headless=20(followe?= =?UTF-8?q?r=20death=20/=20board-removal)?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit First proof that follower DEATH / board-removal commits in the authoritative part of PlayCard headless (not the cosmetic post-Process tail). Card 800144120 (cost-0 when_play destroy of a select_count=1 enemy follower) resolves via the M6 selectedCards path: selected enemy follower removed (board -1 + cemetery +1), un-selected untouched (routing confirmed load-bearing by swapping the selection). Shim gap fixed (the predicted M7 cost): SkillProcessor.SelectCardToHaveDestroyVoicePlay's cosmetic death-voice tail NRE'd on three M1 default!/Null* shadows (IBattleCardView.VoiceInfo, CardVoiceInfoCache.GetCardVoiceInfoForBattle, ReadOnlyVoiceInfo.GetDestroyVoice — the last unusable as the interface since m1_stub_gen dropped its : IReadOnlyVoiceInfo base). Fix = one hand shim HeadlessVoiceInfo : IReadOnlyVoiceInfo returning the engine's own VoiceAndWaitTime._nullVoice sentinel, wired into the two generated seams with // HEADLESS-FIX markers. No Engine/ edit (drift clean). dotnet test SVSim.BattleEngine.Tests -> 7/7 green; check_drift.py clean; engine 0 Error(s). Co-Authored-By: Claude Opus 4.8 --- SVSim.BattleEngine.Tests/HeadlessFixture.cs | 18 ++- .../TargetedDestroySpellOracleTests.cs | 110 ++++++++++++++++++ .../Shim/Generated/CardVoiceInfoCache.g.cs | 2 +- .../Shim/Generated/_IfaceImpl.g.cs | 2 +- .../Shim/View/HeadlessVoiceInfo.cs | 38 ++++++ 5 files changed, 167 insertions(+), 3 deletions(-) create mode 100644 SVSim.BattleEngine.Tests/TargetedDestroySpellOracleTests.cs create mode 100644 SVSim.BattleEngine/Shim/View/HeadlessVoiceInfo.cs diff --git a/SVSim.BattleEngine.Tests/HeadlessFixture.cs b/SVSim.BattleEngine.Tests/HeadlessFixture.cs index 0ed10f6..1069977 100644 --- a/SVSim.BattleEngine.Tests/HeadlessFixture.cs +++ b/SVSim.BattleEngine.Tests/HeadlessFixture.cs @@ -69,6 +69,22 @@ namespace SVSim.BattleEngine.Tests public const int SelectTargetFollowerId = 900041010; // neutral 13/13 public const int UnselectTargetFollowerId = 102011010; // neutral 6/7 + // M7 next milestone: targeted DESTROY — the first card proving follower DEATH / board-removal + // resolves in the AUTHORITATIVE (committed) part of PlayCard headless, not the cosmetic + // post-Process tail. 800144120 is an ELF (clan 1) cost-0 SPELL whose sole skill is `when_play` + // `destroy` of a SELECTED enemy follower + // (skill_target=character=op&target=inplay&card_type=unit&select_count=1), ungated + // (skill_condition=character=me), no RNG, no dynamic value. `destroy` is UNCONDITIONAL removal + // (vs `damage` needing a >=life amount), so the oracle is the cleanest possible "card left the + // board": selected follower gone + enemy board count -1 + selected card in CemeteryList, while + // the un-selected follower stays (routing, M6's lesson, confirmed load-bearing by swapping the + // selection). Reuses the two M2/M6 vanilla followers as the target board (destroy is + // unconditional so their stats are irrelevant — distinct ids only so selected vs un-selected + // can't be confused). InitCardTemplates is NOT needed (destroy creates no card). + public const int DestroySpellId = 800144120; + public const int DestroyTargetFollowerId = FollowerId; // neutral 1/2 (the selected, destroyed one) + public const int DestroyOtherFollowerId = UnselectTargetFollowerId; // neutral 6/7 (the un-selected survivor) + private static bool _done; public static void EnsureInitialized() @@ -89,7 +105,7 @@ namespace SVSim.BattleEngine.Tests // real stats. The summoned token id must be present: Skill_summon_token resolves it // through CardMaster.GetCardParameterFromId during creation. HeadlessCardMaster.Load(FollowerId, SpellId, BuffFollowerId, TokenSpellId, SummonedTokenId, - TargetSpellId, SelectTargetFollowerId, UnselectTargetFollowerId); + TargetSpellId, SelectTargetFollowerId, UnselectTargetFollowerId, DestroySpellId); // Master reference data (class-character list) for leader/class card resolution. HeadlessMasterData.Install(); // Player/enemy leaders (chara ids must map to a ClassCharacterMasterData in Master). diff --git a/SVSim.BattleEngine.Tests/TargetedDestroySpellOracleTests.cs b/SVSim.BattleEngine.Tests/TargetedDestroySpellOracleTests.cs new file mode 100644 index 0000000..dfa82dd --- /dev/null +++ b/SVSim.BattleEngine.Tests/TargetedDestroySpellOracleTests.cs @@ -0,0 +1,110 @@ +using System.Collections.Generic; +using System.Reflection; +using NUnit.Framework; +using Wizard; +using Wizard.Battle; + +namespace SVSim.BattleEngine.Tests +{ + // M7 (the first card to prove follower DEATH / board-removal): a when_play TARGETED-DESTROY spell + // resolves to correct authoritative state HEADLESS via the same IsForecast/IsRecovery + + // ActionProcessor + selectedCards path M6 proved — but for the FIRST time exercising a mechanic + // that REMOVES a card from the board. M2-M6 only ever ADDED to / mutated stats of cards already in + // play; none proved the engine commits board REMOVAL inside the authoritative part of PlayCard + // (rather than the cosmetic post-Process tail the prior docs flag). The new oracle dimension is + // BOARD REMOVAL: with TWO followers on the enemy board and ONE passed as `selectedCards`, the + // `destroy` must remove exactly the SELECTED follower (enemy board count -1, selected gone, landed + // in the enemy CemeteryList) while leaving the un-selected follower on the board. The un-selected- + // survives assertion is load-bearing the same way M4's delta-vs-base and M6's differential were: + // it distinguishes "the destroy was routed to the selection" from "a blanket board wipe" — and is + // confirmed by the routing already proven in M6 (the effect follows the selectedCards entry). + [TestFixture] + public class TargetedDestroySpellOracleTests + { + private static void SetPrivateField(object obj, string name, object value) + { + var t = obj.GetType(); + var f = t.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public); + while (f == null && t.BaseType != null) { t = t.BaseType; f = t.GetField(name, BindingFlags.Instance | BindingFlags.NonPublic); } + Assert.That(f, Is.Not.Null, $"field {name} not found on {obj.GetType().Name}"); + f.SetValue(obj, value); + } + + [Test] + public void Targeted_destroy_spell_removes_only_the_selected_enemy_follower() + { + HeadlessEngineEnv.EnsureInitialized(); + BattleManagerBase.IsForecast = true; // suppress VFX registration (F1) + var mgr = new SingleBattleMgr(new HeadlessContentsCreator()); + mgr.IsRecovery = true; // collapse wait delays to 0 (F1) + + var player = mgr.BattlePlayer; + var enemy = mgr.BattleEnemy; + + // Minimal opponent/turn wiring (see M2-M6 oracles): opponent refs + active turn flag. The + // destroy's target resolver walks player -> opponent -> opponent's in-play followers. + SetPrivateField(player, "_opponentBattlePlayer", enemy); + SetPrivateField(enemy, "_opponentBattlePlayer", player); + player.IsSelfTurn = true; + enemy.IsSelfTurn = false; + + // Seed leader life so neither leader reads as a 0-life game-over state (blocks plays, M3). + HeadlessEngineEnv.InitLeaderLife(mgr); + + // Put TWO vanilla followers on the ENEMY board (the M6 setup). destroy is unconditional, so + // their stats are irrelevant — distinct ids only so the selected vs un-selected can't be + // confused. The selected one is destroyed; the un-selected one must survive. + var selected = HeadlessEngineEnv.PutFollowerInPlay(mgr, HeadlessEngineEnv.DestroyTargetFollowerId, 0, isPlayer: false); + var unselected = HeadlessEngineEnv.PutFollowerInPlay(mgr, HeadlessEngineEnv.DestroyOtherFollowerId, 1, isPlayer: false); + + var cardParam = CardMaster.GetInstanceForBattle().GetCardParameterFromId(HeadlessEngineEnv.DestroySpellId); + + // Place the targeted-destroy spell in the active player's hand with PP to spare. + var card = HeadlessEngineEnv.CreateHeadlessHandCard(HeadlessEngineEnv.DestroySpellId, 1, isPlayer: true, mgr); + player.HandCardList.Add(card); + player.Pp = 10; + + // Pre-state snapshot. + int ppBefore = player.Pp; + int handBefore = player.HandCardList.Count; + int playerInplayBefore = player.ClassAndInPlayCardList.Count; + int enemyInplayBefore = enemy.ClassAndInPlayCardList.Count; + int enemyCemeteryBefore = enemy.CemeteryList.Count; + int enemyLeaderLifeBefore = enemy.ClassAndInPlayCardList[0].Life; + + // Resolve the play through the real engine, passing the chosen target via selectedCards. + var pair = mgr.GetBattlePlayerPair(isPlayer: true); + var ap = new ActionProcessor(pair); + Assert.DoesNotThrow(() => ap.PlayCard(card, selectedCards: new List { selected }), + "ActionProcessor.PlayCard threw on a targeted-destroy spell"); + + // Oracle: board removal is the new M7 dimension; the rest are the §5 spell-shaped invariants. + Assert.Multiple(() => + { + // PRIMARY M7 assertions: the SELECTED follower is removed from the enemy board... + Assert.That(enemy.ClassAndInPlayCardList, Does.Not.Contain(selected), + "selected follower still on the enemy board (destroy did not remove it)"); + Assert.That(enemy.ClassAndInPlayCardList.Count, Is.EqualTo(enemyInplayBefore - 1), + "enemy board count not -1 (a destroy did not commit, or hit the wrong number of cards)"); + // ...and it landed in the enemy's CemeteryList (the engine's destroy/death path). + Assert.That(enemy.CemeteryList, Contains.Item(selected), + "destroyed follower not in the enemy CemeteryList"); + Assert.That(enemy.CemeteryList.Count, Is.EqualTo(enemyCemeteryBefore + 1), + "enemy cemetery count not +1"); + // ...while the UN-SELECTED follower stays on the board (proves routing, not a board wipe). + Assert.That(enemy.ClassAndInPlayCardList, Contains.Item(unselected), + "un-selected follower was destroyed (effect not routed to the selection)"); + // Leader untouched (destroy targets a follower, not the face). + Assert.That(enemy.ClassAndInPlayCardList[0].Life, Is.EqualTo(enemyLeaderLifeBefore), + "opponent leader life changed (destroy hit the leader, not the selected follower)"); + // Cost paid. + Assert.That(player.Pp, Is.EqualTo(ppBefore - cardParam.Cost), "PP not reduced by exactly cost"); + // Spell leaves hand and (being a spell) does NOT occupy the board. + Assert.That(player.HandCardList, Does.Not.Contain(card), "spell still in hand"); + Assert.That(player.HandCardList.Count, Is.EqualTo(handBefore - 1), "hand count not -1"); + Assert.That(player.ClassAndInPlayCardList, Does.Not.Contain(card), "spell wrongly placed on the board"); + Assert.That(player.ClassAndInPlayCardList.Count, Is.EqualTo(playerInplayBefore), "player board count changed"); + }); + } + } +} diff --git a/SVSim.BattleEngine/Shim/Generated/CardVoiceInfoCache.g.cs b/SVSim.BattleEngine/Shim/Generated/CardVoiceInfoCache.g.cs index 2ddfbe4..3af77f2 100644 --- a/SVSim.BattleEngine/Shim/Generated/CardVoiceInfoCache.g.cs +++ b/SVSim.BattleEngine/Shim/Generated/CardVoiceInfoCache.g.cs @@ -10,7 +10,7 @@ public partial class CardVoiceInfoCache public static void ClearCardVoiceInfo() { } public static void CacheCardVoiceInfoForBattle(IList cardID) { } public static void CacheCardVoiceInfo(IList cardID, CardMaster.CardMasterId cardMasterId) { } - public static IReadOnlyVoiceInfo GetCardVoiceInfoForBattle(int cardID) => default!; + public static IReadOnlyVoiceInfo GetCardVoiceInfoForBattle(int cardID) => HeadlessVoiceInfo.Instance; // HEADLESS-FIX (M7): non-null voice info for the IsRecovery death-voice tail public static IReadOnlyVoiceInfo GetCardVoiceInfo(int cardID, CardMaster.CardMasterId cardMasterId) => default!; } } diff --git a/SVSim.BattleEngine/Shim/Generated/_IfaceImpl.g.cs b/SVSim.BattleEngine/Shim/Generated/_IfaceImpl.g.cs index e98edfb..34a9b4a 100644 --- a/SVSim.BattleEngine/Shim/Generated/_IfaceImpl.g.cs +++ b/SVSim.BattleEngine/Shim/Generated/_IfaceImpl.g.cs @@ -11,7 +11,7 @@ namespace Wizard.Battle.View { float global::Wizard.Battle.View.IBattleCardView.OriginalRootYPosition { get => default!; } IReadOnlyBattleCardInfo global::Wizard.Battle.View.IBattleCardView.CardInfo { get => default!; } BattlePlayerReadOnlyInfoPair global::Wizard.Battle.View.IBattleCardView.PlayerInfoPair { get => default!; } - IReadOnlyVoiceInfo global::Wizard.Battle.View.IBattleCardView.VoiceInfo { get => default!; } + IReadOnlyVoiceInfo global::Wizard.Battle.View.IBattleCardView.VoiceInfo { get => global::Wizard.Battle.View.HeadlessVoiceInfo.Instance; } // HEADLESS-FIX (M7): non-null voice info for the death-voice tail GameObject global::Wizard.Battle.View.IBattleCardView.GameObject { get => default!; } GameObject global::Wizard.Battle.View.IBattleCardView.CardWrapObject { get => default!; } Transform global::Wizard.Battle.View.IBattleCardView.Transform { get => default!; } diff --git a/SVSim.BattleEngine/Shim/View/HeadlessVoiceInfo.cs b/SVSim.BattleEngine/Shim/View/HeadlessVoiceInfo.cs new file mode 100644 index 0000000..1494075 --- /dev/null +++ b/SVSim.BattleEngine/Shim/View/HeadlessVoiceInfo.cs @@ -0,0 +1,38 @@ +namespace Wizard.Battle.View +{ + // HEADLESS-FIX (M7): a non-null IReadOnlyVoiceInfo singleton for the headless death-voice tail. + // + // SkillProcessor.SelectCardToHaveDestroyVoicePlay (the cosmetic post-Process step that picks which + // destroyed card plays its death voice) unconditionally dereferences + // `card.BattleCardView.VoiceInfo.GetDestroyVoice(...).Voice` AND, when IsRecovery is set, + // `CardVoiceInfoCache.GetCardVoiceInfoForBattle(id).GetDestroyVoice(...).Voice`. Both seams are + // M1 `default!` shadows headless (BattleCardView is a null view; the voice cache is never primed), + // so the left operand of that `||` NREs before board-removal can be asserted. The destroy itself + // (board removal + cemetery move) already committed in the authoritative part of PlayCard upstream; + // this is purely the audio tail. + // + // The real ReadOnlyVoiceInfo can't be reused here: m1_stub_gen dropped its `: IReadOnlyVoiceInfo` + // base (interfaces are stripped to avoid CS0535 on the no-op stub) and its Get*Voice still return + // null. So this hand singleton implements the interface directly, returning the engine's own + // VoiceAndWaitTime._nullVoice sentinel (Voice == "") from every voice getter — the faithful + // "no voice configured" result for a headless run with no audio. With Voice == "" both operands of + // the IsNullOrEmpty check are false, the selector returns null, and no voice plays. + public sealed class HeadlessVoiceInfo : IReadOnlyVoiceInfo + { + public static readonly HeadlessVoiceInfo Instance = new HeadlessVoiceInfo(); + + public bool HasSummonTokenVoice { get; set; } + public string VoiceId { get; set; } = ""; + + public VoiceAndWaitTime GetPlayVoice(IReadOnlyBattleCardInfo cardInfo, BattlePlayerReadOnlyInfoPair playerPair, int executedFixedUseCostIndex, int skillVoiceIndex) => VoiceAndWaitTime._nullVoice; + public VoiceAndWaitTime GetSummonTokenVoice() => VoiceAndWaitTime._nullVoice; + public VoiceAndWaitTime GetEvolutionVoice() => VoiceAndWaitTime._nullVoice; + public VoiceAndWaitTime GetAttackVoice(bool isEvolution) => VoiceAndWaitTime._nullVoice; + public VoiceAndWaitTime GetDestroyVoice(bool isEvolution, bool isExecutedWhiteRitual) => VoiceAndWaitTime._nullVoice; + public VoiceAndWaitTime GetSkillVoice(bool isEvolution, int skillIndex) => VoiceAndWaitTime._nullVoice; + public int GetSkillVoiceCount(bool isEvolution) => 0; + public void SetDestroyCardId(int id) { } + public int AddAttachSkillVoice(string id) => 0; + public string GetAttachSkillVoice(int index) => ""; + } +}