feat(runtime): own character selection flow

tests/AcDream.Runtime.Tests/Session/LiveSessionControllerTests.cs

@@ -57,10 +57,13 @@ public sealed class LiveSessionControllerTests
         public bool ThrowOnCreate { get; set; }
         public bool ThrowOnCharacters { get; set; }
         public bool ThrowOnEnterWorld { get; set; }
+        public CharacterError.Parsed? EnterWorldRejection { get; set; }
         public bool ThrowOnTick { get; set; }
         public bool FailDisposeOnce { get; set; }
         public List<WorldSession> Sessions { get; } = [];
         public Dictionary<WorldSession, int> DisposeCounts { get; } = [];
+        public List<(string Account, int ActiveIndex)> DeleteRequests { get; } = [];
+        public List<uint> RestoreRequests { get; } = [];
         public int EnterWorldCount { get; private set; }
         public int TickCount { get; private set; }
 
@@ -98,15 +101,35 @@ public sealed class LiveSessionControllerTests
             return Characters;
         }
 
+        public void StartCharacterSelectionReceive(WorldSession session) =>
+            calls.Add("start-character-selection-receive");
+
         public void EnterWorld(WorldSession session, int activeCharacterIndex)
         {
             calls.Add($"enter:{activeCharacterIndex}");
             EnterWorldCount++;
             OnEnterWorld?.Invoke();
+            if (EnterWorldRejection is { } rejection)
+                throw new CharacterSelectionRejectedException(rejection);
             if (ThrowOnEnterWorld)
                 throw new InvalidOperationException("enter failure");
         }
 
+        public void DeleteCharacter(
+            WorldSession session,
+            string accountName,
+            int activeCharacterIndex)
+        {
+            calls.Add($"delete:{activeCharacterIndex}");
+            DeleteRequests.Add((accountName, activeCharacterIndex));
+        }
+
+        public void RestoreCharacter(WorldSession session, uint characterId)
+        {
+            calls.Add($"restore:{characterId:X8}");
+            RestoreRequests.Add(characterId);
+        }
+
         public void Tick(WorldSession session)
         {
             calls.Add("tick");
@@ -340,6 +363,179 @@ public sealed class LiveSessionControllerTests
         Assert.True(calls.IndexOf("roster") < calls.IndexOf("selected"));
     }
 
+    [Fact]
+    public void Start_GraphicalNoSelectorStopsBeforeEnterWorldThenTypedEnterContinuesSameScope()
+    {
+        var calls = new List<string>();
+        var operations = new TestOperations(calls);
+        var host = new TestHost(calls);
+        var controller = new LiveSessionController(operations);
+
+        LiveSessionStartResult result = controller.Start(
+            LiveOptions(awaitSelection: true),
+            host);
+
+        Assert.Equal(
+            LiveSessionStartStatus.AwaitingCharacterSelection,
+            result.Status);
+        Assert.False(controller.IsInWorld);
+        Assert.NotNull(controller.CurrentSession);
+        Assert.Equal(0, operations.EnterWorldCount);
+        Assert.False(host.CommandBuses[0].Active);
+        RuntimeGenerationToken generation = controller.Generation;
+        Assert.Equal(
+            RuntimeCharacterSelectionLifecycle.AwaitingSelection,
+            controller.CharacterSelection.Snapshot.Lifecycle);
+
+        // Greyed entries remain highlightable but cannot enter.
+        Assert.True(controller.Highlight(generation, 0x50000001u).Accepted);
+        Assert.Equal(
+            RuntimeCommandStatus.Rejected,
+            controller.Enter(generation).Status);
+        Assert.True(controller.Highlight(generation, 0x50000002u).Accepted);
+        Assert.True(controller.Enter(generation).Accepted);
+
+        Assert.True(controller.IsInWorld);
+        Assert.Equal(1, operations.EnterWorldCount);
+        Assert.Contains("enter:1", calls);
+        Assert.True(host.CommandBuses[0].Active);
+        Assert.Same(operations.Sessions[0], controller.CurrentSession);
+    }
+
+    [Fact]
+    public void Start_ExplicitSelectorStillEntersWhenGraphicalPauseFlagIsSet()
+    {
+        var calls = new List<string>();
+        var operations = new TestOperations(calls);
+        var host = new TestHost(calls);
+        var controller = new LiveSessionController(operations);
+
+        LiveSessionStartResult result = controller.Start(
+            LiveOptions(
+                selector: new LiveSessionCharacterSelector(
+                    CharacterId: 0x50000002u),
+                awaitSelection: true),
+            host);
+
+        Assert.Equal(LiveSessionStartStatus.Connected, result.Status);
+        Assert.True(controller.IsInWorld);
+        Assert.Equal(1, operations.EnterWorldCount);
+    }
+
+    [Fact]
+    public void EnterRejection_SurfacesErrorAndKeepsExactPreWorldScopeRetryable()
+    {
+        var calls = new List<string>();
+        var operations = new TestOperations(calls)
+        {
+            EnterWorldRejection = new CharacterError.Parsed(
+                (uint)CharacterError.Code.EnterGameCharacterLocked),
+        };
+        var host = new TestHost(calls);
+        var controller = new LiveSessionController(operations);
+        Assert.Equal(
+            LiveSessionStartStatus.AwaitingCharacterSelection,
+            controller.Start(LiveOptions(awaitSelection: true), host).Status);
+        RuntimeGenerationToken generation = controller.Generation;
+        WorldSession session = controller.CurrentSession!;
+
+        Assert.Equal(
+            RuntimeCommandStatus.Rejected,
+            controller.Enter(generation).Status);
+        Assert.Same(session, controller.CurrentSession);
+        Assert.Equal(generation, controller.Generation);
+        Assert.False(controller.IsInWorld);
+        RuntimeCharacterSelectionSnapshot rejected =
+            controller.CharacterSelection.Snapshot;
+        Assert.Equal(
+            RuntimeCharacterSelectionLifecycle.AwaitingSelection,
+            rejected.Lifecycle);
+        Assert.Equal(
+            CharacterError.Code.EnterGameCharacterLocked,
+            rejected.Error!.Value.Code);
+
+        operations.EnterWorldRejection = null;
+        Assert.True(controller.Enter(generation).Accepted);
+        Assert.True(controller.IsInWorld);
+        Assert.Same(session, controller.CurrentSession);
+    }
+
+    [Fact]
+    public async Task CharacterCommands_UseWireSlotAndRestoreNeverWaitsForReply()
+    {
+        var calls = new List<string>();
+        var operations = new TestOperations(calls);
+        var host = new TestHost(calls);
+        var controller = new LiveSessionController(operations);
+        Assert.Equal(
+            LiveSessionStartStatus.AwaitingCharacterSelection,
+            controller.Start(LiveOptions(awaitSelection: true), host).Status);
+        RuntimeGenerationToken generation = controller.Generation;
+
+        Assert.True(controller.Highlight(generation, 0x50000002u).Accepted);
+        Assert.True(controller.RequestDelete(generation).Accepted);
+        Assert.Equal(0x50000002u,
+            controller.CharacterSelection.Snapshot.PendingDeleteCharacterId);
+        Assert.True(controller.Cancel(generation).Accepted);
+        Assert.True(controller.RequestDelete(generation).Accepted);
+        Assert.True(controller.ConfirmDelete(generation).Accepted);
+        Assert.Equal([("Canonical", 1)], operations.DeleteRequests);
+        Assert.False(controller.CharacterSelection.Snapshot.Buttons.CanEnter);
+        controller.CharacterSelectionState.ApplyDeleteAcknowledged();
+        controller.CharacterSelectionState.ApplyRoster(new LiveSessionRosterReport(
+            "Canonical",
+            11,
+            [
+                new(0x50000001u, "Grey", 10u),
+                new(0x50000002u, "Ready", 1u),
+            ]));
+
+        Assert.True(controller.Highlight(generation, 0x50000001u).Accepted);
+        RuntimeCommandResult restore = await Task.Run(
+                () => controller.Restore(generation))
+            .WaitAsync(TimeSpan.FromSeconds(5));
+        Assert.True(restore.Accepted);
+        Assert.Equal([0x50000001u], operations.RestoreRequests);
+        // ACE may send no response for an unknown guid. The synchronous
+        // command has already returned and does not gate later commands.
+        Assert.True(controller.Highlight(generation, 0x50000002u).Accepted);
+        controller.Tick();
+        Assert.Equal(1, operations.TickCount);
+        Assert.False(controller.IsInWorld);
+    }
+
+    [Fact]
+    public void CharacterCommands_AreGenerationGatedAcrossReconnectAndStop()
+    {
+        var calls = new List<string>();
+        var operations = new TestOperations(calls);
+        var host = new TestHost(calls);
+        var controller = new LiveSessionController(operations);
+        controller.Start(LiveOptions(awaitSelection: true), host);
+        RuntimeGenerationToken first = controller.Generation;
+
+        LiveSessionStartResult reconnect = controller.Reconnect(
+            LiveOptions(awaitSelection: true),
+            host);
+
+        Assert.Equal(
+            LiveSessionStartStatus.AwaitingCharacterSelection,
+            reconnect.Status);
+        Assert.Equal(
+            RuntimeCommandStatus.StaleGeneration,
+            controller.Highlight(first, 0x50000002u).Status);
+        RuntimeGenerationToken second = controller.Generation;
+        Assert.True(controller.Highlight(second, 0x50000002u).Accepted);
+        controller.Stop();
+        Assert.Equal(
+            RuntimeCommandStatus.StaleGeneration,
+            controller.Enter(second).Status);
+        Assert.Equal(
+            RuntimeCharacterSelectionLifecycle.Inactive,
+            controller.CharacterSelection.Snapshot.Lifecycle);
+        Assert.Equal(0, controller.CharacterSelection.Snapshot.RosterCount);
+    }
+
     [Fact]
     public void Start_DisabledAndMissingCredentialsResetButNeverConstructSession()
     {
@@ -1232,7 +1428,8 @@ public sealed class LiveSessionControllerTests
         bool live = true,
         string? user = "user",
         LiveSessionCharacterSelector? selector = null,
-        bool probe = false) =>
+        bool probe = false,
+        bool awaitSelection = false) =>
         new(
             live,
             "127.0.0.1",
@@ -1240,7 +1437,8 @@ public sealed class LiveSessionControllerTests
             user ?? string.Empty,
             "password",
             selector,
-            probe);
+            probe,
+            awaitSelection);
 
     private static CharacterList.Parsed AvailableCharacters() => new(
         0u,

tests/AcDream.Runtime.Tests/Session/RuntimeCharacterSelectionStateTests.cs

@@ -0,0 +1,247 @@
+using AcDream.Core.Net.Messages;
+using AcDream.Runtime;
+using AcDream.Runtime.Session;
+
+namespace AcDream.Runtime.Tests.Session;
+
+public sealed class RuntimeCharacterSelectionStateTests
+{
+    private sealed class Collector : IRuntimeCharacterSelectionVisitor
+    {
+        public List<RuntimeCharacterSelectionEntry> Entries { get; } = [];
+
+        public void Visit(in RuntimeCharacterSelectionEntry character) =>
+            Entries.Add(character);
+    }
+
+    private sealed class Observer(
+        Action<RuntimeCharacterSelectionDelta> onDelta)
+        : IRuntimeCharacterSelectionObserver
+    {
+        public void OnCharacterSelectionChanged(
+            in RuntimeCharacterSelectionDelta delta) =>
+            onDelta(delta);
+    }
+
+    [Fact]
+    public void ApplyRoster_PortsRetailOrderFallbackAndDisabledButtonMatrix()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(7));
+
+        state.ApplyRoster(Roster(
+            new(0x50000001u, "Zulu", 1u),
+            new(0x50000002u, "Bravo", 0u),
+            new(0x50000003u, "Alpha", 0u),
+            new(0x50000004u, "Able", 9u)));
+
+        RuntimeCharacterSelectionSnapshot snapshot = state.Snapshot;
+        Assert.Equal(RuntimeCharacterSelectionLifecycle.AwaitingSelection, snapshot.Lifecycle);
+        // Retail falls back in CharacterSet wire order, independently of the
+        // alphabetized display order.
+        Assert.Equal(0x50000002u, snapshot.HighlightedCharacterId);
+        Assert.True(snapshot.Buttons.CanEnter);
+        Assert.True(snapshot.Buttons.CanDelete);
+        Assert.False(snapshot.Buttons.CanRestore);
+        Assert.True(snapshot.Buttons.DeleteVisible);
+        Assert.False(snapshot.Buttons.RestoreVisible);
+
+        var collector = new Collector();
+        state.View.Visit(collector);
+        Assert.Equal(
+            [
+                (0x50000003u, 2, false),
+                (0x50000002u, 1, false),
+                (0x50000004u, 3, true),
+                (0x50000001u, 0, true),
+            ],
+            collector.Entries.Select(entry =>
+                (entry.CharacterId, entry.ActiveIndex, entry.IsPendingDelete)));
+
+        Assert.True(state.TryHighlight(0x50000004u));
+        snapshot = state.Snapshot;
+        Assert.False(snapshot.Buttons.CanEnter);
+        Assert.False(snapshot.Buttons.CanDelete);
+        Assert.True(snapshot.Buttons.CanRestore);
+        Assert.False(snapshot.Buttons.DeleteVisible);
+        Assert.True(snapshot.Buttons.RestoreVisible);
+    }
+
+    [Fact]
+    public void ApplyRoster_PreservesHighlightedGuidAcrossDeleteRefresh()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(3));
+        state.ApplyRoster(Roster(
+            new(0x50000001u, "One", 0u),
+            new(0x50000002u, "Two", 0u)));
+        Assert.True(state.TryHighlight(0x50000002u));
+        Assert.True(state.TryRequestDelete(out uint requested));
+        Assert.Equal(0x50000002u, requested);
+        Assert.True(state.TryTakeDeleteConfirmation(
+            out RuntimeCharacterSelectionEntry deleted,
+            out string account));
+        Assert.Equal(1, deleted.ActiveIndex);
+        Assert.Equal("Canonical", account);
+
+        state.ApplyDeleteAcknowledged();
+        Assert.Equal(
+            RuntimeCharacterSelectionOperation.DeleteAcknowledged,
+            state.Snapshot.Operation);
+        state.ApplyRoster(Roster(
+            new(0x50000001u, "One", 0u),
+            new(0x50000002u, "Two", 1u)));
+
+        RuntimeCharacterSelectionSnapshot snapshot = state.Snapshot;
+        Assert.Equal(0x50000002u, snapshot.HighlightedCharacterId);
+        Assert.Equal(RuntimeCharacterSelectionOperation.None, snapshot.Operation);
+        Assert.True(snapshot.Buttons.CanRestore);
+        Assert.False(snapshot.Buttons.CanEnter);
+    }
+
+    [Fact]
+    public void DeleteConfirmation_CancelIsIdempotentlyGenerationLocal()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(4));
+        state.ApplyRoster(Roster(
+            new LiveSessionRosterEntry(0x50000001u, "One", 0u)));
+
+        Assert.True(state.TryRequestDelete(out _));
+        Assert.Equal(0x50000001u, state.Snapshot.PendingDeleteCharacterId);
+        Assert.False(state.TryHighlight(0x50000001u));
+        Assert.False(state.BeginEnter(out _));
+        Assert.True(state.Cancel());
+        Assert.Equal(0u, state.Snapshot.PendingDeleteCharacterId);
+        Assert.False(state.Cancel());
+
+        state.Reset(new RuntimeGenerationToken(5));
+        Assert.Equal(RuntimeCharacterSelectionLifecycle.Inactive, state.Snapshot.Lifecycle);
+        Assert.Equal(0, state.Snapshot.RosterCount);
+        Assert.Equal(new RuntimeGenerationToken(5), state.Snapshot.Generation);
+    }
+
+    [Fact]
+    public void Restore_IsFireAndObserveAndSuccessUpdatesTheCanonicalEntry()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(11));
+        state.ApplyRoster(Roster(
+            new LiveSessionRosterEntry(0x50000001u, "Grey", 1u)));
+
+        Assert.True(state.TryBeginRestore(out RuntimeCharacterSelectionEntry request));
+        Assert.Equal(0x50000001u, request.CharacterId);
+        Assert.Equal(
+            RuntimeCharacterSelectionOperation.RestoreRequested,
+            state.Snapshot.Operation);
+        // No response is required to keep using the state. ACE's unknown-guid
+        // branch intentionally sends no reply.
+        Assert.True(state.TryHighlight(0x50000001u));
+
+        state.ApplyRestore(new CharacterRestore.Parsed(
+            VerificationFlag: 1u,
+            Guid: 0x50000001u,
+            Name: "Restored",
+            SecondsGreyedOut: 0u));
+
+        Assert.True(state.View.TryGet(0x50000001u, out var restored));
+        Assert.Equal("Restored", restored.Name);
+        Assert.False(restored.IsPendingDelete);
+        Assert.True(state.Snapshot.Buttons.CanEnter);
+        Assert.Equal(
+            RuntimeCharacterSelectionOperation.RestoreSucceeded,
+            state.Snapshot.Operation);
+    }
+
+    [Fact]
+    public void RestoreResponse_FromSupersededRequestCannotCompleteTheCurrentRequest()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(12));
+        state.ApplyRoster(Roster(
+            new(0x50000001u, "First", 1u),
+            new(0x50000002u, "Second", 1u)));
+
+        Assert.True(state.TryBeginRestore(out _));
+        Assert.True(state.TryHighlight(0x50000002u));
+        Assert.True(state.TryBeginRestore(out _));
+        state.ApplyRestore(new CharacterRestore.Parsed(
+            1u,
+            0x50000001u,
+            "First",
+            0u));
+
+        Assert.Equal(
+            RuntimeCharacterSelectionOperation.RestoreRequested,
+            state.Snapshot.Operation);
+        Assert.True(state.View.TryGet(0x50000001u, out var first));
+        Assert.True(first.IsPendingDelete);
+    }
+
+    [Fact]
+    public void CharacterErrors_MapKnownAndUnknownButNeverPublishNumErrorsSentinel()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(2));
+        state.ApplyRoster(Roster(
+            new LiveSessionRosterEntry(0x50000001u, "One", 0u)));
+        var deltas = new List<RuntimeCharacterSelectionDelta>();
+        using IDisposable subscription = state.View.Subscribe(
+            new Observer(deltas.Add));
+
+        state.ApplyError(new CharacterError.Parsed(
+            (uint)CharacterError.Code.Delete));
+        RuntimeCharacterSelectionError known =
+            Assert.IsType<RuntimeCharacterSelectionError>(state.Snapshot.Error);
+        Assert.Equal(CharacterError.Code.Delete, known.Code);
+        Assert.Contains("delete", known.Message, StringComparison.OrdinalIgnoreCase);
+
+        Assert.True(state.Cancel());
+        state.ApplyError(new CharacterError.Parsed(0xDEADBEEFu));
+        RuntimeCharacterSelectionError unknown =
+            Assert.IsType<RuntimeCharacterSelectionError>(state.Snapshot.Error);
+        Assert.Contains("0xDEADBEEF", unknown.Message, StringComparison.Ordinal);
+
+        long revision = state.Snapshot.Revision;
+        int count = deltas.Count;
+        state.ApplyError(new CharacterError.Parsed(
+            (uint)CharacterError.Code.NumErrors));
+        Assert.Equal(revision, state.Snapshot.Revision);
+        Assert.Equal(count, deltas.Count);
+        Assert.Equal(0xDEADBEEFu, state.Snapshot.Error!.Value.RawCode);
+    }
+
+    [Fact]
+    public void Deltas_AreMonotonicAndReentrantMutationsStayOrdered()
+    {
+        using var state = new RuntimeCharacterSelectionState();
+        state.Begin(new RuntimeGenerationToken(9));
+        var deltas = new List<RuntimeCharacterSelectionDelta>();
+        var observer = new Observer(delta =>
+        {
+            deltas.Add(delta);
+            if (delta.Kind == RuntimeCharacterSelectionDeltaKind.RosterChanged)
+                Assert.True(state.TryHighlight(0x50000002u));
+        });
+        using IDisposable subscription = state.View.Subscribe(observer);
+
+        state.ApplyRoster(Roster(
+            new(0x50000001u, "Ready", 0u),
+            new(0x50000002u, "Grey", 1u)));
+
+        Assert.Equal(
+            [
+                RuntimeCharacterSelectionDeltaKind.RosterChanged,
+                RuntimeCharacterSelectionDeltaKind.HighlightChanged,
+            ],
+            deltas.Select(delta => delta.Kind));
+        Assert.True(deltas[0].Sequence < deltas[1].Sequence);
+        Assert.All(
+            deltas,
+            delta => Assert.Equal(new RuntimeGenerationToken(9), delta.Generation));
+    }
+
+    private static LiveSessionRosterReport Roster(
+        params LiveSessionRosterEntry[] entries) =>
+        new("Canonical", 11, entries);
+}