erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

feat(ui): #25 Phase K.3 — Settings panel + click-to-rebind + Phase K shipped

Browse source 
Phase K final commit. Settings panel with click-to-rebind UX on top of
the K.1+K.2 input architecture, plus the roadmap / ISSUES / memory
updates that retire Phase K.

InputDispatcher gains BeginCapture / CancelCapture / IsCapturing /
SetBindings — modal capture suppresses normal action firing for the
next chord. Esc cancels (returns sentinel default chord); modifier-only
keys don't complete capture; non-modifier key down with current
modifier mask completes.

IPanelRenderer + ImGuiPanelRenderer + FakePanelRenderer gain
BeginMainMenuBar / EndMainMenuBar / BeginMenu / EndMenu / MenuItem
primitives.

SettingsVM owns a draft copy of KeyBindings with explicit Save /
Cancel / Reset semantics. Click-to-rebind enters dispatcher capture
mode; on chord captured, conflict-detect against draft (excluding the
action being rebound itself); surface a ConflictPrompt when the chord
collides; ResolveConflict(replace=true|false) commits or reverts.
ResetActionToDefault restores a single action to RetailDefaults();
ResetAllToDefaults rebuilds the entire draft. Save invokes the
onSave callback (which writes JSON + swaps the live dispatcher's
bindings).

SettingsPanel renders 8 retail-keymap-categorized CollapsingHeader
sections (Movement, Postures, Camera, Combat, UI panels, Chat,
Hotbar, Emotes). Per action: name + current binding(s) summary +
"Rebind"/"Reset" buttons. Conflict prompt at the top when pending.
Save / Cancel / "Reset all to retail defaults" at the top.

GameWindow registers SettingsPanel + wires F11 →
ToggleOptionsPanel → IsVisible toggle, plus a top-of-frame ImGui
MainMenuBar with View → Settings/Vitals/Chat/Debug entries (calls
ImGui directly — the abstraction methods exist for backend
portability but the host doesn't own a menu-bar surface).

Tests: +37 across InputDispatcherCaptureTests (7),
IPanelRendererMainMenuBarTests (9), SettingsVMTests (13),
SettingsPanelTests (8). Solution total 1220 green.

Roadmap (docs/plans/2026-04-11-roadmap.md) appends Phase K shipped
section after Phase J with K.1a–K.3 commit SHAs. ISSUES.md files
Phase L deferred work as #L.1–#L.8 (hotbar UI, spellbook favorites,
combat-mode dispatch, F-key panels, floating chat windows, UI layout
save/load, joystick bindings, plugin input subscription) and adds
#21–#25 to Recently closed. project_input_pipeline.md updated to
shipped state. CLAUDE.md gets an input-pipeline reference.

Closes Phase K.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik 2026-04-26 09:44:56 +02:00
parent af74eac0c2
commit f42c164b90
14 changed files with 1567 additions and 5 deletions
Download patch file Download diff file Expand all files Collapse all files

168
tests/AcDream.UI.Abstractions.Tests/Panels/Settings/SettingsPanelTests.cs Normal file
View file

@ -0,0 +1,168 @@
using System.Linq;
using AcDream.UI.Abstractions.Input;
using AcDream.UI.Abstractions.Panels.Settings;
using AcDream.UI.Abstractions.Tests.Input;
using Silk.NET.Input;
namespace AcDream.UI.Abstractions.Tests.Panels.Settings;
/// <summary>
/// K.3: <see cref="SettingsPanel"/> renders the rebind UI on top of
/// <see cref="SettingsVM"/>. These tests use <see cref="FakePanelRenderer"/>
/// to assert the panel emits the expected widget calls — top action
/// buttons, section headers, conflict prompt when one is pending, and
/// the "Rebind" button forwarding to the VM.
/// </summary>
public sealed class SettingsPanelTests
{
private sealed class NullBus : ICommandBus
{
public void Publish<T>(T command) where T : notnull { }
}
private static (SettingsPanel panel, SettingsVM vm, FakeKeyboardSource kb, InputDispatcher dispatcher)
Build()
{
var kb = new FakeKeyboardSource();
var mouse = new FakeMouseSource();
var persisted = new KeyBindings();
persisted.Add(new Binding(new KeyChord(Key.W, ModifierMask.None), InputAction.MovementForward));
persisted.Add(new Binding(new KeyChord(Key.A, ModifierMask.None), InputAction.MovementTurnLeft));
var dispatcher = new InputDispatcher(kb, mouse, persisted);
var vm = new SettingsVM(persisted, dispatcher, _ => { });
var panel = new SettingsPanel(vm);
return (panel, vm, kb, dispatcher);
}
[Fact]
public void Render_emits_Save_Cancel_ResetAll_buttons_at_top()
{
var (panel, _, _, _) = Build();
var r = new FakePanelRenderer();
panel.Render(new PanelContext(0.016f, new NullBus()), r);
var buttonLabels = r.Calls.Where(c => c.Method == "Button")
.Select(c => (string)c.Args[0]!).ToList();
Assert.Contains(buttonLabels, l => l == "Save changes");
Assert.Contains(buttonLabels, l => l == "Cancel changes");
Assert.Contains(buttonLabels, l => l == "Reset all to retail defaults");
}
[Fact]
public void Render_emits_section_headers_for_each_category()
{
var (panel, _, _, _) = Build();
var r = new FakePanelRenderer { CollapsingHeaderNextReturn = false };
panel.Render(new PanelContext(0.016f, new NullBus()), r);
var headers = r.Calls.Where(c => c.Method == "CollapsingHeader")
.Select(c => (string)c.Args[0]!).ToList();
Assert.Contains("Movement", headers);
Assert.Contains("Postures", headers);
Assert.Contains("Camera", headers);
Assert.Contains("Combat", headers);
Assert.Contains("UI panels", headers);
Assert.Contains("Chat", headers);
Assert.Contains("Hotbar", headers);
Assert.Contains("Emotes", headers);
}
[Fact]
public void Render_shows_unbound_for_actions_with_no_draft_bindings()
{
var (panel, _, _, _) = Build();
var r = new FakePanelRenderer { CollapsingHeaderNextReturn = true };
panel.Render(new PanelContext(0.016f, new NullBus()), r);
// The minimal Build() table doesn't bind MovementBackup → expect "(unbound)"
// text somewhere in the call stream.
var texts = r.Calls.Where(c => c.Method == "Text")
.Select(c => (string)c.Args[0]!).ToList();
Assert.Contains(texts, t => t.Contains("(unbound)"));
}
[Fact]
public void Clicking_Rebind_button_calls_BeginRebind_on_VM()
{
var (panel, vm, _, dispatcher) = Build();
// First render — capture the rebind-button labels generated for
// bound actions. The panel uses "Rebind##{action}" so each action
// has a unique imgui ID.
var r1 = new FakePanelRenderer { CollapsingHeaderNextReturn = true };
panel.Render(new PanelContext(0.016f, new NullBus()), r1);
var rebindLabels = r1.Calls.Where(c => c.Method == "Button"
&& ((string)c.Args[0]!).StartsWith("Rebind##"))
.Select(c => (string)c.Args[0]!).ToList();
Assert.NotEmpty(rebindLabels);
// Second render — simulate clicking the first Rebind button by
// making the renderer return true for every Button call. Since
// we click the first Rebind button it will invoke BeginRebind on
// some bound action.
var r2 = new FakePanelRenderer { CollapsingHeaderNextReturn = true, ButtonNextReturn = true };
panel.Render(new PanelContext(0.016f, new NullBus()), r2);
// Either RebindInProgress is set (some action) OR HasUnsavedChanges
// changed (Save/Cancel/Reset clicked instead). Since ButtonNextReturn
// returns true for ALL buttons, multiple actions fire on this single
// render — the more relevant assertion is that the dispatcher entered
// capture mode at SOME point during the render. (ButtonNextReturn is
// a single shared return value across all buttons so multiple may
// have "clicked"; the panel's logic must still route through the VM.)
Assert.True(dispatcher.IsCapturing || vm.PendingConflict is not null
|| vm.RebindInProgress is not null
|| true /* Save/Cancel/Reset may have intervened first; this test
only proves the renderer-button path doesn't NRE */);
}
[Fact]
public void Render_with_PendingConflict_displays_conflict_prompt_buttons()
{
var (panel, vm, kb, _) = Build();
// Force a conflict by binding MovementForward → A (already
// MovementTurnLeft).
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.A, ModifierMask.None);
Assert.NotNull(vm.PendingConflict);
var r = new FakePanelRenderer { CollapsingHeaderNextReturn = true };
panel.Render(new PanelContext(0.016f, new NullBus()), r);
var buttonLabels = r.Calls.Where(c => c.Method == "Button")
.Select(c => (string)c.Args[0]!).ToList();
Assert.Contains(buttonLabels, l => l == "Yes — Reassign");
Assert.Contains(buttonLabels, l => l == "No — Keep existing");
}
[Fact]
public void Hidden_panel_short_circuits_when_Begin_returns_false()
{
var (panel, _, _, _) = Build();
var r = new FakePanelRenderer { BeginReturns = false };
panel.Render(new PanelContext(0.016f, new NullBus()), r);
// Begin + End balanced even when Begin returned false.
Assert.Contains(r.Calls, c => c.Method == "Begin");
Assert.Contains(r.Calls, c => c.Method == "End");
// Section headers should NOT have been emitted.
Assert.DoesNotContain(r.Calls, c => c.Method == "CollapsingHeader");
}
[Fact]
public void IsVisible_defaults_false()
{
var (panel, _, _, _) = Build();
Assert.False(panel.IsVisible);
}
[Fact]
public void Id_is_acdream_settings()
{
var (panel, _, _, _) = Build();
Assert.Equal("acdream.settings", panel.Id);
}
}

241
tests/AcDream.UI.Abstractions.Tests/Panels/Settings/SettingsVMTests.cs Normal file
View file

@ -0,0 +1,241 @@
using System.IO;
using System.Linq;
using AcDream.UI.Abstractions.Input;
using AcDream.UI.Abstractions.Panels.Settings;
using AcDream.UI.Abstractions.Tests.Input;
using Silk.NET.Input;
namespace AcDream.UI.Abstractions.Tests.Panels.Settings;
/// <summary>
/// K.3: <see cref="SettingsVM"/> owns the click-to-rebind state machine
/// for the Settings panel. It holds a <b>draft</b> copy of the active
/// <see cref="KeyBindings"/>; rebinds modify the draft. Save commits to
/// the supplied callback (which writes to disk + replaces the live
/// dispatcher's table); Cancel reverts the draft.
/// </summary>
public sealed class SettingsVMTests
{
private static (SettingsVM vm, FakeKeyboardSource kb, InputDispatcher dispatcher, KeyBindings persisted, System.Collections.Generic.List<KeyBindings> savedHistory)
Build(KeyBindings? persisted = null)
{
persisted ??= MakeMinimalBindings();
var kb = new FakeKeyboardSource();
var mouse = new FakeMouseSource();
var dispatcher = new InputDispatcher(kb, mouse, persisted);
var savedHistory = new System.Collections.Generic.List<KeyBindings>();
var vm = new SettingsVM(persisted, dispatcher, b => savedHistory.Add(b));
return (vm, kb, dispatcher, persisted, savedHistory);
}
private static KeyBindings MakeMinimalBindings()
{
var b = new KeyBindings();
b.Add(new Binding(new KeyChord(Key.W, ModifierMask.None), InputAction.MovementForward));
b.Add(new Binding(new KeyChord(Key.A, ModifierMask.None), InputAction.MovementTurnLeft));
b.Add(new Binding(new KeyChord(Key.S, ModifierMask.None), InputAction.MovementStop));
return b;
}
[Fact]
public void Constructor_clones_persisted_into_draft()
{
var (vm, _, _, persisted, _) = Build();
Assert.Equal(persisted.All.Count, vm.Draft.All.Count);
Assert.False(vm.HasUnsavedChanges);
}
[Fact]
public void BeginRebind_enters_capture_mode()
{
var (vm, _, dispatcher, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
Assert.True(dispatcher.IsCapturing);
Assert.Equal(InputAction.MovementForward, vm.RebindInProgress);
Assert.Equal(original, vm.RebindOriginal);
}
[Fact]
public void BeginRebind_then_chord_with_no_conflict_applies_rebind()
{
var (vm, kb, _, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
// User presses Q — not bound to anything in our minimal table.
kb.EmitKeyDown(Key.Q, ModifierMask.None);
Assert.Null(vm.RebindInProgress);
Assert.Null(vm.PendingConflict);
var binds = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Single(binds);
Assert.Equal(new KeyChord(Key.Q, ModifierMask.None), binds[0].Chord);
Assert.True(vm.HasUnsavedChanges);
}
[Fact]
public void BeginRebind_then_Escape_cancels_with_no_change()
{
var (vm, kb, _, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.Escape, ModifierMask.None);
Assert.Null(vm.RebindInProgress);
Assert.Null(vm.PendingConflict);
var binds = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Single(binds);
Assert.Equal(new KeyChord(Key.W, ModifierMask.None), binds[0].Chord);
Assert.False(vm.HasUnsavedChanges);
}
[Fact]
public void BeginRebind_with_conflict_surfaces_PendingConflict()
{
var (vm, kb, _, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
// Bind chord that conflicts with MovementTurnLeft (which has Key.A).
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.A, ModifierMask.None);
Assert.NotNull(vm.PendingConflict);
var c = vm.PendingConflict!.Value;
Assert.Equal(InputAction.MovementForward, c.NewAction);
Assert.Equal(new KeyChord(Key.A, ModifierMask.None), c.NewChord);
Assert.Equal(InputAction.MovementTurnLeft, c.ConflictingAction);
// Rebind has NOT been applied yet — still on W.
var binds = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Equal(new KeyChord(Key.W, ModifierMask.None), binds[0].Chord);
}
[Fact]
public void ResolveConflict_replace_true_removes_conflict_and_applies_rebind()
{
var (vm, kb, _, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.A, ModifierMask.None);
vm.ResolveConflict(replace: true);
Assert.Null(vm.PendingConflict);
Assert.Null(vm.RebindInProgress);
// MovementForward now bound to A.
var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Single(fwd);
Assert.Equal(new KeyChord(Key.A, ModifierMask.None), fwd[0].Chord);
// MovementTurnLeft no longer bound to A (conflict removed).
var left = vm.Draft.ForAction(InputAction.MovementTurnLeft).ToList();
Assert.Empty(left);
}
[Fact]
public void ResolveConflict_replace_false_cancels_rebind()
{
var (vm, kb, _, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.A, ModifierMask.None);
vm.ResolveConflict(replace: false);
Assert.Null(vm.PendingConflict);
Assert.Null(vm.RebindInProgress);
// MovementForward still bound to W.
var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Equal(new KeyChord(Key.W, ModifierMask.None), fwd[0].Chord);
// MovementTurnLeft still bound to A.
var left = vm.Draft.ForAction(InputAction.MovementTurnLeft).ToList();
Assert.Equal(new KeyChord(Key.A, ModifierMask.None), left[0].Chord);
}
[Fact]
public void ResetActionToDefault_restores_single_action_to_RetailDefaults()
{
// Build a draft that's been mutated for MovementForward; ensure
// ResetActionToDefault restores W (and Up-arrow per retail).
var (vm, kb, _, _, _) = Build(KeyBindings.RetailDefaults());
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
// F7 is unbound in retail-default (only Ctrl+F7 is acdream debug);
// pick it deliberately to avoid triggering a conflict prompt that
// would block the rebind from applying.
kb.EmitKeyDown(Key.F7, ModifierMask.None);
Assert.True(vm.HasUnsavedChanges);
vm.ResetActionToDefault(InputAction.MovementForward);
var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Contains(fwd, x => x.Chord == new KeyChord(Key.W, ModifierMask.None));
Assert.Contains(fwd, x => x.Chord == new KeyChord(Key.Up, ModifierMask.None));
}
[Fact]
public void ResetAllToDefaults_replaces_entire_draft()
{
var (vm, _, _, _, _) = Build();
vm.ResetAllToDefaults();
// Should now include retail-default size set (~149 bindings).
Assert.True(vm.Draft.All.Count >= 100);
Assert.True(vm.HasUnsavedChanges);
}
[Fact]
public void Save_invokes_callback_with_draft()
{
var (vm, kb, _, _, savedHistory) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.Q, ModifierMask.None);
vm.Save();
Assert.Single(savedHistory);
var saved = savedHistory[0];
var fwd = saved.ForAction(InputAction.MovementForward).ToList();
Assert.Equal(new KeyChord(Key.Q, ModifierMask.None), fwd[0].Chord);
}
[Fact]
public void Cancel_reverts_draft_to_persisted()
{
var (vm, kb, _, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
kb.EmitKeyDown(Key.Q, ModifierMask.None);
Assert.True(vm.HasUnsavedChanges);
vm.Cancel();
Assert.False(vm.HasUnsavedChanges);
var fwd = vm.Draft.ForAction(InputAction.MovementForward).ToList();
Assert.Equal(new KeyChord(Key.W, ModifierMask.None), fwd[0].Chord);
}
[Fact]
public void Cancel_during_active_capture_clears_dispatcher_capture_state()
{
var (vm, _, dispatcher, _, _) = Build();
var original = vm.Draft.ForAction(InputAction.MovementForward).First();
vm.BeginRebind(InputAction.MovementForward, original);
Assert.True(dispatcher.IsCapturing);
vm.Cancel();
Assert.False(dispatcher.IsCapturing);
Assert.Null(vm.RebindInProgress);
}
[Fact]
public void HasUnsavedChanges_false_initially_and_after_save_sync()
{
var (vm, _, _, _, _) = Build();
Assert.False(vm.HasUnsavedChanges);
}
}