// 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 . // `CURSOR_CHANGED` — fires when what the cursor holds changes, carrying // the old and new cursor types: // // CURSOR_CHANGED: isDefault, newCursorType, oldCursorType, oldCursorVirtualID // // Plus the `Enum.UICursorType` table the two type arguments index. // // The trigger is a once-per-frame diff of the cursor globals, NOT the // engine's own `CURSOR_UPDATE`, because that event does not cover the // cursor. Its only three fire sites are: // // FUN_00495190 the cursor CLEAR — fires for every type, but only // after it has already zeroed the type global, so the // read at that point always says "empty" // FUN_00494b60 bag-item set — fires only when a GUID is present // FUN_004950f0 generic-item set — fires only when an itemID is // present // // So picking up money, a spell, a macro, a pet action or a stabled pet // produces exactly one `CURSOR_UPDATE`, from the clear, describing an // empty cursor; the write that puts the new content in place announces // nothing. Only the two item paths fire again after the set, which is // why an interceptor on that event reported item cursors correctly and // nothing else. There is no common choke point on the set side — each // type writes `VAR_CURSOR_TYPE` in its own path — so a state diff is // what covers every type, including any path not enumerated above. // // `Info::ReadRaw` is the cheap half of that diff: plain global reads, no // object-manager lookup. Only once it differs do we pay for // `Info::Current()`, which resolves a bag item's itemID. // // `oldCursorVirtualID` is the one argument that is a judgement call: the // modern client's notion of a "virtual ID" is not something this client // has, so it carries the previous content's identifying number instead // (see `Cursor::Info::State::virtualID`). No consumer is known to read // it — Blizzard's own `CURSOR_CHANGED` users all treat the event as a // bare notification and re-check state themselves. #include "Game.h" #include "cursor/Info.h" #include "event/Custom.h" #include "tick/WorldTick.h" #include namespace Cursor::Changed { namespace { const Event::Custom::AutoReserve _evtCursorChanged{"CURSOR_CHANGED"}; // The full modern enum, not just the values this client can produce. An // addon comparing against `Enum.UICursorType.BattlePet` should read a // number it can never match, rather than index a nil field. const Game::Lua::EnumIntegerEntry kCursorTypeEntries[] = { {"Default", 0}, {"Item", 1}, {"Money", 2}, {"Spell", 3}, {"PetAction", 4}, {"Merchant", 5}, {"ActionBar", 6}, {"Macro", 7}, {"Ammo", 8}, {"Pet", 9}, {"GuildBank", 10}, {"GuildBankMoney", 11}, {"EquipmentSet", 12}, {"Currency", 13}, {"Flyout", 14}, {"VoidItem", 15}, {"BattlePet", 16}, {"Mount", 17}, {"Toy", 18}, {"ConduitCollectionItem", 19}, {"PerksProgramVendorItem", 20}, }; // The cursor as of the last event we fired — the raw form for the cheap // per-frame compare, and the reported form to supply the `old*` arguments // of the next fire. Deliberately NOT reset on `/reload`: the DLL and the // engine's cursor globals both outlive the reload, so keeping them means // a cursor still holding something across a reload reports its real // previous type rather than a phantom change back from `Default`. Info::Raw g_lastRaw{}; Info::State g_lastState{0, 0}; void OnTick() { const Info::Raw raw = Info::ReadRaw(); if (Info::Same(raw, g_lastRaw)) return; // cursor untouched this frame — the common case g_lastRaw = raw; const Info::State now = Info::Current(); const Info::State previous = g_lastState; g_lastState = now; const int slot = _evtCursorChanged.Slot(); if (slot < 0) return; // The dispatcher has no boolean code, and pushing `%d` 0 would hand // Lua the number 0 — truthy. `%s` with a null string tail-jumps to // pushnil instead, so `if isDefault then` reads correctly either // way. Same trick the PLAYER_ENTERING_WORLD payload uses. auto *const kNil = static_cast(nullptr); if (now.uiType == 0) { Event::Custom::Fire(slot, "%d%d%d%u", 1, now.uiType, previous.uiType, previous.virtualID); } else { Event::Custom::Fire(slot, "%s%d%d%u", kNil, now.uiType, previous.uiType, previous.virtualID); } } const Tick::WorldTick::AutoSubscribe _tick{&OnTick}; void RegisterLuaFunctions() { Game::Lua::RegisterIntegerEnum( "Enum", "UICursorType", kCursorTypeEntries, sizeof(kCursorTypeEntries) / sizeof(kCursorTypeEntries[0])); } const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; } // namespace } // namespace Cursor::Changed