// 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 . #include "Game.h" #include "Offsets.h" #include "player/StatSignal.h" #include "spell/Arg.h" #include "spell/Lookup.h" #include #include namespace Spell::Info { // Spell.dbc record offsets (from BuildSpellTooltip / Script_GetSpellName / Script_GetSpellTexture). static constexpr int OFF_ATTRIBUTES_EX = 0x1C; static constexpr int OFF_CASTING_TIME_INDEX = 0x48; static constexpr int OFF_POWER_TYPE = 0x7C; static constexpr int OFF_MANA_COST = 0x80; static constexpr int OFF_RANGE_INDEX = 0x90; static constexpr int OFF_ICON_ID = 0x1D4; static constexpr int OFF_NAME = 0x1E0; static constexpr int OFF_RANK = 0x204; // Spell.dbc Attributes (+0x18) and AttributesEx (+0x1C) flag bits we read. // Both bits are 0x40, but on different fields: // Attributes bit 6 = SPELL_ATTR_PASSIVE — passive spell (no cast bar, // applies its effect as soon as learned/equipped) // AttributesEx bit 6 = SPELL_ATTR_EX_FUNNEL_PERCENT — funnel channel static constexpr int OFF_ATTRIBUTES = 0x18; static constexpr uint32_t SPELL_ATTR_PASSIVE = 0x40; static constexpr uint32_t SPELL_ATTR_EX_FUNNEL = 0x40; // Spell.dbc effect-target arrays. Each spell has 3 effects, each // with an implicit target A and an implicit target B (the latter // often 0). Used by IsSpellHarmful / IsSpellHelpful — vanilla has // no dedicated "positive"/"negative" attribute flag (AttributesEx // bit 0x80 = NEGATIVE is sparsely set — most damage spells don't // have it), so we classify by walking effect targets and checking // whether any falls into a known hostile-target or friendly-target // set. Same algorithm CMaNGOS uses in `SpellMgr::IsPositiveSpell`. static constexpr int OFF_EFFECT_IMPLICIT_TARGET_A = 0x148; // uint32[3] static constexpr int OFF_EFFECT_IMPLICIT_TARGET_B = 0x154; // uint32[3] // Target IDs from vanilla 1.12's `SpellTarget` enum that mark a // spell as hostile-targeted (covers single-target damage, // debuffs, AoE damage, etc.). List is conservative — anything not // in here defaults to non-hostile. static bool IsHostileTarget(uint32_t t) { switch (t) { case 6: // TARGET_CHAIN_DAMAGE (Fireball, Polymorph, …) case 15: // TARGET_ALL_ENEMY_IN_AREA case 16: // TARGET_ALL_ENEMY_IN_AREA_INSTANT case 25: // TARGET_DUELVSPLAYER case 28: // TARGET_ALL_ENEMY_IN_AREA_CHANNELED case 36: // TARGET_ALL_HOSTILE_UNITS_AROUND_CASTER case 47: // TARGET_SINGLE_ENEMY case 53: // TARGET_LARGE_FRONTAL_CONE (hostile cone) case 54: // TARGET_NARROW_FRONTAL_CONE return true; default: return false; } } // Friendly-targeted set (including self-cast). Same caveat — list // is curated, false-negatives are possible for edge cases. static bool IsFriendlyTarget(uint32_t t) { switch (t) { case 1: // TARGET_SELF case 5: // TARGET_PET case 20: // TARGET_ALL_PARTY_AROUND_CASTER case 21: // TARGET_SINGLE_FRIEND case 30: // TARGET_ALL_FRIENDLY_UNITS_AROUND_CASTER case 31: // TARGET_ALL_FRIENDLY_UNITS_IN_AREA case 33: // TARGET_ALL_PARTY case 34: // TARGET_ALL_PARTY_AROUND_CASTER_2 case 35: // TARGET_SINGLE_PARTY case 37: // TARGET_AREAEFFECT_PARTY case 40: // TARGET_CHAIN_HEAL case 45: // TARGET_DYNAMIC_OBJECT_RIGHT_SIDE (friendly buffs use this) case 56: // TARGET_RANDOM_NEARBY_LOC (totem placement) case 57: // TARGET_RANDOM_CIRCUMFERENCE_POINT case 61: // TARGET_RANDOM_FRIEND_AROUND_CASTER case 68: // TARGET_NONCOMBAT_PET case 77: // TARGET_SINGLE_FRIEND_2 case 80: // TARGET_AREAEFFECT_PARTY_AND_CLASS return true; default: return false; } } template static T ReadGlobal(uintptr_t addr) { return *reinterpret_cast(addr); } // Sub-DBC lookup (SpellIcon, SpellCastTimes, SpellRange) — these are the // "indirected fields" of a Spell.dbc record. Different base/count // addresses than the main Spell.dbc, so they don't go through // `Spell::Lookup::RecordForID`. static const uint8_t *LookupSubRecord(uintptr_t baseAddr, uintptr_t countAddr, int id) { if (id <= 0) return nullptr; const int count = ReadGlobal(countAddr); if (id > count) return nullptr; const uint8_t *const *records = ReadGlobal(baseAddr); if (records == nullptr) return nullptr; return records[id]; } struct SpellInfoData { int spellID; const char *name; // localized; nullable if record's locale slot is unset const char *rank; // localized; same nullability as name const char *iconPath; // SpellIcon.dbc path; null if icon record missing int cost; // base ManaCost (no per-level scaling) bool isFunnel; int powerType; // 0=mana, 1=rage, 2=focus, 3=energy, 4=happiness int castTimeMs; // base time from SpellCastTimes.dbc float minRange; float maxRange; }; static bool ReadSpellInfo(int spellID, SpellInfoData &out) { const uint8_t *record = Spell::Lookup::RecordForID(spellID); if (record == nullptr) return false; const int locale = ReadGlobal(Offsets::VAR_LOCALE_INDEX); out.spellID = spellID; out.name = *reinterpret_cast(record + OFF_NAME + locale * 4); out.rank = *reinterpret_cast(record + OFF_RANK + locale * 4); out.iconPath = nullptr; const int iconID = *reinterpret_cast(record + OFF_ICON_ID); if (auto *iconRec = LookupSubRecord(Offsets::VAR_SPELL_ICON_RECORDS, Offsets::VAR_SPELL_ICON_COUNT, iconID)) { out.iconPath = *reinterpret_cast(iconRec + 4); } out.cost = *reinterpret_cast(record + OFF_MANA_COST); const uint32_t attrEx = *reinterpret_cast(record + OFF_ATTRIBUTES_EX); out.isFunnel = (attrEx & SPELL_ATTR_EX_FUNNEL) != 0; out.powerType = *reinterpret_cast(record + OFF_POWER_TYPE); out.castTimeMs = 0; const int castIndex = *reinterpret_cast(record + OFF_CASTING_TIME_INDEX); if (auto *castRec = LookupSubRecord(Offsets::VAR_SPELL_CAST_TIMES_RECORDS, Offsets::VAR_SPELL_CAST_TIMES_COUNT, castIndex)) { out.castTimeMs = *reinterpret_cast(castRec + 4); } out.minRange = 0.0f; out.maxRange = 0.0f; const int rangeIndex = *reinterpret_cast(record + OFF_RANGE_INDEX); if (auto *rangeRec = LookupSubRecord(Offsets::VAR_SPELL_RANGE_RECORDS, Offsets::VAR_SPELL_RANGE_COUNT, rangeIndex)) { out.minRange = *reinterpret_cast(rangeRec + 4); out.maxRange = *reinterpret_cast(rangeRec + 8); } return true; } // Case-insensitive match against the literal string "pet". Anything else // (including the explicit "spell") maps to the player spellbook — // matches 1.12's `Script_GetSpellName` behavior, which `SStrCmpI`s the // input against "pet" and treats every other value as the player book. static bool BookTypeIsPet(const char *s) { if (s == nullptr) return false; auto lc = [](char c) -> char { return (c >= 'A' && c <= 'Z') ? static_cast(c + 32) : c; }; return lc(s[0]) == 'p' && lc(s[1]) == 'e' && lc(s[2]) == 't' && s[3] == '\0'; } // Resolves the Lua args to a spellID, supporting: // GetSpellInfo(spellID) -- arg2 absent or non-string // GetSpellInfo(slot, "spell"|"pet") -- arg2 string → spellbook lookup // Returns 0 for invalid/empty inputs (Lua side surfaces 0 as nil since // spellID 0 is never valid). Calls `lua_error` if arg1 isn't a number, // matching the engine's own `lua_error`-on-misuse style. static int ResolveLuaArgsToSpellID(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: GetSpellInfo(spellID) or GetSpellInfo(slot, bookType)"); return 0; } const int arg1 = static_cast(Game::Lua::ToNumber(L, 1)); if (Game::Lua::Type(L, 2) == Game::Lua::TYPE_STRING) { const char *book = Game::Lua::ToString(L, 2); const int bookType = static_cast(BookTypeIsPet(book)); return Spell::Lookup::SpellbookSlotToID(arg1, bookType); } return arg1; } static int __fastcall Script_GetSpellInfo(void *L) { const int spellID = ResolveLuaArgsToSpellID(L); if (spellID <= 0) return 0; SpellInfoData info; if (!ReadSpellInfo(spellID, info)) return 0; // PushString tail-calls PushNil for null pointers, so unset locale // slots (rare, but possible) come through as nil rather than crash. Game::Lua::PushString(L, info.name); // 1. name Game::Lua::PushString(L, info.rank); // 2. rank Game::Lua::PushString(L, info.iconPath); // 3. icon (path string) Game::Lua::PushNumber(L, static_cast(info.cost)); // 4. cost Game::Lua::PushBool(L, info.isFunnel); // 5. isFunnel Game::Lua::PushNumber(L, static_cast(info.powerType)); // 6. powerType Game::Lua::PushNumber(L, static_cast(info.castTimeMs)); // 7. castTime (ms) Game::Lua::PushNumber(L, static_cast(info.minRange)); // 8. minRange Game::Lua::PushNumber(L, static_cast(info.maxRange)); // 9. maxRange Game::Lua::PushNumber(L, static_cast(info.spellID)); // 10. spellID (NEW) return 10; } // Helpers for building the C_Spell.GetSpellInfo result table. Each // expects the table at stack[-3] before the call (key + value get // pushed onto top, then `RawSet(L, -3)` pops them and sets the field). static void SetField(void *L, const char *key, const char *value) { Game::Lua::PushString(L, key); Game::Lua::PushString(L, value); // PushString handles NULL -> nil Game::Lua::RawSet(L, -3); } static void SetField(void *L, const char *key, double value) { Game::Lua::PushString(L, key); Game::Lua::PushNumber(L, value); Game::Lua::RawSet(L, -3); } static void SetFieldBool(void *L, const char *key, bool value) { Game::Lua::PushString(L, key); Game::Lua::PushBool(L, value); Game::Lua::RawSet(L, -3); } static int __fastcall Script_C_GetSpellInfo(void *L) { const int spellID = Spell::Arg::ResolveSpellID(L, 1); SpellInfoData info; if (!ReadSpellInfo(spellID, info)) return 0; // nil for unknown spellID Game::Lua::NewTable(L); SetField(L, "name", info.name); // `iconID` deviates from modern's fileID:number — vanilla has no // fileID system, so we surface the icon path string instead. // Practical: feed it directly to texture:SetTexture(...). SetField(L, "iconID", info.iconPath); SetField(L, "castTime", static_cast(info.castTimeMs)); SetField(L, "minRange", static_cast(info.minRange)); SetField(L, "maxRange", static_cast(info.maxRange)); SetField(L, "spellID", static_cast(info.spellID)); // Vanilla extras beyond the modern signature — present in 1.12's // Spell.dbc, no harm including them for addons backporting from // 3.3.5 where the same data was exposed positionally. SetField(L, "rank", info.rank); SetField(L, "cost", static_cast(info.cost)); SetFieldBool(L, "isFunnel", info.isFunnel); SetField(L, "powerType", static_cast(info.powerType)); return 1; } static int __fastcall Script_C_GetSpellName(void *L) { const int spellID = Spell::Arg::ResolveSpellID(L, 1); const uint8_t *record = Spell::Lookup::RecordForID(spellID); if (record == nullptr) return 0; // nil for unknown spellID const int locale = ReadGlobal(Offsets::VAR_LOCALE_INDEX); const char *name = *reinterpret_cast(record + OFF_NAME + locale * 4); if (name == nullptr || *name == '\0') return 0; // empty / no name in current locale → nil Game::Lua::PushString(L, name); return 1; } static int __fastcall Script_C_GetSpellTexture(void *L) { const int spellID = Spell::Arg::ResolveSpellID(L, 1); const uint8_t *record = Spell::Lookup::RecordForID(spellID); if (record == nullptr) return 0; const int iconID = *reinterpret_cast(record + OFF_ICON_ID); auto *iconRec = LookupSubRecord(Offsets::VAR_SPELL_ICON_RECORDS, Offsets::VAR_SPELL_ICON_COUNT, iconID); if (iconRec == nullptr) return 0; const char *path = *reinterpret_cast(iconRec + 4); if (path == nullptr || *path == '\0') return 0; Game::Lua::PushString(L, path); return 1; } // Builds the spell hyperlink string `|cff71d5ff|Hspell:ID:0|h[Name]|h|r` // into `out`. The trailing `:0` after the spellID matches modern's // hyperlink format (the field's a sub-data slot used for pet-spellbook // flags etc. in later expansions); 1.12 ignores it during link parsing // but addons grepping with `|Hspell:(%d+):` patterns will pick it up. // // Returns false if the spellID is invalid, the locale-resolved name is // missing, or the output buffer is too small (the caller's 256-byte // stack buffer is comfortable for any vanilla spell name). static bool BuildSpellLink(int spellID, char *out, size_t outLen) { const uint8_t *record = Spell::Lookup::RecordForID(spellID); if (record == nullptr) return false; const int locale = ReadGlobal(Offsets::VAR_LOCALE_INDEX); const char *name = *reinterpret_cast(record + OFF_NAME + locale * 4); if (name == nullptr || *name == '\0') return false; const int n = std::snprintf(out, outLen, "|cff71d5ff|Hspell:%d:0|h[%s]|h|r", spellID, name); return n > 0 && static_cast(n) < outLen; } // `GetSpellLink(spellID)` / `GetSpellLink(slot, bookType)` — same arg // shape as `GetSpellInfo`. Returns `(linkString, spellID)`. The second // return is what makes the spellbook overload useful: callers can pass // in `(slot, "spell")` and get back both the link AND the resolved // spellID without a separate lookup. static int __fastcall Script_GetSpellLink(void *L) { const int spellID = ResolveLuaArgsToSpellID(L); if (spellID <= 0) return 0; char buf[256]; if (!BuildSpellLink(spellID, buf, sizeof(buf))) return 0; Game::Lua::PushString(L, buf); Game::Lua::PushNumber(L, static_cast(spellID)); return 2; } // `C_Spell.GetSpellLink(spellID)` — table-namespace version. Returns // only the link string (modern omits the spellID echo since the caller // already had it on hand to call this). static int __fastcall Script_C_GetSpellLink(void *L) { const int spellID = Spell::Arg::ResolveSpellID(L, 1); if (spellID <= 0) return 0; char buf[256]; if (!BuildSpellLink(spellID, buf, sizeof(buf))) return 0; Game::Lua::PushString(L, buf); return 1; } // `FindSpellBookSlotByID(spellID)` — inverse of `GetSpellName(slot, // bookType)`. Searches the player spellbook first, then the pet // spellbook, for a slot whose spellID matches. Returns // `(slot, bookType)` so callers can feed both directly into the // existing slot-and-bookType API surface (`GetSpellName`, // `GetSpellTexture`, etc.). Returns nil if the spellID isn't currently // in either book. static int __fastcall Script_FindSpellBookSlotByID(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: FindSpellBookSlotByID(spellID)"); return 0; } const int spellID = static_cast(Game::Lua::ToNumber(L, 1)); int bookType = 0; const int slot = Spell::Lookup::FindSpellbookSlot(spellID, &bookType); if (slot == 0) return 0; Game::Lua::PushNumber(L, static_cast(slot)); Game::Lua::PushString(L, bookType == 1 ? "pet" : "spell"); return 2; } // Shared back-end for both passive-spell query forms. Reads `Attributes` // (+0x18) bit 6 (`SPELL_ATTR_PASSIVE`) off the Spell.dbc record and // pushes the boolean. Returns 1 with a boolean on the Lua stack for a // valid spellID, 0 (= nil to Lua) for an invalid one. static int PushIsPassive(void *L, int spellID) { if (spellID <= 0) return 0; const uint8_t *record = Spell::Lookup::RecordForID(spellID); if (record == nullptr) return 0; const uint32_t attr = *reinterpret_cast(record + OFF_ATTRIBUTES); Game::Lua::PushBool(L, (attr & SPELL_ATTR_PASSIVE) != 0); return 1; } // `IsPassiveSpell(spellID)` / `IsPassiveSpell(slot, bookType)` — same // arg shape as `GetSpellInfo`. The 3.0-era global form; takes either a // spellID directly or a spellbook slot + bookType (`"spell"` / `"pet"`). static int __fastcall Script_IsPassiveSpell(void *L) { return PushIsPassive(L, ResolveLuaArgsToSpellID(L)); } // `C_Spell.IsSpellPassive(spellID)` — modern table-namespace form // (10.0+; word order flipped from the older `IsPassiveSpell`). // Takes a spellID only — `C_Spell.*` calls don't accept the spellbook // slot+bookType shape. static int __fastcall Script_C_IsSpellPassive(void *L) { return PushIsPassive(L, Spell::Arg::ResolveSpellID(L, 1)); } // `IsPlayerSpell(spellID)` — returns true if the player currently // "knows" the given spellID. Covers everything: trained class abilities, // racials, talent passives, profession recipes (including ones learned // from vendors / discovered tradeskill recipes), and anything else // granted by SMSG_LEARNED_SPELL. // // Implementation: single bitmap lookup at `[VAR_PLAYER_SPELL_BITMAP]`. // The engine maintains a dword bitmap of every spellID the player // knows (one bit per spellID, indexed by `spellID`); learning/unlearning // updates this bitmap. We just consult the same bit the engine itself // reads via the helper at `0x0060C740` — no walks, no profession // caching, no per-source data structure. // // Trade-offs vs. the older spellbook+talent walk implementation: // - Faster (one memory access vs hundreds of comparisons). // - Broader (covers profession recipes that are not in the spellbook // arrays and not in the talent tree). // - Same shape modern WoW (5.4.8+) uses for the same function — see // `[0x011C25D8]` in 5.4.8's `Wow.exe`. static int __fastcall Script_IsPlayerSpell(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: IsPlayerSpell(spellID)"); return 0; } const int spellID = static_cast(Game::Lua::ToNumber(L, 1)); if (spellID < 1) { Game::Lua::PushBool(L, 0); return 1; } const int spellCount = *reinterpret_cast( static_cast(Offsets::VAR_SPELL_RECORD_COUNT)); if (spellID > spellCount) { Game::Lua::PushBoolean(L, 0); return 1; } auto *bitmap = *reinterpret_cast( static_cast(Offsets::VAR_PLAYER_SPELL_BITMAP)); if (bitmap == nullptr) { Game::Lua::PushBoolean(L, 0); return 1; } const uint32_t mask = 1u << (spellID & 31); const bool isKnown = (bitmap[spellID >> 5] & mask) != 0; Game::Lua::PushBoolean(L, isKnown); return 1; } // `IsSpellKnown(spellID, [isPet])` — strict spellbook check, scoped to // the player or pet spellbook depending on `isPet` (default false). // // Critically NOT the same as `IsPlayerSpell`: this is the narrower // modern-semantics function. Returns true only for spells the player // has as a usable spellbook entry (trained class abilities, active // talent grants, racials that appear in the spellbook). Returns false // for talent passives, profession recipes, and anything else that's // "known" but not displayable as a spellbook button. // // Verified against 3.3.5's `Script_IsSpellKnown` at `0x0053C3A0`, // whose inner function at `0x0053B4E0` walks the spellbook arrays // (`[0x00BE6D88]` player / `[0x00BE7D98]` pet) with their respective // counts — strict array scan, not a bitmap. Same shape applies in // 1.12: the spellbook arrays at `VAR_PLAYER_SPELLBOOK` / // `VAR_PET_SPELLBOOK` are the authoritative spellbook display data, // so we walk those via the existing `Spell::Lookup::FindSpellbookSlot` // and filter by the book type the caller asked for. // // Use `IsPlayerSpell(spellID)` for the broader "any kind of known" // check (covers recipes, passives, etc.). static int __fastcall Script_IsSpellKnown(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: IsSpellKnown(spellID, [isPet])"); return 0; } const int spellID = static_cast(Game::Lua::ToNumber(L, 1)); if (spellID < 1) { Game::Lua::PushBool(L, 0); return 1; } const int wantBookType = static_cast(Game::Lua::ToBoolean(L, 2) != 0); int bookType = -1; const int slot = Spell::Lookup::FindSpellbookSlot(spellID, &bookType); const bool found = (slot > 0 && bookType == wantBookType); Game::Lua::PushBoolean(L, found); return 1; } // Walks the spell's 3 effects' implicit target IDs (both A and B // slots) and returns true if `pred` matches any of them. Returns // false for null records. template static bool AnyEffectTarget(const uint8_t *record, Pred pred) { if (record == nullptr) return false; auto *targetsA = reinterpret_cast( record + OFF_EFFECT_IMPLICIT_TARGET_A); auto *targetsB = reinterpret_cast( record + OFF_EFFECT_IMPLICIT_TARGET_B); for (int i = 0; i < 3; ++i) { if (pred(targetsA[i]) || pred(targetsB[i])) return true; } return false; } // `IsSpellHarmful(spellID)` — true iff any effect of the spell // targets a hostile-target type (chain damage, single enemy, AoE // enemy, etc. — see `IsHostileTarget`). Same algorithm CMaNGOS uses // to classify positive vs negative spells, since vanilla 1.12 has // no dedicated "harmful" attribute bit (the `SPELL_ATTR_EX_NEGATIVE` // flag is sparsely set — most damage spells don't have it). static bool ComputeIsHarmful(int spellID) { const uint8_t *record = Spell::Lookup::RecordForID(spellID); return AnyEffectTarget(record, &IsHostileTarget); } // `IsSpellHelpful(spellID)` — true iff any effect targets a // friendly-target type (self, party, single friend, chain heal, // etc.). Disjoint from harmful in practice for vanilla spells — // most spells are clearly one or the other — but they aren't // strict inverses: a few utility/geometry-targeted spells (script- // driven, totem placement, etc.) return false for both. static bool ComputeIsHelpful(int spellID) { const uint8_t *record = Spell::Lookup::RecordForID(spellID); return AnyEffectTarget(record, &IsFriendlyTarget); } // `IsHarmfulSpell(spellID)` / `IsHarmfulSpell(slot, bookType)` — // modern global. Accepts either form via the same // `ResolveLuaArgsToSpellID` path `GetSpellInfo` uses. static int __fastcall Script_IsHarmfulSpell(void *L) { const int spellID = ResolveLuaArgsToSpellID(L); Game::Lua::PushBool(L, ComputeIsHarmful(spellID)); return 1; } // `IsHelpfulSpell(spellID)` / `IsHelpfulSpell(slot, bookType)` — // modern global. True for spells that exist and aren't marked // harmful. Vanilla 1.12 has no dedicated "helpful" flag in // Spell.dbc, so "non-harmful and present" is the best approximation // without parsing every effect's implicit target. static int __fastcall Script_IsHelpfulSpell(void *L) { const int spellID = ResolveLuaArgsToSpellID(L); Game::Lua::PushBool(L, ComputeIsHelpful(spellID)); return 1; } // `C_Spell.IsSpellHarmful(spellID)` — direct-by-ID modern signature. // No spellbook-slot variant; takes a numeric spellID only. static int __fastcall Script_C_Spell_IsSpellHarmful(void *L) { Game::Lua::PushBool(L, ComputeIsHarmful(Spell::Arg::ResolveSpellID(L, 1))); return 1; } // `C_Spell.IsSpellHelpful(spellID)` — direct-by-ID modern signature. static int __fastcall Script_C_Spell_IsSpellHelpful(void *L) { Game::Lua::PushBool(L, ComputeIsHelpful(Spell::Arg::ResolveSpellID(L, 1))); return 1; } // --- Known-spell-bitmap change signal ------------------------------------ // Learning/unlearning a spell rewrites the bitmap GetSpellBonusHealing scans // for talent conversions (Spiritual Guidance / Ironclad). Co-hook the engine's // learn + unlearn writers and bump Player::StatSignal, so a talent respec // invalidates the healing cache immediately — the same event-driven path as // aura/equipment changes, no polling. Both fire only at login and on // learn/unlearn (never per-frame), so they're safe co-hook targets. using LearnSpell_t = void(__fastcall *)(uint32_t spellID, int notify, uint32_t replacedSpellID); static LearnSpell_t g_origLearnSpell = nullptr; static void __fastcall LearnSpell_h(uint32_t spellID, int notify, uint32_t replacedSpellID) { g_origLearnSpell(spellID, notify, replacedSpellID); Player::StatSignal::Notify(); } static const Game::HookAutoRegister _hookLearnSpell{ Offsets::FUN_LEARN_SPELL, reinterpret_cast(&LearnSpell_h), reinterpret_cast(&g_origLearnSpell)}; using UnlearnSpell_t = void(__fastcall *)(uint32_t spellID, int param2); static UnlearnSpell_t g_origUnlearnSpell = nullptr; static void __fastcall UnlearnSpell_h(uint32_t spellID, int param2) { g_origUnlearnSpell(spellID, param2); Player::StatSignal::Notify(); } static const Game::HookAutoRegister _hookUnlearnSpell{ Offsets::FUN_UNLEARN_SPELL, reinterpret_cast(&UnlearnSpell_h), reinterpret_cast(&g_origUnlearnSpell)}; static void RegisterLuaFunctions() { Game::Lua::RegisterGlobalFunction("GetSpellInfo", &Script_GetSpellInfo); Game::Lua::RegisterGlobalFunction("GetSpellLink", &Script_GetSpellLink); Game::Lua::RegisterGlobalFunction("FindSpellBookSlotByID", &Script_FindSpellBookSlotByID); Game::Lua::RegisterGlobalFunction("IsPassiveSpell", &Script_IsPassiveSpell); Game::Lua::RegisterGlobalFunction("IsPlayerSpell", &Script_IsPlayerSpell); Game::Lua::RegisterGlobalFunction("IsSpellKnown", &Script_IsSpellKnown); Game::Lua::RegisterGlobalFunction("IsHarmfulSpell", &Script_IsHarmfulSpell); Game::Lua::RegisterGlobalFunction("IsHelpfulSpell", &Script_IsHelpfulSpell); Game::Lua::RegisterTableFunction("C_Spell", "GetSpellLink", &Script_C_GetSpellLink); Game::Lua::RegisterTableFunction("C_Spell", "GetSpellInfo", &Script_C_GetSpellInfo); Game::Lua::RegisterTableFunction("C_Spell", "GetSpellName", &Script_C_GetSpellName); Game::Lua::RegisterTableFunction("C_Spell", "GetSpellTexture", &Script_C_GetSpellTexture); Game::Lua::RegisterTableFunction("C_Spell", "IsSpellPassive", &Script_C_IsSpellPassive); Game::Lua::RegisterTableFunction("C_Spell", "IsSpellHarmful", &Script_C_Spell_IsSpellHarmful); Game::Lua::RegisterTableFunction("C_Spell", "IsSpellHelpful", &Script_C_Spell_IsSpellHelpful); } static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace Spell::Info