mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
Replace the raw `*reinterpret_cast<const T *>(base + Offsets::OFF_X)` idiom (and its double-cast variant when base wasn't already a byte pointer) with three typed accessors in Game.h: Game::Read<T>(base, offset) field value read Game::Ref<T>(base, offset) writable field lvalue Game::Ptr<T>(base, offset) pointer to a field (arrays / out-params) Game::Read<T>(address) / Ref<T>(address) fixed-VA globals Pure mechanical refactor, zero behavior change: ~330 cast sites across 84 files collapse to 651 helper calls. Offsets stay in Offsets.h per the single-source-of-truth rule — the helpers only remove the cast noise and fold away the inner `reinterpret_cast<uint8_t*>(obj)` base casts. Left as raw casts by design: FUN_* function-pointer casts, void*/char* VA handles passed as arguments (caches, method registries), subobject- anchor pointers fed to __thiscall helpers, `void *volatile` player-ptr readiness gates (converting would strip volatile), and VA-as-array-base captures that are subscripted later.
95 lines
3.5 KiB
C++
95 lines
3.5 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 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 <https://www.gnu.org/licenses/>.
|
|
|
|
// `GetFramesRegisteredForEvent(event)` → the Frame objects currently
|
|
// subscribed to `event`, returned as multiple return values (matching
|
|
// modern WoW's vararg signature — not a table). Empty result set returns
|
|
// nothing.
|
|
//
|
|
// The engine already keeps exactly this list: every `frame:RegisterEvent`
|
|
// appends the frame to a subscriber chain hanging off the matching event
|
|
// table entry. We find the entry by name (same table `Event::Custom`
|
|
// walks), then walk the chain the same way `Frame::RegisterEvent`
|
|
// (`FUN_00702140`) does — node next at `+0x04`, subscriber frame at
|
|
// `+0x08`, with a low-bit-set / null value marking the end sentinel — and
|
|
// push each frame via the shared `UI::FrameObject::Push` so callers get
|
|
// the canonical wrapper table (real frame methods, `:GetName()`, etc.).
|
|
//
|
|
// Event names resolve through `Event::Custom::LookupByName`, so this also
|
|
// works for our `AutoReserve`-claimed custom events, not just engine ones.
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
#include "event/Custom.h"
|
|
#include "ui/FrameObject.h"
|
|
|
|
#include <cstdint>
|
|
|
|
namespace Event::Registered {
|
|
|
|
namespace {
|
|
|
|
int __fastcall Script_GetFramesRegisteredForEvent(void *L) {
|
|
if (!Game::Lua::IsString(L, 1))
|
|
return 0;
|
|
const char *event = Game::Lua::ToString(L, 1);
|
|
if (event == nullptr)
|
|
return 0;
|
|
|
|
const int slot = Event::Custom::LookupByName(event);
|
|
if (slot < 0)
|
|
return 0;
|
|
|
|
auto *base = Game::Read<uint8_t *>(Offsets::VAR_EVENT_TABLE_BASE_PTR);
|
|
if (base == nullptr)
|
|
return 0;
|
|
|
|
const uint8_t *entry = base + slot * Offsets::EVENT_ENTRY_STRIDE;
|
|
const uintptr_t head = Game::Read<uintptr_t>(entry, Offsets::OFF_EVENT_ENTRY_HEAD);
|
|
|
|
// First pass: count subscribers so we can reserve stack up front — an
|
|
// event with many registered frames would otherwise risk overflowing
|
|
// the default Lua stack slack as we push.
|
|
int count = 0;
|
|
for (uintptr_t node = head; (node & 1) == 0 && node != 0;
|
|
node = Game::Read<uintptr_t>(node + Offsets::OFF_EVENT_NODE_NEXT)) {
|
|
if (Game::Read<void *>(node + Offsets::OFF_EVENT_NODE_FRAME))
|
|
++count;
|
|
}
|
|
if (count == 0)
|
|
return 0;
|
|
Game::Lua::CheckStack(L, count);
|
|
|
|
int pushed = 0;
|
|
for (uintptr_t node = head; (node & 1) == 0 && node != 0;
|
|
node = Game::Read<uintptr_t>(node + Offsets::OFF_EVENT_NODE_NEXT)) {
|
|
void *frame = Game::Read<void *>(node + Offsets::OFF_EVENT_NODE_FRAME);
|
|
if (frame != nullptr) {
|
|
UI::FrameObject::Push(L, frame);
|
|
++pushed;
|
|
}
|
|
}
|
|
return pushed;
|
|
}
|
|
|
|
void RegisterLuaFunctions() {
|
|
Game::Lua::RegisterGlobalFunction("GetFramesRegisteredForEvent",
|
|
&Script_GetFramesRegisteredForEvent);
|
|
}
|
|
|
|
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
|
|
|
} // namespace
|
|
|
|
} // namespace Event::Registered
|