220 lines
9.2 KiB
C#
220 lines
9.2 KiB
C#
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();
|
|
}
|
|
}
|