f6fe0f2a4f
Harden keyboard and camera routing, inventory and vendor interactions, chat/emotes, relog portal flow, and paperdoll rendering. Add retail research, connected gate coverage, and release-gate validation.
1159 lines
52 KiB
C#
1159 lines
52 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Numerics;
|
|
using AcDream.App.UI;
|
|
using AcDream.App.UI.Layout;
|
|
using AcDream.Core.Input;
|
|
using AcDream.UI.Abstractions.Input;
|
|
|
|
namespace AcDream.App.Tests.UI.Layout;
|
|
|
|
/// <summary>
|
|
/// Campaign OP slice OP8 conformance + behavior tests for
|
|
/// <see cref="KeyboardConfigController"/> — built against the committed
|
|
/// <c>keyboard_config_21000009.json</c> fixture (real DAT structure, no live dat
|
|
/// access at test time), fed a small synthetic <see cref="RetailActionMapSnapshot"/>
|
|
/// so the behavioral assertions stay focused. Live-DAT row-count/label conformance
|
|
/// lives in <c>AcDream.Core.Tests.Input.RetailActionMapReaderTests</c> and
|
|
/// <c>RetailActionIdentityRoundTripTests</c>.
|
|
///
|
|
/// <para>
|
|
/// Reworked at the 2026-08-11 combined review (M1/M2/M3/S1/S4): the seam now
|
|
/// carries <see cref="Binding"/> (chord + activation + scope). Campaign KB gives
|
|
/// both camera contexts distinct live identities and removes the store-only tier.
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class KeyboardConfigControllerTests
|
|
{
|
|
private static (uint, int, int) NoTex(uint _) => (0, 0, 0);
|
|
|
|
private static ElementInfo? Find(ElementInfo n, uint id)
|
|
{
|
|
if (n.Id == id) return n;
|
|
foreach (ElementInfo c in n.Children)
|
|
{
|
|
ElementInfo? f = Find(c, id);
|
|
if (f is not null) return f;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static Func<uint, uint, UiElement?> MakeTemplateResolver()
|
|
{
|
|
ElementInfo root = FixtureLoader.LoadKeyboardConfigInfos();
|
|
return (layoutId, elementId) =>
|
|
{
|
|
if (layoutId != KeyboardConfigController.LayoutId) return null;
|
|
ElementInfo? templateInfo = Find(root, elementId);
|
|
return templateInfo is null ? null : LayoutImporter.Build(templateInfo, NoTex, null).Root;
|
|
};
|
|
}
|
|
|
|
private static RetailActionMapRow Row(
|
|
uint inputMapId, uint actionId, RetailActionClass cls,
|
|
uint labelHash = 0, uint tooltipHash = 0,
|
|
params RetailKeyChord[] defaults) =>
|
|
new(
|
|
inputMapId,
|
|
actionId,
|
|
cls,
|
|
labelHash == 0 ? 0xDE000000u | (actionId & 0x00FFFFFFu) : labelHash,
|
|
tooltipHash,
|
|
defaults);
|
|
|
|
private static string? ResolveSyntheticString(uint _, uint hash) =>
|
|
(hash & 0xFF000000u) == 0xDE000000u ? $"Action {hash & 0x00FFFFFFu:X}" : null;
|
|
|
|
private sealed class FakeBindings
|
|
{
|
|
public Dictionary<InputAction, List<Binding>> Mapped { get; } = new();
|
|
public Dictionary<(uint, uint), List<KeyChord>> Unmapped { get; } = new();
|
|
public List<(InputAction Action, IReadOnlyList<Binding> Value)> MappedSets { get; } = new();
|
|
public List<((uint, uint) Row, IReadOnlyList<KeyChord> Value)> UnmappedSets { get; } = new();
|
|
public List<string> Messages { get; } = new();
|
|
public int SaveCalls { get; private set; }
|
|
public int ToggleCalls { get; private set; }
|
|
public Action<KeyChord?>? PendingCapture { get; private set; }
|
|
public (string Message, Action<bool> OnResult)? PendingConfirm { get; private set; }
|
|
public List<string> InstructionOpens { get; } = new();
|
|
public List<uint> InstructionCloses { get; } = new();
|
|
public uint NextInstructionContext { get; set; } = 7u;
|
|
public bool WireInstructions { get; set; }
|
|
public string CurrentKeymapFilename { get; set; } = "acdream.keymap";
|
|
public Action? PendingLoadCompleted { get; private set; }
|
|
public Action? PendingSaveCompleted { get; private set; }
|
|
|
|
public void Capture(KeyChord? chord)
|
|
{
|
|
Action<KeyChord?>? cb = PendingCapture;
|
|
PendingCapture = null;
|
|
cb?.Invoke(chord);
|
|
}
|
|
|
|
public void RespondToConfirm(bool accept)
|
|
{
|
|
var pending = PendingConfirm ?? throw new InvalidOperationException("no pending confirm");
|
|
PendingConfirm = null;
|
|
pending.OnResult(accept);
|
|
}
|
|
|
|
public KeyboardConfigController.Bindings ToBindings() => new(
|
|
CurrentForAction: a => Mapped.TryGetValue(a, out var v) ? v : Array.Empty<Binding>(),
|
|
SetForAction: (a, v) =>
|
|
{
|
|
Mapped[a] = v.ToList();
|
|
MappedSets.Add((a, v));
|
|
},
|
|
CurrentForUnmapped: k => Unmapped.TryGetValue(k, out var v) ? v : Array.Empty<KeyChord>(),
|
|
SetForUnmapped: (k, v) =>
|
|
{
|
|
Unmapped[k] = v.ToList();
|
|
UnmappedSets.Add((k, v));
|
|
},
|
|
BeginCapture: cb => PendingCapture = cb,
|
|
Save: () => SaveCalls++,
|
|
Toggle: () => ToggleCalls++,
|
|
ResolveTemplate: (key, variables) => key switch
|
|
{
|
|
"ID_ActionKeyMap_ButtonLabel" => variables[DatStringResolver.ComputeHash("LABEL")],
|
|
"ID_ActionKeyMap_TT_ExistingBinding" =>
|
|
$"({variables[DatStringResolver.ComputeHash("VALUE")]}) existing binding",
|
|
"ID_ActionKeyMap_TT_NewBinding" => "new binding",
|
|
"ID_ActionKeyMap_NonUserBindableBinding" =>
|
|
$"cannot overwrite {variables[DatStringResolver.ComputeHash("KEY")]}",
|
|
"ID_ActionKeyMap_OverwriteExistingBinding" =>
|
|
$"overwrite {variables[DatStringResolver.ComputeHash("KEY")]} "
|
|
+ variables[DatStringResolver.ComputeHash("ACTION")],
|
|
"ID_ActionKeyMap_Binding" =>
|
|
$"{variables[DatStringResolver.ComputeHash("ACTION")]} "
|
|
+ $"({variables[DatStringResolver.ComputeHash("KEY")]})",
|
|
"ID_ActionKeyMap_OverwriteExistingBindings" =>
|
|
$"overwrite {variables[DatStringResolver.ComputeHash("KEY")]}\n"
|
|
+ variables[DatStringResolver.ComputeHash("BINDINGS")],
|
|
_ => null,
|
|
},
|
|
ShowMessage: msg => Messages.Add(msg),
|
|
ConfirmOverwrite: (message, onResult) => PendingConfirm = (message, onResult),
|
|
OpenCaptureInstructions: WireInstructions
|
|
? label =>
|
|
{
|
|
InstructionOpens.Add(label);
|
|
return NextInstructionContext;
|
|
}
|
|
: null,
|
|
CloseCaptureInstructions: context => InstructionCloses.Add(context));
|
|
|
|
public KeyboardConfigController.Bindings ToProfileBindings() =>
|
|
ToBindings() with
|
|
{
|
|
CurrentKeymapFilename = () => this.CurrentKeymapFilename,
|
|
OpenLoadKeymap = completed => PendingLoadCompleted = completed,
|
|
OpenSaveKeymap = completed => PendingSaveCompleted = completed,
|
|
};
|
|
}
|
|
|
|
private static readonly KeyChord ChordW = new(Silk.NET.Input.Key.W, ModifierMask.None);
|
|
private static readonly KeyChord ChordUp = new(Silk.NET.Input.Key.Up, ModifierMask.None);
|
|
private static readonly KeyChord ChordA = new(Silk.NET.Input.Key.A, ModifierMask.None);
|
|
private static readonly KeyChord LeftMouse = new(
|
|
InputDispatcher.MouseButtonToKey(Silk.NET.Input.MouseButton.Left),
|
|
ModifierMask.None,
|
|
Device: 1);
|
|
|
|
[Fact]
|
|
public void Bind_Succeeds_AndBuildsOneRowPerSnapshotRow()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement), // MovementForward
|
|
Row(0x4, 0x2A, RetailActionClass.Movement), // MovementBackup
|
|
Row(0x5, 0x33, RetailActionClass.Camera), // CameraMoveToward
|
|
});
|
|
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
var fake = new FakeBindings();
|
|
KeyboardConfigController? controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings());
|
|
|
|
Assert.NotNull(controller);
|
|
Assert.Equal(3, controller!.Rows.Count);
|
|
Assert.Equal(3, controller.Page.Rows.Count);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bind_ActivatesTheTabControl_MovementDefaultShown_OtherPagesHidden()
|
|
{
|
|
// Gate-2 screenshot finding (#375 residual): OP8 never activated the
|
|
// screen's own Type-8 tab control, so all six ActionClass pages stayed
|
|
// Visible simultaneously — six stacked ListBoxes reading as
|
|
// "overlapping text", with dead tab buttons. Bind must run the
|
|
// authored default-entry switch (Movement, IsDefault=true) exactly
|
|
// like OptionsPanelController does for its own host.
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
Row(0x5, 0x33, RetailActionClass.Camera),
|
|
});
|
|
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
var fake = new FakeBindings();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
Assert.NotNull(controller);
|
|
|
|
UiTabPanel tabHost = Assert.IsType<UiTabPanel>(layout.FindElement(0x1000049Bu));
|
|
Assert.True(tabHost.BehaviorActive);
|
|
Assert.Equal(0x1000049Du, tabHost.ActivePageElementId); // Movement, the authored default
|
|
|
|
// Exactly one page visible: Movement; the other five hidden.
|
|
foreach ((uint pageId, bool expectVisible) in new[]
|
|
{
|
|
(0x1000049Du, true), // Movement
|
|
(0x1000049Fu, false), // Camera
|
|
(0x100004A1u, false), // Combat
|
|
(0x100004A3u, false), // UI
|
|
(0x10000211u, false), // CharacterSettings
|
|
(0x100004A5u, false), // Emote
|
|
})
|
|
{
|
|
UiElement? page = UiElement.FindDescendant(tabHost, pageId);
|
|
Assert.NotNull(page);
|
|
Assert.Equal(expectVisible, page!.Visible);
|
|
}
|
|
|
|
// The tab buttons are live: switching to Camera flips exclusivity.
|
|
tabHost.SwitchTo(0x1000049Fu);
|
|
Assert.False(UiElement.FindDescendant(tabHost, 0x1000049Du)!.Visible);
|
|
Assert.True(UiElement.FindDescendant(tabHost, 0x1000049Fu)!.Visible);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bind_MapsEveryRetailActionRow()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement), // -> MovementForward
|
|
Row(0x10000006, 0x100000A0, RetailActionClass.Emote), // -> EmoteBowDeep
|
|
});
|
|
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
var fake = new FakeBindings();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(r => r.ActionId == 0x29u);
|
|
Assert.Equal(InputAction.MovementForward, forward.MappedAction);
|
|
|
|
KeyboardConfigController.RowView bowDeep = controller.Rows.Single(r => r.ActionId == 0x100000A0u);
|
|
Assert.Equal(InputAction.EmoteBowDeep, bowDeep.MappedAction);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bind_SeedsEveryRowFromLiveBindings()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
Row(0x10000006, 0x100000A0, RetailActionClass.Emote),
|
|
});
|
|
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding>
|
|
{
|
|
new(ChordW, InputAction.MovementForward),
|
|
new(ChordUp, InputAction.MovementForward),
|
|
};
|
|
fake.Mapped[InputAction.EmoteBowDeep] = new List<Binding>
|
|
{
|
|
new(ChordA, InputAction.EmoteBowDeep),
|
|
};
|
|
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(r => r.ActionId == 0x29u);
|
|
Assert.Equal(new[] { ChordW, ChordUp }, forward.Model.Current);
|
|
|
|
KeyboardConfigController.RowView bowDeep = controller.Rows.Single(r => r.ActionId == 0x100000A0u);
|
|
Assert.Equal(new[] { ChordA }, bowDeep.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void KeyButtonClick_CapturesAndAppliesNewBinding()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
Assert.NotEmpty(row.KeyButtons);
|
|
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
Assert.NotNull(fake.PendingCapture);
|
|
fake.Capture(ChordW);
|
|
|
|
Assert.Contains(ChordW, row.Model.Current);
|
|
(InputAction Action, IReadOnlyList<Binding> Value) written = Assert.Single(fake.MappedSets);
|
|
Assert.Equal(InputAction.MovementForward, written.Action);
|
|
Binding onlyBinding = Assert.Single(written.Value);
|
|
Assert.Equal(ChordW, onlyBinding.Chord);
|
|
// No live binding existed at build time — falls back to the retail
|
|
// action identity's activation/scope metadata.
|
|
Assert.Equal(ActivationType.Press, onlyBinding.Activation);
|
|
Assert.Equal(InputScope.Game, onlyBinding.Scope);
|
|
Assert.Equal("W", row.KeyButtons[0].Label);
|
|
}
|
|
|
|
[Fact]
|
|
public void KeyButtonCapture_EscapeCancel_LeavesBindingUnchanged()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding> { new(ChordW, InputAction.MovementForward) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(null); // Escape sentinel
|
|
|
|
Assert.Equal(new[] { ChordW }, row.Model.Current);
|
|
Assert.Empty(fake.MappedSets);
|
|
}
|
|
|
|
// OP8 re-gate (2026-08-14): retail InitiateBinding @ 0x004899D0 opens the
|
|
// capture-instruction wait dialog before arming the key handler, closes it
|
|
// when the capture ends (key or ESC), and refuses to arm at all when the
|
|
// dialog could not open.
|
|
[Fact]
|
|
public void KeyButtonClick_OpensInstructionDialog_AndClosesOnCapturedKey()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings { WireInstructions = true, NextInstructionContext = 42u };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
|
|
Assert.Single(fake.InstructionOpens);
|
|
Assert.NotNull(fake.PendingCapture);
|
|
Assert.Empty(fake.InstructionCloses);
|
|
|
|
fake.Capture(ChordW);
|
|
Assert.Equal(new[] { 42u }, fake.InstructionCloses);
|
|
Assert.Contains(ChordW, row.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void KeyButtonClick_EscapeCapture_StillClosesInstructionDialog()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings { WireInstructions = true, NextInstructionContext = 9u };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(null); // Escape sentinel
|
|
|
|
Assert.Equal(new[] { 9u }, fake.InstructionCloses);
|
|
Assert.Empty(fake.MappedSets);
|
|
}
|
|
|
|
[Fact]
|
|
public void KeyButtonClick_InstructionDialogUnavailable_DoesNotArmCapture()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings { WireInstructions = true, NextInstructionContext = 0u };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
|
|
// Retail refuses to register the input handler when OpenMapWarnDialog
|
|
// fails; the capture must not be armed either.
|
|
Assert.Null(fake.PendingCapture);
|
|
Assert.Empty(fake.InstructionCloses);
|
|
}
|
|
|
|
[Fact]
|
|
public void Bind_ResolvesTheRowTemplatesAuthoredCaptionFont_OncePerTemplate()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
Row(0x4, 0x2A, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
var requests = new List<(uint LayoutId, uint ElementId)>();
|
|
KeyboardConfigController? controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings(),
|
|
resolveTemplateFont: (layoutId, elementId) =>
|
|
{
|
|
requests.Add((layoutId, elementId));
|
|
return null; // UiDatFont needs GPU atlases — the call contract is the assertion.
|
|
});
|
|
|
|
Assert.NotNull(controller);
|
|
// The authored action-row template (0x21000009 element 0x1000002F,
|
|
// FontDid 0x4000000A — live-DAT probed 2026-08-14) is resolved exactly
|
|
// once, not once per row: the per-template cache absorbs row N > 1.
|
|
(uint LayoutId, uint ElementId) single = Assert.Single(requests);
|
|
Assert.Equal(KeyboardConfigController.LayoutId, single.LayoutId);
|
|
Assert.Equal(0x1000002Fu, single.ElementId);
|
|
}
|
|
|
|
[Fact]
|
|
public void KeyButtonRightClick_ErasesThatSlot()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding>
|
|
{
|
|
new(ChordW, InputAction.MovementForward),
|
|
new(ChordUp, InputAction.MovementForward),
|
|
};
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
Assert.Equal(2, row.Model.Current.Count);
|
|
|
|
row.KeyButtons[0].OnRightClick!.Invoke();
|
|
|
|
Assert.Single(row.Model.Current);
|
|
Assert.DoesNotContain(ChordW, row.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void KeyButtonRightClick_OnAlreadyEmptySlot_IsANoOp()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
Assert.Empty(row.Model.Current);
|
|
|
|
row.KeyButtons[0].OnRightClick!.Invoke();
|
|
|
|
Assert.Empty(row.Model.Current);
|
|
Assert.Empty(fake.MappedSets);
|
|
}
|
|
|
|
/// <summary>Retail SetBinding clamps a requested slot past the dense
|
|
/// current-list tail to Count. Mapping 3 on an empty row therefore appends
|
|
/// at Mapping 1.</summary>
|
|
[Fact]
|
|
public void KeyButtonClick_PastDenseTail_AppendsAtFirstAvailableButton()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
Assert.Equal(3, row.KeyButtons.Count);
|
|
Assert.Empty(row.Model.Current);
|
|
|
|
row.KeyButtons[2].OnClick!.Invoke(); // "Mapping 3"
|
|
fake.Capture(ChordW);
|
|
|
|
Assert.Equal("W", row.KeyButtons[0].Label);
|
|
Assert.Null(row.KeyButtons[1].Label);
|
|
Assert.Null(row.KeyButtons[2].Label);
|
|
|
|
(InputAction Action, IReadOnlyList<Binding> Value) written = Assert.Single(fake.MappedSets);
|
|
Binding onlyBinding = Assert.Single(written.Value);
|
|
Assert.Equal(ChordW, onlyBinding.Chord);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_ConflictWithAnotherRow_OpensConfirmDialog_AcceptReassigns()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement), // MovementForward
|
|
Row(0x4, 0x2A, RetailActionClass.Movement), // MovementBackup — will hold ChordA
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementBackup] = new List<Binding> { new(ChordA, InputAction.MovementBackup) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(r => r.ActionId == 0x29u);
|
|
KeyboardConfigController.RowView backup = controller.Rows.Single(r => r.ActionId == 0x2Au);
|
|
|
|
forward.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordA); // steal MovementBackup's chord
|
|
|
|
// M3: nothing is applied yet — a confirm dialog is pending.
|
|
Assert.NotNull(fake.PendingConfirm);
|
|
Assert.Equal("overwrite A Action 2A", fake.PendingConfirm?.Message);
|
|
Assert.DoesNotContain(ChordA, forward.Model.Current);
|
|
Assert.Contains(ChordA, backup.Model.Current);
|
|
Assert.Empty(fake.Messages);
|
|
|
|
fake.RespondToConfirm(true);
|
|
|
|
Assert.Contains(ChordA, forward.Model.Current);
|
|
Assert.DoesNotContain(ChordA, backup.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_BareShiftConflictWithRetailWalkMode_AlwaysPrompts()
|
|
{
|
|
var shift = new KeyChord(
|
|
Silk.NET.Input.Key.ShiftLeft,
|
|
ModifierMask.None);
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement), // Move forward
|
|
Row(0x4, 0x32, RetailActionClass.Movement), // Toggle walk/run
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementWalkMode] =
|
|
[new Binding(
|
|
shift,
|
|
InputAction.MovementWalkMode,
|
|
ActivationType.Hold,
|
|
InputScope.Game)];
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout,
|
|
snapshot,
|
|
MakeTemplateResolver(),
|
|
ResolveSyntheticString,
|
|
fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(
|
|
row => row.ActionId == 0x29u);
|
|
forward.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(shift);
|
|
|
|
Assert.NotNull(fake.PendingConfirm);
|
|
Assert.DoesNotContain(shift, forward.Model.Current);
|
|
Assert.Equal(
|
|
[shift],
|
|
controller.Rows.Single(row => row.ActionId == 0x32u).Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_ConflictWithMultipleRows_UsesRetailPluralBindingList()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
Row(0x4, 0x2A, RetailActionClass.Movement),
|
|
Row(0x4, 0x2B, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementBackup] =
|
|
new List<Binding> { new(ChordA, InputAction.MovementBackup) };
|
|
fake.Mapped[InputAction.MovementStop] =
|
|
new List<Binding> { new(ChordA, InputAction.MovementStop) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
controller.Rows.Single(row => row.ActionId == 0x29u).KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordA);
|
|
|
|
Assert.Equal(
|
|
"overwrite A\nAction 2A (A)\nAction 2B (A)",
|
|
fake.PendingConfirm?.Message);
|
|
}
|
|
|
|
[Fact]
|
|
public void Refresh_UsesRetailExistingAndNewBindingTooltipTemplates()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] =
|
|
new List<Binding> { new(ChordW, InputAction.MovementForward) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = Assert.Single(controller.Rows);
|
|
Assert.Equal("(W) existing binding", row.KeyButtons[0].TooltipText);
|
|
Assert.Equal("new binding", row.KeyButtons[1].TooltipText);
|
|
Assert.Equal("new binding", row.KeyButtons[2].TooltipText);
|
|
|
|
row.KeyButtons[0].OnRightClick!.Invoke();
|
|
Assert.Equal("new binding", row.KeyButtons[0].TooltipText);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_ChordAlreadyInAnotherSlotOfSameRow_IsRetailNoOp()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding>
|
|
{
|
|
new(ChordW, InputAction.MovementForward),
|
|
new(ChordUp, InputAction.MovementForward),
|
|
};
|
|
// Prove retail's same-row early return happens before the
|
|
// non-user-bindable conflict check too.
|
|
fake.Mapped[InputAction.AcdreamToggleAudioMute] = new List<Binding>
|
|
{
|
|
new(ChordW, InputAction.AcdreamToggleAudioMute),
|
|
};
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = Assert.Single(controller.Rows);
|
|
row.KeyButtons[2].OnClick!.Invoke();
|
|
fake.Capture(ChordW);
|
|
|
|
Assert.Equal(new[] { ChordW, ChordUp }, row.Model.Current);
|
|
Assert.Null(fake.PendingConfirm);
|
|
Assert.Empty(fake.Messages);
|
|
Assert.Empty(fake.MappedSets);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_LeftOrRightMouseButton_RemainsArmedUntilSupportedInput()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings { WireInstructions = true };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = Assert.Single(controller.Rows);
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(LeftMouse);
|
|
|
|
Assert.NotNull(fake.PendingCapture);
|
|
Assert.Empty(fake.InstructionCloses);
|
|
Assert.Empty(row.Model.Current);
|
|
|
|
fake.Capture(ChordW);
|
|
|
|
Assert.Null(fake.PendingCapture);
|
|
Assert.Equal(new[] { ChordW }, row.Model.Current);
|
|
Assert.Equal(new[] { 7u }, fake.InstructionCloses);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_ConflictWithAnotherRow_DeclineLeavesBothRowsUnchanged()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
Row(0x4, 0x2A, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding> { new(ChordW, InputAction.MovementForward) };
|
|
fake.Mapped[InputAction.MovementBackup] = new List<Binding> { new(ChordA, InputAction.MovementBackup) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(r => r.ActionId == 0x29u);
|
|
KeyboardConfigController.RowView backup = controller.Rows.Single(r => r.ActionId == 0x2Au);
|
|
|
|
forward.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordA);
|
|
fake.RespondToConfirm(false);
|
|
|
|
Assert.Equal(new[] { ChordW }, forward.Model.Current); // untouched
|
|
Assert.Equal(new[] { ChordA }, backup.Model.Current); // untouched
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_SharedChordAcrossNonConflictingCombatContexts_KeepsBothBindings()
|
|
{
|
|
const uint meleeMap = 0x10000003u;
|
|
const uint missileMap = 0x10000004u;
|
|
var conflicts = new Dictionary<uint, IReadOnlySet<uint>>
|
|
{
|
|
[meleeMap] = new HashSet<uint> { meleeMap },
|
|
[missileMap] = new HashSet<uint> { missileMap },
|
|
};
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(meleeMap, 0x1000005Du, RetailActionClass.Combat),
|
|
Row(missileMap, 0x100000F1u, RetailActionClass.Combat),
|
|
}, conflicts);
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.CombatAimLow] =
|
|
new List<Binding> { new(ChordA, InputAction.CombatAimLow, Scope: InputScope.MissileCombat) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView melee = controller.Rows.Single(
|
|
row => row.InputMapId == meleeMap);
|
|
KeyboardConfigController.RowView missile = controller.Rows.Single(
|
|
row => row.InputMapId == missileMap);
|
|
melee.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordA);
|
|
|
|
Assert.Null(fake.PendingConfirm);
|
|
Assert.Contains(ChordA, melee.Model.Current);
|
|
Assert.Contains(ChordA, missile.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_SharedChordAcrossDatConflictingContexts_StillPrompts()
|
|
{
|
|
const uint movementMap = 0x4u;
|
|
const uint uiMap = 0x10000009u;
|
|
var conflicts = new Dictionary<uint, IReadOnlySet<uint>>
|
|
{
|
|
[movementMap] = new HashSet<uint> { movementMap, uiMap },
|
|
};
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(movementMap, 0x29u, RetailActionClass.Movement),
|
|
Row(uiMap, 0x10000019u, RetailActionClass.Ui),
|
|
}, conflicts);
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.ToggleInventoryPanel] =
|
|
new List<Binding> { new(ChordA, InputAction.ToggleInventoryPanel) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView movement = controller.Rows.Single(
|
|
row => row.InputMapId == movementMap);
|
|
movement.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordA);
|
|
|
|
Assert.NotNull(fake.PendingConfirm);
|
|
Assert.DoesNotContain(ChordA, movement.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void Capture_ConflictWithNonBindableAcdreamAction_ShowsRetailMessageDialog()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
// AcdreamToggleAudioMute has no RetailActionIdentityTable row at all.
|
|
var muteChord = new KeyChord(Silk.NET.Input.Key.M, ModifierMask.Ctrl);
|
|
fake.Mapped[InputAction.AcdreamToggleAudioMute] =
|
|
new List<Binding> { new(muteChord, InputAction.AcdreamToggleAudioMute) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single();
|
|
forward.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(muteChord);
|
|
|
|
// S1: refused outright, with the distinct retail message dialog and no
|
|
// overwrite-confirmation dialog.
|
|
Assert.Null(fake.PendingConfirm);
|
|
Assert.DoesNotContain(muteChord, forward.Model.Current);
|
|
Assert.Contains(fake.Messages, message => message.Contains("cannot overwrite"));
|
|
Assert.Equal(muteChord, Assert.Single(fake.Mapped[InputAction.AcdreamToggleAudioMute]).Chord);
|
|
}
|
|
|
|
/// <summary>S1: retail checks the non-user-bindable target BEFORE any
|
|
/// user-bindable row conflict, even when both exist for the same chord.</summary>
|
|
[Fact]
|
|
public void Capture_ConflictWithBothARowAndANonBindableAction_NonBindableWins()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
Row(0x4, 0x2A, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
var sharedChord = new KeyChord(Silk.NET.Input.Key.M, ModifierMask.Ctrl);
|
|
fake.Mapped[InputAction.MovementBackup] = new List<Binding> { new(sharedChord, InputAction.MovementBackup) };
|
|
fake.Mapped[InputAction.AcdreamToggleAudioMute] =
|
|
new List<Binding> { new(sharedChord, InputAction.AcdreamToggleAudioMute) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(r => r.ActionId == 0x29u);
|
|
forward.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(sharedChord);
|
|
|
|
Assert.Null(fake.PendingConfirm);
|
|
Assert.Contains(fake.Messages, message => message.Contains("cannot overwrite"));
|
|
Assert.DoesNotContain(sharedChord, forward.Model.Current);
|
|
}
|
|
|
|
[Fact]
|
|
public void OkButton_AppliesCommitsSavesAndToggles()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordW);
|
|
Assert.True(row.Model.Changed);
|
|
|
|
UiButton ok = (UiButton)layout.FindElement(0x1000002Cu)!;
|
|
ok.OnClick!.Invoke();
|
|
|
|
Assert.False(row.Model.Changed); // Apply committed saved=current
|
|
Assert.Equal(1, fake.SaveCalls);
|
|
Assert.Equal(1, fake.ToggleCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public void LoadFile_ReplacesRowsAndRevertBaseline_AndRefreshesFilename()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] =
|
|
[new Binding(ChordW, InputAction.MovementForward)];
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString,
|
|
fake.ToProfileBindings())!;
|
|
|
|
((UiButton)layout.FindElement(0x10000027u)!).OnClick!.Invoke();
|
|
Assert.NotNull(fake.PendingLoadCompleted);
|
|
|
|
fake.Mapped[InputAction.MovementForward] =
|
|
[new Binding(ChordUp, InputAction.MovementForward)];
|
|
fake.CurrentKeymapFilename = "friends.keymap";
|
|
fake.PendingLoadCompleted!();
|
|
|
|
ActionKeyMapOptionRow row = controller.Rows.Single().Model;
|
|
Assert.Equal(new[] { ChordUp }, row.Current);
|
|
Assert.Equal(new[] { ChordUp }, row.Saved);
|
|
Assert.False(row.Changed);
|
|
UiText filename = (UiText)layout.FindElement(0x10000028u)!;
|
|
Assert.Equal("friends.keymap", Assert.Single(filename.LinesProvider()).Text);
|
|
}
|
|
|
|
[Fact]
|
|
public void SaveAs_RefreshesActiveFilenameOnlyAfterSuccessfulCallback()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
_ = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString,
|
|
fake.ToProfileBindings());
|
|
UiText filename = (UiText)layout.FindElement(0x10000028u)!;
|
|
|
|
((UiButton)layout.FindElement(0x10000029u)!).OnClick!.Invoke();
|
|
Assert.NotNull(fake.PendingSaveCompleted);
|
|
Assert.Equal("acdream.keymap", Assert.Single(filename.LinesProvider()).Text);
|
|
|
|
fake.CurrentKeymapFilename = "alternate.keymap";
|
|
fake.PendingSaveCompleted!();
|
|
Assert.Equal("alternate.keymap", Assert.Single(filename.LinesProvider()).Text);
|
|
}
|
|
|
|
[Fact]
|
|
public void RevertButton_IsEnabledExactlyWhileWorkingMapDiffersFromSavedMap()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] =
|
|
new List<Binding> { new(ChordW, InputAction.MovementForward) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
UiButton revert = (UiButton)layout.FindElement(0x1000002Bu)!;
|
|
|
|
// gmKeyboardUI::OnOptionChanged @ 0x004DA890: Ghosted while clean.
|
|
Assert.False(revert.Enabled);
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordUp);
|
|
Assert.True(controller.Page.Changed);
|
|
Assert.True(revert.Enabled);
|
|
|
|
revert.OnClick!.Invoke();
|
|
Assert.Equal(new[] { ChordW }, row.Model.Current);
|
|
Assert.False(controller.Page.Changed);
|
|
Assert.False(revert.Enabled);
|
|
|
|
// Defaults is also a live uncommitted edit when the DAT default does
|
|
// not equal the saved user map, and therefore re-enables Revert.
|
|
UiButton defaults = (UiButton)layout.FindElement(0x1000002Au)!;
|
|
defaults.OnClick!.Invoke();
|
|
Assert.True(controller.Page.Changed);
|
|
Assert.True(revert.Enabled);
|
|
|
|
UiButton ok = (UiButton)layout.FindElement(0x1000002Cu)!;
|
|
ok.OnClick!.Invoke();
|
|
Assert.False(controller.Page.Changed);
|
|
Assert.False(revert.Enabled);
|
|
}
|
|
|
|
[Fact]
|
|
public void CancelButton_RevertsUncommittedEditAndToggles()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x29, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding> { new(ChordW, InputAction.MovementForward) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordUp); // now [Up] uncommitted (slot 0 replaced)
|
|
|
|
UiButton cancel = (UiButton)layout.FindElement(0x1000002Du)!;
|
|
cancel.OnClick!.Invoke();
|
|
|
|
Assert.Equal(new[] { ChordW }, row.Model.Current); // reverted to Saved
|
|
Assert.Equal(1, fake.ToggleCalls);
|
|
Assert.Equal(0, fake.SaveCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public void DefaultsButton_RestoresDatDefaultLive_WithoutCommitting()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement, defaults:
|
|
new[] { new RetailKeyChord(0x11, 0, 0, 3) }), // DIK_W
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementForward] = new List<Binding> { new(ChordUp, InputAction.MovementForward) };
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
Assert.Equal(new[] { ChordUp }, row.Model.Current);
|
|
|
|
UiButton defaultsButton = (UiButton)layout.FindElement(0x1000002Au)!;
|
|
defaultsButton.OnClick!.Invoke();
|
|
|
|
Assert.Equal(new[] { ChordW }, row.Model.Current);
|
|
Assert.True(row.Model.Changed); // live but uncommitted, matching retail
|
|
}
|
|
|
|
/// <summary>M1 (2026-08-11 review): Defaults must restore the DAT-sourced
|
|
/// KEY only — the row's live Activation/Scope (Hold + MeleeCombat here,
|
|
/// captured from the action's live binding at build time) must survive the
|
|
/// click unchanged, across the FULL 306-row shape this test represents with
|
|
/// one Hold+scoped action.</summary>
|
|
[Fact]
|
|
public void DefaultsButton_PreservesActivationAndScope_ForAHoldScopedAction()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x10000003, 0x1000005D, RetailActionClass.Combat, defaults:
|
|
new[] { new RetailKeyChord(0xD3, 0, 0, 3) }), // CombatLowAttack, DIK_DELETE
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.CombatLowAttack] = new List<Binding>
|
|
{
|
|
new(ChordUp, InputAction.CombatLowAttack, ActivationType.Hold, InputScope.MeleeCombat),
|
|
};
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
UiButton defaultsButton = (UiButton)layout.FindElement(0x1000002Au)!;
|
|
defaultsButton.OnClick!.Invoke();
|
|
|
|
(InputAction Action, IReadOnlyList<Binding> Value) written = Assert.Single(fake.MappedSets);
|
|
Assert.Equal(InputAction.CombatLowAttack, written.Action);
|
|
Binding result = Assert.Single(written.Value);
|
|
Assert.Equal(Silk.NET.Input.Key.Delete, result.Chord.Key); // the DAT default key
|
|
Assert.Equal(ActivationType.Hold, result.Activation); // preserved, not reset to Press
|
|
Assert.Equal(InputScope.MeleeCombat, result.Scope); // preserved, not reset to Game
|
|
}
|
|
|
|
/// <summary>M1: Cancel/Revert (RestoreSavedValue) must ALSO preserve
|
|
/// Activation/Scope, not just Defaults.</summary>
|
|
[Fact]
|
|
public void CancelButton_PreservesActivationAndScope()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[] { Row(0x4, 0x32, RetailActionClass.Movement) });
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.MovementWalkMode] = new List<Binding>
|
|
{
|
|
new(ChordW, InputAction.MovementWalkMode, ActivationType.Hold, InputScope.Game),
|
|
};
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView row = controller.Rows.Single();
|
|
row.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordUp); // uncommitted edit
|
|
|
|
UiButton cancel = (UiButton)layout.FindElement(0x1000002Du)!;
|
|
cancel.OnClick!.Invoke();
|
|
|
|
// MappedSets also carries the capture's own write (ChordUp) before the
|
|
// revert — take the LAST write, which is Cancel's RestoreSavedValue.
|
|
(InputAction Action, IReadOnlyList<Binding> Value) written = fake.MappedSets[^1];
|
|
Binding result = Assert.Single(written.Value);
|
|
Assert.Equal(ChordW, result.Chord); // reverted to saved
|
|
Assert.Equal(ActivationType.Hold, result.Activation);
|
|
}
|
|
|
|
/// <summary>M2 (2026-08-11 review): InputMap 0x6 (CameraAlternateControls) no
|
|
/// longer aliases InputMap 0x5's (CameraControls) InputAction — each row is
|
|
/// independent, so rebinding one never clobbers the other, and a row cannot
|
|
/// conflict with its own former twin.</summary>
|
|
[Fact]
|
|
public void CameraContext5And6_AreIndependentRows_NotAliased()
|
|
{
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x5, 0x35, RetailActionClass.Camera, defaults: new[] { new RetailKeyChord(0x4B, 0, 0, 3) }),
|
|
Row(0x6, 0x35, RetailActionClass.Camera, defaults: new[] { new RetailKeyChord(0xCB, 0, 0, 3) }),
|
|
});
|
|
var fake = new FakeBindings();
|
|
fake.Mapped[InputAction.CameraRotateLeft] =
|
|
[new Binding(ChordA, InputAction.CameraRotateLeft)];
|
|
fake.Mapped[InputAction.CameraAlternateRotateLeft] =
|
|
[new Binding(
|
|
ChordUp,
|
|
InputAction.CameraAlternateRotateLeft,
|
|
Scope: InputScope.Camera)];
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView ctx5 = controller.Rows.Single(r => r.InputMapId == 0x5u);
|
|
KeyboardConfigController.RowView ctx6 = controller.Rows.Single(r => r.InputMapId == 0x6u);
|
|
|
|
Assert.Equal(InputAction.CameraRotateLeft, ctx5.MappedAction);
|
|
Assert.Equal(InputAction.CameraAlternateRotateLeft, ctx6.MappedAction);
|
|
|
|
// Both rows display their independent live bindings.
|
|
Assert.NotEmpty(ctx6.Model.Current);
|
|
var ctx6InitialDisplay = ctx6.Model.Current.ToArray();
|
|
|
|
// Rebinding ctx5's row must not touch ctx6's display or storage.
|
|
ctx5.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordW);
|
|
Assert.Contains(ChordW, ctx5.Model.Current);
|
|
Assert.Equal(ctx6InitialDisplay, ctx6.Model.Current); // unchanged by ctx5's edit
|
|
Assert.Empty(fake.Unmapped);
|
|
|
|
ctx6.KeyButtons[0].OnClick!.Invoke();
|
|
fake.Capture(ChordA);
|
|
Assert.Contains(ChordA, ctx6.Model.Current);
|
|
Assert.Contains(ChordW, ctx5.Model.Current); // ctx5 unaffected by ctx6's edit
|
|
Assert.Contains(fake.MappedSets, write =>
|
|
write.Action == InputAction.CameraAlternateRotateLeft
|
|
&& write.Value.Any(binding => binding.Chord == ChordA));
|
|
}
|
|
|
|
[Fact]
|
|
public void Bind_MissingWindowRoot_ReturnsNull()
|
|
{
|
|
ElementInfo empty = new() { Id = 0x99999999u, Type = 3 };
|
|
ImportedLayout emptyLayout = LayoutImporter.Build(empty, NoTex, null);
|
|
var snapshot = new RetailActionMapSnapshot(Array.Empty<RetailActionMapRow>());
|
|
var fake = new FakeBindings();
|
|
|
|
KeyboardConfigController? controller = KeyboardConfigController.Bind(
|
|
emptyLayout, snapshot, (_, _) => null, (_, _) => null, fake.ToBindings());
|
|
|
|
Assert.Null(controller);
|
|
}
|
|
|
|
// ── OP8 re-review round 2: identity-map injectivity is load-bearing for
|
|
// BOTH M1 (per-row activation capture) and M2 (no dual rows editing one
|
|
// action) — pin it so a future mapping addition cannot silently alias. ──
|
|
|
|
[Fact]
|
|
public void IdentityMap_IsInjective_NoTwoRowsShareOneInputAction()
|
|
{
|
|
var seen = new Dictionary<InputAction, (uint MapId, uint ActionId)>();
|
|
foreach (((uint mapId, uint actionId), InputAction action) in RetailActionIdentityTable.Map)
|
|
{
|
|
Assert.False(
|
|
seen.TryGetValue(action, out (uint MapId, uint ActionId) prior),
|
|
$"InputAction.{action} is mapped by BOTH (0x{prior.MapId:X}, 0x{prior.ActionId:X}) "
|
|
+ $"and (0x{mapId:X}, 0x{actionId:X}) — aliasing reintroduces the M2 twin-row clobber.");
|
|
seen[action] = (mapId, actionId);
|
|
}
|
|
Assert.Equal(306, seen.Count);
|
|
}
|
|
|
|
// ── AD-78 caption dimming (user-directed, 2026-08-11, gate 2) ───────────
|
|
|
|
[Fact]
|
|
public void EveryRetailRowCaptionIsEnabled()
|
|
{
|
|
// Campaign KB removes AP-203's store-only set. Every DAT row now has
|
|
// a live dispatcher identity and uses the enabled retail caption color.
|
|
var snapshot = new RetailActionMapSnapshot(new[]
|
|
{
|
|
Row(0x4, 0x29, RetailActionClass.Movement), // -> MovementForward (mapped)
|
|
Row(0x10000006, 0x100000A0, RetailActionClass.Emote), // -> EmoteBowDeep
|
|
});
|
|
|
|
ImportedLayout layout = FixtureLoader.LoadKeyboardConfig();
|
|
var fake = new FakeBindings();
|
|
KeyboardConfigController controller = KeyboardConfigController.Bind(
|
|
layout, snapshot, MakeTemplateResolver(), ResolveSyntheticString, fake.ToBindings())!;
|
|
|
|
KeyboardConfigController.RowView forward = controller.Rows.Single(r => r.ActionId == 0x29u);
|
|
Assert.NotNull(forward.MappedAction);
|
|
UiText forwardCaption = RowCaption(forward);
|
|
Assert.Equal(Vector4.One, forwardCaption.DefaultColor);
|
|
|
|
KeyboardConfigController.RowView bowDeep = controller.Rows.Single(r => r.ActionId == 0x100000A0u);
|
|
Assert.Equal(InputAction.EmoteBowDeep, bowDeep.MappedAction);
|
|
UiText bowDeepCaption = RowCaption(bowDeep);
|
|
Assert.Equal(Vector4.One, bowDeepCaption.DefaultColor);
|
|
}
|
|
|
|
/// <summary>The row's synthesized caption (composed beside the authored key
|
|
/// buttons -- see KeyboardConfigController's class doc) has no stable dat
|
|
/// element id of its own, so it is located structurally: the ONLY
|
|
/// <see cref="UiText"/> direct child of the key buttons' shared parent
|
|
/// (the row container <c>BuildActionRow</c> builds).</summary>
|
|
private static UiText RowCaption(KeyboardConfigController.RowView row)
|
|
{
|
|
UiElement parent = row.KeyButtons.First().Parent
|
|
?? throw new InvalidOperationException("row's key button has no parent element");
|
|
return parent.Children.OfType<UiText>().Single();
|
|
}
|
|
}
|