mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
* C_NamePlate.GetNamePlateGUIDs * fixed NameCache header * C_NamePlate.GetNamePlates * GetNamePlates will show blizzard nameplates as well * C_NamePlate.GetNamePlateForUnit * nameplate events * C_NamePlate.GetNamePlateForGUID * NAME_PLATE_CREATED now sends frame as argument * document verification provenance for nameplate-adjacent offsets - Offsets.h: annotate LUA_REF_REF / LUA_REF_UNREF with their Ghidra decompile shapes (FREELIST_REF chain + LUA_REFNIL/NOREF sentinels) so the next maintainer doesn't have to re-derive whether these are really luaL_ref/unref. - Walk.h: warn that the 0x00B41414 player global overlays multiple sub-objects; reading +0x1C/+0x24 here is safe, feeding it to the inventory path crashes. * harden nameplate frame push against stale registry refs PushNamePlateFrame now type-checks the rawgeti'd value; on a stale slot (post-/reload windows, freed slot, etc.) it pops and falls back to a fresh wrapper instead of returning whatever the registry happens to hold at that index in the new Lua state. Script_GetNamePlates now routes through the same helper so it inherits the guard. Also document the bound on g_seenPlates: pool reuse via DAT_00c4d920 caps it at the session's peak simultaneous-plate count. * support nameplateN unit tokens Hook FUN_TOKEN_TO_GUID so every Script_Unit* (UnitName, UnitGUID, UnitHealth, UnitClass, UnitExists, ...) accepts `nameplateN` tokens and their `target`-suffix chains (`nameplate1target`, `nameplate1targettarget`) — modern WoW semantics on the vanilla engine. Hook is gated by an SStrCmpI prefix check; non-nameplate tokens fall straight through to the original resolver. - Ordered GUID list is maintained alongside the existing NAME_PLATE_UNIT_ADDED / _REMOVED diff. Append on ADDED, erase on REMOVED — creation-order, stable for a plate's lifetime, modern semantics. - Suffix walker mirrors the engine's own LAB_005159d3 walker instruction-for-instruction: SStrCmpI "target" + ObjectByGUID + read UNIT_FIELD_TARGET (m_objectFields + 0x28). - SStrCmpI typedef is __stdcall, not __cdecl. The function ends with ret 0xc; declaring it cdecl makes MSVC emit a redundant add esp, 12 on top of the callee cleanup, drifting ESP +12 per call and crashing somewhere deep in Lua once L gets read from a poisoned stack slot. - m_objectFields is a *pointer* at obj+0x110, not an inline byte offset. Two dereferences (mov eax, [obj+0x110]; mov edi, [eax+0x28]), not one — earlier version mistook the inline-vs-pointer shape and read instruction bytes as GUIDs. * document nameplateN unit-token support - API.md NamePlate section: replace the "scope vs. modern (deferred)" callout with a pointer to the new Unit tokens subsection; update the events table and "modern divergence" callout to explain why the GUID payload remains (engine dispatcher can't carry Lua values through %s/%d/%u/%f format codes) even though the token form now works. - New "Unit tokens (`nameplateN`)" subsection covering the resolved ~30 UnitX functions, creation-order semantics, suffix chains (`nameplate1target`, `targettarget`), and the SStrCmpI prefix-gate implementation detail. - UnitTokenFromGUID's "post-1.12 omitted" list: nameplateN is no longer engine-unsupported (we hook the resolver) but it's still not used as a reverse-lookup key — indices can be reassigned during a session, so it'd be unstable. - README: new Unit tokens table row pointing to the API.md anchor. * return stable nameplate wrapper across calls PushNamePlateFrame was building a fresh Lua table on every call for unregistered (default vanilla) nameplates — so fields addons set on the wrapper they received in NAME_PLATE_CREATED were lost on the next GetNamePlateForUnit lookup. pfUI specifically writes `plate.nameplate = styledButton` on the CREATED-delivered table to hand its overlay back through our API, and that field was disappearing. Fix: pin the first wrapper for each nameplate pointer in the Lua registry via luaL_ref, cache the refkey in g_wrapperRefkeys, and rawgeti on every subsequent push. Same table identity for the life of the engine plate. Bound by the CGNamePlateFrame pool size (~80). Cleared on /reload via a new NamePlate::Info::PrepareForReload() wired into FrameScript_Initialize_h next to the existing Event::Custom and NameCache reload hooks — stale refkeys would otherwise point into the freed registry. * NAME_PLATE_UNIT events now fire token * nameplate events: ship "nameplateN" tokens, delegate wrappers to engine Two intertwined changes that together make nameplate-mod addons (pfUI) survive pool recycle. 1. NAME_PLATE_UNIT_ADDED / _REMOVED arg1 is now the "nameplateN" unit token, matching modern WoW exactly. For REMOVED we compute the token before erasing from g_orderedGUIDs so the handler can still resolve the leaving unit. Addons that want a stable hash key call UnitGUID(arg1) to convert. 2. PushNamePlateFrame now delegates to the engine's own FrameScript_Object::ScriptRegister (0x00701BD0) instead of maintaining our own luaL_ref'd wrapper cache. Per-pointer the engine builds a wrapper table once, refs it into the registry, and stores the refkey at nameplate+0x08 - every code path (ours, addons' CreateFrame(parent) extraction, the engine's own internal pushers) then funnels through rawgeti(REGISTRY, nameplate+0x08) and gets the same Lua table. The prior approach kept our own wrapper alongside the engine's once pfUI's CreateFrame inside NAME_PLATE_CREATED caused the engine to register the underlying frame itself - fields set on our wrapper (plate.nameplate = decoratedButton) disappeared from the API surface even though they still existed on the orphaned table. Single-source-of-truth fixes it. The refcount-pinning caveat CLAUDE.md warned about is benign for pool-managed nameplates (never destroyed during a session). Also clear seenPlates / lastTickPlates / orderedGUIDs on FrameScript_Initialize so currently-visible plates refire CREATED + UNIT_ADDED after /reload - re-presents them to the freshly reloaded UI, matching modern WoW. --------- Co-authored-by: Brues <5278969+brues-code@users.noreply.github.com>
133 lines
6.0 KiB
C++
133 lines
6.0 KiB
C++
// 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 <https://www.gnu.org/licenses/>.
|
|
|
|
#include "Common.h"
|
|
#include "Game.h"
|
|
#include "MinHook.h"
|
|
#include "Offsets.h"
|
|
#include "event/Custom.h"
|
|
#include "nameplate/Walk.h"
|
|
#include "player/NameCache.h"
|
|
|
|
static Game::FrameScript_Initialize_t FrameScript_Initialize_o = nullptr;
|
|
static Game::LoadScriptFunctions_t LoadScriptFunctions_o = nullptr;
|
|
static Game::LoadGlueScriptFunctions_t LoadGlueScriptFunctions_o = nullptr;
|
|
|
|
// `Frame::RegisterEvent` is `__thiscall(this, eventName)`. MSVC can't emit
|
|
// __thiscall on free functions, but a __fastcall function with a dummy EDX
|
|
// arg matches the same register layout (ECX=this, EDX unused, stack=name).
|
|
using FrameRegisterEvent_t = void(__fastcall *)(void *frame, void *edx,
|
|
const char *eventName);
|
|
static FrameRegisterEvent_t FrameRegisterEvent_o = nullptr;
|
|
|
|
static void __fastcall InvalidFunctionPtrCheck_h() {}
|
|
|
|
static bool __fastcall FrameScript_Initialize_h() {
|
|
// BEFORE the engine tears down the old event table (at the start of
|
|
// FrameScript_Initialize), invalidate our cached slot indices. The
|
|
// table is rebuilt at a fresh allocation; the old slots are stale.
|
|
Event::Custom::PrepareForReload();
|
|
|
|
// Clear the nameplate diff state so currently-visible plates
|
|
// refire CREATED and UNIT_ADDED on the next tick — re-presents
|
|
// them to the freshly reloaded UI, matching modern WoW. The
|
|
// wrappers themselves now live in the engine's own registry
|
|
// (via `FrameScript_Object::ScriptRegister`), which the engine
|
|
// tears down and rebuilds across the Lua reset — no per-module
|
|
// cache to clear here.
|
|
NamePlate::Events::PrepareForReload();
|
|
|
|
// Persist the name cache before the engine starts tearing down.
|
|
// This hook fires on both `/reload` and `/logout` (the engine
|
|
// re-initializes Lua state in both cases), giving us a clean
|
|
// deterministic save point for the common lifecycle events.
|
|
Player::NameCache::Flush();
|
|
|
|
FrameScript_Initialize_o();
|
|
return true;
|
|
}
|
|
|
|
static void __fastcall LoadScriptFunctions_h() {
|
|
LoadScriptFunctions_o();
|
|
Game::RunModuleRegistrations();
|
|
// Permit `Event::Custom::TryClaim` to actually write to the event
|
|
// table from here on. Earlier writes (during the engine's own
|
|
// boot-time `RegisterEvent` flurry, plus SuperWoWhook/etc.) can
|
|
// race with the engine's table init and trigger `SMemFree` on slots
|
|
// it still considers in-flight.
|
|
Event::Custom::EnableWrites();
|
|
}
|
|
|
|
static void __stdcall LoadGlueScriptFunctions_h() {
|
|
LoadGlueScriptFunctions_o();
|
|
Game::RunGlueModuleRegistrations();
|
|
}
|
|
|
|
// Every Lua-side `frame:RegisterEvent(...)` is a chance to claim a slot
|
|
// for any custom event still waiting. By this point the engine's table
|
|
// is fully populated and SuperWoWhook / other DLLs have done their
|
|
// post-rebuild writes, so the table state is settled and our backwards
|
|
// walk finds genuine NULL slots near the tail.
|
|
static void __fastcall FrameRegisterEvent_h(void *frame, void *edx,
|
|
const char *eventName) {
|
|
Event::Custom::RetryClaims();
|
|
// Throttled-internally; no-op when the cache or scan toggle is off.
|
|
Player::NameCache::Tick();
|
|
FrameRegisterEvent_o(frame, edx, eventName);
|
|
}
|
|
|
|
BOOL APIENTRY DllMain(HMODULE hModule, DWORD reason, LPVOID lpReserved) {
|
|
if (reason == DLL_PROCESS_ATTACH) {
|
|
DisableThreadLibraryCalls(hModule);
|
|
|
|
if (MH_Initialize() != MH_OK)
|
|
return FALSE;
|
|
|
|
auto *target = reinterpret_cast<LPVOID>(Offsets::FUN_INVALID_FUNCTION_PTR_CHECK);
|
|
if (MH_CreateHook(target, reinterpret_cast<LPVOID>(InvalidFunctionPtrCheck_h), nullptr) != MH_OK)
|
|
return FALSE;
|
|
if (MH_EnableHook(target) != MH_OK)
|
|
return FALSE;
|
|
|
|
// Four core init hooks stay here — each runs glue logic
|
|
// (PrepareForReload, RunModuleRegistrations,
|
|
// RunGlueModuleRegistrations, EnableWrites, RetryClaims)
|
|
// that's tightly coupled to DllMain state, so a declarative
|
|
// HookAutoRegister wouldn't simplify them.
|
|
HOOK_FUNCTION(Offsets::FUN_FRAME_SCRIPT_INITIALIZE, FrameScript_Initialize_h,
|
|
FrameScript_Initialize_o);
|
|
HOOK_FUNCTION(Offsets::FUN_LOAD_SCRIPT_FUNCTIONS, LoadScriptFunctions_h,
|
|
LoadScriptFunctions_o);
|
|
HOOK_FUNCTION(Offsets::FUN_LOAD_GLUE_SCRIPT_FUNCTIONS,
|
|
LoadGlueScriptFunctions_h, LoadGlueScriptFunctions_o);
|
|
HOOK_FUNCTION(Offsets::FUN_FRAME_REGISTER_EVENT, FrameRegisterEvent_h,
|
|
FrameRegisterEvent_o);
|
|
|
|
// All feature hooks declared via `Game::HookAutoRegister` at
|
|
// file scope in their respective modules.
|
|
if (!Game::RunHookRegistrations())
|
|
return FALSE;
|
|
} else if (reason == DLL_PROCESS_DETACH) {
|
|
// Clean /quit path. Flush before MH_Uninitialize — the cache's
|
|
// file I/O uses Win32 directly (no MinHook involvement), so
|
|
// either order works in practice, but flushing first lets us
|
|
// bail early if the hook teardown ever grows side effects.
|
|
// Hard process termination (task manager kill) bypasses this
|
|
// path; that's an inherent OS limitation, and the 5-minute
|
|
// backstop flush in Remember() covers the worst case there.
|
|
Player::NameCache::Flush();
|
|
MH_Uninitialize();
|
|
}
|
|
return TRUE;
|
|
}
|