Files
ClassicAPI/src/container/Bag.cpp
T
Brues 426f6b6ec9 fix(container): free slots count the bank and use the engine's counter
GetContainerNumFreeSlots and GetContainerFreeSlots now take the main bank
(-1) and the bank bags (5..10) while a banker is open. The main bank is
gated on the banker GUID (0x00BDD038); bank bags get the gate from the
engine's container-GUID getter (0x004F93E0), which answers 0 for them
while the bank is closed.

A bag's empty slots are counted by the engine's own CountFreeSlots
(0x00622910, __thiscall on the bag's inventory list), and its slot count
comes from that live list instead of the item record. The backpack and
main bank are ranges of the player's list, walked slot by slot. Nothing
walks PackBagSlot per slot any more, so the Lua stack is left alone.

A container that is not there (keyring, empty bag slot, closed bank) now
returns only 0, leaving bagFamily nil.

The bag view SortBags kept for itself moves to Container::Bag so both
modules share it, and Item::Location::EquippedBagInventory becomes
BagInventory (1..10) beside a new BagContainer.

C_Item.GetItemData's bagFamily now goes through BitmaskForRecord, so a
bag whose family field is empty reports the same family there as it does
from GetItemFamily (a Soul Pouch was 0 there, 0x4 here).
2026-11-02 21:03:01 -06:00

105 lines
4.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 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/>.
#include "container/Bag.h"
#include "Game.h"
#include "Offsets.h"
#include "equipmentset/Locations.h"
#include "item/BagFamily.h"
#include "item/ID.h"
#include "item/Location.h"
#include "item/Record.h"
#include "unit/Identity.h"
namespace Container::Bag {
namespace {
bool PlayerRange(int first, int count, View *out) {
auto *inv = Unit::Identity::PlayerInventoryManager();
if (inv == nullptr)
return false;
*out = {inv, first, count, 0};
return true;
}
} // namespace
// The main bank resolves only while a banker is open — 3.3.5 gates it on
// `CGBankInfo::m_banker` the same way. Its GUIDs sit in the player's list
// from login, but the server refuses every bank move without a banker and
// the engine's own slot reader (`0x6228a0`) hides slots 39..68 on the same
// banker-GUID test. Bank bags get that gate from `BagContainer`, whose
// engine GUID getter answers 0 for them while the bank is closed.
bool ViewFor(int bagID, View *out) {
if (bagID == Offsets::BAG_INDEX_BACKPACK)
return PlayerRange(Offsets::INVMGR_BACKPACK_FIRST_SLOT,
Offsets::BACKPACK_NUM_SLOTS, out);
if (bagID == Offsets::BAG_INDEX_BANK) {
if (!EquipmentSet::Locations::BankerOpen())
return false;
return PlayerRange(Offsets::INVMGR_BANK_MAIN_FIRST_SLOT,
Offsets::INVMGR_BANK_MAIN_LAST_SLOT -
Offsets::INVMGR_BANK_MAIN_FIRST_SLOT + 1,
out);
}
const uint8_t *bag = Item::Location::BagContainer(bagID);
auto *inv = static_cast<const uint8_t *>(Item::Location::ContainerInventory(bag));
if (inv == nullptr)
return false;
const int slots = static_cast<int>(
Game::Read<uint32_t>(inv, Offsets::OFF_INVMGR_SLOT_COUNT));
if (slots <= 0)
return false;
// The bag's own family, as 3.3.5's `CGItem_C::GetBagFamily` reads it (0
// while its record isn't cached). `BitmaskForRecord` supplies the family
// a vanilla bag's empty field leaves out, so a quiver reports one rather
// than reading as general-purpose, and agrees with `C_Item.GetItemFamily`.
uint32_t family = 0;
const int bagItemID = Item::ID::FromCGItem(bag);
if (bagItemID > 0) {
if (auto *rec = Item::PeekRecord(static_cast<uint32_t>(bagItemID)))
family = Item::BagFamily::BitmaskForRecord(rec);
}
*out = {inv, 0, slots, family};
return true;
}
uint64_t SlotGuid(const View &view, int slotIndex0) {
const uint32_t linear = static_cast<uint32_t>(view.firstLinear + slotIndex0);
if (linear >= Game::Read<uint32_t>(view.invMgr, Offsets::OFF_INVMGR_SLOT_COUNT))
return 0;
auto *guids = Game::Read<const uint64_t *>(view.invMgr, Offsets::OFF_INVMGR_GUID_ARRAY);
return guids != nullptr ? guids[linear] : 0;
}
int CountFree(const View &view) {
if (view.invMgr != Unit::Identity::PlayerInventoryManager()) {
using CountFreeSlots_t = uint32_t(__thiscall *)(const uint8_t *invMgr);
auto countFreeSlots =
reinterpret_cast<CountFreeSlots_t>(Offsets::FUN_INVMGR_COUNT_FREE_SLOTS);
return static_cast<int>(countFreeSlots(view.invMgr));
}
int free = 0;
for (int i = 0; i < view.slotCount; ++i) {
if (SlotGuid(view, i) == 0)
free++;
}
return free;
}
} // namespace Container::Bag