From 452f3c14fc3270420355edecd82e27868fc19d63 Mon Sep 17 00:00:00 2001 From: Brues <5278969+brues-code@users.noreply.github.com> Date: Thu, 17 Sep 2026 14:04:59 -0500 Subject: [PATCH] fix(macro): keep the unlearn sweep from deleting #showtooltip macros The spell-removal handler FUN_005E9FE0 calls FUN_004E5E20(spellID) right after the unlearn writer. That sweep walks all 0x78 action slots, resolves each through FUN_ACTION_SLOT_TO_SPELL -- which is macro-aware, so a macro slot answers with the primary-spell cache this module writes -- and clears every slot whose spell matches. The clear notifies with sendToServer = 1, so CMSG_SET_ACTION_BUTTON goes out and the server persists it: the macro is gone for good, not until the next reload. That rule is sound for a cache the engine filled from a /cast line and wrong for one filled from a display directive, which names an icon rather than what the button does. `#showtooltip [known:18223] 18223` over a /cast the player can still perform would lose the whole macro on a respec, and a conditional directive makes it arbitrary besides -- the cached value is whichever clause happened to match on the last evaluation. Co-hook the sweep and park every managed macro's cache at 0 for its duration, restoring afterwards with a plain field write (nothing we own changed, so no repaint is owed; the slots the engine really did clear were announced by its own notify). A BusyScope wraps it because the sweep's ACTIONBAR_SLOT_CHANGED handlers reach Lookup, whose catch-up would otherwise re-apply the parked values mid-sweep for slots the loop has yet to reach. Macros with no directive are untouched. Consequence: a plain #showtooltip macro whose /cast line names the unlearned spell now also survives, where stock 1.12 removed it. --- src/Offsets.h | 16 +++++++++ src/macro/ShowTooltip.cpp | 72 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 88 insertions(+) diff --git a/src/Offsets.h b/src/Offsets.h index 34397d7a..8e094ab1 100644 --- a/src/Offsets.h +++ b/src/Offsets.h @@ -4741,6 +4741,22 @@ enum Offsets { // packet (verified by disassembly: the packet build is the `edx != 0` // branch, the event fire the `[esp+4] == 0` branch). FUN_ACTION_SLOT_CHANGED_NOTIFY = 0x004E58E0, + // Single-slot clear — `__fastcall(uint slot0)`: writes + // `VAR_ACTION_TABLE[slot0] = 0` then FUN_ACTION_SLOT_CHANGED_NOTIFY(slot0, + // /*sendToServer=*/1, 0), so the removal goes out as CMSG_SET_ACTION_BUTTON + // and the server persists it. + FUN_ACTION_SLOT_CLEAR = 0x004E5DB0, + // The unlearn sweep — `__fastcall(uint spellID)`. Walks all + // ACTION_TABLE_MAX_SLOTS slots, resolves each through + // FUN_ACTION_SLOT_TO_SPELL, and FUN_ACTION_SLOT_CLEARs every slot whose + // spell equals `spellID`. Sole caller is the spell-removal handler + // FUN_005E9FE0, immediately after FUN_UNLEARN_SPELL (verified by + // disassembly + xrefs). Because the resolver is macro-aware — a macro slot + // answers with its primary-spell cache — a macro whose cache holds the + // unlearned spell is permanently removed from the action bar, which is why + // `Macro::ShowTooltip` co-hooks this to keep its DISPLAY resolution out of + // the comparison. + FUN_ACTION_BAR_PRUNE_SPELL = 0x004E5E20, // Count of `itemID` the player carries, as `UseAction` caches per // item-by-ID slot into VAR_ACTION_ITEM_COUNTS — `uint __fastcall(uint // itemID)`. Charged items (ItemStats `SPELL_CHARGES[0]` set) sum charges diff --git a/src/macro/ShowTooltip.cpp b/src/macro/ShowTooltip.cpp index b05166cd..24a8aa11 100644 --- a/src/macro/ShowTooltip.cpp +++ b/src/macro/ShowTooltip.cpp @@ -52,6 +52,11 @@ // `Util/SecureStateDriver.lua` already uses for the same evaluator); // static ones every second (a newly learned rank / newly looted item — // the engine never re-parses a resolved macro on its own). +// - Unlearn. The engine's own sweep clears any action slot whose spell was +// just unlearned, and it resolves macro slots through the cache above — so +// a display resolution could get a working macro permanently deleted off +// the bar (the clear is sent to the server). `PruneSpell_h` parks every +// managed macro's cache across the sweep; see it for the full trail. // - One deliberate divergence from 3.3.5 (user decision), in the PARSER // rather than here: a group whose only piece is `@unit` passes only while // that unit exists (Util/MacroOptions.lua `GroupPasses`). 3.3.5 passes it @@ -784,6 +789,70 @@ void MaintainExternal(void *L) { } } +// Keep our resolution out of the engine's unlearn sweep. +// +// `FUN_ACTION_BAR_PRUNE_SPELL` runs straight after the unlearn writer and +// walks every action slot, resolving each through the MACRO-AWARE +// `FUN_ACTION_SLOT_TO_SPELL` — for a macro slot, the primary-spell cache this +// module writes — and clears every slot whose spell is the one just unlearned. +// The clear is `FUN_ACTION_SLOT_CLEAR`, which notifies with `sendToServer = 1`, +// so a CMSG_SET_ACTION_BUTTON goes out and the removal is persisted: the macro +// is gone for good, not until the next reload. +// +// That rule is sound for a cache the engine filled from a `/cast` line. It is +// wrong for one we filled from a DISPLAY directive, which names an icon rather +// than what the button does — `#showtooltip [known:18223] 18223` over a +// `/cast` the player can still perform would lose the whole macro on a respec. +// A conditional directive makes it arbitrary besides: the cached value is +// whichever clause happened to match on the last evaluation. +// +// So for the length of the sweep every macro we describe shows a cache of `0`, +// which no real spellID matches, and gets its value back afterwards. A macro +// with no directive is never touched and keeps stock behaviour. The restore is +// a plain field write with no repaint — it puts back exactly what was there a +// moment earlier, and the slots the engine really did clear were announced by +// the engine's own notify. +// +// The directive itself catches up on its own: the spellbook just changed, so +// the next evaluation re-runs `[known:…]` against it and repaints if the +// answer moved. +using PruneSpell_t = void(__fastcall *)(uint32_t spellID); +PruneSpell_t g_origPruneSpell = nullptr; + +void __fastcall PruneSpell_h(uint32_t spellID) { + // The sweep's ACTIONBAR_SLOT_CHANGED handlers run our action overrides, + // which reach `Lookup` — and its catch-up would re-apply the very values + // we just parked, mid-sweep, for every slot the loop has yet to reach. + BusyScope busy; + + uint8_t *entries[kMaxMacros]; + uint32_t saved[kMaxMacros]; + int savedCount = 0; + for (Entry &e : g_entries) { + if (e.macroID == 0) + continue; + // Exactly the macros this module drives — the same test `CatchUp` uses + // to decide what it may evaluate, plus published ones. + const bool managed = + e.external || (e.kind != Kind::None && e.optionCount > 0 && !e.foreign); + if (!managed) + continue; + uint8_t *entry = EntryForID(e.macroID); + if (entry == nullptr) + continue; + auto &cache = Game::Ref(entry, Offsets::OFF_MACRO_PRIMARY_SPELL); + entries[savedCount] = entry; + saved[savedCount] = cache; // whatever is there, ours or the engine's + ++savedCount; + cache = 0; + } + + g_origPruneSpell(spellID); + + for (int i = 0; i < savedCount; ++i) + Game::Ref(entries[i], Offsets::OFF_MACRO_PRIMARY_SPELL) = saved[i]; +} + // Read `CleveRoids.` as a boolean. The table is already at the top of // the stack; leaves the stack as it found it apart from what the caller pops. bool ReadCleveRoidsFlag(void *L, const char *field) { @@ -1034,6 +1103,9 @@ bool LookupEntries(uint32_t macroID, Info *out) { const Tick::WorldTick::AutoSubscribe _tick{&Tick}; const Game::ReloadAutoRegister _reload{&PrepareForReload}; const Spell::MacroPrimarySpell::PostParseAutoRegister _parsed{&OnMacroParsed}; +const Game::HookAutoRegister _hookPruneSpell{ + Offsets::FUN_ACTION_BAR_PRUNE_SPELL, reinterpret_cast(&PruneSpell_h), + reinterpret_cast(&g_origPruneSpell)}; } // namespace