// This file is part of ClassicAPI. // // ClassicAPI is free software: you can redistribute it and/or modify it under the terms // of the GNU Lesser 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 Lesser General Public License for more details. // // You should have received a copy of the GNU Lesser General Public License along with // ClassicAPI. If not, see . #include "Game.h" #include "Offsets.h" #include "spell/Lookup.h" #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; // AttributesEx bit 6 — funnel flag per the public Spell.dbc schema. static constexpr uint32_t SPELL_ATTR_EX_FUNNEL = 0x40; 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 = BookTypeIsPet(book) ? 1 : 0; 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::PushBoolean(L, info.isFunnel ? 1 : 0); // 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::PushBoolean(L, value ? 1 : 0); Game::Lua::RawSet(L, -3); } static int __fastcall Script_C_GetSpellInfo(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: C_Spell.GetSpellInfo(spellID)"); return 0; } const int spellID = static_cast(Game::Lua::ToNumber(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) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: C_Spell.GetSpellName(spellID)"); return 0; } const int spellID = static_cast(Game::Lua::ToNumber(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) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: C_Spell.GetSpellTexture(spellID)"); return 0; } const int spellID = static_cast(Game::Lua::ToNumber(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; } static void RegisterLuaFunctions() { Game::Lua::RegisterGlobalFunction("GetSpellInfo", &Script_GetSpellInfo); 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); } static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace Spell::Info