SVSim/SVSimServer
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

feat(battle-engine-port): M2 COMPLETE — vanilla follower resolves headless (go/no-go = GO)

Browse Source 
First green: a zero-skill vanilla follower (100011010, neutral 1/2) resolves to
correct authoritative state HEADLESS via IsForecast/IsRecovery + ActionProcessor.
PlayCard (DP4), no Unity runtime. §5 oracle passes (PP-cost; hand->in-play;
atk/health == CardCSVData base; opponent unchanged; no exception). VERDICT: the
port approach is validated through the resolution path, not just M1's compile path.

VanillaFollowerOracleTests.Vanilla_follower_resolves_to_correct_state — GREEN.
HeadlessCardMaster now loads the follower's real id from cards.json.

Resolution-path shim/engine gaps closed (all mechanical no-op fills or data seams,
never a Unity/logic wall):
- M1 mis-cut copies (DP1/DP3 — pure no-op logic wrongly stubbed to null):
  Engine/Wizard.Battle.View.Vfx/NullCardVfxCreator.cs (its GetInstance() singleton
  was nulled) + its dep NotEmptyNullVfx.cs. Deleted the generated NullCardVfxCreator
  stub + its _IfaceImpl block; both manifested, check_drift clean.
- _IfaceImpl explicit-impl shadow: interface-typed view/mgr calls dispatch to the
  explicit impls (which returned default!), shadowing public stubs. Fixed
  IBattlePlayerView.GetSideLogControl (SkillProcessor side-log tail) to return a
  non-null no-op. KEY M3+ learning: fix _IfaceImpl.g.cs for interface-typed NREs.

(GameMgr/component-model/Resources/IClassBattleCardView shim fills + CardIconControl
copy + the SVSim.BattleEngine.Tests project landed in the prior commit 2b50657.)

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
gamer147
2026-06-06 01:57:15 -04:00
parent 2b506574e7
commit 171f07ec74
7 changed files with 370 additions and 106 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
SVSim.BattleEngine.Tests/HeadlessFixture.cs
View File

@@ -11,6 +11,9 @@ namespace SVSim.BattleEngine.Tests
// is populated from /load/index at login; here we author the minimum the resolution path reads.
public static class HeadlessEngineEnv
{
// Simplest zero-skill vanilla follower in cards.json: neutral (clan 0), cost 1, 1/2, no skill.
public const int FollowerId = 100011010;
private static bool _done;
public static void EnsureInitialized()
@@ -19,10 +22,15 @@ namespace SVSim.BattleEngine.Tests
// Wizard.Data.Load: static /load/index snapshot. The ctor's CreateBackgroundId reads
// Data.Load.data._userTutorial (LoadDetail self-inits _userTutorial). Suppress VFX too.
Wizard.Data.Load = new Load { data = new LoadDetail() };
// CardParameter(CardCSVData) reads Data.Crossover.RestrictedCard for deck-limit calc;
// an empty Crossover returns the default count (no restriction). Private setter -> reflect.
typeof(Wizard.Data).GetProperty("Crossover",
System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public)
.SetValue(null, new Wizard.Crossover());
BattleManagerBase.IsForecast = true;
// CardMaster must be non-null before construction (the leader/class card looks up id 0).
// Empty load suffices for construction; the oracle reloads with the follower's real id.
HeadlessCardMaster.Load();
// Load the M2 vanilla follower so the oracle can create + look up its real stats.
HeadlessCardMaster.Load(FollowerId);
// 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).

99
SVSim.BattleEngine.Tests/VanillaFollowerOracleTests.cs Normal file
View File

@@ -0,0 +1,99 @@
using System.Collections.Generic;
using System.Reflection;
using NUnit.Framework;
using Wizard;
using Wizard.Battle;
namespace SVSim.BattleEngine.Tests
{
// M2 first-green (go/no-go step 2): a single zero-skill vanilla follower resolves to correct
// authoritative state HEADLESS via the proven IsForecast/IsRecovery + ActionProcessor path
// (design §5 / DP4). No Unity runtime, no VFX clock.
[TestFixture]
public class VanillaFollowerOracleTests
{
private static void SetPrivateField(object obj, string name, object value)
{
var f = obj.GetType().GetField(name,
BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
// Walk up the hierarchy if declared on a base type.
var t = obj.GetType();
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);
}
private static BattleCardBase CreateHeadlessHandCard(int cardId, int index, bool isPlayer, BattleManagerBase mgr)
{
// CardCreatorBase.CreateCardWithoutResources is the engine's own null-view creation path
// (CreateBase -> new UnitBattleCard(buildInfo).Setup(createNullView:true)); it's private,
// so reflect it rather than reimplement the 14-arg BuildInfo wiring.
var io = mgr.CreatePlayerInnerOptionsBuilder();
var m = typeof(CardCreatorBase).GetMethod("CreateCardWithoutResources",
BindingFlags.NonPublic | BindingFlags.Static);
return (BattleCardBase)m.Invoke(null, new object[] { cardId, index, isPlayer, mgr, io });
}
[Test]
public void Vanilla_follower_resolves_to_correct_state()
{
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;
// Wire the opponent links + active turn. The full BattlePlayerBase.Setup(opponent) does
// this but cascades into UI/manager init irrelevant to the resolution path, so set the
// minimal state directly: each player's opponent ref, and the active player's turn flag
// (the on-enter-play skill sweep reads opponent.IsSelfTurn / IsGameFirst).
SetPrivateField(player, "_opponentBattlePlayer", enemy);
SetPrivateField(enemy, "_opponentBattlePlayer", player);
player.IsSelfTurn = true;
enemy.IsSelfTurn = false;
var cardParam = CardMaster.GetInstanceForBattle().GetCardParameterFromId(HeadlessEngineEnv.FollowerId);
// Place the follower in the active player's hand with PP to spare; empty board otherwise.
var card = CreateHeadlessHandCard(HeadlessEngineEnv.FollowerId, 1, isPlayer: true, mgr);
player.HandCardList.Add(card);
player.Pp = 10;
// Pre-state snapshot.
int ppBefore = player.Pp;
int handBefore = player.HandCardList.Count;
int inplayBefore = player.ClassAndInPlayCardList.Count;
int enemyHandBefore = enemy.HandCardList.Count;
int enemyInplayBefore = enemy.ClassAndInPlayCardList.Count;
int enemyLeaderLifeBefore = enemy.ClassAndInPlayCardList[0].Life;
// Resolve the play through the real engine.
var pair = mgr.GetBattlePlayerPair(isPlayer: true);
var ap = new ActionProcessor(pair);
Assert.DoesNotThrow(() => ap.PlayCard(card, selectedCards: null),
"ActionProcessor.PlayCard threw on a vanilla follower");
// Oracle (§5 invariants).
Assert.Multiple(() =>
{
Assert.That(player.Pp, Is.EqualTo(ppBefore - cardParam.Cost), "PP not reduced by exactly cost");
Assert.That(player.HandCardList, Does.Not.Contain(card), "card still in hand");
Assert.That(player.HandCardList.Count, Is.EqualTo(handBefore - 1), "hand count not -1");
Assert.That(player.ClassAndInPlayCardList, Contains.Item(card), "card not in play");
Assert.That(player.ClassAndInPlayCardList.Count, Is.EqualTo(inplayBefore + 1), "in-play count not +1");
Assert.That(card.Atk, Is.EqualTo(cardParam.Atk), "follower atk != CardCSVData base");
Assert.That(card.Life, Is.EqualTo(cardParam.Life), "follower life != CardCSVData base");
// Opponent unchanged.
Assert.That(enemy.HandCardList.Count, Is.EqualTo(enemyHandBefore), "opponent hand changed");
Assert.That(enemy.ClassAndInPlayCardList.Count, Is.EqualTo(enemyInplayBefore), "opponent board changed");
Assert.That(enemy.ClassAndInPlayCardList[0].Life, Is.EqualTo(enemyLeaderLifeBefore), "opponent leader life changed");
// §5 "zero VFX registered with VfxMgr": structural here — the shim VfxMgr is a pure
// no-op (RegisterImmediate/SequentialVfx do nothing) and IsForecast suppresses
// registration in the real engine, so no VFX is ever played headless. Covered by the
// DoesNotThrow above; there is no meaningful count to assert against the no-op shim.
});
}
}
}