From db88fca0506a65e5cc0b430e89ac034b2ebf881c Mon Sep 17 00:00:00 2001 From: Brues <5278969+brues-code@users.noreply.github.com> Date: Mon, 7 Sep 2026 01:38:34 -0500 Subject: [PATCH] feat(container): add C_Container.AutoStoreItem Moves an item and lets the server pick the destination slot, which is worth having because the server does not merely find an empty one: it first merges the stack into existing stacks of the same item, splitting it across several when that is what fits, and places a remainder only if one is left. So one call consolidates a partial stack. Two engine builders back it, because the wire has two autostore opcodes. FUN_005E12E0 sends CMSG_AUTOSTORE_BAG_ITEM (0x10B) and takes a destination container, so it can confine an item to one equipped bag or let the server search the whole inventory. FUN_005E18F0 sends CMSG_AUTOSTORE_BANK_ITEM (0x282) and takes no destination at all - the server derives the direction from the source, so a bank source travels to the inventory and an inventory source to the bank. AutoStore picks between them and accepts only the pairs the wire can honestly serve. Bank-to-bank is not among them, so consolidating stacks within the bank still needs per-pair moves. Both builders' stack-arg counts come from their RET, not from a decompiler parameter list. 0x10B's last slot is never read by the body but is still popped, and declaring seven args instead of eight made the callee pop four bytes we never pushed - which shifted the caller's frame and surfaced as a garbage Lua state pointer in the next function to run, several frames from the call. Noted at both offsets, since this family is not uniform in arity. Three fixes to the shared bagID encoder found while doing it: - EncodeBagSlot had no case for the keyring (bagID -2), so SwapItems, MoveItem and AutoStoreItem all rejected keyring slots. The engine's own map in FUN_PACK_BAG_SLOT has had it all along, and the linear base was already recorded in the invMgr slot map. - Its bank constants restated named Offsets::INVMGR_* values, so they now derive from them, and the slot map is fully named rather than half constants and half comment. Each player-container range is bounded by both its own last linear slot and the live invMgr count - stricter than before, where the backpack had no upper bound at all. - FUN_PACK_BAG_SLOT's fourth out-param was labelled outUnused. It is the bank flag, and it is what makes right-clicking a bank item send 0x282 instead of using the item. --- README.md | 2 +- docs/API.md | 69 +++++++++++ src/Offsets.h | 102 ++++++++++++++++- src/container/AutoStoreItem.cpp | 74 ++++++++++++ src/item/Swap.cpp | 196 +++++++++++++++++++++++++++----- src/item/Swap.h | 44 +++++++ 6 files changed, 453 insertions(+), 34 deletions(-) create mode 100644 src/container/AutoStoreItem.cpp diff --git a/README.md b/README.md index 04a02441..36425bb1 100644 --- a/README.md +++ b/README.md @@ -62,7 +62,7 @@ reference in **[docs/API.md](docs/API.md)**. | [Console](docs/API.md#console) | `CalculateStringEditDistance`, `ConsoleEcho`, `ConsoleExec`, `ConsoleGetAllCommands`, `ConsoleGetColorFromType`, `ConsoleGetFontHeight`, `ConsoleIsActive`, `ConsolePrintAllMatchingCommands`, `SetConsoleKey` | | [CVar](docs/API.md#cvar) | `C_CVar.AreCVarsLoaded`, `C_CVar.DoesCVarExist`, `C_CVar.GetCVarBitfield`, `C_CVar.GetCVarBool`, `C_CVar.GetCVarInfo`, `C_CVar.SetCVarBitfield` | | [Cursor](docs/API.md#cursor) | `GetCursorInfo` | -| [Container](docs/API.md#container) | `C_Container.CalculateTotalNumberOfFreeBagSlots`, `C_Container.GetContainerItemCharges`, `C_Container.GetContainerItemDurability`, `C_Container.GetContainerItemID`, `C_Container.GetContainerItemInfo`, `C_Container.GetContainerItemRepairCost`, `C_Container.GetContainerNumFreeSlots`, `C_Container.GetItemCooldown`, `C_Container.HasContainerItem`, `C_Container.IsContainerItemOpenable`, `C_Container.MoveItem`, `C_Container.PlayerHasHearthstone`, `C_Container.SwapItems`, `C_Container.UseHearthstone`, `GetItemCooldown` | +| [Container](docs/API.md#container) | `C_Container.AutoStoreItem`, `C_Container.CalculateTotalNumberOfFreeBagSlots`, `C_Container.GetContainerItemCharges`, `C_Container.GetContainerItemDurability`, `C_Container.GetContainerItemID`, `C_Container.GetContainerItemInfo`, `C_Container.GetContainerItemRepairCost`, `C_Container.GetContainerNumFreeSlots`, `C_Container.GetItemCooldown`, `C_Container.HasContainerItem`, `C_Container.IsContainerItemOpenable`, `C_Container.MoveItem`, `C_Container.PlayerHasHearthstone`, `C_Container.SwapItems`, `C_Container.UseHearthstone`, `GetItemCooldown` | | [Creature](docs/API.md#creature) | `C_CreatureInfo.GetCreatureID`, `C_CreatureInfo.GetCreatureInfoByID`, `C_CreatureInfo.RequestLoadCreatureByID`, `C_CreatureInfo.GetRaceInfo`, `C_CreatureInfo.GetClassInfo`, `C_CreatureInfo.GetCreatureFamilyInfo`, `C_CreatureInfo.GetCreatureFamilyIDs`, `C_CreatureInfo.GetFactionInfo`, `C_CreatureInfo.GetCreatureTypeInfo`, `C_CreatureInfo.GetCreatureTypeIDs` | | [Currency](docs/API.md#currency) | `GetCoinTextureString`, `C_CurrencyInfo.GetCoinTextureString` | | EncodingUtil | `C_EncodingUtil.CompressString`, `C_EncodingUtil.DecompressString`, `C_EncodingUtil.EncodeBase64`, `C_EncodingUtil.DecodeBase64`, `C_EncodingUtil.EncodeHex`, `C_EncodingUtil.DecodeHex`, `C_EncodingUtil.SerializeJSON`, `C_EncodingUtil.DeserializeJSON`, `C_EncodingUtil.SerializeCBOR`, `C_EncodingUtil.DeserializeCBOR` | diff --git a/docs/API.md b/docs/API.md index 88ab0cb9..35d0b117 100644 --- a/docs/API.md +++ b/docs/API.md @@ -87,6 +87,7 @@ build instructions. - [`C_Container.UseHearthstone()`](#c_containerusehearthstone) - [`C_Container.SwapItems(srcBag, srcSlot, dstBag, dstSlot)`](#c_containerswapitemssrcbag-srcslot-dstbag-dstslot) - [`C_Container.MoveItem(srcBag, srcSlot, dstBag, dstSlot, count)`](#c_containermoveitemsrcbag-srcslot-dstbag-dstslot-count) + - [`C_Container.AutoStoreItem(srcBag, srcSlot [, dstBag])`](#c_containerautostoreitemsrcbag-srcslot--dstbag) - [Creature](#creature) - [`C_CreatureInfo.GetCreatureID(guid)`](#c_creatureinfogetcreatureidguid) @@ -2293,6 +2294,74 @@ constraint as `SwapItems`. Send is fire-and-forget (same as `SwapItems`). +### `C_Container.AutoStoreItem(srcBag, srcSlot [, dstBag])` + +Moves an item and lets the server pick the destination slot. Returns +`true` on send, `false` for bad args (missing bag, out-of-range slot, +empty source, or a source and destination the call cannot serve). + +The server does not just look for an empty slot. It first merges the +item into existing stacks of the same item, and splits it across +several of them when that is what fits. It places a remainder in a +free slot only if some is left over. So one call consolidates a +partial stack: + +```lua +-- Two partial stacks of item 12662: slot 1 holds 5, slot 2 holds 3. +C_Container.AutoStoreItem(0, 2) +-- Slot 1 now holds 8, and slot 2 is empty. + +-- Confine the item to bag 2 +C_Container.AutoStoreItem(0, 5, 2) +``` + +`dstBag` says where you want the item, and defaults to `0`: + +- `0` — anywhere in the main inventory that it fits. This means the + whole inventory, not the backpack. The backpack cannot be named + separately as a destination. +- `1..4` — that equipped bag only. +- `-1` — anywhere in the bank that it fits. + +Deposits and withdrawals both work, and both merge on arrival: + +```lua +-- Deposit, merging into stacks already in the bank +C_Container.AutoStoreItem(0, 3, -1) + +-- Withdraw bank slot 5 back into the bags +C_Container.AutoStoreItem(-1, 5, 0) +``` + +A bank item always travels back to your bags, so you cannot ask for a +new slot inside the bank. These three combinations are accepted, and +every other pair returns `false`: + +| Source | `dstBag` | Result | +|---|---|---| +| inventory | `0..4` | stays in the inventory | +| inventory | `-1` | goes to the bank | +| bank | `0` | comes back to the inventory | + +To consolidate stacks inside the bank, use `C_Container.MoveItem` for +each pair. Individual bank bags (`5..10`) are not valid destinations. + +Bank slots need the bank window open, the same as `SwapItems` and +`MoveItem`. + +> **Prefer this over merging stacks yourself.** This call needs no +> stack-size lookup, because the server decides what fits. A merge you +> compute in Lua has to size each stack first with +> `C_Item.GetItemMaxStackSizeByID`, which returns `nil` until that +> item's data has arrived. A merge written that way silently skips any +> stack it cannot size. + +There is no way to name the destination slot, which is the point of the +call. Use `C_Container.SwapItems` or `C_Container.MoveItem` when you +need to choose it. + +Send is fire-and-forget (same as `SwapItems` and `MoveItem`). + ## Creature ### `C_CreatureInfo.GetCreatureID(guid)` diff --git a/src/Offsets.h b/src/Offsets.h index 980d299e..e1987887 100644 --- a/src/Offsets.h +++ b/src/Offsets.h @@ -799,8 +799,10 @@ enum Offsets { // `Script_EquipCursorItem` (0x00489660) uses after the cursor's // source location has been resolved. Sends opcode 0x10D // (CMSG_SWAP_INV_ITEM) for same-container swaps or 0x10C - // (CMSG_AUTOEQUIP_ITEM) for cross-container, then runs the - // packet through the engine's own send pipeline at FUN_005AB630. + // (CMSG_SWAP_ITEM) for cross-container, then runs the packet + // through the engine's own send pipeline at FUN_005AB630. + // (0x10C is SWAP_ITEM; CMSG_AUTOEQUIP_ITEM is 0x10A and belongs to + // the cursor/equip builder FUN_005E1480, not this one.) // // Signature: // void __thiscall( @@ -853,6 +855,84 @@ enum Offsets { // u32 count); // only low byte FUN_INVENTORY_SPLIT = 0x005E1210, + // Third sibling in the same packet-builder family — `__thiscall`, + // same shared bag-byte converter (`FUN_005E13B0`), same send + // pipeline (`FUN_005AB630`). Builds `CMSG_AUTOSTORE_BAG_ITEM` + // (opcode 0x10B): "take this item and put it wherever it belongs + // in that container", with the DESTINATION SLOT CHOSEN BY THE + // SERVER. Wire format: + // [0x10B, srcBag, srcLinearSlot, dstBag] + // + // Signature — EIGHT stack args, `RET 0x20`. The count is from the + // RET, not from a decompiler parameter list: the last slot + // (`EBP+0x24`) is never READ by the body, but it IS popped, so a + // 7-arg declaration leaves the callee popping four bytes too many + // and ESP walks on every call. Trailing-ignored-arg is this + // family's habit — it is where swap keeps its `flag` and split its + // `count` — but the family is NOT uniform in arity: those two take + // nine (`RET 0x24`), this one eight. + // void __thiscall( + // CGPlayer *this, + // u32 unused1, u32 unused2, // EBP+0x08/+0x0C, unread + // u32 srcContainerLo, u32 srcContainerHi, + // u32 srcLinearSlot, // only low byte hits the wire + // u32 dstContainerLo, u32 dstContainerHi, + // u32 unused3); // EBP+0x24, unread but popped + // + // Note there is no dst slot argument at all — that is the point of + // the opcode. Server-side (`HandleAutoStoreBagItemOpcode`) it runs + // `CanStoreItem(dstBag, NULL_SLOT, …)`, which is a TWO-PASS search: + // first "merge into existing non-full stacks of this item" (filling + // a position/count vector, so one stack can be distributed across + // several destinations), then "find a free slot" for whatever count + // is left. So this single packet performs partial-stack + // consolidation with no stack-size lookup on our side at all. + // + // Note the value in that is NOT that the client's stack size could + // be wrong: 1.12 has no item DBC, so stack size arrives from the + // server and is cached in itemcache.wdb, and the client's copy + // normally agrees by construction. The value is availability — + // `C_Item.GetItemMaxStackSizeByID` is nil until an item's data has + // arrived, so anything that sizes stacks first has a cold-cache + // hole, and the server never needs to size them. + // + // The converter returns `0xFF` for any GUID absent from the + // player's invMgr container array, and the player's own GUID is + // absent — so passing the PLAYER as the destination sends + // `dstBag = 0xFF` (INVENTORY_SLOT_BAG_0), which the server reads as + // "search every bag". The builder guards that case: a converted + // `0xFF` is only allowed through when the destination GUID really is + // the player's, otherwise it drops the send silently. Consequence: + // the backpack is not separately addressable as a destination (it + // IS the player container), so bagID 0 means "anywhere it fits". + FUN_INVENTORY_AUTOSTORE = 0x005E12E0, + + // Bank counterpart — `CMSG_AUTOSTORE_BANK_ITEM` (opcode 0x282). + // THREE stack args, `RET 0xC`. Wire: [0x282, srcBag, srcSlot]. + // void __thiscall( + // CGPlayer *this, + // u32 srcContainerLo, u32 srcContainerHi, + // u32 srcLinearSlot); // only low byte hits the wire + // + // No destination of any kind, because the server DERIVES THE + // DIRECTION FROM THE SOURCE (`HandleAutoStoreBankItemOpcode`): + // a bank source runs `CanStoreItem(NULL_BAG, NULL_SLOT, …)` and + // lands in the inventory; an inventory source runs + // `CanBankItem(NULL_BAG, NULL_SLOT, …)` and lands in the bank. + // Both are the same merge-into-existing-stacks-then-free-slot + // search as 0x10B, just aimed at the other side. + // + // So this opcode moves an item ACROSS the inventory/bank boundary + // and cannot move one within its own side. Bank-internal + // consolidation is not expressible through autostore at all — it + // needs per-pair moves (`FUN_INVENTORY_SPLIT` / `_SWAP`). + // + // Unlike its siblings this one validates the source itself before + // sending: resolves the container by GUID (`FUN_00468460` with + // typeMask 1), bounds-checks the slot against the container's item + // array, and bails when the GUID in that slot is zero. + FUN_INVENTORY_AUTOSTORE_BANK = 0x005E18F0, + // Registers a single global Lua function. __fastcall(name, func). FUN_FRAMESCRIPT_REGISTER_FUNCTION = 0x00704120, @@ -2516,9 +2596,17 @@ enum Offsets { VAR_GUILD_ROSTER_TOTAL_COUNT = 0x00B73118, OFF_GUILD_MEMBER_NAME = 0x08, - // PackBagSlot — __fastcall(L, void **outInvMgr, int *outLinearSlot, int *outUnused) → bool. + // PackBagSlot — __fastcall(L, void **outInvMgr, int *outLinearSlot, int *outIsBank) → bool. // Reads bagID at Lua stack[1] and slot at stack[2], validates them, and // returns the inventory manager + linear slot ready to feed into GetItemBySlot. + // + // The fourth out-param is NOT unused (it was labelled `outUnused` + // here until the bank-autostore work): it is set to 1 for a bank + // position — bagID -1 (main bank) and bagIDs 5..10 (bank bags) — + // and left 0 otherwise, keyring included. `Script_UseContainerItem` + // is what consumes it: a non-zero flag is what makes right-clicking + // a bank item send `CMSG_AUTOSTORE_BANK_ITEM` instead of using it. + // This is the engine's own definition of "is this a bank slot". FUN_PACK_BAG_SLOT = 0x004F9820, // Equipped-bag container-GUID getter — `uint64 __fastcall(uint bagIndex0)` // where `bagIndex0` is 0-based (Lua bagID 1..4 → 0..3; 4..9 are bank bags, @@ -2563,10 +2651,18 @@ enum Offsets { // it hides data that's present from boot. Reading the GUID array // directly recovers it without ever opening the bank window. OFF_INVMGR_GUID_ARRAY = 0x04, + INVMGR_BACKPACK_FIRST_SLOT = 23, + INVMGR_BACKPACK_LAST_SLOT = 38, INVMGR_BANK_MAIN_FIRST_SLOT = 39, INVMGR_BANK_MAIN_LAST_SLOT = 62, INVMGR_BANK_BAG_FIRST_SLOT = 63, INVMGR_BANK_BAG_LAST_SLOT = 68, + // Keyring (Lua bagID -2). No LAST constant: the engine bounds this + // range against the invMgr's own slot count (OFF_INVMGR_SLOT_COUNT) + // rather than a fixed size, since keyring capacity grows with level. + // Base confirmed from FUN_PACK_BAG_SLOT, which maps Lua bagID -2 to + // `slot - 1 + 0x51`. + INVMGR_KEYRING_FIRST_SLOT = 81, // Engine's `ObjectMgr::Get`-style resolver — given a type and GUID, // returns the resolved CGObject pointer (or null). Same function the // engine itself uses inside `GetItemBySlot` (called at `0x00622904`) diff --git a/src/container/AutoStoreItem.cpp b/src/container/AutoStoreItem.cpp new file mode 100644 index 00000000..302a929d --- /dev/null +++ b/src/container/AutoStoreItem.cpp @@ -0,0 +1,74 @@ +// 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 . + +// `C_Container.AutoStoreItem(srcBag, srcSlot [, dstBag])` — move an item +// and let the SERVER choose the destination slot. A ClassicAPI-only +// extension, like its siblings `SwapItems` and `MoveItem`; the modern +// API has no equivalent, because it has no need for one. +// +// The reason to want it: the server does not just find an empty slot. +// It first merges the stack into existing non-full stacks of the same +// item, splitting it across several of them when that is what fits, and +// only places a remainder if any is left over. So this is a one-call +// stack consolidator that needs no stack-size lookup — the caller never +// has to know what fits. A merge computed on this side has to size +// every stack first, and `C_Item.GetItemMaxStackSizeByID` is nil until +// that item's data has arrived, so a cold item cache silently skips +// exactly the stacks it could not size. +// +// `dstBag` defaults to 0, which means "anywhere in the main inventory +// that it fits" rather than "the backpack" — on the wire the backpack +// IS the player container, so the two cannot be distinguished. Pass +// 1..4 to confine the item to one equipped bag. Bank destinations are +// rejected (see [[item/Swap.h]] `AutoStore`). +// +// Returns true once the packet is away — like the other two, the send +// is fire-and-forget and the server confirms through the normal +// BAG_UPDATE / SMSG_INVENTORY_CHANGE_FAILURE flow. + +#include "Game.h" +#include "item/Swap.h" + +namespace Container::AutoStoreItem { + +namespace { + +int __fastcall Script_C_Container_AutoStoreItem(void *L) { + if (!Game::Lua::IsNumber(L, 1) || !Game::Lua::IsNumber(L, 2)) { + Game::Lua::Error(L, + "Usage: C_Container.AutoStoreItem(srcBag, srcSlot [, dstBag])"); + return 0; + } + // Read every arg before calling AutoStore — its source lookup goes + // through ResolveBag, which stomps the Lua stack via PackBagSlot. + const int srcBag = static_cast(Game::Lua::ToNumber(L, 1)); + const int srcSlot = static_cast(Game::Lua::ToNumber(L, 2)); + const int dstBag = Game::Lua::IsNumber(L, 3) + ? static_cast(Game::Lua::ToNumber(L, 3)) + : 0; + + const bool ok = Item::Swap::AutoStore(L, srcBag, srcSlot, dstBag); + Game::Lua::PushBool(L, ok); + return 1; +} + +void RegisterLuaFunctions() { + Game::Lua::RegisterTableFunction("C_Container", "AutoStoreItem", + &Script_C_Container_AutoStoreItem); +} + +const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions}; + +} // namespace + +} // namespace Container::AutoStoreItem diff --git a/src/item/Swap.cpp b/src/item/Swap.cpp index 139aa7f0..3cb45ef4 100644 --- a/src/item/Swap.cpp +++ b/src/item/Swap.cpp @@ -55,35 +55,53 @@ bool ReadGuid(const void *cgObject, uint32_t *lo, uint32_t *hi) { // the magic +19 in FromBag is explained at the call site. constexpr int FIRST_BAG_CONTAINER_LINEAR = 19; -// Backpack contents (bag 0) live at linear slots 23..38 in the -// player invMgr — i.e. 1-based bag-0 slot S maps to linear 22+S. -constexpr int BACKPACK_LINEAR_OFFSET = 22; +// Player-container linear-slot bases, DERIVED from the named +// first-slot constants in Offsets.h rather than restated. The whole map +// (paperdoll / backpack / bank / bank bags / keyring) is documented at +// `Offsets::OFF_INVMGR_GUID_ARRAY`; a 1-based slot S in one of these +// ranges maps to `base + S`, so each base is that range's first linear +// slot minus one. +constexpr int BACKPACK_LINEAR_OFFSET = Offsets::INVMGR_BACKPACK_FIRST_SLOT - 1; +constexpr int BANK_MAIN_LINEAR_OFFSET = Offsets::INVMGR_BANK_MAIN_FIRST_SLOT - 1; +constexpr int KEYRING_LINEAR_OFFSET = Offsets::INVMGR_KEYRING_FIRST_SLOT - 1; -// Main bank contents (bagID -1) live at linear slots 39..62 in the -// player invMgr — i.e. 1-based bank slot S maps to linear 38+S. -// Same encoding shape as the backpack (container is the player -// itself), different base offset. Range valid only when the bank -// window has been opened in the current session. -constexpr int BANK_MAIN_LINEAR_OFFSET = 38; -constexpr int BANK_MAIN_NUM_SLOTS = 24; - -// Bank bag containers occupy 1-based equipment slots 64..69 (linear -// 63..68). Addressed by bagID 5..10 — bagID 5 = first bank bag. +// Bank bag containers are addressed by bagID 5..10 — bagID 5 = first +// bank bag. `ResolveEquipmentSlot` takes a 1-based equipment slot, so +// the base is the bank-bag range's first linear slot plus one. // Requires bank window open; otherwise the engine's CGContainer for // the bag is unsynced and `ResolveEquipmentSlot` returns null. -constexpr int FIRST_BANK_BAG_EQ_SLOT = 64; +constexpr int FIRST_BANK_BAG_EQ_SLOT = Offsets::INVMGR_BANK_BAG_FIRST_SLOT + 1; constexpr int FIRST_BANK_BAG_ID = 5; constexpr int LAST_BANK_BAG_ID = 10; +// Bounds a player-container linear slot the way `FUN_PACK_BAG_SLOT` +// does — against the invMgr's own live slot count, not a hardcoded +// size. That is what makes the keyring addressable without knowing its +// capacity, which grows as the character unlocks slots. +bool LinearSlotInRange(const void *player, uint32_t linearSlot) { + const uint32_t count = Game::Read( + player, + Offsets::OFF_PLAYER_INVENTORY_MANAGER + Offsets::OFF_INVMGR_SLOT_COUNT); + return linearSlot < count; +} + // (bagID, 1-based slot) → (containerGUID, engine linear slot). Returns // false for unequipped bags or out-of-range slots; does NOT validate // that the slot is occupied (caller checks separately). // -// bagID 0 → container = player, linear = 22 + slot (backpack) -// bagID 1..4 → container = equipped bag's CGContainer, linear = slot - 1 -// bagID -1 → container = player, linear = 38 + slot (bank main) +// bagID 0 → container = player, linear = 22 + slot (backpack) +// bagID 1..4 → container = equipped bag's CGContainer, linear = slot - 1 +// bagID -1 → container = player, linear = 38 + slot (bank main) +// bagID -2 → container = player, linear = 80 + slot (keyring) // bagID 5..10 → container = bank bag's CGContainer, linear = slot - 1 // +// This mirrors the engine's own bagID→(container, linear slot) map in +// `FUN_PACK_BAG_SLOT`, minus that function's Lua coupling: it reads its +// bagID and slot off the Lua stack and stomps it, which is why this is +// a separate encoder rather than a call into it. Keep the two in step — +// the keyring row above exists because this encoder was missing it +// while the engine's map had it all along. +// // Bank-side encodings only resolve once the bank window has been // opened in the current session (the engine doesn't sync the bank // CGContainers or bank-slot inventory entries before then). @@ -92,15 +110,41 @@ bool EncodeBagSlot(int bagID, int slotInBag, uint32_t *linearSlot) { if (slotInBag < 1) return false; + + // Backpack, main bank and keyring all live directly in the player's + // invMgr and differ only in their base — and in whether the range + // has a fixed end. `lastLinear == 0` means "no fixed end", which is + // the keyring: its capacity grows, so the invMgr count is the only + // correct bound. + int base = 0; + int lastLinear = 0; + bool inPlayer = true; if (bagID == 0) { - void *player = const_cast(Unit::Identity::PlayerObject()); + base = BACKPACK_LINEAR_OFFSET; + lastLinear = Offsets::INVMGR_BACKPACK_LAST_SLOT; + } else if (bagID == -1) { + base = BANK_MAIN_LINEAR_OFFSET; + lastLinear = Offsets::INVMGR_BANK_MAIN_LAST_SLOT; + } else if (bagID == -2) { + base = KEYRING_LINEAR_OFFSET; + } else { + inPlayer = false; + } + if (inPlayer) { + const void *player = Unit::Identity::PlayerObject(); if (player == nullptr) return false; + const uint32_t linear = static_cast(base + slotInBag); + if (lastLinear != 0 && linear > static_cast(lastLinear)) + return false; // would alias into the next range + if (!LinearSlotInRange(player, linear)) + return false; if (!ReadGuid(player, containerLo, containerHi)) return false; - *linearSlot = static_cast(BACKPACK_LINEAR_OFFSET + slotInBag); + *linearSlot = linear; return true; } + if (bagID >= 1 && bagID <= 4) { const uint8_t *bag = Item::Location::ResolveEquipmentSlot( FIRST_BAG_CONTAINER_LINEAR + bagID); @@ -111,17 +155,6 @@ bool EncodeBagSlot(int bagID, int slotInBag, *linearSlot = static_cast(slotInBag - 1); return true; } - if (bagID == -1) { - if (slotInBag > BANK_MAIN_NUM_SLOTS) - return false; - void *player = const_cast(Unit::Identity::PlayerObject()); - if (player == nullptr) - return false; - if (!ReadGuid(player, containerLo, containerHi)) - return false; - *linearSlot = static_cast(BANK_MAIN_LINEAR_OFFSET + slotInBag); - return true; - } if (bagID >= FIRST_BANK_BAG_ID && bagID <= LAST_BANK_BAG_ID) { const uint8_t *bag = Item::Location::ResolveEquipmentSlot( FIRST_BANK_BAG_EQ_SLOT + (bagID - FIRST_BANK_BAG_ID)); @@ -135,6 +168,35 @@ bool EncodeBagSlot(int bagID, int slotInBag, return false; } +// Container GUID for a bagID, with no slot involved — what the +// autostore opcode needs, since it names a destination container and +// lets the server choose the slot inside it. Bags 0 and -1 resolve to +// the player, which the engine's converter reports as `0xFF` +// (INVENTORY_SLOT_BAG_0); the two are indistinguishable on the wire. +bool EncodeContainerGuid(int bagID, uint32_t *containerLo, uint32_t *containerHi) { + if (bagID == 0 || bagID == -1) { + void *player = const_cast(Unit::Identity::PlayerObject()); + if (player == nullptr) + return false; + return ReadGuid(player, containerLo, containerHi); + } + if (bagID >= 1 && bagID <= 4) { + const uint8_t *bag = Item::Location::ResolveEquipmentSlot( + FIRST_BAG_CONTAINER_LINEAR + bagID); + if (bag == nullptr) + return false; + return ReadGuid(bag, containerLo, containerHi); + } + if (bagID >= FIRST_BANK_BAG_ID && bagID <= LAST_BANK_BAG_ID) { + const uint8_t *bag = Item::Location::ResolveEquipmentSlot( + FIRST_BANK_BAG_EQ_SLOT + (bagID - FIRST_BANK_BAG_ID)); + if (bag == nullptr) + return false; + return ReadGuid(bag, containerLo, containerHi); + } + return false; +} + // Common send path. All paperdoll-side state (player ptr, player // GUID) is resolved here; caller supplies the source side // (already-encoded linear slot + the container GUID it lives in). @@ -285,6 +347,80 @@ bool MoveCount(void *L, int srcBag, int srcSlot, int dstBag, int dstSlot, int co return true; } +bool AutoStore(void *L, int srcBag, int srcSlot, int dstBag) { + const bool srcIsBank = + srcBag == -1 || (srcBag >= FIRST_BANK_BAG_ID && srcBag <= LAST_BANK_BAG_ID); + + // Which of the two autostore opcodes serves this pair — and whether + // either does. The bank opcode takes its direction from the source, + // so it can only cross the boundary; see the header note. + bool crossToBank = false; // use FUN_INVENTORY_AUTOSTORE_BANK + if (srcIsBank) { + if (dstBag != 0) + return false; // bank→bank, or a bank source aimed at one bag + crossToBank = true; // 0x282 sends a bank source to the inventory + } else if (dstBag == -1) { + crossToBank = true; // 0x282 sends an inventory source to the bank + } else if (dstBag < 0 || dstBag > 4) { + return false; // individual bank bags are not addressable + } + + uint32_t srcContainerLo = 0, srcContainerHi = 0, srcLinear = 0; + if (!EncodeBagSlot(srcBag, srcSlot, + &srcContainerLo, &srcContainerHi, &srcLinear)) + return false; + + uint32_t dstContainerLo = 0, dstContainerHi = 0; + if (!crossToBank && + !EncodeContainerGuid(dstBag, &dstContainerLo, &dstContainerHi)) + return false; + + // Confirm the source is occupied so an empty slot is a clean local + // `false` instead of a server reject. Stomps the Lua stack. + if (Item::Location::ResolveBag(L, srcBag, srcSlot) == nullptr) + return false; + + void *player = const_cast(Unit::Identity::PlayerObject()); + if (player == nullptr) + return false; + + if (crossToBank) { + // Three stack args, `RET 0xC`. No destination on the wire — the + // server reads the direction off the source position. + using AutoStoreBankFn_t = void(__thiscall *)( + void *thisPlayer, + uint32_t srcContainerLo, uint32_t srcContainerHi, + uint32_t srcSlot); + auto fnBank = reinterpret_cast( + Offsets::FUN_INVENTORY_AUTOSTORE_BANK); + fnBank(player, srcContainerLo, srcContainerHi, srcLinear); + return true; + } + + // No item GUID on the wire for this opcode — the server locates the + // item from (srcBag, srcLinearSlot). The first two args are the + // family's ABI padding, as with the split builder. + // + // EIGHT stack args, matching the callee's `RET 0x20`. The trailing + // one is never read by the body, but declaring seven makes it pop + // four bytes we never pushed, and the caller's stack shifts under + // it — which shows up much later as a garbage pointer in whoever + // runs next, not as a fault here. + using AutoStoreFn_t = void(__thiscall *)( + void *thisPlayer, + uint32_t unused1, uint32_t unused2, + uint32_t srcContainerLo, uint32_t srcContainerHi, uint32_t srcSlot, + uint32_t dstContainerLo, uint32_t dstContainerHi, + uint32_t unused3); + auto fn = reinterpret_cast(Offsets::FUN_INVENTORY_AUTOSTORE); + fn(player, + 0, 0, + srcContainerLo, srcContainerHi, srcLinear, + dstContainerLo, dstContainerHi, + 0); + return true; +} + bool Containers(void *L, int srcBag, int srcSlot, int dstBag, int dstSlot) { uint32_t srcContainerLo = 0, srcContainerHi = 0, srcLinear = 0; uint32_t dstContainerLo = 0, dstContainerHi = 0, dstLinear = 0; diff --git a/src/item/Swap.h b/src/item/Swap.h index 7142c591..6d68fb61 100644 --- a/src/item/Swap.h +++ b/src/item/Swap.h @@ -97,4 +97,48 @@ bool Containers(void *L, int srcBag, int srcSlot, int dstBag, int dstSlot); // Lua stack. bool MoveCount(void *L, int srcBag, int srcSlot, int dstBag, int dstSlot, int count); +// "Put this item away" — the server picks the destination slot +// (`CMSG_AUTOSTORE_BAG_ITEM`, opcode 0x10B). Unlike `Containers` and +// `MoveCount` there is no destination slot to supply, and that is the +// whole value of it: the server first merges the stack into existing +// non-full stacks of the same item (splitting it across several if +// needed), then places any remainder in a free slot. +// +// So this is the right primitive for consolidating partial stacks, +// because it needs no stack-size lookup on this side. Computing the +// merge here would mean sizing every stack first, and the max-stack +// getter is nil until that item's data has arrived from the server — +// so a cold item cache silently skips exactly the stacks it could not +// size. The server never has to look one up. +// +// `dstBag` says where you want it, and two different engine builders +// serve it because the wire has two autostore opcodes: +// dstBag 0 → anywhere in the main inventory that it fits +// dstBag 1..4 → that equipped bag only +// dstBag -1 → anywhere in the bank that it fits +// +// The backpack is not separately addressable, because on the wire the +// backpack IS the player container — so 0 means the whole inventory, +// not "the backpack". Individual bank bags (5..10) are likewise not +// addressable: the bank opcode carries no destination at all. +// +// WHAT IS NOT EXPRESSIBLE: moving an item to a fresh slot on the side +// it is already on, when that side is the bank. The bank opcode derives +// its direction from the source, so a bank-sourced item always travels +// to the inventory. Consolidating stacks WITHIN the bank therefore +// cannot use this call — use `MoveCount` per pair instead. The +// combinations this accepts are exactly: +// inventory source, dstBag 0..4 → stays in the inventory +// inventory source, dstBag -1 → goes to the bank +// bank source, dstBag 0 → comes back to the inventory +// Anything else returns false rather than sending a packet that would +// do something other than what was asked. +// +// Returns false on bad args, an unequipped bag, a rejected +// source/destination pair, or an empty source slot. Everything else is +// server-side; failures come back as `SMSG_INVENTORY_CHANGE_FAILURE` +// exactly as for the other two. Stomps the Lua stack for the same +// reason `Containers` does. +bool AutoStore(void *L, int srcBag, int srcSlot, int dstBag); + } // namespace Item::Swap