From 4f76fb21f0cf9be909f6cfb888fc96f6364e7753 Mon Sep 17 00:00:00 2001 From: gamer147 Date: Sat, 6 Jun 2026 08:34:22 -0400 Subject: [PATCH] =?UTF-8?q?feat(battle-engine-port):=20M8=20COMPLETE=20?= =?UTF-8?q?=E2=80=94=20lethal=20damage=20proves=20follower=20death=20via?= =?UTF-8?q?=20combat=20math?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit A when_play damage=5 spell (the M6 card 800134020) played at a select_count=1 enemy follower with life <= 5 kills it as a consequence of damage -> life <= 0 -> the dead-check + the same RemoveInplayCard/cemetery path M7 lit up (the dominant real-card removal mechanic), reached through combat math rather than `destroy`. Oracle LethalDamageSpellOracleTests: selected follower (1/2) removed (board -1 + cemetery +1, the M7 dimension); un-selected control (6/7, life > 5) untouched and still on board (M6 routing; select_count=1 hits only the selected target). 8/8 green; engine 0 errors; check_drift clean; ZERO new Engine/shim/manifest work — the death path inherited M7's death-voice fix; the predicted damage-VFX shadow never materialized. Load-bearing (M4/M6 discipline): swapping the selection to the 6/7 -> it survives at 2 and nobody dies, proving removal is gated on the SELECTED follower's life reaching <= 0, not on selection (M7's destroy) or a blanket wipe. Co-Authored-By: Claude Opus 4.8 --- SVSim.BattleEngine.Tests/HeadlessFixture.cs | 13 ++ .../LethalDamageSpellOracleTests.cs | 129 ++++++++++++++++++ 2 files changed, 142 insertions(+) create mode 100644 SVSim.BattleEngine.Tests/LethalDamageSpellOracleTests.cs diff --git a/SVSim.BattleEngine.Tests/HeadlessFixture.cs b/SVSim.BattleEngine.Tests/HeadlessFixture.cs index 1069977..e83e7c3 100644 --- a/SVSim.BattleEngine.Tests/HeadlessFixture.cs +++ b/SVSim.BattleEngine.Tests/HeadlessFixture.cs @@ -85,6 +85,19 @@ namespace SVSim.BattleEngine.Tests public const int DestroyTargetFollowerId = FollowerId; // neutral 1/2 (the selected, destroyed one) public const int DestroyOtherFollowerId = UnselectTargetFollowerId; // neutral 6/7 (the un-selected survivor) + // M8 next milestone: LETHAL damage — proves follower DEATH VIA COMBAT MATH (damage >= life -> + // 0 life -> the same RemoveInplayCard/cemetery death path M7 lit up via `destroy`, but reached + // through the dominant real-card mechanic: "deal N damage"). Reuses the M6 damage=5 spell + // (800134020) but with target followers STRADDLING 5 life so the SAME spell kills one and merely + // chips the other in a single oracle: the SELECTED target has life <= 5 and dies (board -1 + + // cemetery +1, the M7 assertions), while the UN-SELECTED control has life > 5 and survives at + // reduced life (the M6 life-delta assertion). This combines M7's removal dimension with M6's + // life-delta + routing, and distinguishes death-via-damage from the unconditional `destroy`. + public const int LethalDamageSpellId = TargetSpellId; // 800134020, when_play damage=5 + public const int LethalDamage = TargetSpellDamage; // 5 + public const int LethalTargetFollowerId = FollowerId; // neutral 1/2 (life 2 <= 5 -> dies) + public const int SurvivorTargetFollowerId = UnselectTargetFollowerId; // neutral 6/7 (life 7 > 5 -> survives at 2) + private static bool _done; public static void EnsureInitialized() diff --git a/SVSim.BattleEngine.Tests/LethalDamageSpellOracleTests.cs b/SVSim.BattleEngine.Tests/LethalDamageSpellOracleTests.cs new file mode 100644 index 0000000..805ea25 --- /dev/null +++ b/SVSim.BattleEngine.Tests/LethalDamageSpellOracleTests.cs @@ -0,0 +1,129 @@ +using System.Collections.Generic; +using System.Reflection; +using NUnit.Framework; +using Wizard; +using Wizard.Battle; + +namespace SVSim.BattleEngine.Tests +{ + // M8 (death VIA COMBAT MATH): a when_play TARGETED-DAMAGE spell whose amount is >= the target + // follower's life resolves to correct authoritative state HEADLESS via the same IsForecast/ + // IsRecovery + ActionProcessor + selectedCards path M6/M7 proved. M3 proved `damage` to the LEADER + // (life-delta, no death). M7 proved board-removal via UNCONDITIONAL `destroy`. M8 closes the gap + // between them: the follower dies as a CONSEQUENCE of damage -> life<=0 -> the dead-check + the same + // RemoveInplayCard/cemetery path M7 lit up — the dominant real-card removal mechanic (most "deal N + // damage" cards), reached through combat math rather than a `destroy` skill. + // + // The spell is select_count=1 (proven in M6 — it hits ONLY the selected target), so the oracle is: + // with two followers on the enemy board STRADDLING the 5 damage and the LETHAL one passed as + // `selectedCards`, the selected follower (life 2 <= 5) DIES from combat math (enemy board -1, gone, + // in CemeteryList — the M7 removal assertions, but reached via damage not `destroy`), while the + // un-selected control (life 7 > 5) is UNTOUCHED (life unchanged, still on board — the M6 routing + // assertion). The STRADDLE is what makes death-via-combat-math falsifiable: the load-bearing probe + // (swap the selection to the 6/7) makes that follower SURVIVE at 2 (7-5) and NOBODY die — proving + // the removal is gated on the SELECTED follower's life reaching <= 0 (combat math), not on + // "selected gets removed" (which would be M7's unconditional `destroy`) or a blanket wipe. + [TestFixture] + public class LethalDamageSpellOracleTests + { + 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 Lethal_damage_spell_kills_the_selected_follower_and_chips_the_survivor() + { + 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-M7 oracles): opponent refs + active turn flag. The + // spell'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 STRADDLING the 5 damage: the SELECTED target + // has life 2 (<= 5) so it dies; the un-selected control has life 7 (> 5) and, being a + // select_count=1 spell's non-target, is untouched. (The straddle powers the load-bearing + // probe: selecting the 6/7 instead makes it survive at 2 and nobody die.) + var selected = HeadlessEngineEnv.PutFollowerInPlay(mgr, HeadlessEngineEnv.LethalTargetFollowerId, 0, isPlayer: false); + var survivor = HeadlessEngineEnv.PutFollowerInPlay(mgr, HeadlessEngineEnv.SurvivorTargetFollowerId, 1, isPlayer: false); + + // Sanity: the chosen ids actually straddle the damage (one lethal, one not) at setup. + Assert.That(selected.Life, Is.LessThanOrEqualTo(HeadlessEngineEnv.LethalDamage), + "selected follower's life is not <= the spell damage (it would not die)"); + Assert.That(survivor.Life, Is.GreaterThan(HeadlessEngineEnv.LethalDamage), + "survivor follower's life is not > the spell damage (it would not survive)"); + + var cardParam = CardMaster.GetInstanceForBattle().GetCardParameterFromId(HeadlessEngineEnv.LethalDamageSpellId); + + // Place the lethal-damage spell in the active player's hand with PP to spare. + var card = HeadlessEngineEnv.CreateHeadlessHandCard(HeadlessEngineEnv.LethalDamageSpellId, 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 survivorLifeBefore = survivor.Life; + int enemyLeaderLifeBefore = enemy.ClassAndInPlayCardList[0].Life; + + // Resolve the play through the real engine, passing the chosen (lethal) 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 lethal targeted-damage spell"); + + Assert.Multiple(() => + { + // PRIMARY M8 — death via combat math: the SELECTED follower (life <= damage) is removed + // from the enemy board and lands in the cemetery (the M7 removal dimension, reached + // through damage rather than `destroy`). + Assert.That(enemy.ClassAndInPlayCardList, Does.Not.Contain(selected), + "lethal-damaged follower still on the enemy board (death-via-damage did not remove it)"); + Assert.That(enemy.ClassAndInPlayCardList.Count, Is.EqualTo(enemyInplayBefore - 1), + "enemy board count not -1 (lethal damage did not commit a removal, or hit the wrong count)"); + Assert.That(enemy.CemeteryList, Contains.Item(selected), + "lethal-damaged follower not in the enemy CemeteryList"); + Assert.That(enemy.CemeteryList.Count, Is.EqualTo(enemyCemeteryBefore + 1), + "enemy cemetery count not +1"); + + // PRIMARY M8 — routing: the UN-SELECTED control (life > damage) is UNTOUCHED and stays on + // the board (the M6 routing assertion; select_count=1 hits only the selected target, so + // this proves the lethal removal was routed to the selection and is not a blanket wipe). + Assert.That(enemy.ClassAndInPlayCardList, Contains.Item(survivor), + "un-selected follower was removed (effect not routed, or a blanket wipe)"); + Assert.That(survivor.Life, Is.EqualTo(survivorLifeBefore), + "un-selected follower took damage (effect not routed to the selection)"); + + // Leader untouched (the spell targets a follower, not the face). + Assert.That(enemy.ClassAndInPlayCardList[0].Life, Is.EqualTo(enemyLeaderLifeBefore), + "opponent leader life changed (damage hit the leader, not the selected follower)"); + + // Cost paid; spell leaves hand and (being a spell) does NOT occupy the board. + Assert.That(player.Pp, Is.EqualTo(ppBefore - cardParam.Cost), "PP not reduced by exactly cost"); + 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"); + }); + } + } +}