// 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 . // `markN` raid-target-marker unit tokens (`mark1`=star … `mark8`=skull). // // Two halves, mirroring `Unit::Focus`: // // 1. Resolution — `GetGUIDByMark` reads the engine's marker table // (`VAR_RAID_TARGET_GUIDS`); the `markN` branch of the token // resolver in `unit/TokenExtensions.cpp` calls it so every stock // `Script_Unit*` (UnitHealth, UnitExists, UnitName, …) accepts // `"markN"` for free. // // 2. Events — `Unit::TokenObserver` watches each marked unit's // descriptor fields so `UNIT_HEALTH` / `UNIT_MANA` / `UNIT_AURA` / // … fire with `arg1 == "markN"`, exactly like a native token. The // engine only auto-watches its own tokens (target/party/raid/pet/ // mouseover), so a marked mob that is none of those fires no unit // events until we observe it. // // Why the WorldTick poll (vs. a packet hook): the marker table is written // by the server (`SMSG_RAID_TARGET_UPDATE`), and — more importantly — a // `TokenObserver` can only attach to a LIVE `CGUnit`. A unit marked while // out of range has no object to observe; when it enters range there is no // per-mark event announcing it, and when it leaves range its observer // nodes die with the object silently. So each tick we diff the 8 slots // and (re)attach/detach observers against the current live objects — the // same range-transition handling `Unit::Focus::OnWorldTick` does, ×8. The // idle case (no markers set) costs 8 compares and zero object lookups. // // A marker on a non-unit GUID (totem corpse / gameobject / loot) simply // never resolves to a `CGUnit`, so it is never observed and fires no // events — correct, and matches `UnitExists("markN")` being false there. #include "unit/RaidTarget.h" #include "Game.h" #include "Offsets.h" #include "tick/WorldTick.h" #include "unit/TokenObserver.h" #include namespace Unit::RaidTarget { namespace { // `"mark1".."mark8"` — the token strings fired as `arg1`. Static so the // pointers stay valid for the `FUN_FIRE_EVENT` "%s" argument. const char *const kMarkTokens[kMarkCount] = { "mark1", "mark2", "mark3", "mark4", "mark5", "mark6", "mark7", "mark8", }; // GUID we are currently tracking for each marker slot (mirrors the live // marker table), or 0. Doubles as the callback's stale-fire guard. uint64_t g_markGUID[kMarkCount] = {}; // Whether a live descriptor observer is currently registered on // `g_markGUID[i]`. Cleared when that unit leaves the object table so the // tick re-registers when it returns (nodes die with the object). bool g_markObserved[kMarkCount] = {}; using ResolveByGUID_t = void *(__fastcall *)(int type, const char *debugName, uint32_t guidLo, uint32_t guidHi, int priority); // Resolve a GUID to its live `CGUnit`, or null when it isn't currently in // the client's object table (out of range / despawned / a non-unit // marker). Non-throwing — safe from the tick. Mirrors `Focus::ResolveObject`. const uint8_t *ResolveObject(uint64_t guid) { if (guid == 0) return nullptr; auto resolve = reinterpret_cast( static_cast(Offsets::FUN_OBJECT_RESOLVE_BY_GUID)); return static_cast( resolve(Offsets::OBJ_TYPE_UNIT, "RaidTarget", static_cast(guid), static_cast(guid >> 32), 0x172)); } // Descriptor-field observer callback for marker slot `Idx` (0-based). // Fires the changed field's unit event (`fieldOffset >> 2`) with the // `"markN"` token, so `arg1 == "markN"` works for `UNIT_HEALTH`, // `UNIT_MANA`, `UNIT_AURA`, … — exactly like `FocusFieldCb`. Guarded on // the live tracked GUID so an in-flight field change racing an unregister // can't fire a stale token. template int __fastcall MarkFieldCb(uint32_t fieldOffset, uint32_t /*size*/, uint32_t guidLo, uint32_t guidHi, const uint32_t * /*oldValue*/, void * /*userArg*/) { const uint64_t g = g_markGUID[Idx]; if (guidLo != static_cast(g) || guidHi != static_cast(g >> 32)) return 1; using Fire_t = void(__cdecl *)(int eventId, const char *fmt, ...); reinterpret_cast(static_cast(Offsets::FUN_FIRE_EVENT))( static_cast(fieldOffset >> 2), "%s", kMarkTokens[Idx]); return 1; } // One distinct callback per slot — `TokenObserver` keys observer nodes on // the callback pointer, and each fires its own fixed token, so the slots // must not share a function. const TokenObserver::FieldCallback g_markCb[kMarkCount] = { &MarkFieldCb<0>, &MarkFieldCb<1>, &MarkFieldCb<2>, &MarkFieldCb<3>, &MarkFieldCb<4>, &MarkFieldCb<5>, &MarkFieldCb<6>, &MarkFieldCb<7>, }; const uint64_t *MarkerTable() { return reinterpret_cast( static_cast(Offsets::VAR_RAID_TARGET_GUIDS)); } // Keep each slot's observer pointed at the unit currently wearing that // marker. Per slot: adopt a changed/cleared assignment (dropping the old // observer), then (re)register on the live object or note a despawn. The // heavy path (ResolveObject) runs only for slots that actually hold a // marker, so an unmarked table is 8 cheap compares. void OnWorldTick() { const uint64_t *table = MarkerTable(); for (int i = 0; i < kMarkCount; ++i) { const uint64_t want = table[i]; if (want != g_markGUID[i]) { // Marker moved to a different GUID (or was cleared): stop // watching the old unit, adopt the new assignment. if (g_markObserved[i]) { TokenObserver::Unregister(g_markGUID[i], g_markCb[i]); g_markObserved[i] = false; } g_markGUID[i] = want; } if (g_markGUID[i] != 0) { const bool live = ResolveObject(g_markGUID[i]) != nullptr; if (live && !g_markObserved[i]) { TokenObserver::Register(g_markGUID[i], g_markCb[i]); g_markObserved[i] = true; } else if (!live && g_markObserved[i]) { // Marked unit left the object table (out of range / // despawn); its observer nodes died with it. Re-register // when it returns. g_markObserved[i] = false; } } } } const Tick::WorldTick::AutoSubscribe _tickSub{&OnWorldTick}; // Reset tracking on logout→character-select. The DLL isn't reloaded // across a relog, so stale per-slot GUIDs from character A must not leak // into B. Observer nodes already died with the world teardown, and the // tick re-reads the (fresh) marker table anyway, so we only clear our // mirror. Same rationale as `Focus::ClearOnLogout`; glue hook so it fires // on logout but NOT on /reload. void ClearOnLogout() { for (int i = 0; i < kMarkCount; ++i) { g_markGUID[i] = 0; g_markObserved[i] = false; } } const Game::GlueModuleAutoRegister _clearOnLogout{&ClearOnLogout}; } // namespace uint64_t GetGUIDByMark(int mark) { if (mark < 1 || mark > kMarkCount) return 0; return MarkerTable()[mark - 1]; } } // namespace Unit::RaidTarget