// 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 .
// Frame attributes + unit-frame mouseover/click backport.
//
// Backports `frame:SetAttribute` / `frame:SetAttributeNoHandler` /
// `frame:ClearAttribute` / `frame:GetAttribute` to 1.12 as native methods on the base Frame registry
// (every frame gets them, like the modern clients). Vanilla has no attribute
// system at all — it arrived in 2.0 with secure frames. Attributes are just a
// per-frame, case-insensitive key→value store (verified from the 3.3.5
// implementation: a name→Lua-value map plus a getter with prefix/name/suffix
// wildcard precedence). We store the map in the Lua registry keyed by the frame
// (registry[frame]) — invisible to Lua script and tamper-proof, like retail's
// C-side attribute store (see PushSub).
//
// The headline use — SecureUnitButton behavior, minus the secure wrapper (1.12
// has no combat lockdown or taint, so protected actions just work):
//
// unitFrame:SetAttribute("unit", "party1") -- hover → mouseover = party1
// unitFrame:SetAttribute("type1", "target") -- left-click → target party1
//
// ── Mouseover (needs C — the engine's mouseover is a GUID slot) ──
//
// Installing OnEnter/OnLeave would be clobbered by an addon's own
// `SetScript("OnEnter", …)` (pfUI sets `unit` before its scripts), and there's
// nothing to read from Lua anyway — the mouseover unit is an engine global. So
// we mirror 4.3.4's CGWorldFrame::OnLayerUpdate: once per frame (the shared
// WorldTick) read the engine's mouse-focus frame
// (`*(*VAR_UI_CONTEXT_PTR + OFF_UI_CONTEXT_MOUSE_FOCUS)`, the
// CFrameScriptObject* `GetMouseFocus` returns), ask FrameXML's
// `SecureButton_GetModifiedUnit` for its unit (see ModifiedUnit), and hand
// that to the engine's FULL mouseover setter (FUN_00492890) — 1:1 with
// hovering the unit's 3D model: model highlight, UPDATE_MOUSEOVER_UNIT, the
// GUID slot, and the mouseover tooltip. The tooltip is a deliberate
// difference: 4.3.4 shows it only when the world frame has the focus.
// Stomp-proof: the engine's own 3D-hover setter is event-driven, so nothing
// overwrites the slot while the cursor is over UI.
//
// ── Clicks (the frame's own OnClick — scoped, native) ──
//
// Clicks are events, not state, so they belong on the frame's OnClick — but
// ONLY on frames that opt in with a `type` attribute. When a `type*` attribute
// is set we install a chained OnClick on that frame (protected, because OnClick
// is Button-only). It mirrors retail's SecureActionButton_OnClick: resolve ONE
// verb per click from the modifier/button-qualified `type` attribute, perform
// it, done. No global hook, no handler on frames that never asked for one.
//
// Resolution (retail-style): the attribute is `[prefix]type[suffix]`, where the
// prefix is the held modifiers ("alt-"/"ctrl-"/"shift-") and the suffix is the
// button number (1=Left, 2=Right, …). So `type1`, `shift-type1`, `type` all
// resolve via ReadModAttr's precedence. Verbs: `target` (with the engine's
// default-interaction precedence — pending spell / cursor item cast/drop on the
// unit instead of switching target), `assist`, `focus`, `spell` (reads the
// `spell` attribute and casts it: with a `unit` attribute, on that unit via our
// native C_Spell.CastAtUnit — the unit's GUID goes straight to the cast
// dispatcher, no target juggling, and ground-target spells land at its feet;
// with no `unit`, on the current target via the plain CastSpellByName), `item`
// (uses the `item`
// attribute — a name/itemID/link via C_Item.UseItemByName with the unit as the
// use target, or a "bag slot" string like "0 1" via UseContainerItem; the
// deprecated `bag`/`slot` attributes also work), `macro` (from the
// `macrotext`/`macro` attribute — prefers an addon RunMacro, else runs natively
// via the stock ChatEdit_ParseText), `stopcasting`, `menu`/`togglemenu` (pops
// the standard unit dropdown at the cursor via the addon's
// ClassicAPI_ToggleUnitMenu, or cancels spell-targeting when a spell is on the
// cursor), `action` (UseAction of the `action` slot), `pet` (CastPetAction of
// the `action` index), `click` (forwards to the frame in the `clickbutton`
// attribute via delegate:Click), and any other verb as a custom action — a
// function stored as a raw field on the frame named by the verb, called as
// func(self, unit, button). This is the complete secure-button verb set, so the
// !!!ClassicAPI addon ships no parallel Lua dispatcher. Actions call ordinary
// Lua globals where the entry
// is the engine's (TargetUnit, IsAltKeyDown, …); where we own a C++ module the
// dispatch goes straight to it, no Lua round-trip (Spell::AtUnit for `spell`,
// Unit::Focus for `focus`). All run under the engine's protected OnClick.
//
// One verb per click is the point: because we own the click when a verb
// resolves (and only then chain the previous handler), a configured `type1` no
// longer runs *alongside* the addon's own conditional OnClick — that double
// dispatch (our fixed "target" + pfUI's ClickAction) was the conflict. An addon
// expresses all its click behavior as attributes; unconfigured clicks fall
// through to its OnClick (e.g. a right-click menu).
//
// Ordering / clobbering: it chains the handler present when `type*` is set, so
// set `type*` AFTER the frame's own `OnClick`. Addons that re-`SetScript`
// `OnClick` later (pfUI does on every raid relayout) replace our closure — so
// re-set `type*` after re-SetScript to recover. Re-wiring is safe: WireOnClick
// re-wraps a clobbered (Lua) handler but skips its own C closure, so it never
// double-chains. The frame must be a Button registered for the relevant clicks
// (`RegisterForClicks`) — left is the Button default; right needs
// `RegisterForClicks("RightButtonUp")`, which real unit frames do.
//
// `OnAttributeChanged` is a real SetScript-able handler: SetAttribute (not
// SetAttributeNoHandler) fires it as `(self, name, value)` with the vanilla
// `this` / `arg1` / `arg2` globals set too (see FireAttributeChanged). The
// script itself is a `Frame::ExtraScripts` script.
#include "frame/Attributes.h"
#include "frame/ExtraScripts.h"
#include "frame/ScriptArgs.h"
#include "Common.h"
#include "Game.h"
#include "Offsets.h"
#include "baselib/Ascii.h"
#include "cursor/Info.h"
#include "macro/Execute.h"
#include "object/Resolve.h"
#include "spell/AtUnit.h"
#include "spell/Placement.h"
#include "tick/WorldTick.h"
#include "unit/Focus.h"
#include "unit/Identity.h"
#include "unit/Tooltip.h"
#include "xml/FrameLoad.h"
#include
#include
#include
#include
#include
#include
#include
namespace Frame::Attributes {
namespace {
using ScriptFn_t = int(__fastcall *)(void *L);
int CallScript(uintptr_t fn, void *L) {
return reinterpret_cast(fn)(L);
}
// ---- small string helpers --------------------------------------------------
void LowerCopy(char *dst, const char *src, size_t n) {
size_t i = 0;
for (; src && src[i] && i + 1 < n; ++i)
dst[i] = static_cast(std::tolower(static_cast(src[i])));
dst[i] = '\0';
}
using Common::BoundedCopy;
// dst = tolower(a .. b .. c). Truncates at n-1.
void Compose3Lower(char *dst, size_t n, const char *a, const char *b, const char *c) {
size_t i = 0;
const char *parts[3] = {a, b, c};
for (const char *s : parts)
for (; s && *s && i + 1 < n; ++s)
dst[i++] = static_cast(std::tolower(static_cast(*s)));
dst[i] = '\0';
}
// True if `lname` (already lowercase) is a click "type" action attribute: an
// optional modifier prefix (alt-/ctrl-/shift-, any order/combo) followed by
// "type" and an optional button digit — i.e. anything the click resolver
// (ButtonSuffix + ReadModAttr) reads as a verb selector: type, type1..type5,
// shift-type1, alt-ctrl-type2, … . This is the exact set WireOnClick must
// (re)install for; keying the wiring off it (rather than a fixed
// type/type1/type2 list) means a middle-click (type3) or modifier-only config
// still installs the chained OnClick.
bool IsTypeAttr(const char *lname) {
const char *p = lname;
for (bool advanced = true; advanced;) {
if (std::strncmp(p, "alt-", 4) == 0) p += 4;
else if (std::strncmp(p, "ctrl-", 5) == 0) p += 5;
else if (std::strncmp(p, "shift-", 6) == 0) p += 6;
else advanced = false;
}
if (std::strncmp(p, "type", 4) != 0)
return false;
p += 4;
if (p[0] == '\0')
return true; // "type"
return p[0] >= '1' && p[0] <= '5' && p[1] == '\0'; // "typeN"
}
// ---- attribute storage (in the Lua registry, keyed by the frame) -----------
// Pushes the frame's attribute subtable onto the stack. Stored as
// registry[frame] in the Lua registry (LUA_REGISTRYINDEX) rather than as a
// field on the frame's own table — the registry is C-side and has no _G path,
// so the store is invisible to `pairs(frame)` and can't be read or tampered
// with from Lua, matching how retail keeps attributes C-side. With create=true,
// lazily creates and stores it. Returns true iff a subtable is left on top;
// false (nothing left on the stack) when absent and !create. 1.12 frames are
// immortal, so the strong registry key never leaks.
bool PushSub(void *L, int frameIdx, bool create) {
Game::Lua::PushValue(L, frameIdx); // [.., frame] (key)
Game::Lua::RawGet(L, Game::Lua::REGISTRY_INDEX); // [.., sub|nil]
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_TABLE)
return true; // [.., sub]
Game::Lua::SetTop(L, Game::Lua::GetTop(L) - 1); // drop the nil -> [..]
if (!create)
return false;
Game::Lua::NewTable(L); // [.., sub]
Game::Lua::PushValue(L, frameIdx); // [.., sub, frame] (key)
Game::Lua::PushValue(L, -2); // [.., sub, frame, sub] (value)
Game::Lua::RawSet(L, Game::Lua::REGISTRY_INDEX); // registry[frame] = sub -> [.., sub]
return true;
}
// Copies string attribute `lname` (already lowercase) of the frame at
// frameIdx into buf. Returns true iff a string value was found. Restores the
// stack.
bool CopyAttr(void *L, int frameIdx, const char *lname, char *buf, size_t n) {
const int top = Game::Lua::GetTop(L);
bool ok = false;
if (PushSub(L, frameIdx, false)) { // [.., sub]
const int si = Game::Lua::GetTop(L);
Game::Lua::PushString(L, lname);
Game::Lua::RawGet(L, si); // [.., sub, val]
const int t = Game::Lua::Type(L, -1);
if (t == Game::Lua::TYPE_STRING || t == Game::Lua::TYPE_NUMBER) {
// lua_tostring coerces a number to its digits in place — on our
// temporary stack copy, so the stored attribute is untouched. This
// lets a numeric attribute value (e.g. SetAttribute("spell", 12345)
// or a numeric itemID) read as a string.
const char *s = Game::Lua::ToString(L, -1);
if (s) {
BoundedCopy(buf, s, n);
ok = true;
}
}
}
Game::Lua::SetTop(L, top);
return ok;
}
// If the frame's attribute subtable has a non-nil value for keyLower, leave that
// value on the stack top and return true; otherwise restore the stack and
// return false.
bool TryPushValue(void *L, int frameIdx, const char *keyLower) {
const int top = Game::Lua::GetTop(L);
if (PushSub(L, frameIdx, false)) { // [.., sub]
const int si = Game::Lua::GetTop(L);
Game::Lua::PushString(L, keyLower);
Game::Lua::RawGet(L, si); // [.., sub, val]
if (Game::Lua::Type(L, -1) != Game::Lua::TYPE_NIL) {
Game::Lua::Remove(L, si); // [.., val]
return true;
}
}
Game::Lua::SetTop(L, top);
return false;
}
// Unit token → GUID goes through `Unit::Identity::GuidForToken` (engine
// resolver + `"player"` fast-path, handling our focus / nameplateN / raw-GUID
// extensions). For recognized tokens it never raises; unit attributes are
// tokens by contract.
// ---- Lua-global call helpers (used by the click dispatcher) -----------------
//
// The click dispatch mirrors retail's SecureActionButton_OnClick: it's C. It
// performs engine actions by calling ordinary Lua globals (TargetUnit,
// IsAltKeyDown, …) and our own actions by calling the C++ module directly
// (Spell::AtUnit, Unit::Focus). Both run under the engine's protected OnClick
// invocation, so a Lua error inside one is caught there (no crash).
// The plain global-call primitives (push-if-function, call with no/one arg)
// live in Game::Lua now (PushGlobalFunction / CallGlobal / CallGlobalString) —
// shared with the other modules that dispatch to FrameXML globals by name. The
// two shapes below are specific enough to stay here.
// _G[name]() -> boolean (false if the global isn't a function). Distinct from
// Game::Lua::CallGlobal in that it returns the call's boolean RESULT (used for
// the IsAltKeyDown/IsShiftKeyDown modifier probes).
bool CallBoolGlobal(void *L, const char *name) {
const int top = Game::Lua::GetTop(L);
bool r = false;
if (Game::Lua::PushGlobalFunction(L, name)) {
Game::Lua::Call(L, 0, 1);
r = Game::Lua::ToBoolean(L, -1) != 0;
}
Game::Lua::SetTop(L, top);
return r;
}
// _G[table][method](a, b) — two string args (null → nil, since PushString maps
// NULL to nil), no results. Returns true iff the method resolved to a function
// and got called. Used when the target is our own C_* function but the call must
// cross the Lua boundary — e.g. C_Item.UseItemByName, whose bag walk does
// SetTop(L, 0); going through lua_call gives it its own stack frame so that reset
// clears only its frame, not the dispatcher's (a direct C++ call would wipe our
// stack — the reason `spell`, which is stack-free, calls Spell::AtUnit directly
// while `item` routes through here).
bool CallTableFunc2Str(void *L, const char *table, const char *method,
const char *a, const char *b) {
const int top = Game::Lua::GetTop(L);
bool called = false;
Game::Lua::PushString(L, table);
Game::Lua::GetTable(L, Game::Lua::GLOBALS_INDEX); // _G[table]
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_TABLE) {
const int t = Game::Lua::GetTop(L);
Game::Lua::PushString(L, method);
Game::Lua::GetTable(L, t); // _G[table][method]
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_FUNCTION) {
Game::Lua::PushString(L, a);
Game::Lua::PushString(L, b);
Game::Lua::Call(L, 2, 0);
called = true;
}
}
Game::Lua::SetTop(L, top);
return called;
}
// ---- mouse-focus poll (drives the native mouseover slot) -------------------
// Frames whose mouse we enabled when their `unit` attribute was first set
// (a bare frame never becomes the mouse focus otherwise). Keyed by the C
// object. Single-threaded (Lua + WorldTick on the main thread).
std::unordered_set g_unitFrames;
// The last GUID *we* wrote into the mouseover slot. We only touch the slot on a
// change of our own value, so when the cursor isn't over a unit frame (guid 0)
// we never clobber the engine's own 3D mouseover.
uint64_t g_lastSet = 0;
const void *CurrentMouseFocus() {
const void *ctx = Game::Read(
static_cast(Offsets::VAR_UI_CONTEXT_PTR));
if (ctx == nullptr)
return nullptr;
return Game::Read(ctx, Offsets::OFF_UI_CONTEXT_MOUSE_FOCUS);
}
// The engine's real mouseover setter — `__stdcall(guidLo, guidHi, prevLo,
// prevHi)`. Highlights the unit's model, builds the mouseover tooltip, fires
// UPDATE_MOUSEOVER_UNIT, and writes the GUID slot; pass 0,0 for the optional
// previous, and (0,0,0,0) to clear. Same address `Unit::Mouseover` co-hooks, so
// calling it here goes through that hook (loss events keep firing correctly).
void CallEngineMouseover(uint64_t guid) {
reinterpret_cast(
static_cast(Offsets::FUN_SET_MOUSEOVER_UNIT))(
static_cast(guid), static_cast(guid >> 32), 0, 0);
}
// True when the GUID resolves to a live unit/player object (loaded, in range).
// False for an offline or far out-of-range party/raid member — the case the
// engine mouseover setter skips the tooltip for. Same resolver Unit::Mouseover
// uses for its unit test.
bool GuidHasLiveUnit(uint64_t guid) {
if (guid == 0)
return false;
constexpr int kUnitOrPlayerMask =
(1 << Offsets::OBJECT_TYPE_UNIT) | (1 << Offsets::OBJECT_TYPE_PLAYER);
return Object::ByGuid(kUnitOrPlayerMask, guid, "ClassicAPI", 0) != nullptr;
}
// Build the mouseover tooltip for a unit with no live object, straight from the
// party/raid roster. FUN_00529FE0 is the same unit-tooltip builder SetUnit and
// the engine mouseover use; with no object it fills name/level/class + the
// "Offline" line from the roster (verified: `GameTooltip:SetUnit("party1")`
// works for an offline member). The engine's setter (FUN_00492890) gates this
// call on a live object, so offline members get nothing — we do it here.
void BuildRosterUnitTooltip(uint64_t guid) {
void *tooltip = Game::Read(
static_cast(Offsets::VAR_GAMETOOLTIP_OBJECT_PTR));
if (tooltip == nullptr)
return;
// Fire OnTooltipSetDefaultAnchor first, exactly as the engine mouseover
// setter (FUN_00492890) does before it builds — FrameXML's handler sets
// the tooltip's owner + anchor, which is what actually shows it. Without
// this, a rebuild after the tooltip was hidden on the previous leave has
// no owner and never re-appears (only a subsequent live-unit hover, which
// takes the engine's own anchor path, would). Use the self-contained
// invoker FUN_FRAME_INVOKE_SCRIPT, safe to call from the WorldTick.
const int anchorHandler = Game::Read(
tooltip, Offsets::OFF_TOOLTIP_SET_DEFAULT_ANCHOR_HANDLER);
if (anchorHandler != 0)
reinterpret_cast(
static_cast(Offsets::FUN_FRAME_INVOKE_SCRIPT))(anchorHandler,
tooltip);
uint32_t packed[2] = {static_cast(guid),
static_cast(guid >> 32)};
reinterpret_cast(
static_cast(Offsets::FUN_GAMETOOLTIP_BUILD_UNIT))(tooltip, packed);
}
// The unit a hovered frame stands for — 4.3.4's CGWorldFrame::OnLayerUpdate:
// for the mouse-focus frame it pcalls the FrameXML function
// `SecureButton_GetModifiedUnit(frame, macroRunning)` under the engine's
// script error handler and uses the token it returns, so `unitsuffix` and
// modifier-qualified `unit` attributes count. 4.3.4 asks protected frames;
// 1.12 has no protection, so the analog is a frame that has attributes at
// all. macroRunning is nil while hovering (no macro is executing), so the
// call passes the frame alone. Returns "" for no unit.
std::string ModifiedUnit(void *L, void *frame) {
std::string token;
const int top = Game::Lua::GetTop(L);
Game::Lua::PushObject(L, frame); // [frame]
const int fi = Game::Lua::GetTop(L);
if (PushSub(L, fi, /*create*/ false)) { // [frame, attrs]
Game::Lua::SetTop(L, fi);
int errIdx = 0;
const int errRef = Game::Read(
static_cast(Offsets::VAR_FRAMESCRIPT_ERROR_HANDLER_REF));
if (errRef > 0) {
Game::Lua::RawGetI(L, Game::Lua::REGISTRY_INDEX, errRef);
errIdx = Game::Lua::GetTop(L);
}
Game::Lua::PushString(L, "SecureButton_GetModifiedUnit");
Game::Lua::RawGet(L, Game::Lua::GLOBALS_INDEX);
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_FUNCTION) {
Game::Lua::PushValue(L, fi);
if (Game::Lua::PCall(L, 1, 1, errIdx) == 0 &&
Game::Lua::Type(L, -1) == Game::Lua::TYPE_STRING)
token = Game::Lua::ToString(L, -1);
}
}
Game::Lua::SetTop(L, top);
return token;
}
void MouseoverTick() {
void *focus = const_cast(CurrentMouseFocus());
uint64_t guid = 0;
std::string token;
if (focus != nullptr) {
if (void *L = Game::Lua::State()) {
token = ModifiedUnit(L, focus);
if (!token.empty())
guid = Unit::Identity::GuidForToken(token.c_str()); // live — follows target changes
}
}
if (guid != g_lastSet) {
// The tooltip built below is for the frame's unit, so `GetUnit()`
// answers with the frame's token — "mouseover" would not resolve for
// a member with no live object (see Unit::Tooltip).
if (guid != 0)
Unit::Tooltip::StageToken(
Game::Read(static_cast(Offsets::VAR_GAMETOOLTIP_OBJECT_PTR)),
token.c_str());
CallEngineMouseover(guid); // sets slot + highlight + tooltip + event
// Offline / far out-of-range party or raid member: the setter wrote the
// GUID slot but skipped the tooltip (no live object). Build it from the
// roster so hovering the frame still shows name / level / "Offline".
if (guid != 0 && !GuidHasLiveUnit(guid))
BuildRosterUnitTooltip(guid);
Unit::Tooltip::ClearStagedToken();
g_lastSet = guid;
}
}
// ---- click dispatch (the frame's own chained OnClick) ----------------------
// Runs the chained-onto previous handler (upvalue 1), vanilla-style with no
// args (it reads the `this`/`arg1` globals the engine set for this invocation).
void ChainOld(void *L) {
if (Game::Lua::Type(L, Game::Lua::UpvalueIndex(1)) == Game::Lua::TYPE_FUNCTION) {
Game::Lua::PushValue(L, Game::Lua::UpvalueIndex(1));
Game::Lua::Call(L, 0, 0);
}
}
// Builds the modifier prefix ("alt-"/"ctrl-"/"shift-", in that order — retail's
// order) from the live key state, e.g. "alt-shift-". Empty when none held.
void BuildModifierPrefix(void *L, char *buf, size_t n) {
buf[0] = '\0';
size_t i = 0;
auto add = [&](const char *s) {
for (const char *p = s; *p && i + 1 < n; ++p)
buf[i++] = *p;
buf[i] = '\0';
};
if (CallBoolGlobal(L, "IsAltKeyDown")) add("alt-");
if (CallBoolGlobal(L, "IsControlKeyDown")) add("ctrl-");
if (CallBoolGlobal(L, "IsShiftKeyDown")) add("shift-");
}
// Button name -> attribute suffix (retail's convention: the button number).
const char *ButtonSuffix(const char *btn) {
if (Ascii::EqualCI(btn, "RightButton")) return "2";
if (Ascii::EqualCI(btn, "MiddleButton")) return "3";
if (Ascii::EqualCI(btn, "Button4")) return "4";
if (Ascii::EqualCI(btn, "Button5")) return "5";
return "1"; // LeftButton / unknown
}
// Resolves a modified attribute into `buf`. Precedence (practical subset of the
// GetAttribute wildcard rules): prefix..name..suffix (e.g. "shift-type1"),
// then name..suffix ("type1"), then name ("type"). So a plain `type1` still
// applies under any modifier unless a modifier-specific attribute overrides it.
bool ReadModAttr(void *L, int fi, const char *prefix, const char *name,
const char *suffix, char *buf, size_t n) {
char key[128];
Compose3Lower(key, sizeof key, prefix, name, suffix);
if (CopyAttr(L, fi, key, buf, n)) return true;
Compose3Lower(key, sizeof key, "", name, suffix);
if (CopyAttr(L, fi, key, buf, n)) return true;
Compose3Lower(key, sizeof key, "", name, "");
return CopyAttr(L, fi, key, buf, n);
}
// Reads attribute `keyLower` as an int (stored as a number, or a numeric
// string) into *out. Leaves the stack as it found it. Returns true on success.
bool ReadAttrInt(void *L, int fi, const char *keyLower, int *out) {
bool ok = false;
if (TryPushValue(L, fi, keyLower)) { // value left on top
const int t = Game::Lua::Type(L, -1);
if (t == Game::Lua::TYPE_NUMBER) {
*out = static_cast(Game::Lua::ToNumber(L, -1));
ok = true;
} else if (t == Game::Lua::TYPE_STRING) {
const char *s = Game::Lua::ToString(L, -1);
char *end = nullptr;
const long v = s ? std::strtol(s, &end, 10) : 0;
if (s && end != s) {
*out = static_cast(v);
ok = true;
}
}
Game::Lua::SetTop(L, Game::Lua::GetTop(L) - 1); // pop the peeked value
}
return ok;
}
// Numeric analog of ReadModAttr (prefix..name..suffix precedence).
bool ReadModAttrInt(void *L, int fi, const char *prefix, const char *name,
const char *suffix, int *out) {
char key[128];
Compose3Lower(key, sizeof key, prefix, name, suffix);
if (ReadAttrInt(L, fi, key, out)) return true;
Compose3Lower(key, sizeof key, "", name, suffix);
if (ReadAttrInt(L, fi, key, out)) return true;
Compose3Lower(key, sizeof key, "", name, "");
return ReadAttrInt(L, fi, key, out);
}
// Parses a "bag slot" string (two integers, e.g. "0 1") into bag/slot. Returns
// false unless the whole string is exactly two integers, so a normal item name
// or a bare itemID ("12345") falls through to the name path.
bool ParseBagSlot(const char *s, int *bag, int *slot) {
char *end = nullptr;
const long b = std::strtol(s, &end, 10);
if (end == s) return false; // not a leading number
const char *p = end;
const long sl = std::strtol(p, &end, 10);
if (end == p) return false; // only one number
while (*end == ' ' || *end == '\t') ++end;
if (*end != '\0') return false; // trailing junk
*bag = static_cast(b);
*slot = static_cast(sl);
return true;
}
// _G[name](a, b) — two number args, no results. Returns true iff called.
bool CallGlobalNum2(void *L, const char *name, double a, double b) {
const int top = Game::Lua::GetTop(L);
const bool called = Game::Lua::PushGlobalFunction(L, name);
if (called) {
Game::Lua::PushNumber(L, a);
Game::Lua::PushNumber(L, b);
Game::Lua::Call(L, 2, 0);
}
Game::Lua::SetTop(L, top);
return called;
}
// _G[name](a) — one number arg, no results. Returns true iff called.
bool CallGlobalNum1(void *L, const char *name, double a) {
const int top = Game::Lua::GetTop(L);
const bool called = Game::Lua::PushGlobalFunction(L, name);
if (called) {
Game::Lua::PushNumber(L, a);
Game::Lua::Call(L, 1, 0);
}
Game::Lua::SetTop(L, top);
return called;
}
// `click` verb: the `clickbutton` attribute holds a FRAME (not a string).
// Resolve it with the same modified-key precedence as ReadModAttr, then forward
// the click via delegate:Click(button). Returns true iff a delegate was called.
bool ClickDelegate(void *L, int fi, const char *prefix, const char *suffix,
const char *button) {
char key[128];
Compose3Lower(key, sizeof key, prefix, "clickbutton", suffix);
bool got = TryPushValue(L, fi, key);
if (!got) {
Compose3Lower(key, sizeof key, "", "clickbutton", suffix);
got = TryPushValue(L, fi, key);
}
if (!got) {
Compose3Lower(key, sizeof key, "", "clickbutton", "");
got = TryPushValue(L, fi, key);
}
if (!got) return false; // no delegate configured
const int di = Game::Lua::GetTop(L); // the delegate value
bool called = false;
if (Game::Lua::Type(L, di) == Game::Lua::TYPE_TABLE) {
Game::Lua::PushString(L, "Click");
Game::Lua::GetTable(L, di); // delegate.Click
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_FUNCTION) {
Game::Lua::PushValue(L, di); // self = delegate
Game::Lua::PushString(L, button); // button name
Game::Lua::Call(L, 2, 0);
called = true;
}
}
Game::Lua::SetTop(L, di - 1); // drop the delegate (+leftovers)
return called;
}
// Custom verb: a function stored as a raw field on the frame's own table named
// by the verb (retail's escape hatch), invoked as func(self, unit, button).
// Returns true iff such a function existed and was called.
bool CallCustomAction(void *L, int fi, const char *verb, const char *unit,
const char *button) {
if (Game::Lua::Type(L, fi) != Game::Lua::TYPE_TABLE) return false;
Game::Lua::PushString(L, verb);
Game::Lua::RawGet(L, fi); // frame[verb]
bool called = false;
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_FUNCTION) {
Game::Lua::PushValue(L, fi); // self
Game::Lua::PushString(L, unit); // unit (nil if null)
Game::Lua::PushString(L, button); // button name
Game::Lua::Call(L, 3, 0);
called = true;
} else {
Game::Lua::SetTop(L, Game::Lua::GetTop(L) - 1);
}
return called;
}
// Performs the resolved `verb` on `unit` (a token attribute value, may be null).
// `button` is the raw click-button name ("LeftButton", …), needed by the
// `click` and custom verbs. Returns true if it owned the click (so the chained
// handler is skipped).
bool DispatchVerb(void *L, int fi, const char *prefix, const char *suffix,
const char *verb, const char *unit, const char *button) {
if (Ascii::EqualCI(verb, "target")) {
if (!unit) return false;
// `unit="none"` clears the target (retail's SecureActionButton behavior).
if (Ascii::EqualCI(unit, "none")) {
Game::Lua::CallGlobal(L, "ClearTarget");
return true;
}
// Cursor / pending-spell take precedence, matching the engine's default
// unit interaction — cast the pending spell / drop the item on the unit
// instead of switching target. The two predicates are ours (direct C++);
// the actions are engine-only, so they go through the Lua globals (which
// are the engine's own entries, with token→GUID resolution).
if (Spell::Placement::IsActive())
Game::Lua::CallGlobalString(L, "SpellTargetUnit", unit);
else if (Cursor::Info::HasItem())
Game::Lua::CallGlobalString(L, "DropItemOnUnit", unit);
else
Game::Lua::CallGlobalString(L, "TargetUnit", unit);
return true;
}
if (Ascii::EqualCI(verb, "assist")) {
if (!unit) return false;
Game::Lua::CallGlobalString(L, "AssistUnit", unit);
return true;
}
if (Ascii::EqualCI(verb, "focus")) {
if (!unit) return false;
Unit::Focus::Set(Unit::Identity::GuidForToken(unit));
return true;
}
if (Ascii::EqualCI(verb, "spell")) {
// A numeric spell ID (modern addons do SetAttribute("spell", 12345),
// stored as a Lua number; a numeric string is accepted too). Cast the
// EXACT rank by ID through the spellbook-slot resolver — at the unit, or
// with no unit on the current target (targetGuid 0). NOT name
// resolution, which casts the highest known rank regardless of the rank
// the caller asked for.
int spellID;
if (ReadModAttrInt(L, fi, prefix, "spell", suffix, &spellID)) {
if (unit)
Spell::AtUnit::CastByID(spellID, unit);
else
Spell::Placement::DispatchSpellCast(spellID);
return true;
}
// Otherwise a spell name. With a `unit`, cast straight at it (GUID →
// dispatcher, no target juggling; a ground-target spell lands at its
// feet). With no `unit`, fall back to the plain global cast on the
// current target — a `type="spell"` button that sets no `unit`
// attribute (issue #18) works like `/cast `.
char spell[128];
if (!ReadModAttr(L, fi, prefix, "spell", suffix, spell, sizeof spell))
return false;
if (unit)
Spell::AtUnit::CastByName(spell, unit, /*placeGroundSpell*/ true);
else
Game::Lua::CallGlobalString(L, "CastSpellByName", spell);
return true;
}
if (Ascii::EqualCI(verb, "item")) {
char item[128];
int bag, slot;
if (ReadModAttr(L, fi, prefix, "item", suffix, item, sizeof item)) {
if (ParseBagSlot(item, &bag, &slot))
CallGlobalNum2(L, "UseContainerItem", bag, slot);
else
CallTableFunc2Str(L, "C_Item", "UseItemByName", item, unit);
return true;
}
// Deprecated form: no `item`, take the `bag` + `slot` attributes.
if (ReadModAttrInt(L, fi, prefix, "bag", suffix, &bag) &&
ReadModAttrInt(L, fi, prefix, "slot", suffix, &slot)) {
CallGlobalNum2(L, "UseContainerItem", bag, slot);
return true;
}
return false;
}
if (Ascii::EqualCI(verb, "macro")) {
// Give the macro a unit to act on. Vanilla macros have no `@unit`
// conditional, and unlike the `spell` verb (which feeds a GUID straight
// to the cast dispatcher) we can't inject a target into arbitrary macro
// text — so a plain `/cast Flash Heal` would hit the current target, not
// the clicked unit. Emulate the classic Clique click-heal: snapshot the
// current target, retarget the clicked unit, run the macro, then restore
// the previous target so the click doesn't leave the player retargeted.
// The macro's actions (/cast etc.) dispatch against the clicked unit
// synchronously while it's selected, so restoring the target afterward
// doesn't affect them.
uint64_t prevTarget = 0;
const bool swapped = unit != nullptr;
if (swapped) {
prevTarget =
(static_cast(Game::Read(
Offsets::VAR_CURRENT_SELECTION_GUID_HI))
<< 32) |
Game::Read(
Offsets::VAR_CURRENT_SELECTION_GUID_LO);
Game::Lua::CallGlobalString(L, "TargetUnit", unit);
}
char macro[512];
bool handled = false;
// `macrotext` is raw macro text (the modern default). Run it as text
// through the stock chat parser so each line dispatches via
// SlashCmdList — that routes /cast etc. through any addon slash hooks
// (e.g. SuperCleveRoidMacros' conditional /cast). A name-based RunMacro
// (which is what SuperCleveRoidMacros ships) can't interpret text and
// would silently resolve nothing.
if (ReadModAttr(L, fi, prefix, "macrotext", suffix, macro, sizeof macro)) {
Macro::Execute::Text(L, macro);
handled = true;
}
// Deprecated `macro` form: a saved-macro name/index. Prefer an
// addon-provided RunMacro (SuperCleveRoidMacros, pfUI, …) to run the
// named macro's body; fall back to the stock parser when none exists.
else if (ReadModAttr(L, fi, prefix, "macro", suffix, macro, sizeof macro)) {
handled = Macro::Execute::Saved(L, macro);
}
// Restore the target the click swapped away from. `FUN_TARGET_BY_GUID`
// validates the GUID resolves to a live unit and bails otherwise, so a
// target that despawned mid-macro is dropped cleanly rather than
// committed; a zero prior target means "no target" → ClearTarget.
if (swapped) {
if (prevTarget)
reinterpret_cast(
Offsets::FUN_TARGET_BY_GUID)(&prevTarget);
else
Game::Lua::CallGlobal(L, "ClearTarget");
}
return handled;
}
if (Ascii::EqualCI(verb, "stop") || Ascii::EqualCI(verb, "stopcasting")) {
Game::Lua::CallGlobal(L, "SpellStopCasting");
return true;
}
if (Ascii::EqualCI(verb, "action")) {
int slot;
if (!ReadModAttrInt(L, fi, prefix, "action", suffix, &slot)) return false;
CallGlobalNum1(L, "UseAction", slot);
return true;
}
if (Ascii::EqualCI(verb, "pet")) {
int index;
if (!ReadModAttrInt(L, fi, prefix, "action", suffix, &index)) return false;
CallGlobalNum1(L, "CastPetAction", index);
return true;
}
if (Ascii::EqualCI(verb, "click")) {
return ClickDelegate(L, fi, prefix, suffix, button);
}
if (Ascii::EqualCI(verb, "menu") || Ascii::EqualCI(verb, "togglemenu")) {
// While a spell is on the cursor, cancel targeting instead of opening
// the menu (retail's SecureUnitButton behavior).
if (CallBoolGlobal(L, "SpellIsTargeting")) {
Game::Lua::CallGlobal(L, "SpellStopTargeting");
return true;
}
if (!unit) return false;
// The unit dropdown is pure FrameXML work (UnitPopup + ToggleDropDown),
// so it lives in the !!!ClassicAPI addon; we just pop it at the cursor.
Game::Lua::CallGlobalString(L, "ClassicAPI_ToggleUnitMenu", unit);
return true;
}
// Unknown verb → a custom action: a function stored as a raw field on the
// frame named by the verb (retail's escape hatch). If none exists it isn't
// handled here and the frame's own chained OnClick runs.
return CallCustomAction(L, fi, verb, unit, button);
}
// The chained OnClick handler. Upvalues: 1 = previous handler (or nil), 2 = the
// frame (captured at install time, so we don't depend on the `this` global).
// Resolves one verb per click from the (modifier/button) `type` attribute and
// performs it — retail's one-action-per-click model. Only chains the previous
// handler when we DIDN'T own the click, so a configured `type1` no longer runs
// alongside the addon's own OnClick (that double-dispatch was the conflict).
int __fastcall OnClick_c(void *L) {
const int top = Game::Lua::GetTop(L);
Game::Lua::PushValue(L, Game::Lua::UpvalueIndex(2)); // frame
const int fi = Game::Lua::GetTop(L);
bool handled = false;
if (Game::Lua::Type(L, fi) == Game::Lua::TYPE_TABLE) {
char btn[32] = {0};
Game::Lua::PushString(L, "arg1");
Game::Lua::GetTable(L, Game::Lua::GLOBALS_INDEX);
if (Game::Lua::Type(L, -1) == Game::Lua::TYPE_STRING) {
const char *b = Game::Lua::ToString(L, -1);
if (b)
BoundedCopy(btn, b, sizeof btn);
}
Game::Lua::SetTop(L, fi); // drop arg1, keep frame
const char *suffix = ButtonSuffix(btn);
char prefix[24];
BuildModifierPrefix(L, prefix, sizeof prefix);
char verb[32];
if (ReadModAttr(L, fi, prefix, "type", suffix, verb, sizeof verb)) {
char unit[128];
const bool haveUnit =
ReadModAttr(L, fi, prefix, "unit", suffix, unit, sizeof unit);
handled = DispatchVerb(L, fi, prefix, suffix, verb,
haveUnit ? unit : nullptr, btn);
}
}
Game::Lua::SetTop(L, top);
if (!handled)
ChainOld(L); // let the frame's own OnClick handle unconfigured clicks
return 0;
}
// Installs OnClick as a closure over (previous handler, frame). Operates on
// self at stack index 1. Raises if `self` isn't a Button (OnClick is a Button
// script) — callers run it under PCall.
//
// Self-healing against clobbering: addons re-`SetScript("OnClick", …)` their
// own handler (pfUI does it on every raid relayout via UpdateScripts), which
// replaces our closure. So we re-wire whenever a `type*` attribute is (re)set,
// but only when the current OnClick is a *Lua* handler (a real clobber) or nil
// — if it's already a C function it's our own closure, and re-wrapping would
// double-chain. `IsCFunction` cleanly distinguishes the two here (addon click
// handlers are Lua; the only C-function OnClick we ever see is ours).
int __fastcall WireOnClick(void *L) {
Game::Lua::SetTop(L, 1); // (self)
Game::Lua::PushString(L, "OnClick"); // (self, name)
CallScript(Offsets::FUN_SCRIPT_FRAME_GETSCRIPT, L); // (self, name, old)
if (Game::Lua::GetTop(L) < 3) // defensive
Game::Lua::PushNil(L);
Game::Lua::SetTop(L, 3); // (self, name, old|nil)
if (Game::Lua::Type(L, 3) == Game::Lua::TYPE_FUNCTION &&
Game::Lua::IsCFunction(L, 3) != 0)
return 0; // already our closure
Game::Lua::PushValue(L, 1); // (self, name, old, self)
Game::Lua::PushCClosure(L, &OnClick_c, 2); // upvalues (old, self)
CallScript(Offsets::FUN_SCRIPT_FRAME_SETSCRIPT, L);
return 0;
}
// ---- OnAttributeChanged script (settable via SetScript, like retail) --------
//
// Backport of the modern `OnAttributeChanged` widget script: SetAttribute (but
// NOT SetAttributeNoHandler) fires the frame's OnAttributeChanged handler. 1.12
// has no such script; Frame::ExtraScripts makes it SetScript/GetScript/
// HookScript-able on every frame.
const Frame::ExtraScripts::Script g_onAttributeChanged{"onattributechanged", Offsets::VAR_FRAME_LUA_TYPE_ID};
// Fire OnAttributeChanged on `frame` — 4.3.4's
// CSimpleFrame::RunOnAttributeChangedScript: the handler gets the lowercased
// name and the new value (still at stack[3] in DoSet) as real arguments,
// `(self, name, value)`, plus the vanilla `this`/`arg1`/`arg2` globals.
// RunWithValues carries arbitrary Lua values, which the engine's
// printf-style runners cannot, and restores the stack and globals.
//
// No recursion guard, as in 4.3.4: a handler that sets attributes — its own
// or another frame's — fires their handlers too. Secure headers and the
// state driver depend on that. A runaway loop ends at Lua's C-call limit as
// an ordinary, reported script error.
void FireAttributeChanged(void *L, void *frame, const char *name) {
if (frame == nullptr)
return;
uint32_t *slot = g_onAttributeChanged.Slot(frame);
if (slot == nullptr || slot[0] == 0)
return;
const int top = Game::Lua::GetTop(L);
Game::Lua::PushString(L, name);
if (top >= 3)
Game::Lua::PushValue(L, 3); // the new value
else
Game::Lua::PushNil(L);
Frame::ScriptArgs::RunWithValues(L, static_cast(slot[0]), frame, top + 1, 2);
Game::Lua::SetTop(L, top);
}
// ---- the methods -----------------------------------------------------------
// Enables the frame's mouse so it can become the mouse-focus (a bare frame
// otherwise never registers as hovered).
//
// Two properties, both deliberate:
// * STACK-NEUTRAL. The old form did SetTop(L, 1) to set up (self, true) for
// the engine setter, which DESTROYED the (name, value) at stack[2]/[3] that
// FireAttributeChanged reads right after — handing any OnAttributeChanged
// handler a nil `arg2`. We instead push the call at the top and restore the
// caller's stack, so DoSet's (self, name, value) survives intact.
// * PROTECTED. SetAttribute is Frame-scoped (VAR_FRAME_METHOD_REGISTRY), so
// `self` is a real Frame and the setter's type check normally passes;
// invoking through lua_pcall is belt-and-suspenders so a best-effort side
// effect can never surface an error in the addon's SetAttribute. (Calling
// via pcall is also what lets us pass the args at the callee's own stack
// base without clobbering ours.)
void EnableFrameMouse(void *L) {
const int top = Game::Lua::GetTop(L);
Game::Lua::PushCClosure(
L,
reinterpret_cast(Offsets::FUN_SCRIPT_FRAME_ENABLEMOUSE),
0);
Game::Lua::PushValue(L, 1); // self (the frame)
Game::Lua::PushBoolean(L, 1); // enable = true
Game::Lua::PCall(L, 2, 0, 0); // best-effort; swallow a transient type error
Game::Lua::SetTop(L, top); // restore the caller's stack
}
// (self, name, value). `usage` is the method's error text; 4.3.4 requires
// the value argument to be present (`lua_type(L, 3) != LUA_TNONE`), so
// `SetAttribute("x")` is an error while `SetAttribute("x", nil)` clears.
int DoSet(void *L, bool fireHandler, const char *usage) {
void *frame = Game::Lua::ResolveFrame(L);
if (frame == nullptr)
return 0;
if (!Game::Lua::IsString(L, 2) || Game::Lua::GetTop(L) < 3) {
Game::Lua::Error(L, usage, Game::Lua::ObjectDisplayName(frame));
return 0;
}
Game::Lua::SetTop(L, 3);
char lname[256];
LowerCopy(lname, Game::Lua::ToString(L, 2), sizeof lname);
if (PushSub(L, 1, true)) { // [.., sub]
const int si = Game::Lua::GetTop(L);
Game::Lua::PushString(L, lname); // [.., sub, key]
Game::Lua::PushValue(L, 3); // [.., sub, key, value] (nil if absent)
Game::Lua::RawSet(L, si); // sub[lname] = value
Game::Lua::SetTop(L, si - 1); // drop sub
}
const bool isString = Game::Lua::Type(L, 3) == Game::Lua::TYPE_STRING;
// `unit` drives the mouseover binding: index it by the frame's C object
// (the key the mouse-focus poll uses) and enable its mouse so it can be
// hovered.
if (std::strcmp(lname, "unit") == 0) {
if (isString) {
if (g_unitFrames.insert(frame).second)
EnableFrameMouse(L);
} else {
g_unitFrames.erase(frame);
}
}
// A `type*` attribute makes the frame a clickable unit button: (re)install
// the chained OnClick (PCall-guarded — OnClick is Button-only). WireOnClick
// is idempotent and self-healing, so calling it on every `type*` set both
// avoids double-chaining and reinstalls after an addon clobbered our
// OnClick — set `type*` again after re-SetScript to recover. The handler
// reads all the attributes fresh at click time. IsTypeAttr covers every
// form the resolver reads (type, typeN, modifier-prefixed), so a middle-
// click or modifier-only binding still wires.
else if (IsTypeAttr(lname) && isString) {
Game::Lua::PushCClosure(L, &WireOnClick, 0);
Game::Lua::PushValue(L, 1); // arg = self
Game::Lua::PCall(L, 1, 0, 0); // ignore errors (non-Button frame)
}
if (fireHandler)
FireAttributeChanged(L, frame, lname);
return 0;
}
int __fastcall Script_SetAttribute(void *L) {
return DoSet(L, /*fireHandler*/ true, "Usage: %s:SetAttribute(\"name\", value)");
}
int __fastcall Script_SetAttributeNoHandler(void *L) {
return DoSet(L, /*fireHandler*/ false,
"Usage: %s:SetAttributeNoHandler(\"name\", value)");
}
// `cleared = frame:ClearAttribute("name")` — retail (11.2.0) attribute removal;
// `cleared` is true iff the attribute was set (and is now gone). Routes through
// DoSet's nil-value path so it also drops a `unit` mouseover binding, but does
// NOT fire OnAttributeChanged — verified against retail (a live 12.0 test showed
// ClearAttribute firing no handler, unlike SetAttribute).
int __fastcall Script_ClearAttribute(void *L) {
void *frame = Game::Lua::ResolveFrame(L);
if (frame == nullptr)
return 0;
if (!Game::Lua::IsString(L, 2)) {
Game::Lua::Error(L, "Usage: %s:ClearAttribute(\"name\")",
Game::Lua::ObjectDisplayName(frame));
return 0;
}
char lname[256];
LowerCopy(lname, Game::Lua::ToString(L, 2), sizeof lname);
const bool existed = TryPushValue(L, 1, lname); // leaves the value on top if set
if (existed)
Game::Lua::SetTop(L, Game::Lua::GetTop(L) - 1); // drop the peeked value
Game::Lua::SetTop(L, 2); // (self, name)
Game::Lua::PushNil(L); // (self, name, nil) → value = nil clears the key
DoSet(L, /*fireHandler*/ false, ""); // retail ClearAttribute fires no OnAttributeChanged
Game::Lua::PushBool(L, existed);
return 1;
}
// 4.3.4's Script_GetAttribute. The 3-arg form `(prefix, name, suffix)` is
// taken only with exactly those three arguments and a string name; a nil
// prefix or suffix counts as empty. Lookup order: prefix..name..suffix,
// "*"..name..suffix, prefix..name.."*", "*"..name.."*", then name.
int __fastcall Script_GetAttribute(void *L) {
void *frame = Game::Lua::ResolveFrame(L);
if (frame == nullptr)
return 0;
if (Game::Lua::GetTop(L) == 4 && Game::Lua::IsString(L, 3)) {
const char *pfx = Game::Lua::IsString(L, 2) ? Game::Lua::ToString(L, 2) : "";
const char *nm = Game::Lua::ToString(L, 3);
const char *sfx = Game::Lua::IsString(L, 4) ? Game::Lua::ToString(L, 4) : "";
char key[256];
Compose3Lower(key, sizeof key, pfx, nm, sfx);
if (TryPushValue(L, 1, key)) return 1;
Compose3Lower(key, sizeof key, "*", nm, sfx);
if (TryPushValue(L, 1, key)) return 1;
Compose3Lower(key, sizeof key, pfx, nm, "*");
if (TryPushValue(L, 1, key)) return 1;
Compose3Lower(key, sizeof key, "*", nm, "*");
if (TryPushValue(L, 1, key)) return 1;
Compose3Lower(key, sizeof key, "", nm, "");
if (TryPushValue(L, 1, key)) return 1;
Game::Lua::PushNil(L);
return 1;
}
if (!Game::Lua::IsString(L, 2)) {
Game::Lua::Error(L, "Usage: %s:GetAttribute(\"name\")",
Game::Lua::ObjectDisplayName(frame));
return 0;
}
char lname[256];
LowerCopy(lname, Game::Lua::ToString(L, 2), sizeof lname);
if (TryPushValue(L, 1, lname))
return 1;
Game::Lua::PushNil(L);
return 1;
}
// ---- XML --------------------------------------------------------
// 4.3.4's CSimpleFrame::LoadXML_Attributes, for each `` child of
// a frame element:
//
//
//
//
//
//
// `type` is nil / boolean / number / string (the default), converted with the
// loader's own helpers (FUN_XML_ATTR_TO_BOOL, FUN_SSTR_TO_FLOAT). Like 4.3.4
// it stores without firing OnAttributeChanged — here by calling our own
// SetAttributeNoHandler, so a `unit` or `type*` set from XML has the same
// effect as one set from Lua. It runs after the engine has loaded the whole
// node (Xml::FrameLoad), so the element's are already in place, and
// inherited templates are loaded first, so the frame's own values win.
// Problems are the engine's load warnings, with 4.3.4's texts.
void LoadXmlAttributes(void *L, void *frame, const void *attributes, void *status) {
using ToFloat_t = float(__stdcall *)(const char *);
const int top = Game::Lua::GetTop(L);
int frameIdx = 0;
for (const void *e = Xml::FirstChild(attributes); e != nullptr; e = Xml::NextSibling(e)) {
const char *frameName = Game::Lua::ObjectDisplayName(frame);
if (!Xml::TagIs(e, "Attribute")) {
Xml::Warn(status, "Frame %s: Unknown attributes element %s", frameName, Xml::Tag(e));
continue;
}
const char *name = Xml::Attr(e, "name");
if (name == nullptr) {
Xml::Warn(status, "Frame %s: unnamed attribute element", frameName);
continue;
}
const char *type = Xml::Attr(e, "type");
if (type == nullptr)
type = "string";
const char *value = Xml::Attr(e, "value");
const bool isNil = Ascii::EqualCI(type, "nil");
if (value == nullptr && !isNil) {
Xml::Warn(status, "Frame %s: attribute element named %s missing value",
frameName, name);
continue;
}
if (frameIdx == 0) {
if (!Xml::PushWrapper(L, frame))
break;
frameIdx = Game::Lua::GetTop(L);
}
Game::Lua::PushCClosure(L, &Script_SetAttributeNoHandler, 0);
Game::Lua::PushValue(L, frameIdx);
Game::Lua::PushString(L, name);
if (isNil)
Game::Lua::PushNil(L);
else if (Ascii::EqualCI(type, "boolean"))
Game::Lua::PushBool(L, Game::StringToFlag(value));
else if (Ascii::EqualCI(type, "number"))
Game::Lua::PushNumber(L, reinterpret_cast(Offsets::FUN_SSTR_TO_FLOAT)(value));
else
Game::Lua::PushString(L, value);
Game::Lua::PCall(L, 3, 0, 0);
Game::Lua::SetTop(L, frameIdx);
}
Game::Lua::SetTop(L, top);
}
void OnFrameNode(void *frame, const void *node, void *status) {
void *L = nullptr;
for (const void *c = Xml::FirstChild(node); c != nullptr; c = Xml::NextSibling(c)) {
if (!Xml::TagIs(c, "Attributes"))
continue;
if (L == nullptr && (L = Game::Lua::State()) == nullptr)
return;
LoadXmlAttributes(L, frame, c, status);
}
}
const Xml::FrameLoad::AutoSubscribe _frameNode{&OnFrameNode};
// ---- registration ----------------------------------------------------------
const Game::Lua::FrameMethodEntry g_frameMethods[] = {
{"SetAttribute", &Script_SetAttribute},
{"SetAttributeNoHandler", &Script_SetAttributeNoHandler},
{"ClearAttribute", &Script_ClearAttribute},
{"GetAttribute", &Script_GetAttribute},
};
void RegisterLuaFunctions() {
Game::Lua::RegisterFrameMethods(
reinterpret_cast(Offsets::VAR_FRAME_METHOD_REGISTRY),
g_frameMethods,
static_cast(sizeof(g_frameMethods) / sizeof(g_frameMethods[0])));
}
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
const Tick::WorldTick::AutoSubscribe _tick{&MouseoverTick};
} // namespace
// Drop the per-frame map before a /reload (or logout) resets the Lua state.
// It is keyed by the frame's C object pointer, which the allocator recycles
// across a reload: g_unitFrames records which frames already had their mouse
// enabled, and a stale entry at a reused address would skip enabling a new
// frame's. (The OnAttributeChanged cells are dropped by Frame::ExtraScripts.)
void PrepareForReload() {
g_unitFrames.clear();
}
static const Game::ReloadAutoRegister _reloadReg{&PrepareForReload};
} // namespace Frame::Attributes