// 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 . // `C_SpellActivationOverlay.IsSpellOverlayed(spellID)` / `IsSpellOverlayed` // and the SPELL_ACTIVATION_OVERLAY_SHOW / _HIDE / _GLOW_SHOW / _GLOW_HIDE // events — 4.3.4's `CGSpellActivationOverlay`, without its FrameXML: drawing // the alerts and the button glows is the addon's job. // // 4.3.4 keys everything off SpellActivationOverlay.dbc rows, with two triggers: // - an aura on the player (triggerType 0): `OnAuraAdded` fires SHOW with the // row's art and glows every book spell the row's class mask selects; // `OnAuraRemoved` fires HIDE and drops the glows. // - a learned spell turning usable (triggerType 1): `UpdateUsable`, run next // to `CGSpellBook::UpdateUsable` on target, combo-point, aura-state, health // and power changes, retests each such spell and glows what its mask // selects while it is usable. // GLOW_SHOW / GLOW_HIDE fire on a spell's glowing ↔ not-glowing transitions, // and `IsSpellOverlayed` answers "glowing now". After PLAYER_ENTERING_WORLD, // `EnterWorld` fires HIDE with no spell, fires SHOW again for every active // aura row, and reconciles the glows (which survive a /reload — FrameXML's // action buttons ask `IsSpellOverlayed` when they update). // // 1.12 has no SpellActivationOverlay.dbc. The triggers come from: // - Usable: the engine's reactive list (VAR_REACTIVE_SPELL_ENTRIES), the // AttributesEx4 0x200 spells `FireUsableEvents` retests from the same // triggers. It is the 1.12 form of the triggerType-1 rows: 4.3.4 lists // Overpower, Revenge, Execute and Hammer of Wrath; 1.12 flags those plus // Riposte, Counterattack and Mongoose Bite. Turtle's Spell.dbc clears the // bit on Mongoose Bite and sets it on Arcane Surge, warrior Counterattack, // Kill Command and Surprise Attack. We read the answers the engine has just stored, at its // SPELL_UPDATE_USABLE signal, rather than retest: the verdict is // FUN_SPELL_IS_USABLE's, aura states and combo points included (Overpower // is gated by the hidden combo point the server grants on a dodge). A // usable entry glows every book spell with its name — the list's own // identity rule — so a bar slot holding any rank glows. 4.3.4's // triggerType-1 rows have no art (ScreenLocation 0), so these fire no SHOW. // - Aura: `kAuraRows`, the Cata rows (Cata Classic 4.4.2's table, the // nearest Blizzard data to 4.3.4) whose spell 1.12 has under the same ID // and name. Of 83, two qualify — Shadow Trance and the druid's // Clearcasting — and Shadow Trance's mask selects Shadow Bolt in 1.12's // SpellFamilyFlags too (stock and Turtle Spell.dbc, parsed). The other // 81 are spells 1.12 lacks; Era carries no such table at all. // // The active aura rows are read from the player's aura descriptor, not // counted from add / remove calls: a map change clears the descriptor without // per-aura removals (see Aura::Source), so a count would stick. The // descriptor already holds the change when Aura::Source's observers run. // // The SHOW payload is retail's with one substitution: 1.12 has no // FileDataIDs, so the art arrives as its texture path (as LossOfControl // passes spell icons). `locationType` is Enum.ScreenLocationType. #include "Game.h" #include "Offsets.h" #include "aura/Source.h" #include "event/Custom.h" #include "event/EnteringWorld.h" #include "event/SignalHook.h" #include "spell/Lookup.h" #include "unit/Identity.h" #include #include #include #include #include namespace Spell::ActivationOverlay { namespace { // Enum.ScreenLocationType. enum ScreenLocation { CENTER = 0, LEFT = 1, RIGHT = 2, TOP = 3, BOTTOM = 4, TOP_LEFT = 5, TOP_RIGHT = 6, LEFT_OUTSIDE = 7, RIGHT_OUTSIDE = 8, LEFT_RIGHT = 9, TOP_BOTTOM = 10, LEFT_RIGHT_OUTSIDE = 11, }; struct AuraRow { uint32_t spellID; // the aura on the player const char *texture; // the row's FileData path int location; // ScreenLocation double scale; uint32_t color; // 0xRRGGBB uint64_t classMask; // book spells of the aura's family with any of these flags glow }; // Cata ScreenLocation 9 is "Left + Right (Flipped)", retail's LeftRight. const AuraRow kAuraRows[] = { // Row 144: Shadow Trance (from Nightfall) glows Shadow Bolt (warlock 0x1). {17941, "Textures\\SpellActivationOverlays\\Nightfall", LEFT_RIGHT, 1.0, 0xFFFFFF, 0x1}, // Row 148: Clearcasting (from Omen of Clarity); its mask is empty. {16870, "Textures\\SpellActivationOverlays\\Natures_Grace", LEFT_RIGHT, 1.0, 0xFFFFFF, 0}, }; constexpr int kAuraRowCount = sizeof(kAuraRows) / sizeof(kAuraRows[0]); // --- Events ----------------------------------------------------------------- const Game::Doc::Field kShowPayload[] = { Game::Doc::Req("spellID", "number", "The aura that triggered the alert."), Game::Doc::Req("texture", "string", "Texture path of the alert art."), Game::Doc::Req("locationType", "ScreenLocationType", "Where the art goes around the screen center."), Game::Doc::Req("scale", "number"), Game::Doc::Req("r", "number", "Red tint, 0 to 255."), Game::Doc::Req("g", "number", "Green tint, 0 to 255."), Game::Doc::Req("b", "number", "Blue tint, 0 to 255."), }; const Game::Doc::Event kShowDoc{ "SpellActivationOverlay", "Fires when a proc aura lands on the player and its alert art should show.", kShowPayload}; const Game::Doc::Field kHidePayload[] = { Game::Doc::Opt("spellID", "number", nullptr, "The aura whose alert ends; nil ends every alert."), }; const Game::Doc::Event kHideDoc{ "SpellActivationOverlay", "Fires when a proc aura leaves the player and its alert art should hide.", kHidePayload}; const Game::Doc::Field kGlowPayload[] = { Game::Doc::Req("spellID", "number", "The spell whose action buttons glow."), }; const Game::Doc::Event kGlowShowDoc{ "SpellActivationOverlay", "Fires when a spell starts to glow on the action bar.", kGlowPayload}; const Game::Doc::Event kGlowHideDoc{ "SpellActivationOverlay", "Fires when a spell stops glowing on the action bar.", kGlowPayload}; const Event::Custom::AutoReserve g_show{"SPELL_ACTIVATION_OVERLAY_SHOW", &kShowDoc}; const Event::Custom::AutoReserve g_hide{"SPELL_ACTIVATION_OVERLAY_HIDE", &kHideDoc}; const Event::Custom::AutoReserve g_glowShow{"SPELL_ACTIVATION_OVERLAY_GLOW_SHOW", &kGlowShowDoc}; const Event::Custom::AutoReserve g_glowHide{"SPELL_ACTIVATION_OVERLAY_GLOW_HIDE", &kGlowHideDoc}; // --- State ------------------------------------------------------------------ // Inputs at the last reconcile: bit i = kAuraRows[i]'s aura on the player; // the reactive entries the engine called usable. uint32_t g_activeRows = 0; std::vector g_usable; // This pass's read of the reactive list; swapped with g_usable on a change, // so a SPELL_UPDATE_USABLE that changes nothing (every power tick) allocates // nothing. std::vector g_read; // Published: bit i = SHOW sent for row i with no HIDE since; the sorted // spell IDs with GLOW_SHOW sent and no GLOW_HIDE since. uint32_t g_shownRows = 0; std::vector g_glowing; bool g_reconciling = false; bool g_again = false; const char *SpellName(const uint8_t *rec) { const int locale = Game::Read(Offsets::VAR_LOCALE_INDEX); return Game::Read(rec, Offsets::OFF_SPELL_NAMES + locale * 4); } uint32_t ActiveRows() { const uint8_t *player = Unit::Identity::PlayerObject(); if (player == nullptr) return 0; const auto *desc = Game::Read(player, Offsets::OFF_UNIT_DESCRIPTOR); if (desc == nullptr) return 0; uint32_t rows = 0; for (int slot = 0; slot < Offsets::UNIT_AURA_TOTAL; ++slot) { const uint32_t id = Game::Read(desc, Offsets::OFF_UNIT_FIELD_AURA + slot * 4); for (int i = 0; id != 0 && i < kAuraRowCount; ++i) { if (kAuraRows[i].spellID == id) rows |= 1u << i; } } return rows; } void UsableReactive(std::vector &out) { out.clear(); const auto *entries = Game::Read(Offsets::VAR_REACTIVE_SPELL_ENTRIES); if (entries == nullptr) return; const uint32_t count = Game::Read(Offsets::VAR_REACTIVE_SPELL_COUNT); for (uint32_t i = 0; i < count; ++i) { const uint8_t *entry = entries + i * Offsets::REACTIVE_SPELL_ENTRY_STRIDE; if (Game::Read(entry, Offsets::OFF_REACTIVE_SPELL_ENTRY_USABLE) != 0) out.push_back(Game::Read(entry, 0)); } } // The book spells the active sources glow, sorted. 4.3.4 matches each source // against its glowable list — every spell added to the book — so this walks // the book the same way. std::vector GlowTargets(uint32_t rows, const std::vector &usable) { std::vector out; if (rows == 0 && usable.empty()) return out; struct Mask { uint32_t family; uint64_t flags; }; std::vector masks; for (int i = 0; i < kAuraRowCount; ++i) { const uint8_t *aura = Spell::Lookup::RecordForID(static_cast(kAuraRows[i].spellID)); if ((rows & (1u << i)) != 0 && kAuraRows[i].classMask != 0 && aura != nullptr) masks.push_back({Game::Read(aura, Offsets::OFF_SPELL_RECORD_FAMILY_NAME), kAuraRows[i].classMask}); } std::vector names; for (uint32_t id : usable) { const uint8_t *rec = Spell::Lookup::RecordForID(static_cast(id)); if (rec != nullptr && SpellName(rec) != nullptr) names.push_back(SpellName(rec)); } const int count = std::min(Game::Read(Offsets::VAR_PLAYER_SPELLBOOK_COUNT), static_cast(Offsets::SPELLBOOK_MAX_SLOTS)); for (int slot = 0; slot < count; ++slot) { const int id = Game::Read(Offsets::VAR_PLAYER_SPELLBOOK + slot * 4); const uint8_t *rec = Spell::Lookup::RecordForID(id); if (rec == nullptr) continue; bool glow = false; for (const Mask &m : masks) glow = glow || Spell::Lookup::IsFitToFamily(rec, m.family, m.flags); const char *name = SpellName(rec); for (const char *n : names) glow = glow || (name != nullptr && std::strcmp(name, n) == 0); if (glow) out.push_back(static_cast(id)); } std::sort(out.begin(), out.end()); out.erase(std::unique(out.begin(), out.end()), out.end()); return out; } void Step(bool enterWorld) { const uint32_t rows = ActiveRows(); UsableReactive(g_read); if (!enterWorld && rows == g_activeRows && g_read == g_usable) return; g_activeRows = rows; g_usable.swap(g_read); // Art first, then glows — 4.3.4's order on both triggers. if (enterWorld) { Event::Custom::Fire(g_hide.Slot(), ""); g_shownRows = 0; } const uint32_t wasShown = g_shownRows; g_shownRows = rows; for (int i = 0; i < kAuraRowCount; ++i) { const uint32_t bit = 1u << i; const AuraRow &row = kAuraRows[i]; if ((rows & bit) != 0 && (wasShown & bit) == 0) Event::Custom::Fire(g_show.Slot(), "%d%s%d%f%d%d%d", static_cast(row.spellID), row.texture, row.location, row.scale, static_cast((row.color >> 16) & 0xFF), static_cast((row.color >> 8) & 0xFF), static_cast(row.color & 0xFF)); else if ((rows & bit) == 0 && (wasShown & bit) != 0) Event::Custom::Fire(g_hide.Slot(), "%d", static_cast(row.spellID)); } // Published before the events, so a handler's IsSpellOverlayed agrees. std::vector was = std::move(g_glowing); g_glowing = GlowTargets(rows, g_usable); std::vector stopped, started; std::set_difference(was.begin(), was.end(), g_glowing.begin(), g_glowing.end(), std::back_inserter(stopped)); std::set_difference(g_glowing.begin(), g_glowing.end(), was.begin(), was.end(), std::back_inserter(started)); for (uint32_t id : stopped) Event::Custom::Fire(g_glowHide.Slot(), "%d", static_cast(id)); for (uint32_t id : started) Event::Custom::Fire(g_glowShow.Slot(), "%d", static_cast(id)); } // A handler of one of our events can change what we read (a target change // re-runs FireUsableEvents); that request runs once the outer pass is done. void Reconcile(bool enterWorld) { if (g_reconciling) { g_again = true; return; } g_reconciling = true; Step(enterWorld); while (g_again) { g_again = false; Step(false); } g_reconciling = false; } bool OnSignal(int eventID) { if (eventID == Offsets::EVENT_SPELL_UPDATE_USABLE) Reconcile(false); return false; } const Event::SignalHook::AutoSubscribe _usable{&OnSignal}; void OnAuraChange(const Aura::Source::Change &c) { if (c.type != Aura::Source::ChangeType::Added && c.type != Aura::Source::ChangeType::Removed) return; bool ours = false; for (const AuraRow &row : kAuraRows) ours = ours || row.spellID == c.spellId; if (ours && c.unit == Unit::Identity::PlayerObject()) Reconcile(false); } const Aura::Source::AutoObserve _auras{&OnAuraChange}; void OnEnterWorld() { Reconcile(true); } const Event::EnteringWorld::AutoObserve _enterWorld{&OnEnterWorld}; // Logout (4.3.4's ShutdownGame): the Lua state that saw our events is gone. void OnGlueInit() { g_activeRows = 0; g_usable.clear(); g_shownRows = 0; g_glowing.clear(); } const Game::GlueModuleAutoRegister _glue{&OnGlueInit}; // --- Lua -------------------------------------------------------------------- int __fastcall Script_IsSpellOverlayed(void *L) { if (!Game::Lua::IsNumber(L, 1)) { Game::Lua::Error(L, "Usage: IsSpellOverlayed(spellID)"); return 0; } const auto id = static_cast(Game::Lua::ToNumber(L, 1)); Game::Lua::PushBool(L, std::binary_search(g_glowing.begin(), g_glowing.end(), id)); return 1; } const Game::Doc::Field kArgs[] = { Game::Doc::Req("spellID", "number"), }; const Game::Doc::Field kRets[] = { Game::Doc::Req("isSpellOverlayed", "bool", "True while the spell glows on the action bar."), }; const Game::Doc::Function kIsSpellOverlayedGlobal{ "Whether the spell glows on the action bar now.", kArgs, kRets, "SpellGlobals"}; const Game::Doc::Function kIsSpellOverlayed{ "Whether the spell glows on the action bar now.", kArgs, kRets}; const Game::Lua::EnumIntegerEntry kScreenLocationEntries[] = { {"Center", CENTER}, {"Left", LEFT}, {"Right", RIGHT}, {"Top", TOP}, {"Bottom", BOTTOM}, {"TopLeft", TOP_LEFT}, {"TopRight", TOP_RIGHT}, {"LeftOutside", LEFT_OUTSIDE}, {"RightOutside", RIGHT_OUTSIDE}, {"LeftRight", LEFT_RIGHT}, {"TopBottom", TOP_BOTTOM}, {"LeftRightOutside", LEFT_RIGHT_OUTSIDE}, }; } // namespace static void RegisterLuaFunctions() { Game::Lua::RegisterGlobalFunction("IsSpellOverlayed", &Script_IsSpellOverlayed, &kIsSpellOverlayedGlobal); Game::Lua::RegisterTableFunction("C_SpellActivationOverlay", "IsSpellOverlayed", &Script_IsSpellOverlayed, &kIsSpellOverlayed); Game::Lua::RegisterIntegerEnum( "Enum", "ScreenLocationType", kScreenLocationEntries, "ScreenLocationConstants"); } static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace Spell::ActivationOverlay