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

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

Browse source 
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>
This commit is contained in:
Erik 2026-06-18 15:33:03 +02:00
parent 2fc253d9ff
commit b506f53633
8 changed files with 142 additions and 145 deletions
Download patch file Download diff file Expand all files Collapse all files

220
src/AcDream.Core/Items/ItemRepository.cs
View file

@ -1,220 +0,0 @@
using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
namespace AcDream.Core.Items;
/// <summary>
/// Live item-state mirror — the client-side view of every item the
/// server has spawned for this session. Owns <see cref="ItemInstance"/>
/// records, tracks which container holds each item, and fires events so
/// UI panels (inventory, paperdoll, hotbars) can redraw on change.
///
/// <para>
/// Retail semantics (r06):
/// <list type="bullet">
/// <item><description>
/// Every item is a <see cref="ItemInstance"/> 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 ItemRepository
{
private readonly ConcurrentDictionary<uint, ItemInstance> _items = new();
private readonly ConcurrentDictionary<uint, Container> _containers = new();
/// <summary>Fires when an item is first added to the session.</summary>
public event Action<ItemInstance>? ItemAdded;
/// <summary>
/// Fires when an item'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<ItemInstance, uint, uint>? ItemMoved;
/// <summary>Fires when an item is removed from the session.</summary>
public event Action<ItemInstance>? ItemRemoved;
/// <summary>Fires when an item's properties are updated (typically after Appraise).</summary>
public event Action<ItemInstance>? ItemPropertiesUpdated;
/// <summary>PropertyInt.UiEffects (ACE enum value 18) — the icon effect bitfield;
/// the typed mirror <see cref="UpdateIntProperty"/> maintains on
/// <see cref="ItemInstance.Effects"/>.</summary>
public const uint UiEffectsPropertyId = 18u;
public int ItemCount => _items.Count;
public int ContainerCount => _containers.Count;
public IEnumerable<ItemInstance> Items => _items.Values;
public IEnumerable<Container> Containers => _containers.Values;
/// <summary>
/// Look up an item by its server-assigned <c>ObjectId</c>.
/// </summary>
public ItemInstance? GetItem(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 item in the repository. Called on
/// CreateObject for item-typed weenies and on IdentifyObjectResponse
/// to fill in detail properties.
/// </summary>
public void AddOrUpdate(ItemInstance item)
{
ArgumentNullException.ThrowIfNull(item);
bool existed = _items.ContainsKey(item.ObjectId);
_items[item.ObjectId] = item;
if (!existed) ItemAdded?.Invoke(item);
else ItemPropertiesUpdated?.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 ItemMoved.
/// </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;
ItemMoved?.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;
ItemRemoved?.Invoke(item);
return true;
}
/// <summary>
/// Enrich an already-known item (a stub created from PlayerDescription) with the
/// fuller data carried by its CreateObject (icon, name, type). Returns false if the
/// item isn't tracked yet — phase 1 enriches existing items only; full
/// CreateObject ingestion of newly-acquired items is the inventory phase.
/// Raises ItemPropertiesUpdated whenever the item 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;
ItemPropertiesUpdated?.Invoke(item);
return true;
}
/// <summary>
/// Apply a <see cref="PropertyBundle"/> patch (e.g. from an
/// <c>IdentifyObjectResponse</c>) to an existing item. 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;
ItemPropertiesUpdated?.Invoke(item);
return true;
}
/// <summary>
/// Apply a single PropertyInt update (from PublicUpdatePropertyInt 0x02CE) to an
/// item: store it in the bundle and, for known typed ints, mirror to the typed
/// field. Today: UiEffects (18) → <see cref="ItemInstance.Effects"/>. Fires
/// ItemPropertiesUpdated so bound widgets re-composite. Extensible hook for future
/// typed PropertyInts (StackSize, Structure, …). False if the item 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;
ItemPropertiesUpdated?.Invoke(item);
return true;
}
/// <summary>
/// Flush the repository — typically called on logoff or teleport
/// that drops the session's item state.
/// </summary>
public void Clear()
{
_items.Clear();
_containers.Clear();
}
}