// 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 . // Replicates the engine's per-unit "watch descriptor fields → fire per-token // unit events" registration (`FUN_0051bbb0` / `FUN_0051bdb0`) so synthetic // tokens can be made first-class. The engine reaches this from // `FUN_0060c520`, which recomputes a unit's token-category mask // (target/party/raid/pet/mouseover) at `unit+0xc90` and, on a 0→nonzero // transition, registers a bank-UNIT observer on every named event field with // callback `FUN_0051bd50` → `FUN_00515e50(guid, eventId)` → the GUID→token // reverse map `FUN_00515c50` → fire the event once per token. // // We register the same field set with a caller-supplied callback instead, so // the caller fires its own token. The field set / sizes are read from the // static event-name table exactly as the engine does; see the // FUN_DESC_OBSERVER_REGISTER block in Offsets.h. // // Cross-checked against nampower's offsets.hpp: `SendUnitSignal` (the // broadcast) = `0x00515e50`, `StringParamFormat` ("%s") = `0x0082E280`, // `SignalEventParam` = `0x00703F50`, `UNIT_HEALTH` = 16 — all consistent with // the field-index-is-event-id derivation here. (nampower left its // `GetNamesFromGUID` reverse-map offset as an unfilled TODO; it is // `FUN_00515c50`.) #include "unit/TokenObserver.h" #include "Offsets.h" #include namespace Unit::TokenObserver { namespace { using Register_t = void(__fastcall *)(int bank, uint32_t fieldOffset, uint32_t guidLo, uint32_t guidHi, int size, const void *callback, void *userArg1, void *userArg2); using Unregister_t = void(__fastcall *)(int bank, uint32_t fieldOffset, uint32_t guidLo, uint32_t guidHi, const void *callback, void *userArg1); const char *const *EventNames() { return reinterpret_cast( static_cast(Offsets::VAR_EVENT_NAME_TABLE_STATIC)); } // Both register and unregister funnel through `FUN_00464890`, which // dereferences the client/player-rooted observer registry at // `[VAR_LOCAL_PLAYER_PTR]` (reads its `+0x24` mask). That root is NULL out of // world — login screen, loading screens, logout teardown — where the engine // helper null-derefs (crash: `MOV EAX,[EDX+0x24]`, EDX=0). Bail when it isn't // up: there are no live objects or observer nodes to touch anyway (nodes die // with their objects during teardown), and in-world callers re-register/clean // up on the next tick. Unlike `Player::Equipment` (which only ever registers // from the enter-world hook), our consumers register from Lua / WorldTick, // which can run mid-transition — hence the guard here. bool RegistryReady() { return *reinterpret_cast( static_cast(Offsets::VAR_LOCAL_PLAYER_PTR)) != nullptr; } // Bytes the engine watches for the observer on event index `i` — verbatim // from `FUN_0051bbb0`'s size switch. The 8-byte entries are the 64-bit GUID // fields; index 0x29 (`UNIT_FIELD_AURA`) spans the whole 0xD8 aura block. int SizeForIndex(int i) { switch (i) { case 0: case 2: case 4: case 10: return 8; case 0x29: return 0xD8; case 0x6B: return 0x30; case 0xA7: case 0xAE: return 0x1C; default: return 4; } } } // namespace void Register(uint64_t guid, FieldCallback cb) { if (guid == 0 || cb == nullptr || !RegistryReady()) return; auto reg = reinterpret_cast(Offsets::FUN_DESC_OBSERVER_REGISTER); const char *const *names = EventNames(); const uint32_t lo = static_cast(guid); const uint32_t hi = static_cast(guid >> 32); for (int i = 0; i < Offsets::EVENT_NAME_UNIT_MAX; ++i) { if (names[i] == nullptr) continue; // unnamed slot → not a real unit event reg(Offsets::DESC_OBSERVER_BANK_UNIT, static_cast(i * 4), lo, hi, SizeForIndex(i), reinterpret_cast(cb), nullptr, nullptr); } } void Unregister(uint64_t guid, FieldCallback cb) { if (guid == 0 || cb == nullptr || !RegistryReady()) return; auto unreg = reinterpret_cast(Offsets::FUN_DESC_OBSERVER_UNREGISTER); const char *const *names = EventNames(); const uint32_t lo = static_cast(guid); const uint32_t hi = static_cast(guid >> 32); for (int i = 0; i < Offsets::EVENT_NAME_UNIT_MAX; ++i) { if (names[i] == nullptr) continue; unreg(Offsets::DESC_OBSERVER_BANK_UNIT, static_cast(i * 4), lo, hi, reinterpret_cast(cb), nullptr); } } } // namespace Unit::TokenObserver