fix(interaction): close selection lifecycle review gaps

Bind queued actions and pending inventory requests to exact live incarnations, separate optimistic placement from authoritative responses, and serialize retail-style inventory ownership across UI surfaces. Co-authored-by: OpenAI Codex <codex@openai.com>
2026-07-21 09:01:02 +02:00 · 2026-07-21 09:01:02 +02:00 · 5acc3f01cf
commit 5acc3f01cf
parent d2bb5af453
23 changed files with 2635 additions and 168 deletions
--- a/tests/AcDream.App.Tests/Interaction/SelectionInteractionControllerTests.cs
+++ b/tests/AcDream.App.Tests/Interaction/SelectionInteractionControllerTests.cs
@ -26,6 +26,8 @@ public sealed class SelectionInteractionControllerTests
        public bool Hostile { get; set; }
        public bool Useable { get; set; } = true;
        public bool Pickupable { get; set; } = true;
+        public bool CaptureIdentity { get; set; } = true;
+        public uint LocalEntityId { get; set; } = 101u;
        public ClosestCombatTarget? Closest { get; set; }
        public InteractionApproach? Approach { get; set; }
        public List<string> Events { get; } = new();
@ -41,6 +43,11 @@ public sealed class SelectionInteractionControllerTests
            => PickAtCursor(includeSelf);

        public void BeginLightingPulse(uint serverGuid) => Events.Add("pulse");
+        public bool TryCaptureIdentity(uint serverGuid, out uint localEntityId)
+        {
+            localEntityId = LocalEntityId;
+            return CaptureIdentity;
+        }
        public bool IsCurrent(uint serverGuid, uint localEntityId) => Current;
        public string Describe(uint serverGuid) => $"Target {serverGuid:X8}";
        public bool IsCreature(uint serverGuid) => Creature;
@ -100,9 +107,15 @@ public sealed class SelectionInteractionControllerTests
    private sealed class Movement : IPlayerInteractionMovementSink
    {
        public List<InteractionApproach> Approaches { get; } = new();
-        public bool BeginApproach(InteractionApproach approach)
+        public bool Starts { get; set; } = true;
+        public Action? AfterArm { get; set; }
+        public bool BeginApproach(InteractionApproach approach, Action? armAfterCancel = null)
        {
            Approaches.Add(approach);
+            if (!Starts)
+                return false;
+            armAfterCancel?.Invoke();
+            AfterArm?.Invoke();
            return true;
        }
    }
@ -116,6 +129,8 @@ public sealed class SelectionInteractionControllerTests
        public readonly ClientObjectTable Objects = new();
        public readonly List<string> Toasts = new();
        public readonly List<uint> Examines = new();
+        public readonly List<PendingBackpackPlacement> PendingPlacements = new();
+        public readonly List<PendingBackpackPlacement> CancelledPlacements = new();
        public readonly ItemInteractionController Items;
        public readonly SelectionInteractionController Controller;

@ -127,6 +142,12 @@ public sealed class SelectionInteractionControllerTests
                ObjectId = Player,
                Type = ItemType.Creature,
            });
+            Objects.AddOrUpdate(new ClientObject
+            {
+                ObjectId = Target,
+                Name = "Target",
+                Type = ItemType.Misc,
+            });
            Items = new ItemInteractionController(
                Objects,
                () => Player,
@ -148,6 +169,8 @@ public sealed class SelectionInteractionControllerTests
                Transport,
                Movement,
                Toasts.Add);
+            Items.PendingBackpackPlacementRequested += PendingPlacements.Add;
+            Items.PendingBackpackPlacementCancelled += CancelledPlacements.Add;
        }

        public void SetApproach(bool closeRange, uint localEntityId = 101u)
@ -270,12 +293,14 @@ public sealed class SelectionInteractionControllerTests
        h.Selection.Select(Target, SelectionChangeSource.World);
        h.Controller.HandleInputAction(InputAction.SelectionPickUp);
        h.Controller.SendUse(Target);
+        h.Items.InteractionState.EnterExamine();

        h.Controller.ResetSession();
        h.Controller.DrainOutbound();
        h.Controller.OnNaturalMoveToComplete();

        Assert.Null(h.Selection.SelectedObjectId);
+        Assert.False(h.Items.IsAnyTargetModeActive);
        Assert.Empty(h.Transport.Pickups);
        Assert.Empty(h.Transport.Uses);
    }
@ -305,6 +330,216 @@ public sealed class SelectionInteractionControllerTests
        Assert.Empty(h.Transport.Uses);
    }

+    [Fact]
+    public void SynchronousNaturalCompletionObservesTheArmedCloseAction()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        h.Movement.AfterArm = h.Controller.OnNaturalMoveToComplete;
+
+        h.Controller.SendUse(Target);
+        h.Controller.OnNaturalMoveToComplete();
+
+        Assert.Equal(new[] { Target }, h.Transport.Uses);
+    }
+
+    [Fact]
+    public void SynchronousResetCannotResurrectTheCloseAction()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        h.Movement.AfterArm = h.Controller.ResetSession;
+
+        h.Controller.SendUse(Target);
+        h.Controller.OnNaturalMoveToComplete();
+
+        Assert.Empty(h.Transport.Uses);
+    }
+
+    [Fact]
+    public void CancelledClosePickupWithdrawsPresentationAndNeverFiresLater()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+
+        Assert.True(h.Items.PlaceWorldItemInBackpack(Target));
+        Assert.Single(h.PendingPlacements);
+        Assert.Empty(h.Transport.Pickups);
+
+        h.Controller.OnMoveToCancelled(WeenieError.ActionCancelled);
+        h.Controller.OnNaturalMoveToComplete();
+
+        Assert.Equal(new[] { Target }, h.CancelledPlacements.Select(p => p.ItemId));
+        Assert.Empty(h.Transport.Pickups);
+    }
+
+    [Fact]
+    public void ErrorCompletionClearsCloseActionBeforeALaterSuccess()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        h.Controller.SendUse(Target);
+
+        h.Controller.OnMoveToCancelled(WeenieError.NoObject);
+        h.Controller.OnNaturalMoveToComplete();
+
+        Assert.Empty(h.Transport.Uses);
+    }
+
+    [Fact]
+    public void FailedClosePickupStartWithdrawsPresentation()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        h.Movement.Starts = false;
+
+        Assert.True(h.Items.PlaceWorldItemInBackpack(Target));
+
+        Assert.Single(h.PendingPlacements);
+        Assert.Equal(new[] { Target }, h.CancelledPlacements.Select(p => p.ItemId));
+        Assert.Empty(h.Transport.Pickups);
+    }
+
+    [Theory]
+    [InlineData(false)]
+    [InlineData(true)]
+    public void InvalidKeyboardPickupNeverPublishesAWaitingSlot(bool creature)
+    {
+        var h = new Harness();
+        h.Query.Creature = creature;
+        h.Query.Pickupable = false;
+        h.Selection.Select(Target, SelectionChangeSource.World);
+
+        h.Controller.HandleInputAction(InputAction.SelectionPickUp);
+        h.Controller.DrainOutbound();
+
+        Assert.Empty(h.PendingPlacements);
+        Assert.Empty(h.Transport.Pickups);
+    }
+
+    [Theory]
+    [InlineData(InputAction.SelectDblLeft)]
+    [InlineData(InputAction.UseSelected)]
+    [InlineData(InputAction.SelectionPickUp)]
+    public void QueuedWorldActionCannotCrossAnIncarnationBoundary(InputAction action)
+    {
+        var h = new Harness();
+        h.Query.Picked = Target;
+        h.SetApproach(closeRange: false);
+        h.Selection.Select(Target, SelectionChangeSource.World);
+
+        h.Controller.HandleInputAction(action);
+        h.Query.Current = false;
+        h.Controller.DrainOutbound();
+
+        Assert.Empty(h.Transport.Uses);
+        Assert.Empty(h.Transport.Pickups);
+        Assert.Empty(h.PendingPlacements);
+    }
+
+    [Fact]
+    public void DragReleasePulsesTheDropTargetWithoutChangingSelection()
+    {
+        var h = new Harness();
+        h.Query.Picked = Target;
+        const uint item = 0x7000_0002u;
+        h.Objects.AddOrUpdate(new ClientObject
+        {
+            ObjectId = item,
+            Name = "Dragged",
+            Type = ItemType.Misc,
+        });
+        var payload = new ItemDragPayload(
+            item,
+            ItemDragSource.Inventory,
+            SourceSlot: 0,
+            new UiItemSlot());
+
+        h.Controller.PlaceDraggedItem(payload, 10f, 20f);
+
+        Assert.Contains("pulse", h.Query.Events);
+        Assert.Null(h.Selection.SelectedObjectId);
+    }
+
+    [Fact]
+    public void RejectedTargetModeClickConsumesTheFollowingDoubleClick()
+    {
+        var h = new Harness();
+        h.Query.Picked = Target;
+        h.Objects.Remove(Target);
+        h.Items.InteractionState.EnterUse();
+
+        h.Controller.HandleInputAction(InputAction.SelectLeft);
+        h.Controller.HandleInputAction(InputAction.SelectDblLeft);
+        h.Controller.DrainOutbound();
+
+        Assert.Null(h.Selection.SelectedObjectId);
+        Assert.Empty(h.Transport.Uses);
+        Assert.Empty(h.Transport.Pickups);
+    }
+
+    [Fact]
+    public void TransportLossAtClosePickupCompletionWithdrawsPresentation()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        Assert.True(h.Items.PlaceWorldItemInBackpack(Target));
+
+        h.Transport.IsInWorld = false;
+        h.Controller.OnNaturalMoveToComplete();
+
+        Assert.Equal(new[] { Target }, h.CancelledPlacements.Select(p => p.ItemId));
+        Assert.Empty(h.Transport.Pickups);
+    }
+
+    [Fact]
+    public void RepeatedPickupKeepsTheOriginalReservationAndDeferredAction()
+    {
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        Assert.True(h.Items.PlaceWorldItemInBackpack(Target));
+        h.Selection.Select(Target, SelectionChangeSource.World);
+
+        h.Controller.HandleInputAction(InputAction.SelectionPickUp);
+        h.Controller.DrainOutbound();
+
+        Assert.Single(h.PendingPlacements);
+        Assert.Empty(h.CancelledPlacements);
+
+        h.Controller.OnNaturalMoveToComplete();
+        Assert.Equal(new[] { (Target, Player, 0) }, h.Transport.Pickups);
+    }
+
+    [Fact]
+    public void WithdrawnPickupReservationInvalidatesDeferredWireAction()
+    {
+        const uint replacement = 0x7000_0002u;
+        var h = new Harness();
+        h.SetApproach(closeRange: true);
+        h.Objects.AddOrUpdate(new ClientObject
+        {
+            ObjectId = replacement,
+            Name = "Replacement loot",
+            Type = ItemType.Misc,
+        });
+
+        Assert.True(h.Items.PlaceWorldItemInBackpack(Target));
+        Assert.Empty(h.Transport.Pickups);
+        PendingBackpackPlacement original = Assert.Single(h.PendingPlacements);
+        h.Items.CancelPendingBackpackPlacement(Target, original.Token);
+        Assert.True(h.Items.TryBeginPendingBackpackPlacement(
+            replacement,
+            Player,
+            placement: 0,
+            out _));
+
+        h.Controller.OnNaturalMoveToComplete();
+
+        Assert.Empty(h.Transport.Pickups);
+        Assert.True(h.Items.TryGetPendingBackpackPlacement(replacement, out _));
+        Assert.False(h.Items.TryGetPendingBackpackPlacement(Target, out _));
+    }
+
    private static WorldSession.EntitySpawn Spawn(uint guid, ushort instance)
        => new(
            guid,