fix(app,headless): Campaign CC slice CC4 re-review round — R1 arbiter + R2-R4

CC4 re-review returned NOT CLOSED: R1 (MEDIUM, blocking) is a new residual
the F1 fix itself introduced, plus three LOW riders (R2, R3, R4).

R1 — nulling UiRoot.FixedCanvasSize on chargen Close() stripped it from
character-management, which stays active underneath and only sets the
canvas on its own activation edge. Root cause (reviewer-named): two
controllers writing one host-global with no owner. Fixed with the
root-cause shape (reviewer's option (c)): UiRoot.DeclareFixedCanvas(owner,
size)/RevokeFixedCanvas(owner), an owner-scoped arbiter — every declarer
must agree on the canvas size (a mismatch throws instead of silently
last-writer-wins), and the canvas nulls only once EVERY declarer has
revoked. Both CharacterCreationUiController and CharacterManagementUi-
Controller now declare/revoke instead of writing FixedCanvasSize directly;
grepped for stragglers, none remain in production code (the raw setter
stays public only for UiRootFixedCanvasTests' isolated scale-math
coverage). New test (reviewer-specified):
CharacterScreensFixedCanvasArbiterTests — two controllers sharing one
UiRoot, proving the canvas stays set through chargen's Exit-confirm Close
while char-management is still active, nulling only once char-management
also deactivates, plus the original F1 defect's own covering case (both
revoke together at world entry).

R3 — HeadlessSessionHostTests.ContentLease_InstallsRealChargenOptions_
SelectHeritageIsAccepted proves F6's install actually opens the gate: a
content lease carrying a real hand-built DatCharGen heritage (not
ChargenOptions.Empty) is installed, and TrySelectHeritage for it succeeds.

R2 — filed docs/ISSUES.md #402 for the pre-existing
Streaming.LandblockBuildFactoryTests.Build_UsesTheSuppliedSharedReaderGate
full-suite flake (unrelated to Campaign CC).

R4 — fixed "unchached" -> "uncached" typo in
InteractionRetainedUiComposition.cs.

Runtime 1713/0, App 5127/13 skips (+2), Headless 166/0 (+1), full solution
Release build green. Live-DAT probes 7/7 under ACDREAM_PROBE_LIVE_MOUNT=1.
The known #402 flake did not fire across 3 consecutive full-suite runs
this session.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik 2026-08-15 19:04:04 +02:00
parent ec854db045
commit 8add0667a5
9 changed files with 780 additions and 29 deletions

View file

@ -0,0 +1,430 @@
using System.Numerics;
using AcDream.App.UI;
using AcDream.App.UI.Layout;
using AcDream.Core.CharGen;
using AcDream.Runtime;
using AcDream.Runtime.Session;
namespace AcDream.App.Tests.UI.Layout;
/// <summary>
/// Campaign CC slice CC4 review-fix round R1 (2026-08-15):
/// <see cref="CharacterCreationUiController"/> and
/// <see cref="CharacterManagementUiController"/> can be SIMULTANEOUSLY
/// active against the SAME <see cref="UiRoot"/> — character-creation opens
/// on top of character-management, which keeps ticking underneath it. Both
/// controllers share <see cref="UiRoot.FixedCanvasSize"/>, and before this
/// fix each wrote it directly — a raw write from either screen was a last-
/// writer-wins race with no owner: the F1 fix's own chargen
/// <c>Close()</c> nulled the canvas out from under a STILL-ACTIVE
/// character-management screen underneath it (the exact AD-98 gate-round-2
/// defect resurfacing one layer up). These tests drive
/// <see cref="UiRoot.DeclareFixedCanvas"/>/<see cref="UiRoot.RevokeFixedCanvas"/>
/// across BOTH controllers on one shared host, per the reviewer's required
/// sequence.
/// </summary>
public sealed class CharacterScreensFixedCanvasArbiterTests
{
private static readonly Vector2 AuthoredCanvas = new(800f, 600f);
[Fact]
public void CanvasStaysSetWhileEitherScreenIsActive_AndNullsOnlyWhenBothRevoke()
{
using var environment = new TwoControllerHarness();
// char-mgmt alone: declared on its own activation edge (Tick's
// `if (!_active)` arm).
Assert.Equal(AuthoredCanvas, environment.Host.FixedCanvasSize);
// chargen opens ON TOP of the still-active char-mgmt screen.
environment.Chargen.Controller.Open();
Assert.Equal(AuthoredCanvas, environment.Host.FixedCanvasSize);
// chargen Exit-confirms and closes -- char-mgmt is STILL ACTIVE, so
// the canvas must stay set. This is R1's regression: the pre-fix
// Close() nulled UiRoot.FixedCanvasSize unconditionally here,
// stripping it from char-management underneath.
environment.Chargen.Button(CharacterCreationUiController.ExitElementId)
.OnClick!();
environment.Chargen.ConfirmActiveDialog(confirmed: true);
Assert.Equal(AuthoredCanvas, environment.Host.FixedCanvasSize);
Assert.False(environment.Chargen.Controller.Root.Visible);
// char-mgmt deactivates (e.g. entering the world) -- now NEITHER
// screen declares, so the canvas nulls.
environment.Management.Runtime.SetLifecycle(
RuntimeCharacterSelectionLifecycle.InWorld);
environment.Management.Controller.Tick();
Assert.Null(environment.Host.FixedCanvasSize);
}
/// <summary>The original F1 defect's own covering case: both screens
/// revoke together (world entry while chargen was ALSO still open)
/// still nulls the canvas -- not just "one revokes while the other
/// holds," the scenario above.</summary>
[Fact]
public void CanvasNulls_WhenBothScreensRevokeAtWorldEntry()
{
using var environment = new TwoControllerHarness();
environment.Chargen.Controller.Open();
Assert.Equal(AuthoredCanvas, environment.Host.FixedCanvasSize);
environment.Management.Runtime.SetLifecycle(
RuntimeCharacterSelectionLifecycle.InWorld);
environment.Management.Controller.Tick();
environment.Chargen.Runtime.ProvideView = false;
environment.Chargen.Controller.Tick();
Assert.Null(environment.Host.FixedCanvasSize);
}
// ── Fixture: one shared UiRoot, both controllers ────────────────────
private sealed class TwoControllerHarness : IDisposable
{
public TwoControllerHarness()
{
Host = new UiRoot { Width = 800f, Height = 600f };
Management = new ManagementHarness(Host);
Chargen = new ChargenHarness(Host);
}
public UiRoot Host { get; }
public ManagementHarness Management { get; }
public ChargenHarness Chargen { get; }
public void Dispose()
{
Chargen.Dispose();
Management.Dispose();
}
}
private sealed class ManagementHarness : IDisposable
{
private readonly RetailDialogFactory _dialogs;
public ManagementHarness(UiRoot host)
{
ImportedLayout screen = BuildManagementScreen();
Runtime = new ManagementFakeRuntime();
_dialogs = new RetailDialogFactory(
host,
type => RetailDialogFactoryTests.BuildDialogLayout(type));
Controller = Assert.IsType<CharacterManagementUiController>(
CharacterManagementUiController.Bind(
host,
screen,
static (_, _) => BuildRow(),
_dialogs,
Runtime.Bindings,
new CharacterManagementUiController.DialogStrings(
name => $"WARNING! {name}",
"DELETE",
"Please Wait",
"Entering World",
"Are you sure you want to leave?")));
}
public ManagementFakeRuntime Runtime { get; }
public CharacterManagementUiController Controller { get; }
public void Dispose()
{
Controller.Dispose();
_dialogs.Dispose();
}
private static UiElement BuildRow() => LayoutImporter.Build(
new ElementInfo { Id = 0x100003A5u, Type = 1u, Width = 160f, Height = 16f },
_ => (0u, 0, 0),
null).Root;
private static ImportedLayout BuildManagementScreen()
{
var root = new ElementInfo
{
Id = CharacterManagementUiController.RootElementId,
Type = 3u,
Width = 800f,
Height = 600f,
};
var list = new ElementInfo
{
Id = CharacterManagementUiController.ListElementId,
Type = 5u,
X = 42f,
Y = 212f,
Width = 160f,
Height = 320f,
};
list.TemplateList.Add(new UiTemplateListEntry(0x21000004u, 0x100003A5u));
root.Children.Add(list);
root.Children.Add(new ElementInfo
{
Id = CharacterManagementUiController.WorldTextElementId,
Type = 12u,
Width = 193f,
Height = 110f,
});
root.Children.Add(ButtonInfo(CharacterManagementUiController.CreateElementId));
root.Children.Add(ButtonInfo(CharacterManagementUiController.EnterElementId));
root.Children.Add(ButtonInfo(CharacterManagementUiController.DeleteElementId));
root.Children.Add(ButtonInfo(CharacterManagementUiController.RestoreElementId));
root.Children.Add(ButtonInfo(CharacterManagementUiController.CreditsElementId));
root.Children.Add(ButtonInfo(CharacterManagementUiController.ExitElementId));
return LayoutImporter.Build(root, _ => (0u, 0, 0), null);
}
}
private sealed class ManagementFakeRuntime
{
private static readonly RuntimeGenerationToken Generation = new(11u);
private readonly FakeManagementView _view = new();
public ManagementFakeRuntime()
{
_view.Entries = [new RuntimeCharacterSelectionEntry(0, 0x50000001u, "Alpha", 0u)];
_view.Snapshot = new RuntimeCharacterSelectionSnapshot(
Generation,
RuntimeCharacterSelectionLifecycle.AwaitingSelection,
Revision: 1,
AccountName: "account",
SlotCount: 5,
RosterCount: _view.Entries.Length,
WorldName: "sawato",
HighlightedCharacterId: 0x50000001u,
HighlightedDisplayIndex: 0,
PendingDeleteCharacterId: 0u,
LastRestoreRequestedCharacterId: 0u,
Operation: RuntimeCharacterSelectionOperation.None,
Error: null,
Buttons: new RuntimeCharacterSelectionButtons(true, true, false, true, false));
Bindings = new CharacterSelectionRuntimeBindings(
View: () => _view,
Highlight: _ => Result(),
Enter: Result,
RequestDelete: Result,
ConfirmDelete: Result,
Restore: Result,
Cancel: Result,
RequestExit: () => { });
}
public CharacterSelectionRuntimeBindings Bindings { get; }
private static RuntimeCommandResult Result() =>
new(RuntimeCommandStatus.Accepted, Generation);
public void SetLifecycle(RuntimeCharacterSelectionLifecycle lifecycle)
{
RuntimeCharacterSelectionSnapshot current = _view.Snapshot;
_view.Snapshot = current with { Lifecycle = lifecycle, Revision = current.Revision + 1 };
}
private sealed class FakeManagementView : IRuntimeCharacterSelectionView
{
public RuntimeCharacterSelectionEntry[] Entries { get; set; } = [];
public RuntimeCharacterSelectionSnapshot Snapshot { get; set; }
public bool TryGetAt(int displayIndex, out RuntimeCharacterSelectionEntry character)
{
if ((uint)displayIndex >= (uint)Entries.Length)
{
character = default;
return false;
}
character = Entries[displayIndex];
return true;
}
public bool TryGet(uint characterId, out RuntimeCharacterSelectionEntry character)
{
int index = Array.FindIndex(Entries, entry => entry.CharacterId == characterId);
if (index < 0)
{
character = default;
return false;
}
character = Entries[index];
return true;
}
public void Visit(IRuntimeCharacterSelectionVisitor visitor)
{
foreach (RuntimeCharacterSelectionEntry character in Entries)
visitor.Visit(in character);
}
public IDisposable Subscribe(IRuntimeCharacterSelectionObserver observer) =>
NullSubscription.Instance;
private sealed class NullSubscription : IDisposable
{
public static readonly NullSubscription Instance = new();
public void Dispose() { }
}
}
}
private sealed class ChargenHarness : IDisposable
{
private readonly List<ImportedLayout> _dialogLayouts = [];
private readonly RetailDialogFactory _dialogs;
public ChargenHarness(UiRoot host)
{
Screen = BuildChargenScreen();
Runtime = new ChargenFakeRuntime();
_dialogs = new RetailDialogFactory(host, type =>
{
ImportedLayout layout = RetailDialogFactoryTests.BuildDialogLayout(type);
_dialogLayouts.Add(layout);
return layout;
});
Controller = Assert.IsType<CharacterCreationUiController>(
CharacterCreationUiController.CreateDetached(
host,
Screen,
static (_, _) => null,
_dialogs,
Runtime.Bindings,
new CharacterCreationUiController.DialogStrings(
"Are you sure you want to leave?")));
Controller.AttachAndTick();
}
public ImportedLayout Screen { get; }
public ChargenFakeRuntime Runtime { get; }
public CharacterCreationUiController Controller { get; }
public UiButton Button(uint id) =>
Assert.IsType<UiButton>(Screen.FindElement(id));
public void ConfirmActiveDialog(bool confirmed)
{
ImportedLayout dialog = _dialogLayouts[^1];
uint buttonId = confirmed
? RetailConfirmationDialogView.AcceptButtonId
: RetailConfirmationDialogView.RejectButtonId;
UiButton button = Assert.IsType<UiButton>(dialog.FindElement(buttonId));
button.OnClick!();
}
public void Dispose()
{
Controller.Dispose();
_dialogs.Dispose();
}
private static ImportedLayout BuildChargenScreen()
{
var root = new ElementInfo
{
Id = CharacterCreationUiController.RootElementId,
Type = 3u,
Width = 800f,
Height = 600f,
};
root.Children.Add(ContainerInfo(CharacterCreationUiController.ProgressBarElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.BackElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.NextElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.FinishElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.HelpElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.ExitElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.RandomElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.MasterPageElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.HeritagePageElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.ProfessionPageElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.SkillsPageElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.AppearancePageElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.TownPageElementId));
root.Children.Add(ContainerInfo(CharacterCreationUiController.SummaryPageElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.HeritageTabElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.ProfessionTabElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.SkillsTabElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.AppearanceTabElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.TownTabElementId));
root.Children.Add(ButtonInfo(CharacterCreationUiController.SummaryTabElementId));
return LayoutImporter.Build(root, _ => (0u, 0, 0), null);
}
private static ElementInfo ContainerInfo(uint id) =>
new() { Id = id, Type = 3u, Width = 200f, Height = 60f };
}
private sealed class ChargenFakeRuntime
{
private static readonly RuntimeGenerationToken Generation = new(13u);
public ChargenFakeRuntime()
{
View = new FakeChargenView();
Bindings = new CharacterCreationRuntimeBindings(
() => ProvideView ? View : null,
_ => Result(),
_ => Result(),
_ => Result(),
(_, _) => Result(),
(_, _) => Result(),
_ => Result(),
_ => Result(),
_ => Result(),
_ => Result(),
_ => Result(),
RequestExit: () => { },
ResolveText: _ => null,
OpenOnStart: false);
}
public FakeChargenView View { get; }
public CharacterCreationRuntimeBindings Bindings { get; }
public bool ProvideView { get; set; } = true;
private static RuntimeCommandResult Result() =>
new(RuntimeCommandStatus.Accepted, Generation);
public sealed class FakeChargenView : IRuntimeCharacterCreationView
{
public RuntimeCharacterCreationSnapshot Snapshot { get; set; } =
new(
Generation,
IsActive: true,
Revision: 1,
HeritageId: 0u,
GenderKey: 0u,
Appearance: RuntimeCharacterCreationAppearance.Default,
Template: RuntimeCharacterCreationSnapshot.TemplateUnset,
Attributes: default,
AttributeLockMask: 0u,
TotalAttributeCredits: 0u,
RemainingAttributeCredits: 0,
TotalSkillCredits: 0u,
RemainingSkillCredits: 0,
Name: string.Empty,
StartArea: -1,
Slot: 0u,
VerificationPending: false,
LastLocalRefusal: default,
LastRejection: null,
LastCreated: null);
public ChargenOptions Options => ChargenOptions.Empty;
public ChargenSkillAdvancementClass GetSkillLevel(uint skillId) =>
ChargenSkillAdvancementClass.Inactive;
public IDisposable Subscribe(IRuntimeCharacterCreationObserver observer) =>
NullSubscription.Instance;
private sealed class NullSubscription : IDisposable
{
public static readonly NullSubscription Instance = new();
public void Dispose() { }
}
}
}
private static ElementInfo ButtonInfo(uint id) =>
new() { Id = id, Type = 1u, Width = 100f, Height = 30f };
}

View file

@ -1,10 +1,15 @@
using System.Buffers.Binary;
using System.Collections.Immutable;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Net;
using System.Numerics;
using System.Reflection;
using System.Runtime.InteropServices;
using System.Text.Json;
using AcDream.Content;
using AcDream.Content.CharGen;
using AcDream.Core.Net;
using AcDream.Core.Net.Messages;
using AcDream.Core.Physics;
@ -19,11 +24,68 @@ using AcDream.Runtime.Gameplay;
using AcDream.Runtime.Physics;
using AcDream.Runtime.Session;
using AcDream.Runtime.World;
using DatCharGen = DatReaderWriter.DBObjs.CharGen;
using DatHeritageGroupCG = DatReaderWriter.Types.HeritageGroupCG;
using DatIDBObj = DatReaderWriter.Lib.IO.IDBObj;
using DatDatabaseImpl = DatReaderWriter.DatDatabase;
using DatPStringBaseByte = DatReaderWriter.Types.PStringBase<byte>;
namespace AcDream.Headless.Tests;
public sealed class HeadlessSessionHostTests
{
/// <summary>
/// Review fix round R3 (2026-08-15): proves the F6 fix actually opens
/// the gate, not just that <c>InstallOptions</c> was called. A content
/// lease carrying a REAL chargen table (one heritage that does NOT
/// exist in <see cref="AcDream.Core.CharGen.ChargenOptions.Empty"/>) is
/// installed by the host constructor; selecting that heritage — refused
/// against the pre-F6 empty default — is ACCEPTED once the session
/// reaches character-creation-active. <c>Begin</c>/<c>TrySelectHeritage</c>
/// are called directly (both <c>internal</c>, reachable via this
/// project's InternalsVisibleTo on <c>AcDream.Runtime</c>) to isolate the
/// F6 wiring from the unrelated real-network handshake that would
/// otherwise be needed to reach the same session state.
/// </summary>
[Fact]
public void ContentLease_InstallsRealChargenOptions_SelectHeritageIsAccepted()
{
var factory = new ChargenFixtureContentFactory();
using var owner = new HeadlessProcessContentOwner(
ContentDescriptor(),
_ => { },
factory);
HeadlessProcessContentOwner.HeadlessProcessContentLease lease =
owner.AcquireLease("chargen-fixture");
using var credential = new HeadlessCredentialSecret(
"fixture",
"password");
using var diagnosticsOutput = new StringWriter();
using var host = new HeadlessSessionHost(
Descriptor(),
credential,
new HeadlessDiagnosticWriter(diagnosticsOutput),
new FixtureSessionOperations(),
contentLease: lease);
RuntimeCharacterCreationState creation =
host.Runtime.Session.CharacterCreationState;
// F6 proof #1: the fixture heritage (absent from ChargenOptions.Empty)
// is actually installed off the content lease's real Dats.
Assert.True(creation.Options.HeritagesById.ContainsKey(
ChargenFixtureContentFactory.HeritageId));
// F6 proof #2: with real options installed, selecting that heritage
// is accepted once character-creation is active (Begin mirrors the
// real wire trigger this unit test bypasses).
creation.Begin(host.Runtime.Generation);
Assert.True(creation.TrySelectHeritage(ChargenFixtureContentFactory.HeritageId));
Assert.Equal(
ChargenFixtureContentFactory.HeritageId,
creation.View.Snapshot.HeritageId);
}
[Fact]
public void LoginCommandsUseTheHeadlessLiveBusAndPreserveWireOrder()
{
@ -3685,4 +3747,140 @@ public sealed class HeadlessSessionHostTests
}
}
private static HeadlessContentDescriptor ContentDescriptor() => new()
{
DatDirectory = "fixture-dats",
PreparedAssetPath = "fixture.pak",
};
/// <summary>Review fix round R3 (2026-08-15): a content factory whose
/// <c>Dats</c> is a REAL (hand-built, not DispatchProxy-stubbed)
/// <see cref="IDatReaderWriter"/> serving one heritage off
/// <see cref="ChargenTableReader.ChargenTableDid"/> — the existing
/// <c>TestResourceProxy</c> pattern elsewhere in this project always
/// returns null/default and can't serve typed record data.</summary>
private sealed class ChargenFixtureContentFactory : IHeadlessProcessContentFactory
{
internal const uint HeritageId = 1u;
public HeadlessOpenedProcessContent Open(
HeadlessContentDescriptor descriptor,
Action<string> diagnostic) =>
new(
new FixtureChargenDatReaderWriter(),
DispatchProxy.Create<ITestPreparedSource, TestResourceProxy>(),
MagicCatalog.Empty,
ImmutableArray.CreateRange(new float[256]));
}
/// <summary>Minimal <see cref="IDatReaderWriter"/> mirroring
/// <c>ChargenTableReaderTests.EmptyDatReaderWriter</c>'s shape, except
/// <see cref="Get{T}"/> serves a real <see cref="DatCharGen"/> for
/// <see cref="ChargenTableReader.ChargenTableDid"/> — everything else
/// still misses, matching the missing-table tolerance
/// <see cref="ChargenTableReader.Load"/> already has tests for.</summary>
private sealed class FixtureChargenDatReaderWriter : IDatReaderWriter
{
private readonly StubDatabase _db = new();
private readonly DatCharGen _chargenTable = BuildChargenTable();
public string SourceDirectory => string.Empty;
public IDatDatabase Portal => _db;
public IDatDatabase Cell => _db;
public ReadOnlyDictionary<uint, IDatDatabase> CellRegions { get; } =
new(new Dictionary<uint, IDatDatabase>());
public IDatDatabase HighRes => _db;
public IDatDatabase Language => _db;
public IDatDatabase Local => _db;
public ReadOnlyDictionary<uint, uint> RegionFileMap { get; } =
new(new Dictionary<uint, uint>());
public int PortalIteration => 0;
public int CellIteration => 0;
public int HighResIteration => 0;
public int LanguageIteration => 0;
public bool TryGetFileBytes(
uint regionId,
uint fileId,
ref byte[] bytes,
out int bytesRead)
{
bytesRead = 0;
return false;
}
public IEnumerable<uint> GetAllIdsOfType<T>() where T : DatIDBObj =>
Array.Empty<uint>();
public IEnumerable<IDatReaderWriter.IdResolution> ResolveId(uint id) =>
Array.Empty<IDatReaderWriter.IdResolution>();
public bool TrySave<T>(T obj, int iteration = 0) where T : DatIDBObj =>
throw new NotSupportedException();
public bool TrySave<T>(uint regionId, T obj, int iteration = 0) where T : DatIDBObj =>
throw new NotSupportedException();
[return: MaybeNull]
public T Get<T>(uint fileId) where T : DatIDBObj =>
fileId == ChargenTableReader.ChargenTableDid
&& typeof(T) == typeof(DatCharGen)
? (T)(object)_chargenTable
: default;
public bool TryGet<T>(uint fileId, [MaybeNullWhen(false)] out T value)
where T : DatIDBObj
{
value = Get<T>(fileId);
return value is not null;
}
public void Dispose() { }
private static DatCharGen BuildChargenTable()
{
var table = new DatCharGen();
var heritage = new DatHeritageGroupCG
{
Name = Str("FixtureHeritage"),
AttributeCredits = 60u,
SkillCredits = 50u,
};
table.HeritageGroups.Add(ChargenFixtureContentFactory.HeritageId, heritage);
return table;
}
private static DatPStringBaseByte Str(string value)
{
var s = new DatPStringBaseByte();
s.Value = value;
return s;
}
private sealed class StubDatabase : IDatDatabase
{
public DatDatabaseImpl Db => null!;
public int Iteration => 0;
public IEnumerable<uint> GetAllIdsOfType<T>() where T : DatIDBObj =>
Array.Empty<uint>();
public bool TryGet<T>(uint fileId, [MaybeNullWhen(false)] out T value)
where T : DatIDBObj
{
value = default;
return false;
}
public bool TryGetFileBytes(uint fileId, [MaybeNullWhen(false)] out byte[] value)
{
value = default;
return false;
}
public bool TryGetFileBytes(uint fileId, ref byte[] bytes, out int bytesRead)
{
bytesRead = 0;
return false;
}
public bool TrySave<T>(T obj, int iteration = 0) where T : DatIDBObj => false;
public void Dispose() { }
}
}
}