refactor(D.5.4): rename ItemRepository->ClientObjectTable, ItemInstance->ClientObject

Broaden naming to the data side of every server object (retail weenie_object_table
shape). Pure rename; no behavior change.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

src/AcDream.Core/Items/ClientObjectTable.cs

@@ -0,0 +1,218 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+
+namespace AcDream.Core.Items;
+
+/// <summary>
+/// The client's table of every server object (retail <c>weenie_object_table</c> /
+/// <c>CObjectMaint</c>). Resolve by guid via <c>Get</c>.
+///
+/// <para>
+/// Retail semantics (r06):
+/// <list type="bullet">
+///   <item><description>
+///     Every object is a <see cref="ClientObject"/> with a unique
+///     <c>ObjectId</c>. CreateObject seeds it when the server tells us
+///     the item exists (in our inventory, on the ground, in a
+///     vendor's list, etc).
+///   </description></item>
+///   <item><description>
+///     Moves happen via <see cref="GameEventType"/>-carrying messages:
+///     <c>WieldObject</c>, <c>InventoryPutObjInContainer</c>,
+///     <c>InventoryPutObjectIn3D</c>, <c>ViewContents</c>,
+///     <c>CloseGroundContainer</c>.
+///   </description></item>
+///   <item><description>
+///     <c>InventoryServerSaveFailed</c> reverts a speculative local
+///     state change (e.g. when a drag-drop was rejected server-side).
+///   </description></item>
+/// </list>
+/// </para>
+///
+/// <para>
+/// Thread safety: designed for single-threaded use from the render
+/// thread; the event delegates run synchronously on the caller's
+/// thread. A <see cref="ConcurrentDictionary{TKey,TValue}"/> backs the
+/// map so plugin code can look up items from any thread without
+/// corrupting state.
+/// </para>
+/// </summary>
+public sealed class ClientObjectTable
+{
+    private readonly ConcurrentDictionary<uint, ClientObject> _items = new();
+    private readonly ConcurrentDictionary<uint, Container> _containers = new();
+
+    /// <summary>Fires when an object is first added to the session.</summary>
+    public event Action<ClientObject>? ObjectAdded;
+
+    /// <summary>
+    /// Fires when an object's container / slot changes (moved between
+    /// packs, equipped, unequipped, dropped on ground). Old and new
+    /// container ids are 0 if origin or destination is "world" / "nowhere".
+    /// </summary>
+    public event Action<ClientObject, uint, uint>? ObjectMoved;
+
+    /// <summary>Fires when an object is removed from the session.</summary>
+    public event Action<ClientObject>? ObjectRemoved;
+
+    /// <summary>Fires when an object's properties are updated (typically after Appraise).</summary>
+    public event Action<ClientObject>? ObjectUpdated;
+
+    /// <summary>PropertyInt.UiEffects (ACE enum value 18) — the icon effect bitfield;
+    /// the typed mirror <see cref="UpdateIntProperty"/> maintains on
+    /// <see cref="ClientObject.Effects"/>.</summary>
+    public const uint UiEffectsPropertyId = 18u;
+
+    public int ObjectCount => _items.Count;
+    public int ContainerCount => _containers.Count;
+
+    public IEnumerable<ClientObject> Objects => _items.Values;
+    public IEnumerable<Container> Containers => _containers.Values;
+
+    /// <summary>
+    /// Look up an object by its server-assigned <c>ObjectId</c>.
+    /// </summary>
+    public ClientObject? Get(uint objectId) =>
+        _items.TryGetValue(objectId, out var item) ? item : null;
+
+    /// <summary>
+    /// Look up a container by object id, creating a lightweight stub if
+    /// the id doesn't match any known container (defensive — avoids losing
+    /// references when the server announces a move into a container it
+    /// hasn't described yet).
+    /// </summary>
+    public Container? GetContainer(uint objectId) =>
+        _containers.TryGetValue(objectId, out var c) ? c : null;
+
+    /// <summary>
+    /// Register / refresh an object in the table. Called on
+    /// CreateObject for item-typed weenies and on IdentifyObjectResponse
+    /// to fill in detail properties.
+    /// </summary>
+    public void AddOrUpdate(ClientObject item)
+    {
+        ArgumentNullException.ThrowIfNull(item);
+        bool existed = _items.ContainsKey(item.ObjectId);
+        _items[item.ObjectId] = item;
+        if (!existed) ObjectAdded?.Invoke(item);
+        else ObjectUpdated?.Invoke(item);
+    }
+
+    /// <summary>
+    /// Register a container. Idempotent.
+    /// </summary>
+    public void AddContainer(Container container)
+    {
+        ArgumentNullException.ThrowIfNull(container);
+        _containers[container.ObjectId] = container;
+    }
+
+    /// <summary>
+    /// Handle a server-driven move — called from
+    /// InventoryPutObjInContainer (0x0022) and WieldObject (0x0023)
+    /// handlers. Updates ContainerId / ContainerSlot / CurrentlyEquippedLocation
+    /// and fires ObjectMoved.
+    /// </summary>
+    public bool MoveItem(uint itemId, uint newContainerId, int newSlot = -1,
+        EquipMask newEquipLocation = EquipMask.None)
+    {
+        if (!_items.TryGetValue(itemId, out var item)) return false;
+
+        uint oldContainer = item.ContainerId;
+        item.ContainerId = newContainerId;
+        item.ContainerSlot = newSlot;
+        item.CurrentlyEquippedLocation = newEquipLocation;
+
+        ObjectMoved?.Invoke(item, oldContainer, newContainerId);
+        return true;
+    }
+
+    /// <summary>
+    /// Handle a server-driven remove (destroyed item, dropped into 3D
+    /// space, stolen, etc).
+    /// </summary>
+    public bool Remove(uint itemId)
+    {
+        if (!_items.TryRemove(itemId, out var item)) return false;
+        ObjectRemoved?.Invoke(item);
+        return true;
+    }
+
+    /// <summary>
+    /// Enrich an already-known object (a stub created from PlayerDescription) with the
+    /// fuller data carried by its CreateObject (icon, name, type). Returns false if the
+    /// object isn't tracked yet — phase 1 enriches existing objects only; full
+    /// CreateObject ingestion of newly-acquired items is the inventory phase.
+    /// Raises ObjectUpdated whenever the object is found (matching the
+    /// UpdateProperties convention — it fires on found regardless of whether a field
+    /// actually changed) so bound widgets (the toolbar) re-render.
+    /// <para>
+    /// D.5.1 (2026-06-17): also accepts <paramref name="iconOverlayId"/> and
+    /// <paramref name="iconUnderlayId"/> from the extended WeenieHeader tail. Both
+    /// default to 0 (not sent by server). IconComposer.GetIcon already composites
+    /// underlay/base/overlay in the correct retail layer order and early-returns on 0.
+    /// </para>
+    /// </summary>
+    public bool EnrichItem(uint objectId, uint iconId, string name, ItemType type,
+        uint iconOverlayId = 0, uint iconUnderlayId = 0, uint effects = 0)
+    {
+        if (!_items.TryGetValue(objectId, out var item)) return false;
+        if (iconId != 0) item.IconId = iconId;
+        if (!string.IsNullOrEmpty(name)) item.Name = name;
+        if (type != default) item.Type = type;
+        if (iconOverlayId != 0) item.IconOverlayId = iconOverlayId;
+        if (iconUnderlayId != 0) item.IconUnderlayId = iconUnderlayId;
+        // D.5.2: 0 is a meaningful "no effect" state (e.g. a caster out of mana),
+        // so assign unconditionally — re-composition reflects the CURRENT state.
+        item.Effects = effects;
+        ObjectUpdated?.Invoke(item);
+        return true;
+    }
+
+    /// <summary>
+    /// Apply a <see cref="PropertyBundle"/> patch (e.g. from an
+    /// <c>IdentifyObjectResponse</c>) to an existing object. Individual
+    /// keys in the incoming bundle overwrite existing values; keys not
+    /// present are left untouched.
+    /// </summary>
+    public bool UpdateProperties(uint itemId, PropertyBundle incoming)
+    {
+        if (!_items.TryGetValue(itemId, out var item)) return false;
+        foreach (var kv in incoming.Ints)     item.Properties.Ints[kv.Key] = kv.Value;
+        foreach (var kv in incoming.Int64s)   item.Properties.Int64s[kv.Key] = kv.Value;
+        foreach (var kv in incoming.Bools)    item.Properties.Bools[kv.Key] = kv.Value;
+        foreach (var kv in incoming.Floats)   item.Properties.Floats[kv.Key] = kv.Value;
+        foreach (var kv in incoming.Strings)  item.Properties.Strings[kv.Key] = kv.Value;
+        foreach (var kv in incoming.DataIds)  item.Properties.DataIds[kv.Key] = kv.Value;
+        foreach (var kv in incoming.InstanceIds) item.Properties.InstanceIds[kv.Key] = kv.Value;
+        ObjectUpdated?.Invoke(item);
+        return true;
+    }
+
+    /// <summary>
+    /// Apply a single PropertyInt update (from PublicUpdatePropertyInt 0x02CE) to an
+    /// object: store it in the bundle and, for known typed ints, mirror to the typed
+    /// field. Today: UiEffects (18) → <see cref="ClientObject.Effects"/>. Fires
+    /// ObjectUpdated so bound widgets re-composite. Extensible hook for future
+    /// typed PropertyInts (StackSize, Structure, …). False if the object is unknown.
+    /// </summary>
+    public bool UpdateIntProperty(uint itemId, uint propertyId, int value)
+    {
+        if (!_items.TryGetValue(itemId, out var item)) return false;
+        item.Properties.Ints[propertyId] = value;
+        if (propertyId == UiEffectsPropertyId) item.Effects = (uint)value;
+        ObjectUpdated?.Invoke(item);
+        return true;
+    }
+
+    /// <summary>
+    /// Flush the table — typically called on logoff or teleport
+    /// that drops the session's object state.
+    /// </summary>
+    public void Clear()
+    {
+        _items.Clear();
+        _containers.Clear();
+    }
+}