ff3592ec25
Matches the ClientObjectTable model-placement convention; Load now takes (slot,objGuid) pairs so the store has no Core.Net dependency. + self-drop wire-count assert + comment fix. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
368 lines
18 KiB
C#
368 lines
18 KiB
C#
using System;
|
||
using System.Collections.Generic;
|
||
using AcDream.Core.Combat;
|
||
using AcDream.Core.Items;
|
||
using AcDream.Core.Net.Messages;
|
||
|
||
namespace AcDream.App.UI.Layout;
|
||
|
||
/// <summary>
|
||
/// Binds the imported gmToolbarUI window (LayoutDesc 0x21000016) to live data —
|
||
/// the gm*UI::PostInit analogue. Finds the 18 shortcut slots (UiItemList) by id,
|
||
/// populates them from the persisted PlayerDescription shortcuts
|
||
/// (UpdateFromPlayerDesc), re-binds deferred slots when an item's CreateObject
|
||
/// arrives (SetDelayedShortcutNum), and on click uses the bound item
|
||
/// (UseShortcut -> ItemHolder::UseObject -> use-item callback).
|
||
///
|
||
/// <para>
|
||
/// Retail reference: <c>gmToolbarUI::PostInit</c> grabs each slot widget by its
|
||
/// id, calls <c>UpdateFromPlayerDesc</c> to flush-and-bind shortcuts from the
|
||
/// PlayerDescription trailer, and hooks <c>OnEvent</c> for the Click case to fire
|
||
/// <c>UseShortcut</c>. The deferred-rebind path matches
|
||
/// <c>gmToolbarUI::SetDelayedShortcutNum</c> which re-tries binding after
|
||
/// <c>CreateObject</c> resolves a formerly-unknown guid.
|
||
/// </para>
|
||
/// </summary>
|
||
public sealed class ToolbarController : IItemListDragHandler
|
||
{
|
||
// Slot element ids in slot-index order (toolbar LayoutDesc 0x21000016, pre-dump).
|
||
// Row 1 = slots 0-8 (0x100001A7..0x100001AF), Row 2 = slots 9-17 (0x100006B7..0x100006BF).
|
||
private static readonly uint[] SlotIds =
|
||
{
|
||
0x100001A7, 0x100001A8, 0x100001A9, 0x100001AA, 0x100001AB,
|
||
0x100001AC, 0x100001AD, 0x100001AE, 0x100001AF,
|
||
0x100006B7, 0x100006B8, 0x100006B9, 0x100006BA, 0x100006BB,
|
||
0x100006BC, 0x100006BD, 0x100006BE, 0x100006BF,
|
||
};
|
||
|
||
// Elements hidden by default in retail gmToolbarUI::PostInit.
|
||
// Ids confirmed from the toolbar LayoutDesc dump.
|
||
// 0x100001A1 (health meter) is now OWNED by SelectedObjectController (D.5.3a) —
|
||
// it hides A1 at bind and shows it on a health-target selection, so A1 is removed
|
||
// from here to avoid double-ownership. 0x100001A2 (mana meter), 0x100001A3 (stack-size
|
||
// entry box) and 0x100001A4 (stack slider) are DEFERRED features (mana #140, stack-split
|
||
// UI) with no controller yet, so they stay hidden here — otherwise their dat sprites
|
||
// render as stray bars / a black box on the toolbar. Retail hides A3/A4 in
|
||
// gmToolbarUI::HandleSelectionChanged (acclient_2013_pseudo_c.txt:198660/198742),
|
||
// showing them only for a stacked-item selection.
|
||
private static readonly uint[] HiddenIds = { 0x100001A2, 0x100001A3, 0x100001A4 };
|
||
|
||
// Four mutually-exclusive combat-mode indicator elements — exactly one visible at a time.
|
||
// Index 0 = NonCombat (peace), 1 = Melee, 2 = Missile, 3 = Magic.
|
||
// Retail ref: gmToolbarUI::RecvNotice_SetCombatMode (acclient_2013_pseudo_c.txt:196632-196669)
|
||
// SetVisible's exactly one element depending on the incoming mode.
|
||
private static readonly uint[] CombatIndicatorIds =
|
||
{ 0x10000192u, 0x10000193u, 0x10000194u, 0x10000195u };
|
||
|
||
private readonly UiItemList?[] _slots = new UiItemList?[SlotIds.Length];
|
||
private readonly UiElement?[] _combatIndicators = new UiElement?[CombatIndicatorIds.Length];
|
||
private readonly ClientObjectTable _repo;
|
||
private readonly Func<IReadOnlyList<PlayerDescriptionParser.ShortcutEntry>> _shortcuts;
|
||
private readonly Func<ItemType, uint, uint, uint, uint, uint> _iconIds; // (itemType, icon, underlay, overlay, effects) → GL tex
|
||
private readonly Action<uint> _useItem; // guid → fire UseObject
|
||
private readonly AcDream.Core.Items.ShortcutStore _store = new();
|
||
private bool _storeLoaded;
|
||
private readonly Action<uint, uint>? _sendAddShortcut; // (index, objectGuid)
|
||
private readonly Action<uint>? _sendRemoveShortcut; // (index)
|
||
|
||
// Digit sprite DID arrays for slot labels (top row, numbers 1-9).
|
||
// Read from LayoutDesc 0x21000037, element 0x1000034A under composite 0x10000346.
|
||
// Retail ref: UIElement_UIItem::SetShortcutNum (acclient_2013_pseudo_c.txt:229465);
|
||
// gmToolbarUI::RecvNotice_SetCombatMode (196610-196621) re-stamps per stance.
|
||
// Occupancy branch (decomp 229481):
|
||
// occupied → peace 0x10000042 / war 0x10000043 (split by stance)
|
||
// empty → background digit 0x1000005e (stance-independent)
|
||
private uint[]? _peaceDigits;
|
||
private uint[]? _warDigits;
|
||
private uint[]? _emptyDigits;
|
||
private bool _peace = true; // true = NonCombat (peace), false = any war stance
|
||
|
||
private ToolbarController(
|
||
ImportedLayout layout,
|
||
ClientObjectTable repo,
|
||
Func<IReadOnlyList<PlayerDescriptionParser.ShortcutEntry>> shortcuts,
|
||
Func<ItemType, uint, uint, uint, uint, uint> iconIds,
|
||
Action<uint> useItem,
|
||
CombatState? combatState,
|
||
uint[]? peaceDigits,
|
||
uint[]? warDigits,
|
||
uint[]? emptyDigits,
|
||
Action<uint, uint>? sendAddShortcut = null,
|
||
Action<uint>? sendRemoveShortcut = null)
|
||
{
|
||
_repo = repo;
|
||
_shortcuts = shortcuts;
|
||
_iconIds = iconIds;
|
||
_useItem = useItem;
|
||
_peaceDigits = peaceDigits;
|
||
_warDigits = warDigits;
|
||
_emptyDigits = emptyDigits;
|
||
_sendAddShortcut = sendAddShortcut;
|
||
_sendRemoveShortcut = sendRemoveShortcut;
|
||
|
||
for (int i = 0; i < SlotIds.Length; i++)
|
||
{
|
||
_slots[i] = layout.FindElement(SlotIds[i]) as UiItemList;
|
||
if (_slots[i] is { } list)
|
||
{
|
||
WireClick(list);
|
||
// B.1 drag-drop spine: this controller is the drop handler for every
|
||
// toolbar slot list; each cell knows its slot index + that it's a
|
||
// shortcut-bar source (retail UIElement_ItemList::RegisterItemListDragHandler).
|
||
list.RegisterDragHandler(this);
|
||
list.Cell.SlotIndex = i;
|
||
list.Cell.SourceKind = ItemDragSource.ShortcutBar;
|
||
list.Cell.DragAcceptSprite = 0x060011FAu; // green cross (toolbar), not the ring 0x060011F9 (inventory)
|
||
}
|
||
}
|
||
|
||
// Cache the four mutually-exclusive combat-mode indicator elements.
|
||
for (int i = 0; i < CombatIndicatorIds.Length; i++)
|
||
_combatIndicators[i] = layout.FindElement(CombatIndicatorIds[i]);
|
||
|
||
// Hide target-object meters + stack slider (gmToolbarUI::PostInit).
|
||
foreach (var id in HiddenIds)
|
||
if (layout.FindElement(id) is { } e) e.Visible = false;
|
||
|
||
// Port of gmToolbarUI::RecvNotice_SetCombatMode (acclient_2013_pseudo_c.txt:196632-196669):
|
||
// exactly one indicator visible at a time. Default to NonCombat (peace) — the player
|
||
// always spawns in peace mode; retail has not yet called SetVisible when PostInit runs.
|
||
SetCombatMode(CombatMode.NonCombat);
|
||
|
||
// Wire live combat-mode changes if a CombatState was provided.
|
||
if (combatState is not null)
|
||
combatState.CombatModeChanged += SetCombatMode;
|
||
|
||
// D.5.4: the table now holds ALL objects (creatures, NPCs, etc.), so filter
|
||
// to our 18 shortcut guids — else every creature spawn in a busy zone
|
||
// needlessly re-populates the bar (gmToolbarUI::SetDelayedShortcutNum pattern).
|
||
repo.ObjectAdded += o => { if (IsShortcutGuid(o.ObjectId)) Populate(); };
|
||
repo.ObjectUpdated += o => { if (IsShortcutGuid(o.ObjectId)) Populate(); };
|
||
repo.ObjectRemoved += o => { if (IsShortcutGuid(o.ObjectId)) Populate(); };
|
||
}
|
||
|
||
/// <summary>
|
||
/// Returns true if <paramref name="guid"/> is one of the currently-active shortcut guids
|
||
/// (i.e., present in the live <see cref="AcDream.Core.Items.ShortcutStore"/>).
|
||
/// Used to gate repo-event subscriptions so we don't re-populate on every creature spawn.
|
||
/// Falls back to scanning <c>_shortcuts()</c> before the store is loaded (pre-PD window).
|
||
/// </summary>
|
||
private bool IsShortcutGuid(uint guid)
|
||
{
|
||
if (_storeLoaded)
|
||
{
|
||
for (int s = 0; s < AcDream.Core.Items.ShortcutStore.SlotCount; s++)
|
||
if (_store.Get(s) == guid) return true;
|
||
return false;
|
||
}
|
||
// Store not yet loaded — fall back to the shortcuts provider (pre-PD window).
|
||
foreach (var sc in _shortcuts())
|
||
if (sc.ObjectGuid == guid) return true;
|
||
return false;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Create and bind a <see cref="ToolbarController"/> to <paramref name="layout"/>.
|
||
/// Calls <see cref="Populate"/> immediately (binds whatever items are in the repo now).
|
||
/// Returns the controller so the caller can call <see cref="Populate"/> again
|
||
/// if the shortcut list is refreshed outside the repo-event path.
|
||
/// </summary>
|
||
/// <param name="layout">Imported toolbar layout (LayoutDesc 0x21000016).</param>
|
||
/// <param name="repo">Live item repository — must stay alive for the controller's lifetime.</param>
|
||
/// <param name="shortcuts">Provider for the current shortcut bar list.</param>
|
||
/// <param name="iconIds">Resolves (itemType, iconId, underlayId, overlayId, effects) → GL texture handle.</param>
|
||
/// <param name="useItem">Callback fired when a bound slot is clicked; receives the item guid.</param>
|
||
/// <param name="combatState">
|
||
/// Optional live combat state — when provided, the toolbar subscribes to
|
||
/// <see cref="CombatState.CombatModeChanged"/> and updates the four mutually-exclusive
|
||
/// combat-mode indicator elements accordingly.
|
||
/// Pass null to skip live wiring (e.g. in unit tests that don't exercise the indicator).
|
||
/// </param>
|
||
/// <param name="peaceDigits">
|
||
/// Peace-mode digit DID array (property 0x10000042 from LayoutDesc 0x21000037 element
|
||
/// 0x1000034A under composite 0x10000346). Index i → slot label digit (i+1) RenderSurface id.
|
||
/// Null if the dat lookup failed (no digits drawn). Retail reference:
|
||
/// UIElement_UIItem::SetShortcutNum (acclient_2013_pseudo_c.txt:229465).
|
||
/// </param>
|
||
/// <param name="warDigits">War-mode digit DID array (property 0x10000043, same element).</param>
|
||
/// <param name="emptyDigits">
|
||
/// Empty-slot background digit DID array (property 0x1000005e, stance-independent).
|
||
/// Used when a slot is EMPTY (ItemId == 0). Retail ref: UIElement_UIItem::SetShortcutNum
|
||
/// (decomp 229481) — else branch when m_elem_Icon->m_state == 0x1000001c (empty state).
|
||
/// Null if the dat lookup failed (empty slots draw no digit, which is safe).
|
||
/// </param>
|
||
public static ToolbarController Bind(
|
||
ImportedLayout layout,
|
||
ClientObjectTable repo,
|
||
Func<IReadOnlyList<PlayerDescriptionParser.ShortcutEntry>> shortcuts,
|
||
Func<ItemType, uint, uint, uint, uint, uint> iconIds,
|
||
Action<uint> useItem,
|
||
CombatState? combatState = null,
|
||
uint[]? peaceDigits = null,
|
||
uint[]? warDigits = null,
|
||
uint[]? emptyDigits = null,
|
||
Action<uint, uint>? sendAddShortcut = null,
|
||
Action<uint>? sendRemoveShortcut = null)
|
||
{
|
||
var c = new ToolbarController(layout, repo, shortcuts, iconIds, useItem, combatState,
|
||
peaceDigits, warDigits, emptyDigits,
|
||
sendAddShortcut, sendRemoveShortcut);
|
||
c.Populate();
|
||
return c;
|
||
}
|
||
|
||
/// <summary>
|
||
/// Port of <c>gmToolbarUI::UpdateFromPlayerDesc</c>: clear all slots, then bind
|
||
/// each shortcut entry that has a resolved item in the repository.
|
||
/// Entries whose item is not yet in the repo are silently skipped here; the
|
||
/// <c>ObjectAdded</c> event re-fires this method when the item arrives
|
||
/// (matching retail's <c>SetDelayedShortcutNum</c> deferred-rebind path).
|
||
/// As of B.2: the <see cref="AcDream.Core.Items.ShortcutStore"/> is the
|
||
/// authoritative in-session slot map; <c>_shortcuts()</c> seeds it on first call.
|
||
/// </summary>
|
||
public void Populate()
|
||
{
|
||
// Lazy-load the store from the login shortcut list the first time it's present (PD arrives
|
||
// after Bind); thereafter the store is authoritative and drag ops mutate it directly.
|
||
if (!_storeLoaded && _shortcuts().Count > 0)
|
||
{
|
||
_store.Load(System.Linq.Enumerable.Select(_shortcuts(), e => ((int)e.Index, e.ObjectGuid)));
|
||
_storeLoaded = true;
|
||
}
|
||
|
||
foreach (var list in _slots) list?.Cell.Clear();
|
||
|
||
for (int slot = 0; slot < _slots.Length; slot++)
|
||
{
|
||
uint guid = _store.Get(slot);
|
||
if (guid == 0) continue;
|
||
var list = _slots[slot];
|
||
if (list is null) continue;
|
||
var item = _repo.Get(guid);
|
||
if (item is null) continue; // deferred: ObjectAdded re-calls Populate
|
||
uint tex = _iconIds(item.Type, item.IconId, item.IconUnderlayId, item.IconOverlayId, item.Effects);
|
||
list.Cell.SetItem(guid, tex);
|
||
}
|
||
|
||
// Re-stamp slot number labels after any item change.
|
||
// Digit SPRITE SOURCE depends on occupancy (decomp UIElement_UIItem::SetShortcutNum:229481):
|
||
// occupied → peace 0x10000042 / war 0x10000043; empty → background 0x1000005e.
|
||
// The digit is ALWAYS shown on top-row slots (SetVisible(1) at decomp 229511).
|
||
RestampShortcutNumbers();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Port of <c>gmToolbarUI::RecvNotice_SetCombatMode</c>
|
||
/// (acclient_2013_pseudo_c.txt:196632-196669): show exactly one of the four
|
||
/// mutually-exclusive combat-mode indicator elements and hide the other three.
|
||
/// Called at bind-time with <see cref="CombatMode.NonCombat"/> (the player
|
||
/// always starts in peace mode) and subsequently whenever
|
||
/// <see cref="CombatState.CombatModeChanged"/> fires.
|
||
/// </summary>
|
||
public void SetCombatMode(CombatMode mode)
|
||
{
|
||
// Index → mode mapping matches CombatIndicatorIds declaration order:
|
||
// 0 = NonCombat (peace), 1 = Melee, 2 = Missile, 3 = Magic.
|
||
bool[] show =
|
||
{
|
||
mode == CombatMode.NonCombat,
|
||
mode == CombatMode.Melee,
|
||
mode == CombatMode.Missile,
|
||
mode == CombatMode.Magic,
|
||
};
|
||
|
||
for (int i = 0; i < _combatIndicators.Length; i++)
|
||
{
|
||
if (_combatIndicators[i] is { } e)
|
||
e.Visible = show[i];
|
||
}
|
||
|
||
// Re-stamp digit set: peace glyphs in NonCombat, war glyphs in any combat stance.
|
||
// Retail ref: gmToolbarUI::RecvNotice_SetCombatMode (acclient_2013_pseudo_c.txt:196610-196621).
|
||
_peace = (mode == CombatMode.NonCombat);
|
||
RestampShortcutNumbers();
|
||
}
|
||
|
||
/// <summary>
|
||
/// Push digit-array references and shortcut-number state into every slot cell.
|
||
/// Top row (indices 0–8): SetShortcutNum(i, _peace) — numbers 1–9 always shown
|
||
/// (the digit is ALWAYS visible, SetVisible(1) at decomp 229511; only the sprite
|
||
/// SOURCE differs by occupancy — see UIElement_UIItem::SetShortcutNum decomp 229481).
|
||
/// Bottom row (indices 9–17): ClearShortcutNum() — retail shows no numbers there.
|
||
/// Retail ref: UIElement_UIItem::SetShortcutNum (acclient_2013_pseudo_c.txt:229465);
|
||
/// gmToolbarUI::RecvNotice_SetCombatMode (196610-196621).
|
||
/// Occupancy → source: occupied → peace 0x10000042 / war 0x10000043;
|
||
/// empty → background 0x1000005e (decomp 229481/229493).
|
||
/// </summary>
|
||
private void RestampShortcutNumbers()
|
||
{
|
||
for (int i = 0; i < _slots.Length; i++)
|
||
{
|
||
var cell = _slots[i]?.Cell;
|
||
if (cell is null) continue;
|
||
cell.PeaceDigits = _peaceDigits;
|
||
cell.WarDigits = _warDigits;
|
||
cell.EmptyDigits = _emptyDigits;
|
||
if (i < 9)
|
||
cell.SetShortcutNum(i, _peace); // top row: slot label digits 1–9 always shown
|
||
else
|
||
cell.ClearShortcutNum(); // bottom row: no slot labels
|
||
}
|
||
}
|
||
|
||
/// <summary>
|
||
/// Wire the <see cref="UiItemSlot.Clicked"/> callback on a slot cell so that
|
||
/// clicking a bound item fires <see cref="_useItem"/> with the slot's current guid.
|
||
/// Mirrors retail's <c>gmToolbarUI</c> click → <c>UseShortcut</c> dispatch.
|
||
/// </summary>
|
||
private void WireClick(UiItemList list)
|
||
{
|
||
list.Cell.Clicked = () =>
|
||
{
|
||
if (list.Cell.ItemId != 0)
|
||
_useItem(list.Cell.ItemId);
|
||
};
|
||
}
|
||
|
||
// ── IItemListDragHandler (B.2 live handler) ──────────────────────────────
|
||
// Retail: gmToolbarUI is the m_dragHandler for every shortcut slot list.
|
||
// Retail model (remove-on-lift / place-on-drop / no-restore):
|
||
// lift → RemoveShortcut (0x019D) + store.Remove (slot empties immediately)
|
||
// drop → AddShortcut (0x019C) + optional swap of evicted item into source
|
||
// off-bar release → the lift's removal stands (no restore)
|
||
// Retail ref: gmToolbarUI::HandleDropRelease acclient_2013_pseudo_c.txt:197971
|
||
|
||
/// <inheritdoc/>
|
||
public void OnDragLift(UiItemList sourceList, UiItemSlot sourceCell, ItemDragPayload payload)
|
||
{
|
||
// Retail RecvNotice_ItemListBeginDrag → RemoveShortcut (0x004bd930/0x004bd450): the lifted
|
||
// shortcut leaves the bar (+ wire) the instant the drag starts; it's re-placed only on a
|
||
// drop onto a slot. Off-bar release leaves it removed.
|
||
_store.Remove(payload.SourceSlot);
|
||
_sendRemoveShortcut?.Invoke((uint)payload.SourceSlot);
|
||
Populate();
|
||
}
|
||
|
||
/// <inheritdoc/>
|
||
public bool OnDragOver(UiItemList targetList, UiItemSlot targetCell, ItemDragPayload payload)
|
||
=> payload.ObjId != 0;
|
||
|
||
/// <inheritdoc/>
|
||
public void HandleDropRelease(UiItemList targetList, UiItemSlot targetCell, ItemDragPayload payload)
|
||
{
|
||
// Retail gmToolbarUI::HandleDropRelease (0x004be7c0) within-bar reorder branch (deep-dive §5):
|
||
// evict the target's occupant, place the dragged item there, and bump the evicted item into
|
||
// the (now-vacated) source slot if it's free.
|
||
int target = targetCell.SlotIndex;
|
||
uint evicted = _store.Get(target); // RemoveShortCutInSlotNum(target)
|
||
if (evicted != 0) { _store.Remove(target); _sendRemoveShortcut?.Invoke((uint)target); }
|
||
_store.Set(target, payload.ObjId); // AddShortcut(dragged, target)
|
||
_sendAddShortcut?.Invoke((uint)target, payload.ObjId);
|
||
if (evicted != 0 && evicted != payload.ObjId && _store.IsEmpty(payload.SourceSlot))
|
||
{ // displaced → vacated source slot
|
||
_store.Set(payload.SourceSlot, evicted);
|
||
_sendAddShortcut?.Invoke((uint)payload.SourceSlot, evicted);
|
||
}
|
||
Populate();
|
||
}
|
||
}
|