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

feat(battle-engine-port): M2 step 1 — SingleBattleMgr constructs headless

Browse Source 
First green of the M2 go/no-go probe: `new SingleBattleMgr(StandardBattleMgr-
ContentsCreator)` now builds the two-player pair fully headless against the shim,
no Unity runtime. Verdict: headless construction is feasible; every blocker was a
mechanical no-op shim fill or data seam, not a Unity/logic wall.

Shim fills (authored):
- GameMgr: lazy non-null DataMgr/PrefabMgr/InputMgr/SoundMgr/BattleControl.
- GameObject: lazy cached component model so GetComponent<T>/AddComponent<T> return
  non-null no-op instances for Component-derived T (F1: unguarded view touches).
- Resources.Load(string): cached non-null GameObject so the prefab->Instantiate->
  GetComponent chain (UnityEventAgent) yields a real object.
- ClassBattleCardViewBase: re-attach dropped IClassBattleCardView (no-op members);
  ClassBattleCardBase.Setup casts the created view to it.

Engine copy (DP1/DP3 mis-cut fix):
- CardIconControl.cs copied verbatim (manifested) + generated null-stub deleted.
  SplitAndCompleteIconStr is pure string logic on the resolution path that M1 had
  wrongly stubbed as "View" -> null deref in SkillCreator.CreateBuildInfo.

Test harness (SVSim.BattleEngine.Tests, authored fixture):
- HeadlessContentsCreator/HeadlessPhaseCreator: deterministic replica of the solo
  practice init (StandardBattleMgrContentsCreator + SingleBattlePhaseCreator) with
  no-op recovery/replay managers.
- HeadlessCardMaster: reflects the loader cards.json dump into CardMaster.
- HeadlessMasterData: minimal Data.Master (class-character list, empty collections)
  + Data.Load + player/enemy chara ids.
- ConstructionProbeTests.SingleBattleMgr_constructs_headless — GREEN.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
gamer147
2026-06-06 01:36:22 -04:00
parent 1078b1ef50
commit 2b506574e7
13 changed files with 456 additions and 22 deletions
Download Patch File Download Diff File Expand all files Collapse all files

42
SVSim.BattleEngine.Tests/ConstructionProbeTests.cs Normal file
View File

@@ -0,0 +1,42 @@
using System;
using NUnit.Framework;
namespace SVSim.BattleEngine.Tests
{
// M2 probe (go/no-go step 1): can BattleManagerBase / the two-player pair be constructed
// HEADLESS at all? This drives the real practice init path
// (`new SingleBattleMgr(StandardBattleMgrContentsCreator)`), which internally builds the
// BattlePlayer + BattleEnemy pair, against the M1 shim — with NO Unity runtime.
//
// The point of this test is diagnostic: if construction throws, the stack trace tells us the
// first shim gap on the *resolution* path (vs the compile path M1 already proved). We assert
// success, but a failure here is the informative outcome we want surfaced.
[TestFixture]
public class ConstructionProbeTests
{
[Test]
public void SingleBattleMgr_constructs_headless()
{
// Mirror the forecast flags the design pins (DP4 / §3): suppress VFX registration and
// collapse wait delays. Set before construction so any ctor-time VFX path no-ops.
HeadlessEngineEnv.EnsureInitialized();
BattleManagerBase.IsForecast = true;
SingleBattleMgr mgr = null;
try
{
mgr = new SingleBattleMgr(new HeadlessContentsCreator());
}
catch (Exception ex)
{
Assert.Fail(
"Headless construction of SingleBattleMgr threw — first shim gap on the " +
"resolution path:\n" + ex);
}
Assert.That(mgr, Is.Not.Null);
Assert.That(mgr.BattlePlayer, Is.Not.Null, "BattlePlayer (self) not created");
Assert.That(mgr.BattleEnemy, Is.Not.Null, "BattleEnemy (opponent) not created");
}
}
}

96
SVSim.BattleEngine.Tests/HeadlessCardMaster.cs Normal file
View File

@@ -0,0 +1,96 @@
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using System.Runtime.Serialization;
using System.Text.Json;
using Wizard;
namespace SVSim.BattleEngine.Tests
{
// Populates the engine's static CardMaster headless, from the loader's cards.json dump
// (serialized CardCSVData objects). We bypass the network/Resources init path
// (CardMaster.InitializeCardMaster) and the private ctor/field via reflection — CardMaster
// exposes no public injection seam. Class cards (id < 100) resolve via the ctor's
// _classCardParam, so an empty load still satisfies construction; pass real ids for the oracle.
public static class HeadlessCardMaster
{
private static readonly string CardsJsonPath =
Path.Combine(AppContext.BaseDirectory, "Data", "cards.json");
// Load the given card ids (empty = none) into a fresh CardMaster registered as Default.
public static void Load(params int[] cardIds)
{
var want = new HashSet<int>(cardIds);
var rows = new List<CardCSVData>();
if (want.Count > 0)
{
using var doc = JsonDocument.Parse(File.ReadAllText(CardsJsonPath));
int sort = 0;
foreach (var el in doc.RootElement.EnumerateArray())
{
if (!el.TryGetProperty("card_id", out var idEl)) continue;
if (!int.TryParse(idEl.GetString(), out var id) || !want.Contains(id)) continue;
rows.Add(BuildCardCsvData(el, sort++));
}
var missing = want.Except(rows.Select(r => int.Parse(r.card_id))).ToArray();
if (missing.Length > 0)
throw new InvalidOperationException(
"cards.json missing requested ids: " + string.Join(",", missing));
}
var cm = NewCardMaster(rows);
InjectAsDefault(cm);
}
// Construct a CardCSVData without running its CSV ctor; set each member from the JSON object
// by exact name match (cards.json keys == CardCSVData member names).
private static CardCSVData BuildCardCsvData(JsonElement el, int sortIndex)
{
var c = (CardCSVData)FormatterServices.GetUninitializedObject(typeof(CardCSVData));
const BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
foreach (var prop in el.EnumerateObject())
{
string val = prop.Value.ValueKind == JsonValueKind.Null ? null : prop.Value.ToString();
var f = typeof(CardCSVData).GetField(prop.Name, bf);
if (f != null) { SetMember(f.FieldType, val, v => f.SetValue(c, v)); continue; }
var p = typeof(CardCSVData).GetProperty(prop.Name, bf);
if (p != null && p.CanWrite) SetMember(p.PropertyType, val, v => p.SetValue(c, v));
}
// SortIndex is normally set by the ctor; mirror it.
var si = typeof(CardCSVData).GetProperty("SortIndex", bf);
if (si != null && si.CanWrite) si.SetValue(c, sortIndex);
return c;
}
private static void SetMember(Type t, string val, Action<object> set)
{
if (t == typeof(string)) set(val);
else if (t == typeof(int)) set(int.TryParse(val, out var i) ? i : 0);
else if (t == typeof(bool)) set(val == "1" || string.Equals(val, "true", StringComparison.OrdinalIgnoreCase));
// other types left at default
}
private static CardMaster NewCardMaster(List<CardCSVData> rows)
{
var ctor = typeof(CardMaster).GetConstructor(
BindingFlags.Instance | BindingFlags.NonPublic, null,
new[] { typeof(List<CardCSVData>) }, null);
if (ctor == null) throw new InvalidOperationException("CardMaster(List<CardCSVData>) ctor not found");
return (CardMaster)ctor.Invoke(new object[] { rows });
}
private static void InjectAsDefault(CardMaster cm)
{
var idType = typeof(CardMaster).GetNestedType("CardMasterId");
var defaultId = Enum.Parse(idType, "Default");
var dictType = typeof(Dictionary<,>).MakeGenericType(idType, typeof(CardMaster));
var dict = (System.Collections.IDictionary)Activator.CreateInstance(dictType);
dict[defaultId] = cm;
var fld = typeof(CardMaster).GetField("_dictCardMaster",
BindingFlags.Static | BindingFlags.NonPublic);
fld.SetValue(null, dict);
}
}
}

77
SVSim.BattleEngine.Tests/HeadlessFixture.cs Normal file
View File

@@ -0,0 +1,77 @@
using Wizard.Battle.Phase;
using Wizard.Battle.Recovery;
using Wizard.Battle.Replay;
using Wizard.Battle.Resource;
using Wizard.Battle.View.Vfx;
using Wizard.BattleMgr;
namespace SVSim.BattleEngine.Tests
{
// Initializes the global engine state a headless battle assumes exists. In the real client this
// is populated from /load/index at login; here we author the minimum the resolution path reads.
public static class HeadlessEngineEnv
{
private static bool _done;
public static void EnsureInitialized()
{
if (_done) return;
// 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() };
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();
// 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).
// Set the backing fields directly: the public SetPlayerCharaId() also pulls MyRotation/
// AvatarBattle info (more null statics) which the resolution path doesn't need (the
// TryGet* accessors are null-tolerant).
var dm = GameMgr.GetIns().GetDataMgr();
SetField(dm, "_playerCharaId", HeadlessMasterData.PlayerCharaId);
SetField(dm, "_enemyCharaId", HeadlessMasterData.EnemyCharaId);
_done = true;
}
private static void SetField(object obj, string name, object value)
{
var f = obj.GetType().GetField(name,
System.Reflection.BindingFlags.Instance |
System.Reflection.BindingFlags.NonPublic |
System.Reflection.BindingFlags.Public);
if (f == null) throw new System.InvalidOperationException(
$"{obj.GetType().Name} has no field '{name}'");
f.SetValue(obj, value);
}
}
// Test-side replica of the engine's own StandardBattleMgrContentsCreator (the practice/solo
// init path: GameMgr.cs:244 `new SingleBattleMgr(new StandardBattleMgrContentsCreator(null, null))`).
// Authored here (not copied) so we control the seed deterministically; uses the real engine
// managers verbatim. The real StandardBattleMgrContentsCreator + SingleBattlePhaseCreator were
// cut from the M1 copy set (entry-point constructors), so we reproduce them minimally.
public sealed class HeadlessContentsCreator : IBattleMgrContentsCreator
{
public int RandomSeed => 12345; // fixed; vanilla follower has no RNG so value is irrelevant
// No-op managers (vs the practice path's file-backed SingleBattleRecoveryRecordManager):
// the ctor's FirstRecoverySetting/FirstReplaySetting dereference these, and recovery/replay
// recording is irrelevant to the M2 oracle, so use the engine's own null implementations.
public IRecoveryManager RecoveryManager { get; } = new NullRecoveryManager();
public IRecoveryRecordManager RecoveryRecordManager { get; } = new NullRecoveryRecordManager();
public IReplayRecordManager ReplayRecordManager { get; } = new NullReplayRecordManager();
public IBattleResourceMgr CreateResourceMgr() => new BattleResourceMgr();
public VfxMgr CreateVfxMgr() => new VfxMgr();
public IPhaseCreator CreatePhaseCreator(BattleManagerBase battleMgr) =>
new HeadlessPhaseCreator(battleMgr);
}
// Equivalent of the engine's SingleBattlePhaseCreator: inherits PhaseCreatorBase wholesale.
public sealed class HeadlessPhaseCreator : PhaseCreatorBase
{
public HeadlessPhaseCreator(BattleManagerBase battleMgr) : base(battleMgr) { }
}
}

95
SVSim.BattleEngine.Tests/HeadlessMasterData.cs Normal file
View File

@@ -0,0 +1,95 @@
using System;
using System.Collections.Generic;
using System.Reflection;
using System.Runtime.Serialization;
using Wizard;
namespace SVSim.BattleEngine.Tests
{
// Builds the minimal Data.Master reference context a headless battle reads. In the client this
// comes from the /load/index master section; here we author just enough for the resolution path
// (currently: ClassCharacterList, so the leader/class card can resolve player/enemy class_id).
// Entries are constructed without their CSV ctor (private setters set via reflection).
public static class HeadlessMasterData
{
public const int PlayerCharaId = 1;
public const int EnemyCharaId = 2;
public const int PlayerClassId = 1; // ClanType -> class card clan
public const int EnemyClassId = 2;
public static void Install()
{
var master = (Master)FormatterServices.GetUninitializedObject(typeof(Master));
// The resolution path reads many Master.* collections (e.g. WhenPlayEffectKeywordMaster)
// and calls LINQ on them unguarded. Default every collection member to an empty instance
// so those touches no-op instead of NRE; then override the ones we need with content.
EnsureEmptyCollections(master);
var list = new List<ClassCharacterMasterData>
{
NewChara(PlayerCharaId, PlayerClassId),
NewChara(EnemyCharaId, EnemyClassId),
};
SetMember(master, "ClassCharacterList", list);
Data.Master = master;
}
// Initialize every List<>/array/Dictionary<> field/auto-property on the object to an empty
// non-null instance (only if currently null).
private static void EnsureEmptyCollections(object obj)
{
const BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
foreach (var f in obj.GetType().GetFields(bf))
{
if (f.GetValue(obj) != null) continue;
var empty = EmptyOf(f.FieldType);
if (empty != null) f.SetValue(obj, empty);
}
}
private static object EmptyOf(Type t)
{
if (t.IsArray) return Array.CreateInstance(t.GetElementType(), 0);
if (t.IsGenericType)
{
var def = t.GetGenericTypeDefinition();
if (def == typeof(List<>) || def == typeof(Dictionary<,>) ||
def == typeof(HashSet<>) || def == typeof(IList<>) ||
def == typeof(IDictionary<,>) || def == typeof(ICollection<>) ||
def == typeof(IEnumerable<>))
{
var concrete = def == typeof(List<>) || def == typeof(IList<>) ||
def == typeof(ICollection<>) || def == typeof(IEnumerable<>)
? typeof(List<>).MakeGenericType(t.GetGenericArguments())
: def == typeof(HashSet<>)
? typeof(HashSet<>).MakeGenericType(t.GetGenericArguments())
: typeof(Dictionary<,>).MakeGenericType(t.GetGenericArguments());
return Activator.CreateInstance(concrete);
}
}
return null;
}
private static ClassCharacterMasterData NewChara(int charaId, int classId)
{
var c = (ClassCharacterMasterData)FormatterServices.GetUninitializedObject(typeof(ClassCharacterMasterData));
SetMember(c, "chara_id", charaId);
SetMember(c, "class_id", classId);
SetMember(c, "skin_id", charaId);
SetMember(c, "is_usable", true);
return c;
}
// Set a member (auto-property backing field or field) by name, tolerating private setters.
private static void SetMember(object obj, string name, object value)
{
var t = obj.GetType();
const BindingFlags bf = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance;
var p = t.GetProperty(name, bf);
if (p != null && p.SetMethod != null) { p.SetValue(obj, value); return; }
var f = t.GetField(name, bf)
?? t.GetField($"<{name}>k__BackingField", bf);
if (f != null) { f.SetValue(obj, value); return; }
throw new InvalidOperationException($"{t.Name} has no settable member '{name}'");
}
}
}

31
SVSim.BattleEngine.Tests/SVSim.BattleEngine.Tests.csproj Normal file
View File

@@ -0,0 +1,31 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<TargetFramework>net8.0</TargetFramework>
<!-- Match the engine: decompiled types are not nullable-clean and use explicit usings. -->
<Nullable>disable</Nullable>
<ImplicitUsings>disable</ImplicitUsings>
<LangVersion>latest</LangVersion>
<IsPackable>false</IsPackable>
<IsTestProject>true</IsTestProject>
</PropertyGroup>
<ItemGroup>
<PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.6.0" />
<PackageReference Include="NUnit" Version="3.13.3" />
<PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\SVSim.BattleEngine\SVSim.BattleEngine.csproj" />
</ItemGroup>
<ItemGroup>
<!-- The loader's card-master dump (serialized CardCSVData objects). The headless fixture
reflects these into CardMaster so the resolution path can look up real card stats. -->
<Content Include="..\SVSim.Bootstrap\Data\cards.json" Link="Data\cards.json">
<CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
</Content>
</ItemGroup>
</Project>