mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
Add item/Record.{h,cpp} with Item::PeekRecord(itemID) -- the passive
ItemStats_C cache peek (null callback, no network query). Route the three
duplicate implementations through it:
- the per-module GetItemRecord_t typedef + fn(cache,id,&zero,nullptr,
nullptr,0) call in ~25 read-only item accessors
- Item::StatAccum::FetchRecord (deleted; 7 callers repointed)
- item/Tooltip.cpp's local PeekItemRecord (deleted)
Behavior-identical: every converted call was already a passive peek with
identical args (dedup flag is a no-op when the callback is null).
item/Data.cpp is deliberately untouched -- it owns the ACTIVE fetch
(CacheFetch passes a real callback to fire SMSG_ITEM_QUERY_SINGLE, the
load-bearing cache-race path in CLAUDE.md) and keeps its own typedef.
156 lines
6.4 KiB
C++
156 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/>.
|
||
|
||
#include "Game.h"
|
||
#include "Offsets.h"
|
||
#include "item/BagFamily.h"
|
||
#include "item/ID.h"
|
||
#include "item/Location.h"
|
||
#include "item/Record.h"
|
||
|
||
#include <cstdint>
|
||
|
||
namespace Container::FreeSlots {
|
||
|
||
namespace {
|
||
|
||
// Resolves the bag's metadata: total slot count + BagFamily bitfield.
|
||
//
|
||
// - bagID 0 (backpack) → (16, 0). Vanilla 1.12 backpack is fixed at 16
|
||
// slots and unfamilied (0). 3.3.5's `Script_GetContainerNumFreeSlots`
|
||
// hardcodes both values for the backpack path too.
|
||
// - bagID 1..4 → looks up the equipped bag at INVSLOT_BAGn, reads
|
||
// `m_containerSlots` and `m_bagFamily` from the cached `ItemStats_C`
|
||
// record. If no bag equipped or item not cached: (0, 0).
|
||
// - other bagIDs (bank, keyring) → (0, 0). Not supported in this
|
||
// implementation.
|
||
struct BagInfo {
|
||
int slotCount;
|
||
int bagType;
|
||
};
|
||
|
||
BagInfo ResolveBagInfo(int bagID) {
|
||
if (bagID == 0)
|
||
return {Offsets::BACKPACK_NUM_SLOTS, 0};
|
||
if (bagID < 1 || bagID > 4)
|
||
return {0, 0};
|
||
|
||
const int equipSlot = Offsets::INVSLOT_BAG1 + bagID - 1;
|
||
auto *bagItem = Item::Location::ResolveEquipmentSlot(equipSlot);
|
||
if (bagItem == nullptr)
|
||
return {0, 0};
|
||
|
||
const int itemID = Item::ID::FromCGItem(bagItem);
|
||
if (itemID == 0)
|
||
return {0, 0};
|
||
|
||
auto *record = Item::PeekRecord(static_cast<uint32_t>(itemID));
|
||
if (record == nullptr)
|
||
return {0, 0};
|
||
|
||
const int slots = static_cast<int>(*reinterpret_cast<const uint32_t *>(
|
||
record + Offsets::OFF_ITEMSTATS_CONTAINER_SLOTS));
|
||
// BagFamily bitmask: the item's field if populated, else derived from
|
||
// the container subclass — Turtle leaves bags' m_bagFamily at 0, so a
|
||
// Soul Bag would otherwise report family 0 and get miscounted as a
|
||
// general-purpose bag by CalculateTotalNumberOfFreeBagSlots. Shared
|
||
// with C_Item.GetItemFamily so a bag and its contents agree. See
|
||
// `Item::BagFamily`.
|
||
const int family =
|
||
static_cast<int>(Item::BagFamily::BitmaskForRecord(record));
|
||
return {slots, family};
|
||
}
|
||
|
||
// Walks the bag and counts empty slots. Each `Item::Location::ResolveBag`
|
||
// call stomps Lua stack[1]/[2] (a requirement of the engine's
|
||
// `PackBagSlot` helper), but we own the stack here — Lua just called us
|
||
// — and the caller's bagID arg has already been read into a local. So
|
||
// it's safe to repeatedly clobber the stack across iterations.
|
||
int CountFreeSlotsInBag(void *L, int bagID, int slotCount) {
|
||
int free = 0;
|
||
for (int slot = 1; slot <= slotCount; slot++) {
|
||
if (Item::Location::ResolveBag(L, bagID, slot) == nullptr)
|
||
free++;
|
||
}
|
||
return free;
|
||
}
|
||
|
||
// `C_Container.GetContainerNumFreeSlots(bagID)` — returns
|
||
// `(numberOfFreeSlots, bagType)`. `bagID` is 0..4 (0 = backpack,
|
||
// 1..4 = equipped bag slots). For invalid or unsupported bag IDs
|
||
// (negative bank/keyring indices, out-of-range values), returns
|
||
// `(0, 0)` — matching 3.3.5's behavior of always pushing two values
|
||
// rather than nil/nothing.
|
||
//
|
||
// `bagType` is the `BagFamily` bitmask in modern encoding. Bags leave the
|
||
// raw family field empty in Turtle's data (Soul/Herb/quiver/ammo pouch/…
|
||
// all read 0), so it's derived from the bag's class + subclass via
|
||
// `Item::BagFamily`: a Soul Bag reports `0x4`, a quiver `0x1`, an ammo
|
||
// pouch `0x2` — matching what `C_Item.GetItemFamily` reports for both the
|
||
// bag and the items it holds. See that helper for the Turtle custom-family
|
||
// caveat (Meat/Fish/Leather/Mining, IDs 10–13).
|
||
int __fastcall Script_C_Container_GetContainerNumFreeSlots(void *L) {
|
||
if (!Game::Lua::IsNumber(L, 1)) {
|
||
Game::Lua::Error(L,
|
||
"Usage: C_Container.GetContainerNumFreeSlots(bagID)");
|
||
return 0;
|
||
}
|
||
const int bagID = static_cast<int>(Game::Lua::ToNumber(L, 1));
|
||
|
||
const BagInfo info = ResolveBagInfo(bagID);
|
||
const int free = (info.slotCount > 0) ? CountFreeSlotsInBag(L, bagID, info.slotCount) : 0;
|
||
|
||
Game::Lua::PushNumber(L, static_cast<double>(free));
|
||
Game::Lua::PushNumber(L, static_cast<double>(info.bagType));
|
||
return 2;
|
||
}
|
||
|
||
// `C_Container.CalculateTotalNumberOfFreeBagSlots()` — the total number of
|
||
// free slots across the player's *general-purpose* bags (backpack + equipped
|
||
// bags 0..4 whose BagFamily is 0). Specialty bags (quivers, soul bags, herb
|
||
// bags, …) are excluded, mirroring FrameXML's implementation exactly:
|
||
//
|
||
// for bag = BACKPACK .. lastBag:
|
||
// free, family = C_Container.GetContainerNumFreeSlots(bag)
|
||
// if family == 0 then total = total + free end
|
||
//
|
||
// Takes no arguments. Specialty bags are correctly excluded: their family
|
||
// comes from `Item::BagFamily` (container-subclass fallback), so a Soul
|
||
// Bag / Herb Bag / Meat Bag reports a non-zero family and its slots are
|
||
// left out of the general-purpose total — matching retail's FrameXML
|
||
// behavior. (An earlier version miscounted them because Turtle leaves the
|
||
// raw family field at 0 for bags.)
|
||
int __fastcall Script_C_Container_CalculateTotalNumberOfFreeBagSlots(void *L) {
|
||
int total = 0;
|
||
for (int bagID = 0; bagID <= 4; bagID++) {
|
||
const BagInfo info = ResolveBagInfo(bagID);
|
||
if (info.slotCount > 0 && info.bagType == 0)
|
||
total += CountFreeSlotsInBag(L, bagID, info.slotCount);
|
||
}
|
||
Game::Lua::PushNumber(L, static_cast<double>(total));
|
||
return 1;
|
||
}
|
||
|
||
} // namespace
|
||
|
||
static void RegisterLuaFunctions() {
|
||
Game::Lua::RegisterTableFunction("C_Container", "GetContainerNumFreeSlots",
|
||
&Script_C_Container_GetContainerNumFreeSlots);
|
||
Game::Lua::RegisterTableFunction("C_Container", "CalculateTotalNumberOfFreeBagSlots",
|
||
&Script_C_Container_CalculateTotalNumberOfFreeBagSlots);
|
||
}
|
||
|
||
static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||
|
||
} // namespace Container::FreeSlots
|