mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
Backport the modern C_NewItems system - IsNewItem / RemoveNewItem / ClearAll - flagging items freshly added to bags as "new", cleared once acknowledged. Vanilla has none of the machinery (no DBC, no server data), so it is pure client-side bookkeeping, done entirely in C++ like retail. Newness is keyed on each item's instance GUID (read off the CGItem), so a flag survives the item being moved between slots - impossible for a Lua addon, which can only track by (bag, slot). Bags 0..4 only; equipment and bank are out of scope, matching retail. The feed is event-driven, not polled: it subscribes to Bag::UpdateDelayed (which co-hooks the engine's three BAG_UPDATE fire sites), so a bag rescan runs only on frames where a bag actually changed. A one-time baseline taken ~1.5s after login (re-armed on character switch) keeps items owned at login from being flagged. BAG_NEW_ITEMS_UPDATED fires when the set changes. Consolidations along the way: - New Bag::UpdateDelayed::AutoSubscribe exposes the authoritative "a bag changed this frame" signal as a C++ subscription. - New Item::Location::ContainerInventory factors the CGContainer -> its inventory (vtable +0x10) dispatch hand-rolled in item/Count, item/AverageLevel, and equipmentset/Locations; all now share it. - New Item::Location::EquippedBagInventory (equipped bag -> inventory) plus the FUN_GET_EQUIPPED_BAG_GUID / OFF_CONTAINER_GET_INVENTORY offsets. - NewItems resolves the player via the shared Unit::Identity::PlayerObject.
157 lines
6.4 KiB
C++
157 lines
6.4 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/>.
|
|
|
|
// `BAG_UPDATE_DELAYED` event — fires once per frame in which any
|
|
// `BAG_UPDATE` fired. Polyfills modern WoW's event of the same name
|
|
// (added 5.4.x) with exact same-semantic coalescing: addons listen
|
|
// to DELAYED instead of BAG_UPDATE and rescan once per frame.
|
|
//
|
|
// See TODO #67 for the full investigation history.
|
|
//
|
|
// Architecture: three MinHooks plus one tick subscription.
|
|
//
|
|
// 1. `FUN_004F91A0` — bag-slot diff loop. Hook just sets the
|
|
// `g_pending` flag.
|
|
// 2. `FUN_004F9370` — item→bag resolver (most common path). Hook
|
|
// just sets the `g_pending` flag.
|
|
// 3. `FUN_004F8DB0` — bag-descriptor change callback. Covers the
|
|
// keyring `BAG_UPDATE(slot)` direct-fire branch that doesn't
|
|
// route through `FUN_004F9370`.
|
|
// 4. `Tick::WorldTick::AutoSubscribe` — shared per-frame
|
|
// subscription (the engine's world-subsystem update at
|
|
// `FUN_0066FD50`, single-hooked in `src/tick/WorldTick.cpp`).
|
|
// Our callback drains `g_pending` and fires DELAYED if set.
|
|
//
|
|
// All hook targets are quiet (≤3 callers each, in code regions
|
|
// other DLLs don't touch). The previous attempt at this feature
|
|
// hooked `FUN_FIRE_EVENT` (100+ callers, in the chat path) and a
|
|
// per-frame UI dispatcher — both prime collision targets for
|
|
// SuperWoWhook / nampower / transmogfix. By contrast:
|
|
//
|
|
// - `FUN_0066FD50` is the WORLD-subsystem update (not the UI one),
|
|
// deep in the rendering pipeline. Only one caller, no DLL
|
|
// touches it. It runs exactly once per frame and increments
|
|
// the engine's own per-frame counter at `0x00C7B2C8`, so we
|
|
// know it ticks 1:1 with frames.
|
|
// - The bag-subsystem hooks (`FUN_004F91A0`, `FUN_004F9370`,
|
|
// `FUN_004F8DB0`) live in the `0x004F8xxx`/`0x004F9xxx` region
|
|
// none of the popular DLLs care about.
|
|
//
|
|
// Coverage verified by pattern-searching the `.text` for every
|
|
// caller of `FUN_FIRE_EVENT(0x148, "%d", ...)` (the BAG_UPDATE
|
|
// event ID): exactly three sites, all covered by these three
|
|
// hooks. Double-fire concern with `FUN_004F8DB0` → `FUN_004F9370`
|
|
// path is moot: `g_pending` is a bool, idempotent until the
|
|
// per-frame drain clears it.
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
#include "bag/UpdateDelayed.h"
|
|
#include "event/Custom.h"
|
|
#include "tick/WorldTick.h"
|
|
|
|
namespace Bag::UpdateDelayed {
|
|
|
|
namespace {
|
|
|
|
constexpr const char *kEventName = "BAG_UPDATE_DELAYED";
|
|
|
|
const Event::Custom::AutoReserve _reserve{kEventName};
|
|
|
|
// Set by the bag-update hooks, drained by the world-tick hook.
|
|
// Single bool, no atomics needed — the engine is single-threaded.
|
|
bool g_pending = false;
|
|
|
|
// C++ subscribers notified once per bag-change frame (see UpdateDelayed.h).
|
|
AutoSubscribe *g_subs = nullptr;
|
|
|
|
} // namespace
|
|
|
|
AutoSubscribe::AutoSubscribe(Callback cb) : cb(cb), next(g_subs) {
|
|
g_subs = this;
|
|
}
|
|
|
|
// `FUN_004F91A0` — `__cdecl void()`. Bag-slot diff loop. Walks the
|
|
// 10 bag slots, fires BAG_UPDATE for each that changed.
|
|
using BagSlotDiff_t = void(__cdecl *)();
|
|
BagSlotDiff_t BagSlotDiff_o = nullptr;
|
|
void __cdecl BagSlotDiff_h() {
|
|
BagSlotDiff_o();
|
|
g_pending = true;
|
|
}
|
|
|
|
// `FUN_004F9370` — `__stdcall void(int guidLo, int guidHi)`. Most
|
|
// common BAG_UPDATE path — fires from every per-item descriptor
|
|
// field change.
|
|
using BagItemToBag_t = void(__stdcall *)(int guidLo, int guidHi);
|
|
BagItemToBag_t BagItemToBag_o = nullptr;
|
|
void __stdcall BagItemToBag_h(int guidLo, int guidHi) {
|
|
BagItemToBag_o(guidLo, guidHi);
|
|
g_pending = true;
|
|
}
|
|
|
|
// `FUN_004F8DB0` — `__thiscall unsigned(this, a1, a2, a3, a4)` in the
|
|
// Octo build. Wired with `__fastcall` + dummy EDX to match the
|
|
// thiscall ABI: ECX takes `this`, EDX unused, stack takes the four
|
|
// dword args, callee cleans 16 bytes (`RET 0x10`). Same trick
|
|
// `Frame::RegisterEvent` uses in DllMain, just with four stack args
|
|
// instead of one — the Octo function is wider than the vanilla
|
|
// signature Ghidra showed when this hook was first written.
|
|
using KeyringDescChange_t = unsigned(__fastcall *)(void *bagDesc, void *edx_unused,
|
|
unsigned a1, unsigned a2,
|
|
unsigned a3, unsigned a4);
|
|
KeyringDescChange_t KeyringDescChange_o = nullptr;
|
|
unsigned __fastcall KeyringDescChange_h(void *bagDesc, void *edx,
|
|
unsigned a1, unsigned a2,
|
|
unsigned a3, unsigned a4) {
|
|
const unsigned result = KeyringDescChange_o(bagDesc, edx, a1, a2, a3, a4);
|
|
g_pending = true;
|
|
return result;
|
|
}
|
|
|
|
// Per-frame drain. Runs at the tail of each world tick (subscribed
|
|
// through `Tick::WorldTick`, which owns the single hook on
|
|
// `FUN_0066FD50`). All this frame's BAG_UPDATEs have already fired
|
|
// by the time we run; we just consume the pending flag and emit one
|
|
// DELAYED if set.
|
|
void OnWorldTick() {
|
|
if (!g_pending)
|
|
return;
|
|
g_pending = false;
|
|
const int slot = Event::Custom::Lookup(kEventName);
|
|
if (slot >= 0)
|
|
Event::Custom::Fire(slot, "");
|
|
// Notify C++ subscribers of the bag-change frame (see UpdateDelayed.h).
|
|
for (auto *node = g_subs; node != nullptr; node = node->next)
|
|
node->cb();
|
|
}
|
|
|
|
static const Game::HookAutoRegister _hookSlotDiff{
|
|
Offsets::FUN_BAG_SLOT_DIFF,
|
|
reinterpret_cast<void *>(&BagSlotDiff_h),
|
|
reinterpret_cast<void **>(&BagSlotDiff_o)};
|
|
|
|
static const Game::HookAutoRegister _hookItemToBag{
|
|
Offsets::FUN_BAG_ITEM_TO_BAG,
|
|
reinterpret_cast<void *>(&BagItemToBag_h),
|
|
reinterpret_cast<void **>(&BagItemToBag_o)};
|
|
|
|
static const Game::HookAutoRegister _hookKeyringDesc{
|
|
Offsets::FUN_BAG_KEYRING_DESC_CHANGE,
|
|
reinterpret_cast<void *>(&KeyringDescChange_h),
|
|
reinterpret_cast<void **>(&KeyringDescChange_o)};
|
|
|
|
static const Tick::WorldTick::AutoSubscribe _tickSub{&OnWorldTick};
|
|
|
|
} // namespace Bag::UpdateDelayed
|