Equipment: Get bank location without ever talking to banker

This commit is contained in:
Brues
2026-05-11 15:36:57 -05:00
parent 82dde7b124
commit a0fb3ec009
4 changed files with 131 additions and 117 deletions
+8 -6
View File
@@ -1727,13 +1727,15 @@ set 2
Identity is by **item GUID**, snapshotted at `CreateEquipmentSet` /
`SaveEquipmentSet` time. `UseEquipmentSet` searches every player-owned
container for those GUIDs and dispatches pickup→equip pairs for items
that aren't already where they belong. Two limitations to know about:
that aren't already where they belong. The search reads the
underlying GUID arrays directly (same trick `C_Item.GetItemCount`
uses for its `includeBank=true` path), so bank items resolve **even
without the bank window being open** — the bank gate at
`VAR_BANK_GATE_GUID` only suppresses `GetItemBySlot`, not the
underlying data.
One limitation worth knowing about:
- **Bank bag contents** (the items inside bags 5..10) only resolve
while the bank window is open. The engine populates each bank-bag
invMgr on `BANKFRAME_OPENED` and clears it on close. Items in the
24-slot core bank are always available (their GUIDs live on the
player invMgr's flat array, populated at login).
- **Equipping from the bank** is not supported by vanilla's protocol
— `UseEquipmentSet` skips bank items rather than try and fail.
Retrieve the items first, then re-run.
+7 -9
View File
@@ -20,12 +20,9 @@
//
// Identity is by item GUID — `SaveEquipmentSet` snapshots the GUIDs
// currently worn, and `UseEquipmentSet` searches every player-owned
// container for those GUIDs at use time. Bank bag *contents* (the
// items inside bank bags 5..10) are only resolvable while the bank
// window is open, since the engine populates each bank-bag invMgr
// lazily on `BANKFRAME_OPENED`. Save and Use both observe this
// limitation; main-bank slots (24-slot core) are always available
// because their GUIDs live on the player invMgr's flat array.
// container for those GUIDs at use time. The GUID search reads
// invMgr GUID arrays directly (same trick `C_Item.GetItemCount`
// uses), so bank items resolve without the bank window being open.
//
// Modern Classic Era's signatures use a numeric `iconFileID`; we
// accept icon paths (e.g. `"INV_Shield_06"`) instead because vanilla
@@ -178,7 +175,7 @@ int __fastcall Script_GetEquipmentSetInfo(void *L) {
if (g == GUID_EMPTY)
continue;
++numItems;
const int loc = Locations::FindGUID(L, g);
const int loc = Locations::FindGUID(g);
if (loc == 0) {
++numMissing;
} else if ((loc & LOC_BAGS) == 0 && (loc & LOC_BANK) == 0 &&
@@ -256,6 +253,7 @@ int __fastcall Script_GetItemLocations(void *L) {
const Set *s = Data::FindByID(setID);
if (s == nullptr)
return 0;
Game::Lua::SetTop(L, 0);
Game::Lua::NewTable(L);
for (int i = 0; i < SLOT_COUNT; ++i) {
@@ -266,7 +264,7 @@ int __fastcall Script_GetItemLocations(void *L) {
if (g == GUID_IGNORED) {
loc = LOC_IGNORED;
} else {
loc = Locations::FindGUID(L, g);
loc = Locations::FindGUID(g);
if (loc == 0)
loc = LOC_MISSING;
}
@@ -419,7 +417,7 @@ int __fastcall Script_UseEquipmentSet(void *L) {
if (g == GUID_EMPTY || g == GUID_IGNORED)
continue;
const int loc = Locations::FindGUID(L, g);
const int loc = Locations::FindGUID(g);
if (loc == 0)
continue; // missing — nothing to do
+104 -87
View File
@@ -13,9 +13,7 @@
#include "Locations.h"
#include "Game.h"
#include "Offsets.h"
#include "item/Location.h"
#include <cstdint>
@@ -23,6 +21,25 @@ namespace EquipmentSet::Locations {
namespace {
// Linear slot ranges inside the player invMgr's flat GUID array.
// Documented in Offsets.h ("Slot ranges, matching PackBagSlot's
// linearization"); summarized here for quick reference:
// 0..18 paperdoll equipment slots 1..19 (HEAD..TABARD)
// 19..22 player bag SLOTS — bags 1..4 equipped on character
// 23..38 backpack contents (16 slots)
// 39..62 main bank (24 slots)
// 63..68 bank bag SLOTS — bags 5..10 equipped in bank
// 81+ keyring (irrelevant for equipment sets)
//
// Backpack lives inline in this array; the four player bag bags and
// six bank bag bags each have their own invMgr with the same shape
// (slot count at +0x00, GUID array pointer at +0x04). We reach them
// by resolving the bag's CGContainer via `FUN_OBJECT_RESOLVE_BY_GUID`
// and reading the bag's invMgr off `vtable[+0x10]`.
constexpr int LINEAR_BAG_SLOT_FIRST = 19; // bag1 → linear 19
constexpr int LINEAR_BACKPACK_FIRST = 23;
constexpr int LINEAR_BACKPACK_LAST = 38;
void *ResolvePlayer() {
using ResolveUnitToken_t = void *(__fastcall *)(const char *);
auto fn = reinterpret_cast<ResolveUnitToken_t>(Offsets::FUN_RESOLVE_UNIT_TOKEN);
@@ -36,110 +53,118 @@ uint8_t *ResolvePlayerInvMgr() {
return player + Offsets::OFF_PLAYER_INVENTORY_MANAGER;
}
// Reads the GUID at a given linear slot in the player invMgr's flat
// array. The array covers paperdoll → backpack → main bank → bank bag
// slots. Bag contents (player or bank) live in separate per-bag
// invMgrs and aren't reachable through this array.
uint64_t ReadFlatGUID(int linearSlot) {
auto *invMgr = ResolvePlayerInvMgr();
uint64_t *InvMgrGuidArray(const uint8_t *invMgr) {
if (invMgr == nullptr)
return nullptr;
return *reinterpret_cast<uint64_t *const *>(
invMgr + Offsets::OFF_INVMGR_GUID_ARRAY);
}
int InvMgrSlotCount(const uint8_t *invMgr) {
if (invMgr == nullptr)
return 0;
auto *guids = *reinterpret_cast<uint64_t **>(
invMgr + Offsets::OFF_INVMGR_GUID_ARRAY);
return static_cast<int>(*reinterpret_cast<const uint32_t *>(invMgr));
}
uint8_t *ResolveByGUID(int type, uint64_t guid) {
if (guid == 0)
return nullptr;
using ResolveByGUID_t = void *(__fastcall *)(int, const char *, uint32_t,
uint32_t, int);
auto fn = reinterpret_cast<ResolveByGUID_t>(Offsets::FUN_OBJECT_RESOLVE_BY_GUID);
return static_cast<uint8_t *>(fn(type, "ItemMgr",
static_cast<uint32_t>(guid),
static_cast<uint32_t>(guid >> 32),
0x172));
}
// CGContainer exposes its own `CContainerInventory *` via vtable
// `+0x10` — same dispatch `GetItemCount`'s bank walk uses. The
// returned invMgr has the standard shape: slot count at +0x00,
// flat GUID array at +0x04.
uint8_t *BagInvMgr(uint8_t *bag) {
if (bag == nullptr)
return nullptr;
auto *vtable = *reinterpret_cast<uint8_t **>(bag);
using GetInvMgr_t = void *(__thiscall *)(void *);
auto getInvMgr = reinterpret_cast<GetInvMgr_t>(
*reinterpret_cast<uintptr_t *>(vtable + 0x10));
return static_cast<uint8_t *>(getInvMgr(bag));
}
// Walks one bag's contents for a matching GUID. Returns the 1-based
// slot index of the match, or 0 if not found / bag unresolvable.
// Works for both player bags (linear 19..22 of player invMgr) and
// bank bags (linear 63..68) — the only differences are the source of
// the bag's GUID and how the result encodes back into a location.
int WalkBagContents(uint64_t bagGuid, uint64_t targetGuid) {
auto *bag = ResolveByGUID(Offsets::OBJ_TYPE_CONTAINER, bagGuid);
if (bag == nullptr)
return 0;
auto *bagInvMgr = BagInvMgr(bag);
if (bagInvMgr == nullptr)
return 0;
const int count = InvMgrSlotCount(bagInvMgr);
auto *guids = InvMgrGuidArray(bagInvMgr);
if (guids == nullptr)
return 0;
return guids[linearSlot];
}
// Reads the GUID off a `CGItem *` (instance block at +0x08, GUID at
// the start of that block). Used to verify bag walks — `ResolveBag`
// returns a CGItem and we then check its GUID against our target.
uint64_t ReadCGItemGUID(const uint8_t *item) {
if (item == nullptr)
return 0;
auto *instance = *reinterpret_cast<const uint8_t *const *>(
item + Offsets::OFF_ITEM_INSTANCE_BLOCK);
if (instance == nullptr)
return 0;
return *reinterpret_cast<const uint64_t *>(
instance + Offsets::OFF_INSTANCE_BLOCK_GUID);
}
// Engine helper for "what's the slot count of bag N" — same primitive
// the hearthstone finder uses. Returns 0 for empty bag slots.
int BagSlotCount(void *L, int bagID) {
Game::Lua::SetTop(L, 0);
Game::Lua::PushNumber(L, static_cast<double>(bagID));
using ScriptFn_t = int(__fastcall *)(void *);
auto fn = reinterpret_cast<ScriptFn_t>(Offsets::FUN_SCRIPT_GET_CONTAINER_NUM_SLOTS);
fn(L);
if (!Game::Lua::IsNumber(L, -1))
return 0;
return static_cast<int>(Game::Lua::ToNumber(L, -1));
}
// Scans a single bag's contents for `targetGuid`. `bagID` is one of
// 0..4 (player) or 5..10 (bank). Returns the 1-based slot index of
// the match, or 0 if not found. Bank bag walks may legitimately
// return 0 when the bank is closed — the engine's `GetItemBySlot`
// gate suppresses the data, and we can't probe it without bypassing
// engine-internal state.
int WalkBagForGUID(void *L, int bagID, uint64_t targetGuid) {
const int count = BagSlotCount(L, bagID);
for (int slot = 1; slot <= count; ++slot) {
const uint8_t *item = Item::Location::ResolveBag(L, bagID, slot);
if (item == nullptr)
continue;
if (ReadCGItemGUID(item) == targetGuid)
return slot;
for (int i = 0; i < count; ++i) {
if (guids[i] == targetGuid)
return i + 1;
}
return 0;
}
} // namespace
int FindGUID(void *L, uint64_t targetGuid) {
int FindGUID(uint64_t targetGuid) {
if (targetGuid == GUID_EMPTY || targetGuid == GUID_IGNORED)
return 0;
// Paperdoll first — by far the most common hit since the user
// already has their gear on, especially right after `SaveEquipmentSet`.
auto *invMgr = ResolvePlayerInvMgr();
auto *guids = InvMgrGuidArray(invMgr);
if (guids == nullptr)
return 0;
// Paperdoll (linear 0..18 → slots 1..19). Most common hit
// because every set's items are equipped at save time.
for (int slot = 1; slot <= SLOT_COUNT; ++slot) {
if (ReadFlatGUID(slot - 1) == targetGuid)
if (guids[slot - 1] == targetGuid)
return PackEquipped(slot);
}
// Backpack: linear slots 23..38 = bag 0 slots 1..16.
for (int s = Offsets::INVMGR_BANK_MAIN_FIRST_SLOT - 16;
s < Offsets::INVMGR_BANK_MAIN_FIRST_SLOT; ++s) {
if (ReadFlatGUID(s) == targetGuid) {
const int slot1 = s - (Offsets::INVMGR_BANK_MAIN_FIRST_SLOT - 16) + 1;
return PackBag(0, slot1);
}
// Backpack contents (linear 23..38 → bag 0, slots 1..16).
for (int s = LINEAR_BACKPACK_FIRST; s <= LINEAR_BACKPACK_LAST; ++s) {
if (guids[s] == targetGuid)
return PackBag(0, s - LINEAR_BACKPACK_FIRST + 1);
}
// Main bank: linear slots 39..62 → bank slots 1..24.
// Main bank (linear 39..62 → slots 1..24). Direct read; the bank
// gate at `VAR_BANK_GATE_GUID` doesn't affect the underlying data.
for (int s = Offsets::INVMGR_BANK_MAIN_FIRST_SLOT;
s <= Offsets::INVMGR_BANK_MAIN_LAST_SLOT; ++s) {
if (ReadFlatGUID(s) == targetGuid) {
const int slot1 = s - Offsets::INVMGR_BANK_MAIN_FIRST_SLOT + 1;
return PackMainBank(slot1);
}
if (guids[s] == targetGuid)
return PackMainBank(s - Offsets::INVMGR_BANK_MAIN_FIRST_SLOT + 1);
}
// Player bag contents (bags 1..4). Walks each bag's own invMgr
// via the engine's `PackBagSlot` path.
// Player bags 1..4 — bag containers live at linear 19..22 of the
// player invMgr; their contents live in each bag's own invMgr.
for (int bag = 1; bag <= 4; ++bag) {
const int slot = WalkBagForGUID(L, bag, targetGuid);
const int linear = LINEAR_BAG_SLOT_FIRST + (bag - 1);
const int slot = WalkBagContents(guids[linear], targetGuid);
if (slot > 0)
return PackBag(bag, slot);
}
// Bank bag contents (bags 5..10) — only resolves while bank is open.
for (int bag = 5; bag <= 10; ++bag) {
const int slot = WalkBagForGUID(L, bag, targetGuid);
if (slot > 0)
return PackBankBag(bag, slot);
// Bank bags 5..10 — bag containers at linear 63..68. Same walk as
// player bags; works without the bank window being open.
for (int linear = Offsets::INVMGR_BANK_BAG_FIRST_SLOT;
linear <= Offsets::INVMGR_BANK_BAG_LAST_SLOT; ++linear) {
const int slot = WalkBagContents(guids[linear], targetGuid);
if (slot > 0) {
const int bagID = 5 + (linear - Offsets::INVMGR_BANK_BAG_FIRST_SLOT);
return PackBankBag(bagID, slot);
}
}
return 0;
@@ -148,15 +173,7 @@ int FindGUID(void *L, uint64_t targetGuid) {
const uint8_t *ResolveItemByGUID(uint64_t guid) {
if (guid == GUID_EMPTY || guid == GUID_IGNORED)
return nullptr;
using ResolveByGUID_t = void *(__fastcall *)(int type, const char *debugName,
uint32_t guidLo, uint32_t guidHi,
int priority);
auto fn = reinterpret_cast<ResolveByGUID_t>(Offsets::FUN_OBJECT_RESOLVE_BY_GUID);
auto *obj = fn(Offsets::OBJ_TYPE_ITEM, "ItemMgr",
static_cast<uint32_t>(guid),
static_cast<uint32_t>(guid >> 32),
0x172);
return static_cast<const uint8_t *>(obj);
return ResolveByGUID(Offsets::OBJ_TYPE_ITEM, guid);
}
} // namespace EquipmentSet::Locations
+12 -15
View File
@@ -24,21 +24,18 @@ namespace EquipmentSet::Locations {
// (see Set.h's `PackEquipped`/`PackBag`/`PackMainBank`/`PackBankBag`).
// Returns 0 if the GUID isn't found anywhere.
//
// Coverage:
// - paperdoll (slots 1..19) — always available
// - backpack (bag 0, slots 1..16) — always available
// - player bags 1..4 — always available
// - main bank (24 slots) — always (raw GUID array read)
// - bank bag slots (bank bag items) — always (raw GUID array read)
// - bank bag CONTENTS (bags 5..10) — only while bank window is open;
// the engine's bag invMgr is
// populated lazily and reading
// before that returns nothing
//
// `L` is required because the engine's `PackBagSlot` reads bag/slot
// args off the Lua stack; we shape the stack inside this function.
// Callers must own the stack; we leave it cleared on return.
int FindGUID(void *L, uint64_t targetGuid);
// Coverage — ALL locations are read via the player invMgr's flat
// GUID array at `+0x04` and (for bag contents) via each bag's own
// invMgr reached through the bag's vtable `+0x10`. None of this
// goes through the engine's `GetItemBySlot` / `PackBagSlot` path,
// so:
// - no Lua stack is touched (safe to call from any callback)
// - bank items resolve without the bank window ever being open
// (the GUIDs are populated from server data at login; only
// `GetItemBySlot` is gated by `VAR_BANK_GATE_GUID`, the
// underlying data is always present — same trick
// `C_Item.GetItemCount` uses)
int FindGUID(uint64_t targetGuid);
// Resolves a GUID to a `CGItem*` via the engine's GUID→CObject
// resolver (`FUN_OBJECT_RESOLVE_BY_GUID`). Returns null if the item