diff --git a/README.md b/README.md
index 3da96bcf..34c19125 100644
--- a/README.md
+++ b/README.md
@@ -103,7 +103,7 @@ In the Frame rows, a name that starts with `:` is a method of the widget that th
| [LootHistory](docs/API.md#loothistory) | `C_LootHistory.GetNumItems`, `C_LootHistory.GetItem`, `C_LootHistory.GetPlayerInfo`, `C_LootHistory.Clear` |
| [LossOfControl](docs/API.md#lossofcontrol) | `C_LossOfControl.GetActiveLossOfControlData`, `C_LossOfControl.GetActiveLossOfControlDataCount`, `C_LossOfControl.GetSchoolLockout` |
| [Lua](docs/API.md#lua) | `collectgarbage` (5.1 options), `coroutine.create`, `coroutine.resume`, `coroutine.running`, `coroutine.status`, `coroutine.wrap`, `coroutine.yield`, `CreateFromMixins`, `math.fmod`, `math.huge`, `math.modf`, `Mixin`, `select`, `strcmputf8i`, `strconcat`, `string.concat`, `string.gmatch`, `string.gsub` (table replacement), `string.join`, `string.match`, `string.reverse`, `string.split`, `string.trim`, `strjoin`, `strlenutf8`, `strmatch`, `strreplace`, `strrev`, `strsplit`, `strsplittable`, `strtrim`, `table.count`, `table.maxn`, `table.wipe`, `unpack` (range args), `xpcall` (argument forwarding) |
-| [Macros](docs/API.md#macros) | `C_Macro.CreateMacro`, `C_Macro.EditMacro`, `C_Macro.SetMacroDisplay`, `DeleteMacro` / `EditMacro` / `GetMacroInfo` / `PickupMacro` by name, `GetLooseMacroIcons`, `GetLooseMacroItemIcons`, `GetMacroIcons`, `GetMacroItem`, `GetMacroItemIcons`, `GetMacroSpell`, `GetRunningMacro`, `GetRunningMacroButton`, `RunMacroText`, `StopMacro` |
+| [Macros](docs/API.md#macros) | `C_Macro.CreateMacro`, `C_Macro.EditMacro`, `C_Macro.SetMacroDisplay`, `DeleteMacro` / `EditMacro` / `GetMacroInfo` / `PickupMacro` by name, `GetLooseMacroIcons`, `GetLooseMacroItemIcons`, `GetMacroIcons`, `GetMacroItem`, `GetMacroItemIcons`, `GetMacroSpell`, `GetRunningMacro`, `GetRunningMacroButton`, `RunMacroText`, `SetMacroItem`, `SetMacroSpell`, `StopMacro` |
| [Mail](docs/API.md#mail) | `GetInboxItemLink`, `GetSendMailItemLink` |
| [Map](docs/API.md#map) | `C_Map.CanSetUserWaypointOnMap`, `C_Map.ClearUserWaypoint`, `C_Map.GetAreaInfo`, `C_Map.GetAreas`, `C_Map.GetAreaTriggerInfo`, `C_Map.GetAreaTriggers`, `C_Map.GetBestMapForUnit`, `C_Map.GetFallbackWorldMapID`, `C_Map.GetMapAreaIDs`, `C_Map.GetMapArtLayers`, `C_Map.GetMapArtLayerTextures`, `C_Map.GetMapChildrenInfo`, `C_Map.GetMapInfo`, `C_Map.GetMapInfoAtPosition`, `C_Map.GetMapOverlays`, `C_Map.GetMapPosFromWorldPos`, `C_Map.GetMapRectOnMap`, `C_Map.GetMapWorldSize`, `C_Map.GetPlayerMapPosition`, `C_Map.GetUserWaypoint`, `C_Map.GetUserWaypointFromHyperlink`, `C_Map.GetUserWaypointHyperlink`, `C_Map.GetUserWaypointPositionForMap`, `C_Map.GetWorldPosFromMapPos`, `C_Map.HasUserWaypoint`, `C_Map.MapHasArt`, `C_Map.SetUserWaypoint` |
| [MapExplorationInfo](docs/API.md#mapexplorationinfo) | `C_MapExplorationInfo.GetExploredAreaIDsAtPosition`, `C_MapExplorationInfo.GetExploredMapTextures`, `C_MapExplorationInfo.GetUnexploredMapTextures` |
diff --git a/docs/API.md b/docs/API.md
index 59cda1e7..bd7163dd 100644
--- a/docs/API.md
+++ b/docs/API.md
@@ -617,6 +617,7 @@ build instructions.
- [Macro names in `GetMacroInfo` / `EditMacro` / `PickupMacro` / `DeleteMacro`](#macro-names-in-getmacroinfo--editmacro--pickupmacro--deletemacro)
- [`GetMacroSpell(macroSlot)`](#getmacrospellmacroslot)
- [`GetMacroItem(macroSlot)`](#getmacroitemmacroslot)
+ - [`SetMacroSpell(macro, spell [, target])` / `SetMacroItem(macro, item [, target])`](#setmacrospellmacro-spell--target--setmacroitemmacro-item--target)
- [`GetMacroIcons` / `GetMacroItemIcons` / `GetLooseMacroIcons` / `GetLooseMacroItemIcons`](#getmacroicons--getmacroitemicons--getloosemacroicons--getloosemacroitemicons)
- [`C_Macro.CreateMacro` / `C_Macro.EditMacro`](#c_macrocreatemacro--c_macroeditmacro)
- [`C_Macro.GetMacroIcon(macroSlot)`](#c_macrogetmacroiconmacroslot)
@@ -14549,6 +14550,10 @@ does the same, but keeps the macro name as the tooltip.
the cursor, and `[@mouseover][] Rejuvenation` shows the spell and casts on
your target instead. If the value names a spell by name that you do not
know, nothing shows. Name it by ID to show it anyway.
+- The unit of the clause that matched (`[@focus]`, `[target=party1]`) is the
+ unit for the button's range check. `IsActionInRange` then tells whether that
+ unit is in range, not whether your target is. With no unit in the clause, the
+ range check uses your target.
A macro without `#showtooltip` or `#show` works the same way as `#show`
with no value. If its icon is the question mark, it shows the icon of its
@@ -14776,6 +14781,37 @@ local name, link = GetMacroItem(4)
-- name = "Major Healthstone", link = "|cffffffff|Hitem:9421:0:0:0|h[Major Healthstone]|h|r"
```
+### `SetMacroSpell(macro, spell [, target])` / `SetMacroItem(macro, item [, target])`
+
+Sets the spell or the item that a macro's action button shows. The button
+then follows it, as for a [`#showtooltip`](#showtooltip-and-show) value: icon,
+cooldown, count, usable state and range.
+
+```lua
+SetMacroSpell("Heal", "Flash Heal", "focus") -- show Flash Heal, range to focus
+SetMacroItem(3, "Hearthstone") -- show the Hearthstone
+```
+
+| Argument | Type | Description |
+|---|---|---|
+| `macro` | number or string | The macro's index, or its name. |
+| `spell` | string | `SetMacroSpell` only. A spell in your spellbook, by name, with an optional `(Rank N)`. |
+| `item` | string | `SetMacroItem` only. An item you carry, by name, or `item:N` or an item link. |
+| `target` | string (optional) | A unit token or a name. The button's range check uses this unit in place of your target. |
+
+Both functions return `1` when they find the spell or the item. If they do
+not find it, they return `nil`, and the button is greyed. If no macro has that
+index or name, they return nothing.
+
+The setting stays until you edit the macro, or until the interface reloads.
+Then the macro shows what its own lines resolve to again. The unit of
+`target` is found when you call the function. If that unit goes away, the
+button has no range state.
+
+If `spell` or `item` is not a string or a number, the function raises the
+error `Usage: SetMacroSpell(macro, spell [,target])` or
+`Usage: SetMacroItem(macro, item [,target])`.
+
### `GetMacroIcons` / `GetMacroItemIcons` / `GetLooseMacroIcons` / `GetLooseMacroItemIcons`
A 4-function append-to-table icon enumeration
diff --git a/src/Offsets.h b/src/Offsets.h
index 4fd003af..5981d9de 100644
--- a/src/Offsets.h
+++ b/src/Offsets.h
@@ -6533,6 +6533,18 @@ enum Offsets {
// returned via the second arg.
// __fastcall uint(uint slot0Based, uint *outPetFlag)
FUN_ACTION_SLOT_TO_SPELL = 0x004E5A50,
+ // An action slot's range answer, `int __fastcall(int slot0, int
+ // *inRange)`: 0 for no answer (no player, a bad slot, a pet-book spell,
+ // no record, a spell whose first implicit target takes no unit, or no
+ // target selected), else 1 with `*inRange` 0 or 1. It calls
+ // FUN_CHECK_SPELL_TARGET_RANGE(player, record, GUID 0 = the selection,
+ // report 0) at 0x004E5765; a pass then answers 1 only for a first implicit
+ // target of 6, 21, 23, 25, 26, 35, 45, 57 or 61 (jump table 0x004E57C4,
+ // index bytes 0x004E57CC: case 0 for exactly those) with a target selected
+ // (0x004E579C). Sole caller Script_IsActionInRange, at the call below;
+ // `Action::Range` redirects it.
+ FUN_ACTION_SLOT_RANGE = 0x004E56F0,
+ CALL_IS_ACTION_IN_RANGE_SLOT_RANGE = 0x004E7583,
ACTION_TYPE_MASK = 0xF0000000,
ACTION_TYPE_SPELL = 0x00000000,
// 0x40000000 entries are macros — live only while `entry & 0xBFFFFFFF`
diff --git a/src/action/Range.cpp b/src/action/Range.cpp
new file mode 100644
index 00000000..c0fbba84
--- /dev/null
+++ b/src/action/Range.cpp
@@ -0,0 +1,110 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under
+// the terms of the GNU General Public License as published by the Free Software
+// Foundation, either version 3 of the License, or (at your option) any later
+// version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
+// A PARTICULAR PURPOSE. See the GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License along with
+// ClassicAPI. If not, see .
+
+// The range answer of an action button whose macro is aimed at a unit.
+//
+// 4.3.4 keeps that unit on the macro (MACRONODE::m_target: the `[@unit]` of
+// the clause its display resolved from, or the target SetMacroSpell /
+// SetMacroItem named), and CGActionBar::HasValidTarget range-checks the slot's
+// spell against it in place of the current target. 1.12's slot range function
+// FUN_ACTION_SLOT_RANGE already takes the unit as a GUID for its range check,
+// and always passes 0, the selection. `Macro::ShowTooltip` keeps the unit (its
+// `Info::unit`), and this answers for those slots with that GUID, in the
+// engine's order: the range check, then the implicit-target test, where the
+// unit standing in for the selection must exist. Every other slot goes to the
+// engine function unchanged.
+//
+// The function's one caller, Script_IsActionInRange, is redirected rather than
+// the function hooked.
+
+#include "Common.h"
+#include "Game.h"
+#include "Offsets.h"
+#include "action/Slot.h"
+#include "macro/ShowTooltip.h"
+#include "object/Resolve.h"
+#include "spell/Lookup.h"
+#include "unit/Identity.h"
+
+#include
+
+namespace Action::Range {
+
+namespace {
+
+using SlotRange_t = int(__fastcall *)(int slot0, int *inRange);
+using SlotToSpell_t = int(__fastcall *)(int slot0, uint32_t *outPetFlag);
+using CheckRange_t = uint8_t(__fastcall *)(const void *caster, const uint8_t *record,
+ uint32_t guidLo, uint32_t guidHi, uint32_t report);
+
+// The first implicit targets the engine answers for: case 0 of its table.
+bool TakesUnitTarget(int32_t implicitTarget) {
+ switch (implicitTarget) {
+ case 6: case 21: case 23: case 25: case 26: case 35: case 45: case 57: case 61:
+ return true;
+ default:
+ return false;
+ }
+}
+
+uint64_t MacroUnit(int slot0) {
+ const uint32_t macroID = Action::Slot::MacroIDForSlot(slot0);
+ Macro::ShowTooltip::Info info{};
+ // Passive: this runs inside a Lua call, from a button's OnUpdate.
+ if (macroID == 0 || !Macro::ShowTooltip::LookupPassive(macroID, &info))
+ return 0;
+ return info.unit;
+}
+
+int __fastcall SlotRange_h(int slot0, int *inRange) {
+ const auto original = reinterpret_cast(Offsets::FUN_ACTION_SLOT_RANGE);
+ if (slot0 < 0 || slot0 >= Offsets::ACTION_TABLE_MAX_SLOTS)
+ return original(slot0, inRange);
+ const uint64_t unit = MacroUnit(slot0);
+ if (unit == 0)
+ return original(slot0, inRange);
+
+ const uint8_t *player = Unit::Identity::PlayerObject();
+ if (player == nullptr)
+ return 0;
+ uint32_t pet = 0;
+ const int spellID =
+ reinterpret_cast(Offsets::FUN_ACTION_SLOT_TO_SPELL)(slot0, &pet);
+ const uint8_t *record = ::Spell::Lookup::RecordForID(spellID);
+ if (record == nullptr || pet != 0)
+ return 0;
+ if (!reinterpret_cast(Offsets::FUN_CHECK_SPELL_TARGET_RANGE)(
+ player, record, static_cast(unit), static_cast(unit >> 32), 0)) {
+ *inRange = 0;
+ return 1;
+ }
+ const int32_t implicitTarget =
+ Game::Read(record, Offsets::OFF_SPELL_RECORD_EFFECT_IMPLICIT_TARGET_A);
+ if (!TakesUnitTarget(implicitTarget) || Object::ByGuid(Offsets::TYPEMASK_UNIT, unit) == nullptr)
+ return 0;
+ *inRange = 1;
+ return 1;
+}
+
+void Register() {
+ Common::RedirectCall(Offsets::CALL_IS_ACTION_IN_RANGE_SLOT_RANGE,
+ Offsets::FUN_ACTION_SLOT_RANGE,
+ reinterpret_cast(&SlotRange_h));
+}
+
+const Game::ModuleAutoRegister _autoreg{&Register};
+
+} // namespace
+
+} // namespace Action::Range
diff --git a/src/macro/Display.cpp b/src/macro/Display.cpp
index ca7c4fac..edf1be8f 100644
--- a/src/macro/Display.cpp
+++ b/src/macro/Display.cpp
@@ -26,10 +26,19 @@
// publisher hands over what it would have written in the macro and gets the
// item-before-spell precedence, `item:N`, links, inventory slots and
// `bag slot` for free.
+//
+// `SetMacroSpell(macro, spell [, target])` and `SetMacroItem(macro, item
+// [, target])` are 4.3.4's narrower doors onto the same publish: a spellbook
+// spell only, or an item only, aimed at `target` (the unit the button's range
+// check uses, see `Action::Range`). As in 4.3.4 the claim lasts until the
+// macro is edited, and a name that resolves to nothing greys the button.
#include "Game.h"
+#include "Offsets.h"
#include "macro/ShowTooltip.h"
+#include
+
namespace Macro::Display {
namespace {
@@ -57,7 +66,75 @@ int __fastcall Script_C_Macro_SetMacroDisplay(void *L) {
return 1;
}
+// The macro slot (1-based) that argument 1 names, as 4.3.4's GetMacroFromLua
+// reads it: a number, or a string that converts to one, is an index; any other
+// string is a name. 0 when no macro is there.
+int MacroSlotArg(void *L) {
+ using NameToSlot_t = uint32_t(__fastcall *)(const char *name);
+ using SlotToEntry_t = const uint8_t *(__fastcall *)(uint32_t slot0);
+ uint32_t slot0 = 0xFFFFFFFFu;
+ if (Game::Lua::IsNumber(L, 1))
+ slot0 = static_cast(static_cast(Game::Lua::ToNumber(L, 1)) - 1);
+ else if (Game::Lua::IsString(L, 1))
+ slot0 = reinterpret_cast(Offsets::FUN_MACRO_NAME_TO_SLOT)(
+ Game::Lua::ToString(L, 1));
+ if (reinterpret_cast(Offsets::FUN_MACRO_SLOT_TO_ENTRY)(slot0) == nullptr)
+ return 0;
+ return static_cast(slot0) + 1;
+}
+
+int SetMacroValue(void *L, Macro::ShowTooltip::Accept accept, const char *usage) {
+ if (!Game::Lua::IsString(L, 2)) {
+ Game::Lua::Error(L, usage);
+ return 0;
+ }
+ const int macroSlot = MacroSlotArg(L);
+ if (macroSlot == 0)
+ return 0;
+ Macro::ShowTooltip::PublishOptions options;
+ options.accept = accept;
+ options.unit = Game::Lua::IsString(L, 3) ? Game::Lua::ToString(L, 3) : nullptr;
+ options.untilEdit = true;
+ if (Macro::ShowTooltip::Publish(macroSlot, Game::Lua::ToString(L, 2), options))
+ Game::Lua::PushNumber(L, 1);
+ else
+ Game::Lua::PushNil(L);
+ return 1;
+}
+
+int __fastcall Script_SetMacroSpell(void *L) {
+ return SetMacroValue(L, Macro::ShowTooltip::Accept::Spell,
+ "Usage: SetMacroSpell(macro, spell [,target])");
+}
+
+int __fastcall Script_SetMacroItem(void *L) {
+ return SetMacroValue(L, Macro::ShowTooltip::Accept::Item,
+ "Usage: SetMacroItem(macro, item [,target])");
+}
+
+const Game::Doc::Field kSetMacroSpellArgs[] = {
+ Game::Doc::Req("macro", "string", "The macro's index or name."),
+ Game::Doc::Req("spell", "string", "The spell's name, with an optional \"(Rank N)\"."),
+ Game::Doc::Opt("target", "string", nullptr, "The unit that the button's range check uses."),
+};
+const Game::Doc::Field kSetMacroItemArgs[] = {
+ Game::Doc::Req("macro", "string", "The macro's index or name."),
+ Game::Doc::Req("item", "string", "The item's name, item:N or link."),
+ Game::Doc::Opt("target", "string", nullptr, "The unit that the button's range check uses."),
+};
+const Game::Doc::Field kSetMacroValueRets[] = {
+ Game::Doc::Opt("found", "number", nullptr, "1 when the name was found."),
+};
+const Game::Doc::Function kSetMacroSpell{
+ "Sets the spell that a macro's action button shows, until the macro is edited.",
+ kSetMacroSpellArgs, kSetMacroValueRets, "MacroGlobals"};
+const Game::Doc::Function kSetMacroItem{
+ "Sets the item that a macro's action button shows, until the macro is edited.",
+ kSetMacroItemArgs, kSetMacroValueRets, "MacroGlobals"};
+
void RegisterLuaFunctions() {
+ Game::Lua::RegisterGlobalFunction("SetMacroSpell", &Script_SetMacroSpell, &kSetMacroSpell);
+ Game::Lua::RegisterGlobalFunction("SetMacroItem", &Script_SetMacroItem, &kSetMacroItem);
Game::Lua::RegisterTableFunction("C_Macro", "SetMacroDisplay",
&Script_C_Macro_SetMacroDisplay);
}
diff --git a/src/macro/ShowTooltip.cpp b/src/macro/ShowTooltip.cpp
index 36fc06cc..50435b29 100644
--- a/src/macro/ShowTooltip.cpp
+++ b/src/macro/ShowTooltip.cpp
@@ -81,6 +81,7 @@
#include "tick/WorldTick.h"
#include "time/Clock.h"
#include "unit/Identity.h"
+#include "unit/TokenResolve.h"
#include
#include
@@ -140,6 +141,10 @@ struct Entry {
// macro: we neither parse the body nor re-evaluate it, and the lookups
// answer from it even while yielding. See the header.
bool external = false;
+ // A `SetMacroSpell` / `SetMacroItem` claim: it ends when the body changes,
+ // which `Rescan` tells by this hash of the body taken at the claim.
+ bool untilEdit = false;
+ uint32_t bodyHash = 0;
// The last resolution had a value to resolve, even if it resolved to
// nothing. The engine's cache tells those two apart — a value that named
// something unresolvable greys the button (`0xFFFFFFFF`), nothing matched
@@ -154,6 +159,7 @@ struct Entry {
uint32_t spellID = 0;
uint32_t isPet = 0;
int itemID = 0;
+ uint64_t unit = 0; // Info::unit
uint32_t lastEvalMs = 0;
};
@@ -427,6 +433,15 @@ bool Drives(const Entry &e) {
return e.kind != Kind::None && !e.foreign && (e.optionCount > 0 || e.none);
}
+// FNV-1a over a macro's body: enough to tell that an edit changed it.
+uint32_t BodyHash(const uint8_t *macroEntry) {
+ uint32_t h = 2166136261u;
+ for (const char *p = reinterpret_cast(macroEntry + Offsets::OFF_MACRO_BODY);
+ *p != '\0'; ++p)
+ h = (h ^ static_cast(*p)) * 16777619u;
+ return h;
+}
+
void Rescan(void *L) {
if (!g_slashNamesLoaded)
LoadSlashNames(L);
@@ -445,7 +460,8 @@ void Rescan(void *L) {
// its body. Ownership follows the macro, so it only drops when the
// slot comes to hold a different one.
if (e.external) {
- if (e.macroID == macroID)
+ if (e.macroID == macroID &&
+ !(e.untilEdit && BodyHash(entry) != e.bodyHash))
continue;
e = Entry{};
}
@@ -484,12 +500,17 @@ void Rescan(void *L) {
// shared with `/cast`, so a `[@mouseover][]` clause falls through to its
// `[]` group here exactly as it does for the cast.
//
+// `unit` gets the matched clause's `@unit` (the parser's second return), or
+// an empty string when it named none.
+//
// `*outForeign` is set when the line uses a condition our parser does not
// own. We ask quietly, because a macro body is not ours: another macro addon
// has its own conditions, and naming one at the player would be noise about a
// macro that works.
-bool ResolveOptions(void *L, const char *options, char *out, size_t outSize, bool *outForeign) {
+bool ResolveOptions(void *L, const char *options, char *out, size_t outSize, char *unit,
+ size_t unitSize, bool *outForeign) {
out[0] = '\0';
+ unit[0] = '\0';
*outForeign = false;
if (std::strchr(options, '[') == nullptr && std::strchr(options, ';') == nullptr) {
CopyTrimmed(options, out, outSize);
@@ -513,6 +534,10 @@ bool ResolveOptions(void *L, const char *options, char *out, size_t outSize, boo
CopyTrimmed(value, out, outSize); // copy before the SetTop below
matched = true;
}
+ if (Game::Lua::Type(L, -2) == Game::Lua::TYPE_STRING) {
+ if (const char *token = Game::Lua::ToString(L, -2))
+ CopyTrimmed(token, unit, unitSize);
+ }
}
}
Game::Lua::SetTop(L, top);
@@ -553,8 +578,20 @@ struct Resolution {
uint32_t spellID = 0;
uint32_t isPet = 0;
int itemID = 0;
+ uint64_t unit = 0;
};
+// The GUID of the unit a clause or a publisher names: a unit token through the
+// engine's resolver, else a unit with that exact name. 0 for none, and for a
+// token that points at nothing, which leaves the current target in charge.
+uint64_t UnitGuid(const char *unit) {
+ if (unit == nullptr || unit[0] == '\0')
+ return 0;
+ if (::Unit::TokenResolve::IsUnitToken(unit))
+ return ::Unit::Identity::GuidForToken(unit);
+ return ::Unit::Identity::FindGuidByName(unit, Offsets::TYPEMASK_UNIT, true);
+}
+
void SetItem(const uint8_t *cgItem, Resolution *r) {
const int itemID = Item::ID::FromCGItem(cgItem);
if (itemID > 0) {
@@ -667,6 +704,28 @@ void ResolveValue(const char *value, Resolution *r, bool explicitValue, bool ite
SetSpellByID(n, r);
}
+// A spell only, as 4.3.4's SetMacroSpell finds it: by name in the spellbook
+// (the player's, then the pet's), with `spell:N` and a bare ID as the display
+// forms `ResolveValue` gives a published value.
+void ResolveSpell(const char *value, Resolution *r) {
+ if (const int spellRef = ParseSpellRef(value)) {
+ SetSpellByID(spellRef, r);
+ return;
+ }
+ int isPet = 0;
+ const int spellID = reinterpret_cast(
+ Offsets::FUN_RESOLVE_SPELL_NAME_TO_BOOK_ID)(value, &isPet);
+ if (spellID > 0) {
+ r->target = Target::Spell;
+ r->spellID = static_cast(spellID);
+ r->isPet = (isPet != 0) ? 1u : 0u;
+ return;
+ }
+ int n = 0;
+ if (ParseInt(value, &n))
+ SetSpellByID(n, r);
+}
+
// Repaint every action slot holding `macroID` through the engine's own
// slot-changed notifier (recompute usable + ACTIONBAR_SLOT_CHANGED, no server
// packet). Lua handlers run synchronously inside — keep the stack balanced.
@@ -720,6 +779,9 @@ void ApplyResolution(void *L, Entry &e, const Resolution &r, bool matched) {
e.spellID = r.spellID;
e.isPet = r.isPet;
e.itemID = r.itemID;
+ // The unit changes no button state the engine caches (the range answer is
+ // asked for fresh), so it never forces a repaint.
+ e.unit = r.unit;
e.matched = matched;
cache = cacheSpell;
pet = cachePet;
@@ -794,9 +856,11 @@ void Evaluate(void *L, Entry &e, uint32_t nowMs) {
bool matched = false;
int matchedLine = -1;
char value[kOptionsMax] = {};
+ char unit[kOptionsMax] = {};
for (int i = 0; i < e.optionCount; ++i) {
bool foreign = false;
- bool got = ResolveOptions(L, e.options[i], value, sizeof(value), &foreign);
+ bool got = ResolveOptions(L, e.options[i], value, sizeof(value), unit, sizeof(unit),
+ &foreign);
if (got && value[0] != '\0') {
switch (e.lineType[i]) {
case LineType::Sequence:
@@ -845,6 +909,7 @@ void Evaluate(void *L, Entry &e, uint32_t nowMs) {
const LineType type = e.lineType[matchedLine];
ResolveValue(value, &r, type == LineType::Directive,
type == LineType::Equip || type == LineType::EquipSlot);
+ r.unit = UnitGuid(unit);
}
ApplyResolution(L, e, r, matched);
}
@@ -868,6 +933,7 @@ void MaintainExternal(void *L) {
r.spellID = e.spellID;
r.isPet = e.isPet;
r.itemID = e.itemID;
+ r.unit = e.unit;
uint32_t wantSpell = 0, wantPet = 0;
// `e.matched`, never `kind != None`: `Publish` marks a claimed macro
// `ShowTooltip` even when the publisher had nothing for us, and
@@ -1167,6 +1233,7 @@ bool LookupEntries(uint32_t macroID, Info *out) {
out->spellID = e.spellID;
out->isPet = e.isPet;
out->itemID = e.itemID;
+ out->unit = e.unit;
// A publisher re-publishes the moment its answer changes, so a claimed
// macro never needs the polling refresh a condition of ours does.
out->conditional = false;
@@ -1180,6 +1247,7 @@ bool LookupEntries(uint32_t macroID, Info *out) {
out->spellID = e.spellID;
out->isPet = e.isPet;
out->itemID = e.itemID;
+ out->unit = e.unit;
out->conditional = e.conditional;
return true;
}
@@ -1198,6 +1266,7 @@ bool LookupEntries(uint32_t macroID, Info *out) {
out->spellID = spellID;
out->isPet = Game::Read(entry, Offsets::OFF_MACRO_PRIMARY_SPELL_IS_PET);
out->itemID = 0;
+ out->unit = 0;
// A bare directive has no option lines, so nothing to re-evaluate.
out->conditional = false;
return true;
@@ -1214,7 +1283,7 @@ const Game::HookAutoRegister _hookPruneSpell{
} // namespace
-bool Publish(int macroSlot, const char *value) {
+bool Publish(int macroSlot, const char *value, const PublishOptions &options) {
if (macroSlot < 1 || macroSlot > kMaxMacros)
return false;
void *L = ReadyState();
@@ -1234,6 +1303,8 @@ bool Publish(int macroSlot, const char *value) {
e.macroID = macroID;
e.external = true;
}
+ e.untilEdit = options.untilEdit;
+ e.bodyHash = options.untilEdit ? BodyHash(macroEntry) : 0;
// Kind marks the macro as claimed even when nothing resolved, so the button
// falls back to the question mark rather than to our own parse. WHICH kind
// is the body's call, not the publisher's: `#show` is the macro's author
@@ -1249,8 +1320,14 @@ bool Publish(int macroSlot, const char *value) {
const bool matched = value != nullptr && value[0] != '\0';
// A publisher naming a value is naming it explicitly, the same as a
// directive that carries one.
- if (matched)
- ResolveValue(value, &r, /*explicitValue=*/true, /*itemOnly=*/false);
+ if (matched) {
+ if (options.accept == Accept::Spell)
+ ResolveSpell(value, &r);
+ else
+ ResolveValue(value, &r, /*explicitValue=*/true,
+ /*itemOnly=*/options.accept == Accept::Item);
+ }
+ r.unit = UnitGuid(options.unit);
BusyScope busy;
ApplyResolution(L, e, r, matched);
diff --git a/src/macro/ShowTooltip.h b/src/macro/ShowTooltip.h
index 6ff3543e..2e69d9ce 100644
--- a/src/macro/ShowTooltip.h
+++ b/src/macro/ShowTooltip.h
@@ -71,6 +71,25 @@ struct Info {
// to announce it — a modifier going down, a new mouseover. A tooltip built
// from it has to keep re-reading while the cursor rests on the button.
bool conditional;
+ // The unit the macro's spell is aimed at, 4.3.4's MACRONODE::m_target: the
+ // `[@unit]` of the clause that matched, or the target a `SetMacroSpell` /
+ // `SetMacroItem` named. 0 means the current target, as for any action.
+ uint64_t unit;
+};
+
+// What a published value may resolve to: every form a `#showtooltip` value
+// takes (`C_Macro.SetMacroDisplay`), a spellbook spell only (`SetMacroSpell`),
+// or an item only (`SetMacroItem`).
+enum class Accept : uint8_t { Any, Spell, Item };
+
+struct PublishOptions {
+ Accept accept = Accept::Any;
+ // A unit token or a name the spell is aimed at; null for the current target.
+ const char *unit = nullptr;
+ // The claim ends when the macro's body is edited, as 4.3.4's SetMacroSpell
+ // and SetMacroItem last only until the macro is parsed again. Otherwise it
+ // lasts until `Release` or a reload.
+ bool untilEdit = false;
};
// Publish the resolution for macro slot `macroSlot` (1-based, as
@@ -89,7 +108,7 @@ struct Info {
// state. Whether it also replaces the TOOLTIP is the macro body's call: only
// `#showtooltip` hands the tooltip over, while `#show` (icon only) and a body
// with no directive at all keep the engine's macro-name tooltip.
-bool Publish(int macroSlot, const char *value);
+bool Publish(int macroSlot, const char *value, const PublishOptions &options = {});
// Give a published macro back, so our own `#showtooltip` parse resumes for
// it. No-op for a macro that was never published.