520 lines
19 KiB
C#
520 lines
19 KiB
C#
using System.Numerics;
|
|
using System.Reflection;
|
|
using System.Runtime.CompilerServices;
|
|
using AcDream.App.Combat;
|
|
using AcDream.App.Composition;
|
|
using AcDream.App.Diagnostics;
|
|
using AcDream.App.Input;
|
|
using AcDream.App.Rendering;
|
|
using AcDream.App.Settings;
|
|
using AcDream.Core.Chat;
|
|
using AcDream.Core.Combat;
|
|
using AcDream.Core.Player;
|
|
using AcDream.Core.Spells;
|
|
using AcDream.UI.Abstractions.Input;
|
|
using AcDream.UI.Abstractions.Panels.Settings;
|
|
using AcDream.UI.Abstractions.Settings;
|
|
using AcDream.UI.ImGui;
|
|
using Silk.NET.Input;
|
|
using Silk.NET.Maths;
|
|
using Silk.NET.OpenGL;
|
|
using Silk.NET.Windowing;
|
|
|
|
namespace AcDream.App.Tests.Composition;
|
|
|
|
public sealed class SettingsDevToolsCompositionTests
|
|
{
|
|
[Fact]
|
|
public void DisabledFrontendAppliesSettingsAndAcquiresNothingOptional()
|
|
{
|
|
using var fixture = new Fixture(enabled: false);
|
|
|
|
SettingsDevToolsResult result = fixture.Compose();
|
|
|
|
Assert.Null(result.DevTools);
|
|
Assert.Equal(1, fixture.Startup.DisplayCalls);
|
|
Assert.Equal(1, fixture.Startup.AudioCalls);
|
|
Assert.Equal(0, fixture.Factory.Calls);
|
|
Assert.Equal(
|
|
[SettingsDevToolsCompositionPoint.SettingsApplied],
|
|
fixture.Points);
|
|
}
|
|
|
|
[Fact]
|
|
public void UnsupportedInputDisablesBeforeAcquiringFrontendResources()
|
|
{
|
|
using var fixture = new Fixture(inputSupported: false);
|
|
|
|
SettingsDevToolsResult result = fixture.Compose();
|
|
|
|
Assert.Null(result.DevTools);
|
|
Assert.Null(fixture.Factory.Input);
|
|
Assert.Null(fixture.Factory.Bootstrap);
|
|
Assert.Equal(1, fixture.Factory.Calls);
|
|
}
|
|
|
|
[Fact]
|
|
public void EnabledFrontendPublishesOneCompleteOwnerAfterEveryEdge()
|
|
{
|
|
using var fixture = new Fixture();
|
|
|
|
SettingsDevToolsResult result = fixture.Compose();
|
|
|
|
Assert.Same(fixture.Publication.Owner, result.DevTools);
|
|
Assert.Equal(
|
|
Enum.GetValues<SettingsDevToolsCompositionPoint>(),
|
|
fixture.Points);
|
|
Assert.True(fixture.Factory.Input!.Activated);
|
|
Assert.Equal(4, fixture.Factory.Backend!.LayoutCalls);
|
|
Assert.Equal(1, fixture.Publication.PublishCalls);
|
|
}
|
|
|
|
[Theory]
|
|
[MemberData(nameof(OptionalFailurePoints))]
|
|
public void OptionalPrefixFailureDisablesOnlyAfterCompleteReverseCleanup(
|
|
int pointValue)
|
|
{
|
|
var point = (SettingsDevToolsCompositionPoint)pointValue;
|
|
using var fixture = new Fixture(failurePoint: point);
|
|
|
|
SettingsDevToolsResult result = fixture.Compose();
|
|
|
|
Assert.Null(result.DevTools);
|
|
Assert.Null(fixture.Publication.Owner);
|
|
Assert.Equal(
|
|
Enum.GetValues<SettingsDevToolsCompositionPoint>()
|
|
.TakeWhile(candidate => candidate <= point),
|
|
fixture.Points);
|
|
if (fixture.Factory.Input is { } input)
|
|
Assert.True(input.IsDisposalComplete);
|
|
if (fixture.Factory.Bootstrap is { } bootstrap)
|
|
Assert.Equal(1, bootstrap.DisposeCalls);
|
|
if (fixture.Factory.Backend is { } backend)
|
|
Assert.Equal(1, backend.DisposeCalls);
|
|
}
|
|
|
|
public static TheoryData<int> OptionalFailurePoints()
|
|
{
|
|
var data = new TheoryData<int>();
|
|
foreach (SettingsDevToolsCompositionPoint point in
|
|
Enum.GetValues<SettingsDevToolsCompositionPoint>())
|
|
{
|
|
if (point is SettingsDevToolsCompositionPoint.SettingsApplied
|
|
or SettingsDevToolsCompositionPoint.DevToolsPublished)
|
|
{
|
|
continue;
|
|
}
|
|
data.Add((int)point);
|
|
}
|
|
return data;
|
|
}
|
|
|
|
[Fact]
|
|
public void FailureAfterPublicationPropagatesToLifetimeOwner()
|
|
{
|
|
using var fixture = new Fixture(
|
|
failurePoint: SettingsDevToolsCompositionPoint.DevToolsPublished);
|
|
|
|
Assert.Throws<InvalidOperationException>(fixture.Compose);
|
|
|
|
Assert.NotNull(fixture.Publication.Owner);
|
|
Assert.False(fixture.Publication.Owner!.IsDisposalComplete);
|
|
}
|
|
|
|
[Fact]
|
|
public void CleanupFailurePropagatesAndRetrySkipsCompletedOperations()
|
|
{
|
|
using var fixture = new Fixture(
|
|
failurePoint: SettingsDevToolsCompositionPoint.InitialLayoutApplied,
|
|
backendDisposeFailures: 1);
|
|
|
|
var failure = Assert.Throws<CompositionAcquisitionException>(fixture.Compose);
|
|
Assert.False(failure.IsCleanupComplete);
|
|
Assert.Equal(1, fixture.Factory.Backend!.DisposeCalls);
|
|
Assert.True(fixture.Factory.Input!.IsDisposalComplete);
|
|
|
|
failure.RetryCleanup();
|
|
|
|
Assert.True(failure.IsCleanupComplete);
|
|
Assert.Equal(2, fixture.Factory.Backend.DisposeCalls);
|
|
Assert.Equal(1, fixture.Factory.Input.DisposeCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public void BootstrapConstructionWithoutCleanupOwnerAbortsHostStartup()
|
|
{
|
|
var bootstrapFailure = (ImGuiBootstrapperConstructionException)
|
|
Activator.CreateInstance(
|
|
typeof(ImGuiBootstrapperConstructionException),
|
|
BindingFlags.Instance | BindingFlags.NonPublic,
|
|
binder: null,
|
|
args: [new InvalidOperationException("partial Silk construction")],
|
|
culture: null)!;
|
|
using var fixture = new Fixture(bootstrapFailure: bootstrapFailure);
|
|
|
|
Assert.Throws<ImGuiBootstrapperConstructionException>(fixture.Compose);
|
|
|
|
Assert.True(fixture.Factory.Input!.IsDisposalComplete);
|
|
Assert.Null(fixture.Publication.Owner);
|
|
Assert.DoesNotContain(
|
|
fixture.Logs,
|
|
message => message.Contains("devtools disabled", StringComparison.Ordinal));
|
|
}
|
|
|
|
[Fact]
|
|
public void GameWindowUsesProductionPhaseAndDoesNotRetainHostClosures()
|
|
{
|
|
string source = File.ReadAllText(Path.Combine(
|
|
FindRepoRoot(),
|
|
"src",
|
|
"AcDream.App",
|
|
"Rendering",
|
|
"GameWindow.cs"));
|
|
|
|
Assert.Contains("new SettingsDevToolsCompositionPhase(", source,
|
|
StringComparison.Ordinal);
|
|
Assert.DoesNotContain("new AcDream.UI.ImGui.ImGuiBootstrapper(", source,
|
|
StringComparison.Ordinal);
|
|
Assert.DoesNotContain("getPlayerPosition: () => GetDebugPlayerPosition()", source,
|
|
StringComparison.Ordinal);
|
|
Assert.DoesNotContain("_runtimeSettings.ApplyStartup(", source,
|
|
StringComparison.Ordinal);
|
|
}
|
|
|
|
private sealed class Fixture : IDisposable
|
|
{
|
|
private readonly SettingsDevToolsCompositionPoint? _failurePoint;
|
|
private readonly InputDispatcher _dispatcher;
|
|
private readonly FrameProfiler _profiler = new();
|
|
|
|
public Fixture(
|
|
bool enabled = true,
|
|
SettingsDevToolsCompositionPoint? failurePoint = null,
|
|
int backendDisposeFailures = 0,
|
|
bool inputSupported = true,
|
|
Exception? bootstrapFailure = null)
|
|
{
|
|
_failurePoint = failurePoint;
|
|
Factory = new Factory(
|
|
backendDisposeFailures,
|
|
inputSupported,
|
|
bootstrapFailure);
|
|
Publication = new Publication();
|
|
Startup = new StartupTarget();
|
|
Settings = new RuntimeSettingsController(
|
|
new Storage(),
|
|
QualitySettings.From,
|
|
static _ => { });
|
|
_dispatcher = InputDispatcher.CreateDetached(
|
|
new KeyboardSource(),
|
|
new MouseSource(),
|
|
new KeyBindings());
|
|
_dispatcher.Attach();
|
|
var camera = new CameraController(new OrbitCamera(), new FlyCamera());
|
|
Host = new HostInputCameraResult(
|
|
null!,
|
|
null!,
|
|
null,
|
|
null,
|
|
null,
|
|
_dispatcher,
|
|
camera,
|
|
null);
|
|
Platform = new GameWindowPlatformResult<GL, IInputContext>(null!, null!);
|
|
Content = (ContentEffectsAudioResult)RuntimeHelpers.GetUninitializedObject(
|
|
typeof(ContentEffectsAudioResult));
|
|
Dependencies = new SettingsDevToolsDependencies(
|
|
DispatchProxy.Create<IView, ViewProxy>(),
|
|
Settings,
|
|
Startup,
|
|
new HostQuiescenceGate(),
|
|
new ChatLog(),
|
|
new CombatState(),
|
|
new LocalPlayerState(new Spellbook()),
|
|
enabled
|
|
? new SettingsDevToolsOptionalDependencies(
|
|
new Facts(),
|
|
new KeyBindingTarget(),
|
|
new DeferredCanonicalWorldEntityCountSource(),
|
|
new DeferredRenderFrameDiagnosticsSource(),
|
|
new DeferredDevToolsPlayerModeCommands())
|
|
: null,
|
|
new RuntimeDiagnosticCommandSlot(),
|
|
new CombatFeedbackSlot(),
|
|
new KeyBindings(),
|
|
_profiler,
|
|
new FramebufferResizeController(new ViewportAspectState()),
|
|
Logs.Add);
|
|
}
|
|
|
|
public List<SettingsDevToolsCompositionPoint> Points { get; } = [];
|
|
public List<string> Logs { get; } = [];
|
|
public Factory Factory { get; }
|
|
public Publication Publication { get; }
|
|
public StartupTarget Startup { get; }
|
|
public RuntimeSettingsController Settings { get; }
|
|
public SettingsDevToolsDependencies Dependencies { get; }
|
|
public HostInputCameraResult Host { get; }
|
|
public GameWindowPlatformResult<GL, IInputContext> Platform { get; }
|
|
public ContentEffectsAudioResult Content { get; }
|
|
|
|
public SettingsDevToolsResult Compose() =>
|
|
new SettingsDevToolsCompositionPhase(
|
|
Dependencies,
|
|
Publication,
|
|
Factory,
|
|
point =>
|
|
{
|
|
Points.Add(point);
|
|
if (point == _failurePoint)
|
|
throw new InvalidOperationException($"fault at {point}");
|
|
}).Compose(Platform, Host, Content);
|
|
|
|
public void Dispose()
|
|
{
|
|
Publication.Owner?.Dispose();
|
|
_dispatcher.Dispose();
|
|
_profiler.Dispose();
|
|
}
|
|
}
|
|
|
|
private sealed class Publication : IGameWindowSettingsDevToolsPublication
|
|
{
|
|
public DevToolsCompositionOwner? Owner { get; private set; }
|
|
public int PublishCalls { get; private set; }
|
|
|
|
public void PublishDevTools(DevToolsCompositionOwner value)
|
|
{
|
|
if (Owner is not null)
|
|
throw new InvalidOperationException("duplicate publication");
|
|
Owner = value;
|
|
PublishCalls++;
|
|
}
|
|
}
|
|
|
|
private sealed class Factory(
|
|
int backendDisposeFailures,
|
|
bool inputSupported,
|
|
Exception? bootstrapFailure)
|
|
: ISettingsDevToolsCompositionFactory
|
|
{
|
|
public int Calls { get; private set; }
|
|
public InputContext? Input { get; private set; }
|
|
public Bootstrap? Bootstrap { get; private set; }
|
|
public Backend? Backend { get; private set; }
|
|
|
|
public bool IsSupported(IInputContext input)
|
|
{
|
|
Calls++;
|
|
return inputSupported;
|
|
}
|
|
|
|
public IDevToolsInputContext CreateInputContext(
|
|
IInputContext input,
|
|
HostQuiescenceGate quiescence)
|
|
{
|
|
Calls++;
|
|
return Input = new InputContext();
|
|
}
|
|
|
|
public IImGuiBootstrapper CreateBootstrap(
|
|
GL gl,
|
|
IView window,
|
|
IInputContext input)
|
|
{
|
|
Calls++;
|
|
if (bootstrapFailure is not null)
|
|
throw bootstrapFailure;
|
|
return Bootstrap = new Bootstrap();
|
|
}
|
|
|
|
public ImGuiPanelHost CreatePanelHost()
|
|
{
|
|
Calls++;
|
|
return new ImGuiPanelHost();
|
|
}
|
|
|
|
public IDevToolsFrameBackend CreateBackend(
|
|
IImGuiBootstrapper bootstrap,
|
|
ImGuiPanelHost panels)
|
|
{
|
|
Calls++;
|
|
return Backend = new Backend(
|
|
(Bootstrap)bootstrap,
|
|
backendDisposeFailures);
|
|
}
|
|
}
|
|
|
|
private sealed class InputContext : IDevToolsInputContext
|
|
{
|
|
public bool Activated { get; private set; }
|
|
public int DisposeCalls { get; private set; }
|
|
public bool IsDisposalComplete { get; private set; }
|
|
public nint Handle => 0;
|
|
public IReadOnlyList<IGamepad> Gamepads { get; } = [];
|
|
public IReadOnlyList<IJoystick> Joysticks { get; } = [];
|
|
public IReadOnlyList<IKeyboard> Keyboards { get; } = [];
|
|
public IReadOnlyList<IMouse> Mice { get; } = [];
|
|
public IReadOnlyList<IInputDevice> OtherDevices { get; } = [];
|
|
#pragma warning disable CS0067
|
|
public event Action<IInputDevice, bool>? ConnectionChanged;
|
|
#pragma warning restore CS0067
|
|
public void Activate() => Activated = true;
|
|
public void Deactivate() => Activated = false;
|
|
public void Dispose()
|
|
{
|
|
DisposeCalls++;
|
|
Activated = false;
|
|
IsDisposalComplete = true;
|
|
}
|
|
}
|
|
|
|
private sealed class Bootstrap : IImGuiBootstrapper
|
|
{
|
|
public int DisposeCalls { get; private set; }
|
|
public void BeginFrame(float deltaSeconds) { }
|
|
public void Render() { }
|
|
public void AbortFrame() { }
|
|
public void Dispose() => DisposeCalls++;
|
|
}
|
|
|
|
private sealed class Backend(
|
|
Bootstrap bootstrap,
|
|
int remainingDisposeFailures) : IDevToolsFrameBackend
|
|
{
|
|
private int _remainingDisposeFailures = remainingDisposeFailures;
|
|
public int DisposeCalls { get; private set; }
|
|
public int LayoutCalls { get; private set; }
|
|
public void BeginFrame(float deltaSeconds) { }
|
|
public void AbortFrame() { }
|
|
public bool BeginMainMenuBar() => false;
|
|
public void EndMainMenuBar() { }
|
|
public bool BeginMenu(string label) => false;
|
|
public void EndMenu() { }
|
|
public bool MenuItem(string label, string? shortcut = null, bool selected = false) => false;
|
|
public void Separator() { }
|
|
public void RenderPanels(AcDream.UI.Abstractions.PanelContext context) { }
|
|
public void RenderDrawData() { }
|
|
public void SetWindowLayout(
|
|
string title,
|
|
Vector2 position,
|
|
Vector2 size,
|
|
DevToolsPanelLayoutCondition condition) => LayoutCalls++;
|
|
public void Dispose()
|
|
{
|
|
DisposeCalls++;
|
|
if (_remainingDisposeFailures-- > 0)
|
|
throw new InvalidOperationException("backend cleanup failed");
|
|
bootstrap.Dispose();
|
|
}
|
|
}
|
|
|
|
private sealed class StartupTarget : IRuntimeSettingsStartupTarget
|
|
{
|
|
public int DisplayCalls { get; private set; }
|
|
public int AudioCalls { get; private set; }
|
|
public void ApplyDisplay(DisplaySettings display) => DisplayCalls++;
|
|
public void ApplyAudio(AudioSettings audio) => AudioCalls++;
|
|
}
|
|
|
|
private sealed class Storage : IRuntimeSettingsStorage
|
|
{
|
|
public SettingsStore? LayoutStore => null;
|
|
public string Location => "memory://settings";
|
|
public DisplaySettings LoadDisplay() => DisplaySettings.Default;
|
|
public AudioSettings LoadAudio() => AudioSettings.Default;
|
|
public GameplaySettings LoadGameplay() => GameplaySettings.Default;
|
|
public ChatSettings LoadChat() => ChatSettings.Default;
|
|
public CharacterSettings LoadCharacter(string toonKey) => CharacterSettings.Default;
|
|
public void SaveDisplay(DisplaySettings display) { }
|
|
public void SaveAudio(AudioSettings audio) { }
|
|
public void SaveGameplay(GameplaySettings gameplay) { }
|
|
public void SaveChat(ChatSettings chat) { }
|
|
public void SaveCharacter(string toonKey, CharacterSettings character) { }
|
|
}
|
|
|
|
private sealed class KeyBindingTarget : IRuntimeKeyBindingTarget
|
|
{
|
|
public void Apply(KeyBindings bindings) { }
|
|
}
|
|
|
|
private sealed class Facts : IDevToolsRuntimeFacts
|
|
{
|
|
public Vector3 PlayerPosition => default;
|
|
public float PlayerHeadingDegrees => 0;
|
|
public uint PlayerCellId => 0;
|
|
public bool PlayerOnGround => false;
|
|
public bool InPlayerMode => false;
|
|
public bool InFlyMode => false;
|
|
public float VerticalVelocity => 0;
|
|
public int EntityCount => 0;
|
|
public int AnimatedCount => 0;
|
|
public int VisibleLandblocks => 0;
|
|
public int TotalLandblocks => 0;
|
|
public int ShadowObjectCount => 0;
|
|
public float NearestObjectDistance => float.PositiveInfinity;
|
|
public string NearestObjectLabel => "-";
|
|
public bool Colliding => false;
|
|
public bool CollisionWireframesVisible => false;
|
|
public int StreamingRadius => 0;
|
|
public float MouseSensitivity => 1;
|
|
public float ChaseDistance => 0;
|
|
public bool RmbOrbitHeld => false;
|
|
public string HourName => "0";
|
|
public float DayFraction => 0;
|
|
public string Weather => "Clear";
|
|
public int ActiveLights => 0;
|
|
public int RegisteredLights => 0;
|
|
public int ParticleCount => 0;
|
|
public float Fps => 60;
|
|
public float FrameMilliseconds => 16.7f;
|
|
}
|
|
|
|
private sealed class KeyboardSource : IKeyboardSource
|
|
{
|
|
#pragma warning disable CS0067
|
|
public event Action<Key, ModifierMask>? KeyDown;
|
|
public event Action<Key, ModifierMask>? KeyUp;
|
|
#pragma warning restore CS0067
|
|
public bool IsHeld(Key key) => false;
|
|
public ModifierMask CurrentModifiers => ModifierMask.None;
|
|
}
|
|
|
|
private sealed class MouseSource : IMouseSource
|
|
{
|
|
#pragma warning disable CS0067
|
|
public event Action<MouseButton, ModifierMask>? MouseDown;
|
|
public event Action<MouseButton, ModifierMask>? MouseUp;
|
|
public event Action<float, float>? MouseMove;
|
|
public event Action<float>? Scroll;
|
|
#pragma warning restore CS0067
|
|
public bool IsHeld(MouseButton button) => false;
|
|
public bool WantCaptureMouse => false;
|
|
public bool WantCaptureKeyboard => false;
|
|
}
|
|
|
|
public class ViewProxy : DispatchProxy
|
|
{
|
|
protected override object? Invoke(MethodInfo? targetMethod, object?[]? args)
|
|
{
|
|
if (targetMethod?.Name == "get_Size")
|
|
return new Vector2D<int>(1280, 720);
|
|
Type type = targetMethod?.ReturnType ?? typeof(void);
|
|
if (type == typeof(void))
|
|
return null;
|
|
return type.IsValueType ? Activator.CreateInstance(type) : null;
|
|
}
|
|
}
|
|
|
|
private static string FindRepoRoot()
|
|
{
|
|
DirectoryInfo? directory = new(AppContext.BaseDirectory);
|
|
while (directory is not null)
|
|
{
|
|
if (File.Exists(Path.Combine(directory.FullName, "AcDream.slnx")))
|
|
return directory.FullName;
|
|
directory = directory.Parent;
|
|
}
|
|
throw new DirectoryNotFoundException("Could not find AcDream.slnx.");
|
|
}
|
|
}
|