diff --git a/docs/API.md b/docs/API.md index b5959326..f6289502 100644 --- a/docs/API.md +++ b/docs/API.md @@ -2743,7 +2743,7 @@ without scanning tooltips. A ClassicAPI extension. ### `C_Container.GetContainerItemCharges(containerIndex, slotIndex)` -Per-slot equivalent of +Per-slot counterpart of [`C_Item.GetItemCount`](#c_itemgetitemcountiteminfo-includebank-includeuses)'s `includeCharges=true` mode — returns the total uses available in *this single slot*, where `GetItemCount` totals the same value @@ -2780,7 +2780,7 @@ Returns `nil` only when the slot is empty. local charges = C_Container.GetContainerItemCharges(0, 1) print("Wand charges remaining: " .. charges) --- "how many drinks across the bags?" — same as GetItemCount(water, false, true) +-- "how many drinks across the bags?" local total = 0 for bag = 0, 4 do for slot = 1, GetContainerNumSlots(bag) do @@ -10038,60 +10038,50 @@ local ilvl = C_Item.GetCurrentItemLevel({equipmentSlotIndex = INVSLOT_HEAD}) ### `C_Item.GetItemCount(itemInfo, [includeBank], [includeUses])` -Returns the player's total count of `itemInfo` — equipped items + -bags, and optionally bank. +Returns the number of `itemInfo` that the player carries. ``` count = C_Item.GetItemCount(itemInfo [, includeBank [, includeUses]]) ``` - `itemInfo` — a numeric `itemID`, a string that contains `"item:NNN"` - (full chat links work), or an item name. A name is compared, without - regard to case, with the full name of each item that you carry (the - suffix included, so `"Foo of the Owl"` matches and `"Foo"` does not). -- `includeBank` *(optional, default false)* — also walk bank slots - (bag `-1` for the main bank, bags `5..10` for bank-bag slots). -- `includeUses` *(optional, default false)* — when `true`, multiplies - each match by the item's spell-charges count. A wand with 50 charges - contributes 50 instead of 1. Items without charges pass their plain - stack count through unchanged, so the flag is a no-op for them. + (full chat links work), or an item name. The name must match the + full name of an item that you carry, with the suffix (`"Foo of the + Owl"`). Case is not important. The count is for the item ID of the + first match. +- `includeBank` *(optional, default false)* — also count the bank and + the bank bags. The bank does not have to be open. +- `includeUses` *(optional, default false)* — for an item that does + not stack and that has charges, return the total charges instead of + the item count. If the item's use spell needs reagents, return the + number of casts that the carried reagents allow. For all other + items, this flag has no effect. + +The count includes: + +- equipped items +- equipped bags (the bag items themselves) +- the backpack, the contents of the equipped bags, and the keyring +- the bank and the bank bags, if `includeBank` is true + +Broken items (durability 0) are not counted. `includeUses` does not +count bank items. ```lua -local n = C_Item.GetItemCount(2589) -- Linen Cloth in bags + equipped -local n = C_Item.GetItemCount(2589, true) -- + bank -local n = C_Item.GetItemCount("item:2589") -- string form works too +local n = C_Item.GetItemCount(2589) -- Linen Cloth that you carry +local n = C_Item.GetItemCount(2589, true) -- also the bank +local n = C_Item.GetItemCount("item:2589") -- string form local n = C_Item.GetItemCount("Linen Cloth") -- by name --- Equipped items count toward the total: +-- Equipped items count: local trinketID = GetInventoryItemID("player", INVSLOT_TRINKET1) C_Item.GetItemCount(trinketID) -- 1 --- includeUses multiplies by charges for charged items: -C_Item.GetItemCount(wandID, false, true) -- 50 for one 50-charge wand -C_Item.GetItemCount(linenID, false, true) -- same as stack count (no charges) +-- includeUses returns the total charges of an item with charges: +C_Item.GetItemCount(chargedItemID, false, true) -- the sum of the charges +C_Item.GetItemCount(linenID, false, true) -- the stack count (no charges) ``` -> **Bank works cold — no banker visit required.** The server -> sends bank inventory at login alongside the rest of the player's -> data; only the engine's own `GetItemBySlot` gates bank slots until -> the window opens. We bypass that gate by reading the GUID array -> directly out of the player invMgr and resolving each entry via the -> engine's object resolver — same path `GetItemBySlot` would take -> internally if the gate let us through. Counts are correct from -> session start. - -Walks the 19 equipment slots via -`Item::Location::ResolveEquipmentSlot`, then bags via the same -`Item::Location::ResolveBag` chain -[`C_Container.GetContainerItemID`](#c_containergetcontaineritemidbagindex-slotindex) -uses. Slot counts come from the engine's `Script_GetContainerNumSlots` -so custom server bag sizes work transparently. Stack counts read -directly off the CGItem's m_objectFields descriptor at +0x20 -(`ITEM_FIELD_STACK_COUNT`, verified by decoding -`Script_GetContainerItemInfo` at `0x004F9670`). - -Equivalent to the global `GetItemCount` and `C_Item.GetItemCount`. - ### `C_Item.GetItemData(itemLocation)` / `C_Item.GetItemDataByID(item)` ClassicAPI-only kitchen-sink reader: returns a single table with every diff --git a/src/Offsets.h b/src/Offsets.h index 62c22055..df78349f 100644 --- a/src/Offsets.h +++ b/src/Offsets.h @@ -4814,8 +4814,7 @@ enum Offsets { // `m_stackable` — max stack size for this item type (1 for non- // stackable; 5/20/200/etc. for stackable). The instance-level // current stack count is a different field (`OFF_DESCRIPTOR_STACK_COUNT` - // at +0x20 on the CGItem's m_objectFields descriptor — see - // `Item::Count.cpp`). + // at +0x20 on the CGItem's m_objectFields descriptor). OFF_ITEMSTATS_STACKABLE = 0x60, // Bag-only fields. `m_containerSlots` (slot count) and `m_bagFamily` // (the BagFamily bitfield — quiver=1, ammo pouch=2, soul bag=4 in @@ -6224,20 +6223,34 @@ enum Offsets { FUN_ACTION_BAR_PRUNE_SPELL = 0x004E5E20, // Count of `itemID` the player carries, as `UseAction` caches per // item-by-ID slot into VAR_ACTION_ITEM_COUNTS — `uint __fastcall(uint - // itemID)`. Charged items (ItemStats `SPELL_CHARGES[0]` set) sum charges - // via FUN_INVMGR_COUNT_ITEM_BY_ID, everything else sums stacks - // (`FUN_00622130`). The inner GetActionCount (`0x004E6C70`) only reads - // the cached array, item-by-ID slots only. + // itemID)`. Charged items (ItemStats `SPELL_CHARGES[0]` not 0 / -1) sum + // charges via FUN_INVMGR_COUNT_CHARGES_BY_ID, everything else sums stacks + // via FUN_INVMGR_COUNT_STACKS_BY_ID. The inner GetActionCount + // (`0x004E6C70`) only reads the cached array, item-by-ID slots only. FUN_ACTION_ITEM_COUNT = 0x004E6D20, VAR_ACTION_ITEM_COUNTS = 0x00BC6390, // uint[120] - // Inventory-manager searches behind the action-bar item branches — - // `__thiscall(invMgr, uint itemID, uint flags)`. Both drive the slot - // visitor `FUN_00622420`, which with `flags == 0` on the player - // inventory manager walks equipment (linear 0..18), bag slots (19..22), - // backpack (23..38), keyring (81..112) and recurses into each equipped - // bag — never the bank. - FUN_INVMGR_FIND_ITEM_BY_ID = 0x00622270, // → CGItem *, first match - FUN_INVMGR_COUNT_ITEM_BY_ID = 0x00622180, // → summed charges of the matches + // Inventory-manager searches (3.3.5/4.3.4 `CGBag_C::FindItem` family) — + // `__thiscall(invMgr, uint itemID, uint flags)`. All drive the slot + // visitor `FUN_00622420`, which skips broken items (max durability set, + // durability 0, ITEM_FIELD_FLAGS 0x8 clear) and items with field flag + // 0x10 — there is no 3.3.5 `BAG_SEARCH_IGNORE_ITEM_STATE` (0x80) bypass. + // On the player inventory manager a `flags` with none of 0x47 set gets + // 0x47 ORed in: equipment (linear 0..18), bag slots (19..22), backpack + // (23..38), keyring (81..112), recursing into each bag — 3.3.5's + // `BAG_SEARCH_DEFAULT_LOCATIONS` minus currency. The bag items in 19..22 + // reach the callback themselves before their contents. + FUN_INVMGR_FIND_ITEM_BY_ID = 0x00622270, // → CGItem *, first match + FUN_INVMGR_COUNT_STACKS_BY_ID = 0x00622130, // → summed ITEM_FIELD_STACK_COUNT (3.3.5 GetItemTypeCount) + FUN_INVMGR_COUNT_CHARGES_BY_ID = 0x00622180, // → summed abs(SPELL_CHARGES[0]) (3.3.5 GetItemTypeCharges) + // The walk with a caller callback — `CGItem *__thiscall(invMgr, + // int (__fastcall *cb)(CGItem *item, void *ctx), void *ctx, uint flags)`, + // returning the first item `cb` answered nonzero for (null = none). + // `cb` gets the item in ECX and `ctx` in EDX (`0x0062253C`). + FUN_INVMGR_WALK = 0x006223F0, + // `flags` bit adding the bank: main bank (39..62) and the bank-bag slots + // (63..68), recursing into each bag. Reads the GUID array directly, so + // unlike FUN_ITEMMGR_GET_ITEM_BY_SLOT it needs no open bank window. + INVMGR_SEARCH_BANK = 0x08, // The registered action-bar Lua C functions that `Action::ItemState` // re-registers in front of. Tail-call these with the untouched stack for // every slot we don't own (they raise their own usage errors). diff --git a/src/item/Charges.h b/src/item/Charges.h index d389d2a6..ac7c2aac 100644 --- a/src/item/Charges.h +++ b/src/item/Charges.h @@ -18,13 +18,12 @@ namespace Item::Charges { // Pushes the total uses available in this single slot — the -// per-slot equivalent of `GetItemCount(_, _, includeCharges=true)`. +// per-slot counterpart of `GetItemCount(_, _, includeCharges=true)`. // Returns `1` (pushed one value) on success, `0` (pushes nothing, // caller surfaces as `nil`) when the item is missing or the // descriptor is null. // -// Math is `stack * usesPerItem` where `usesPerItem` follows -// `Item::Count::GetUsesPerItem`: +// Math is `stack * usesPerItem` where `usesPerItem` is: // - `SPELL_CHARGES[0] >= 0` → `1` (no destroy-on-zero behavior; // stack count alone reflects "how many uses"). // - `SPELL_CHARGES[0] < 0` → `abs(value)` (consume-on-use items; diff --git a/src/item/Count.cpp b/src/item/Count.cpp index 454015ea..627e03a5 100644 --- a/src/item/Count.cpp +++ b/src/item/Count.cpp @@ -11,240 +11,116 @@ // You should have received a copy of the GNU General Public License along with // ClassicAPI. If not, see . +// `C_Item.GetItemCount(itemInfo [, includeBank [, includeUses]])` — a +// straight port of 3.3.5's `Script_GetItemCount` (0x0051C2E0; 4.3.4's is +// identical) onto 1.12's own inventory searches, which are the ancestors of +// 3.3.5's `CGBag_C::FindItem` family with the same flag bits: +// +// total = GetItemTypeCount(itemID, includeBank ? BANK : 0) +// → FUN_INVMGR_COUNT_STACKS_BY_ID +// includeUses, for a non-stackable item whose base charges are negative: +// total = GetItemTypeCharges(itemID, 0) → FUN_INVMGR_COUNT_CHARGES_BY_ID +// and if the use spell's reagents allow N casts, total = N. +// +// So the count is the engine's: equipment, the equipped bags themselves, +// backpack, keyring and bag contents (plus the bank, read without a banker), +// broken items skipped. 1.12's walk has no 3.3.5 IGNORE_ITEM_STATE (0x80) +// bit, so includeUses can't count broken items the way 3.3.5 does. 3.3.5's +// use-enchant branch (`FindUseEnchantItemPtr`) is not ported; base charges +// and the base use spell stand for it. + #include "item/Count.h" #include "Game.h" #include "Offsets.h" #include "item/Arg.h" -#include "item/CGItem.h" #include "item/ID.h" #include "item/Location.h" -#include "object/Resolve.h" +#include "item/Record.h" +#include "spell/CastCount.h" #include "unit/Identity.h" #include -#include namespace Item::Count { namespace { -// Reads ITEM_FIELD_STACK_COUNT off a CGItem's m_objectFields -// descriptor at +0x20. Returns 0 if the descriptor is null. Stack -// counts are always positive — non-stackable items have count = 1. -int GetStackCount(const uint8_t *cgItem) { - if (cgItem == nullptr) - return 0; - auto *descriptor = Item::ObjectFields(cgItem); - if (descriptor == nullptr) - return 0; - return static_cast(*reinterpret_cast( - descriptor + Offsets::OFF_DESCRIPTOR_STACK_COUNT)); -} +using CountByID_t = int(__thiscall *)(const void *invMgr, int itemID, uint32_t flags); +using WalkCallback_t = int(__fastcall *)(const uint8_t *item, void *ctx); +using Walk_t = const uint8_t *(__thiscall *)(const void *invMgr, WalkCallback_t cb, void *ctx, + uint32_t flags); +using LooseBool_t = int(__fastcall *)(void *L, int idx, int defaultValue); -// Per-item uses count for `includeUses` mode. Reads -// ITEM_FIELD_SPELL_CHARGES[0] (signed dword). Only negative values -// count — they mark "consume-on-use, destroyed at 0" items -// (Healthstone, Mana Gem, etc.). Positive or zero returns 1, so the -// multiplier is neutral for stacked consumables and ordinary items. -// Mirrors 3.3.5's `Script_GetItemCount` charge gate at -// `FUN_0051c2e0` — it only swaps to the charge-summing walker when -// `SPELL_CHARGES[0] < 0`. -int GetUsesPerItem(const uint8_t *cgItem) { - if (cgItem == nullptr) - return 1; - auto *descriptor = Item::ObjectFields(cgItem); - if (descriptor == nullptr) - return 1; - const int32_t raw = *reinterpret_cast( - descriptor + Offsets::OFF_DESCRIPTOR_SPELL_CHARGES_0); - if (raw >= 0) - return 1; - return -raw; -} - -// Combined per-slot contribution to GetItemCount. `includeUses=false` -// gives plain stack count (matches old behavior); `true` multiplies by -// abs(SPELL_CHARGES[0]) for charged items. -int GetItemContribution(const uint8_t *cgItem, bool includeUses) { - const int stack = GetStackCount(cgItem); - if (!includeUses) - return stack; - return stack * GetUsesPerItem(cgItem); -} - -// Walks `bagID` and accumulates per-slot contributions for items -// matching `arg` (itemID, or name via `MatchesArg`). Skips empty slots. -// Each `ResolveBag` call clobbers Lua stack[1]/[2]; we own the stack -// inside the callback. -int CountInBag(void *L, int bagID, const Item::Arg::Resolved &arg, bool includeUses) { - int total = 0; - const int slotCount = Item::Location::GetBagSlotCount(bagID); - for (int slot = 1; slot <= slotCount; slot++) { - const uint8_t *item = Item::Location::ResolveBag(L, bagID, slot); - if (item == nullptr) - continue; - if (!Item::Location::MatchesArg(item, arg)) - continue; - total += GetItemContribution(item, includeUses); - } - return total; -} - -// Direct GUID-array bypass for bank slots — sidesteps the gate at -// `0x006228C1` that `GetItemBySlot` applies to slots 39..68 when no -// bank window is open. The slot data in `invMgr+0x04` is populated at -// login (verified empirically — see `Offsets::OFF_INVMGR_GUID_ARRAY`), -// so we can read GUIDs directly and resolve them via the engine's own -// object resolver `FUN_OBJECT_RESOLVE_BY_GUID` (the same function -// `GetItemBySlot` would call internally if the gate let us through). - -const uint8_t *ResolveByGuid(int type, uint64_t guid) { - if (guid == 0) - return nullptr; - return static_cast( - Object::ByGuid(type, guid, "ItemMgr", 0x172)); -} - -// Walks linear slots `[firstSlot, lastSlot]` of `invMgr`'s GUID array -// at `+0x04`, resolves each non-zero GUID as a TYPE_ITEM, sums -// contributions of items matching `targetItemID`. Used for both the -// main bank (slots 39..62 in player invMgr) and individual bank-bag -// invMgrs (slots 0..N-1). -int CountInGuidArray(const uint8_t *invMgr, int firstSlot, int lastSlot, - const Item::Arg::Resolved &arg, bool includeUses) { +int CountByID(uintptr_t fn, int itemID, uint32_t flags) { + const uint8_t *invMgr = Unit::Identity::PlayerInventoryManager(); if (invMgr == nullptr) return 0; - auto *guidArray = *reinterpret_cast( - invMgr + Offsets::OFF_INVMGR_GUID_ARRAY); - if (guidArray == nullptr) + return reinterpret_cast(fn)(invMgr, itemID, flags); +} + +int __fastcall MatchesName(const uint8_t *item, void *ctx) { + return Item::Location::MatchesArg(item, *static_cast(ctx)) ? 1 + : 0; +} + +// 3.3.5 resolves a name through `s_itemByName`, filled with each item +// object's decorated name as it is created; 1.12 has no such map. The first +// item carried under that name (same walk, same flags) gives the same ID. +int IDForName(const char *name, uint32_t flags) { + const uint8_t *invMgr = Unit::Identity::PlayerInventoryManager(); + if (invMgr == nullptr) return 0; - int total = 0; - for (int slot = firstSlot; slot <= lastSlot; slot++) { - const uint8_t *item = ResolveByGuid(Offsets::TYPEMASK_ITEM, guidArray[slot]); - if (item == nullptr) - continue; - if (!Item::Location::MatchesArg(item, arg)) - continue; - total += GetItemContribution(item, includeUses); + Item::Arg::Resolved arg{0, 0, name}; + const uint8_t *item = + reinterpret_cast(Offsets::FUN_INVMGR_WALK)(invMgr, &MatchesName, &arg, flags); + return item != nullptr ? Item::ID::FromCGItem(item) : 0; +} + +// 3.3.5's `CGItem_C::NumBaseCharges` / `GetUseSpell`: the first on-use +// spell slot's charges and spell. +struct UseSpell { + int spellID; + int charges; +}; + +UseSpell FirstUseSpell(const uint8_t *record) { + for (int i = 0; i < Offsets::ITEMSTATS_SPELL_SLOT_COUNT; ++i) { + const int spellID = Game::Read(record, Offsets::OFF_ITEMSTATS_SPELL_ID + i * 4); + const uint32_t trigger = + Game::Read(record, Offsets::OFF_ITEMSTATS_SPELL_TRIGGER + i * 4); + if (spellID != 0 && trigger == Offsets::ITEM_SPELLTRIGGER_ON_USE) + return {spellID, Game::Read(record, Offsets::OFF_ITEMSTATS_SPELL_CHARGES + i * 4)}; } + return {0, 0}; +} + +int CountUses(int itemID, int total) { + const uint8_t *record = Item::PeekRecord(static_cast(itemID)); + if (record == nullptr || Game::Read(record, Offsets::OFF_ITEMSTATS_STACKABLE) > 1) + return total; + const UseSpell use = FirstUseSpell(record); + if (use.charges < 0) + total = CountByID(Offsets::FUN_INVMGR_COUNT_CHARGES_BY_ID, itemID, 0); + if (const int casts = ::Spell::CastCount::ForSpell(use.spellID)) + total = casts; return total; } -// For bank bag CONTENTS: the equipped bank bags themselves live at -// linear slots 63..68 in the player invMgr. Each is a CGContainer with -// its own invMgr accessed via `vtable[+0x10]` (`CGContainer::GetInvMgr` -// or similar). We resolve the bag, get its invMgr, and walk that. -// -// Layout: bag invMgr+0x00 = max slot count (the bag's size); bag -// invMgr+0x04 = its GUID array. Same shape as the player invMgr. -int CountInBankBags(const Item::Arg::Resolved &arg, bool includeUses) { - auto *playerInvMgr = Unit::Identity::PlayerInventoryManager(); - if (playerInvMgr == nullptr) - return 0; - auto *playerGuidArray = *reinterpret_cast( - playerInvMgr + Offsets::OFF_INVMGR_GUID_ARRAY); - if (playerGuidArray == nullptr) - return 0; - - int total = 0; - for (int slot = Offsets::INVMGR_BANK_BAG_FIRST_SLOT; - slot <= Offsets::INVMGR_BANK_BAG_LAST_SLOT; slot++) { - const uint8_t *bag = ResolveByGuid(Offsets::TYPEMASK_CONTAINER, - playerGuidArray[slot]); - if (bag == nullptr) - continue; - auto *bagInvMgr = - static_cast(Item::Location::ContainerInventory(bag)); - if (bagInvMgr == nullptr) - continue; - const int bagSlots = static_cast(*reinterpret_cast(bagInvMgr)); - if (bagSlots <= 0) - continue; - total += CountInGuidArray(bagInvMgr, 0, bagSlots - 1, arg, includeUses); - } - return total; -} - -// Walks the player's 19 equipment slots and accumulates contributions -// for items matching `targetItemID`. Equipped items are part of the -// player's total inventory in the modern API — `GetItemCount` of a -// currently-equipped trinket returns 1, not 0. -int CountEquipped(const Item::Arg::Resolved &arg, bool includeUses) { - int total = 0; - for (int slot = 1; slot <= 19; slot++) { - const uint8_t *item = Item::Location::ResolveEquipmentSlot(slot); - if (item == nullptr) - continue; - if (!Item::Location::MatchesArg(item, arg)) - continue; - total += GetItemContribution(item, includeUses); - } - return total; -} - -// `C_Item.GetItemCount(itemInfo [, includeBank [, includeUses]])` — -// returns the player's total count of `itemInfo` across equipped -// items + bags (and optionally bank). `itemInfo` is a number, an -// `"item:NNN"` string / link, or an item NAME — a plain string is matched -// case-insensitively against each carried item's decorated display name -// (`Item::Location::MatchesArg`, the same rule `C_Item.UseItemByName` -// uses), which is what lets the `/cast` / `/use` handler decide -// "is this an item I carry" before falling back to a spell cast. -// -// What's counted: -// - **Equipped items** (slots 1..19) — always. Matches modern -// behavior: a currently-equipped trinket returns 1. -// - **Bags 0..4** (backpack + 4 equipped bag slots) — always. -// Live walk via `Item::Location::ResolveBag`. -// - **Bank** (if `includeBank=true`): main bank (linear slots -// 39..62 in player invMgr) + each equipped bank bag's contents -// (slots 63..68 in player invMgr). Bank walks **bypass -// `GetItemBySlot`** by reading the GUID array at `invMgr+0x04` -// directly and resolving via `FUN_OBJECT_RESOLVE_BY_GUID`. This -// works without the bank window ever being opened — the GUIDs -// are populated from server data at login. The engine gates -// `GetItemBySlot` for bank slots via a banker-GUID check at -// `VAR_BANK_GATE_GUID`, but the underlying data is always -// present. -// -// `includeUses` (arg 3, boolean) multiplies each match by the item's -// `abs(SPELL_CHARGES[0])` — so a wand with 50 charges contributes 50 -// instead of 1. Items without charges contribute their plain stack -// count (via the `or 1` neutralizer in `GetUsesPerItem`), so the flag -// is a no-op for them. int __fastcall Script_C_Item_GetItemCount(void *L) { - Item::Arg::Resolved arg = Item::Arg::Resolve(L, 1); - // A plain string is a name. Copy it off the Lua string heap before the - // bag walk — `ResolveBag` clears the stack. - char nameBuf[128]; - if (arg.itemID <= 0) { - if (arg.name == nullptr || arg.name[0] == '\0') { - Game::Lua::PushNumber(L, 0); - return 1; - } - std::snprintf(nameBuf, sizeof(nameBuf), "%s", arg.name); - arg.name = nameBuf; - } - // Read both flags before the bag walk — `ResolveBag` clobbers - // the Lua stack via SetTop(0) and would invalidate any later - // `ToBoolean` reads. - const bool includeBank = Game::Lua::ToBoolean(L, 2) != 0; - const bool includeUses = Game::Lua::ToBoolean(L, 3) != 0; + const auto looseBool = reinterpret_cast(Offsets::FUN_LUA_TO_BOOLEAN_LOOSE); + const bool includeBank = looseBool(L, 2, 0) != 0; + const bool includeUses = looseBool(L, 3, 0) != 0; + const uint32_t flags = includeBank ? Offsets::INVMGR_SEARCH_BANK : 0; - int total = CountEquipped(arg, includeUses); - for (int bag = 0; bag <= 4; bag++) - total += CountInBag(L, bag, arg, includeUses); - if (includeBank) { - // Direct GUID-array reads — bypass the bank gate so this works - // without the bank window having ever been opened in the - // session. - total += CountInGuidArray(Unit::Identity::PlayerInventoryManager(), - Offsets::INVMGR_BANK_MAIN_FIRST_SLOT, - Offsets::INVMGR_BANK_MAIN_LAST_SLOT, - arg, includeUses); - total += CountInBankBags(arg, includeUses); - } + const Item::Arg::Resolved arg = Item::Arg::Resolve(L, 1); + int itemID = arg.itemID; + if (itemID <= 0 && arg.name != nullptr && arg.name[0] != '\0') + itemID = IDForName(arg.name, flags); + + int total = itemID > 0 ? CountByID(Offsets::FUN_INVMGR_COUNT_STACKS_BY_ID, itemID, flags) : 0; + if (total != 0 && includeUses) + total = CountUses(itemID, total); Game::Lua::SetTop(L, 0); Game::Lua::PushNumber(L, static_cast(total)); @@ -253,14 +129,10 @@ int __fastcall Script_C_Item_GetItemCount(void *L) { } // namespace -int InInventory(void *L, int itemID) { +int InInventory(int itemID) { if (itemID <= 0) return 0; - const Item::Arg::Resolved arg{itemID, 0, nullptr}; - int total = CountEquipped(arg, /*includeUses*/ false); - for (int bag = 0; bag <= 4; bag++) - total += CountInBag(L, bag, arg, /*includeUses*/ false); - return total; + return CountByID(Offsets::FUN_INVMGR_COUNT_STACKS_BY_ID, itemID, 0); } static void RegisterLuaFunctions() { diff --git a/src/item/Count.h b/src/item/Count.h index 437f0ebb..61faf576 100644 --- a/src/item/Count.h +++ b/src/item/Count.h @@ -15,11 +15,10 @@ namespace Item::Count { -// Total plain stack count of `itemID` across the player's equipped slots -// and bags 0..4 (no bank, no charge multiplier) — the "carried on me" -// count. Needs the Lua state `L`: the bag walk uses the engine's slot -// packer, which reads and clears the Lua stack, so the caller must have -// already consumed any stack arguments it still needs before calling. -int InInventory(void *L, int itemID); +// Total stack count of `itemID` the player carries, through the engine's +// own search (FUN_INVMGR_COUNT_STACKS_BY_ID, flags 0): equipment, equipped +// bags, backpack, keyring and bag contents, no bank, broken items skipped — +// the count the engine's reagent and totem gate uses. +int InInventory(int itemID); } // namespace Item::Count diff --git a/src/item/Usable.cpp b/src/item/Usable.cpp index 91790613..121ffc67 100644 --- a/src/item/Usable.cpp +++ b/src/item/Usable.cpp @@ -60,9 +60,7 @@ struct Usability { bool noMana; }; -// `L` is needed for the carried count (see Item::Count::InInventory); the -// caller has already read its arguments. -Usability ComputeUsability(void *L, int itemID) { +Usability ComputeUsability(int itemID) { Usability r{false, false}; if (itemID <= 0 || Unit::Identity::PlayerObject() == nullptr) return r; @@ -71,7 +69,7 @@ Usability ComputeUsability(void *L, int itemID) { if (record == nullptr) return r; // not cached → sync "false", no load fired - if (Item::Count::InInventory(L, itemID) <= 0) + if (Item::Count::InInventory(itemID) <= 0) return r; if (reinterpret_cast(Offsets::FUN_ITEM_SPELL_HELD)(itemID) != 0) return r; @@ -101,7 +99,7 @@ Usability ComputeUsability(void *L, int itemID) { // `IsUsableSpell` convention. int __fastcall Script_IsUsableItem(void *L) { const int itemID = Item::Arg::ResolveItemID(L, 1); - const Usability r = ComputeUsability(L, itemID); + const Usability r = ComputeUsability(itemID); Game::Lua::SetTop(L, 0); if (r.usable) Game::Lua::PushNumber(L, 1.0); @@ -118,7 +116,7 @@ int __fastcall Script_IsUsableItem(void *L) { // proper booleans (`usable`, `noMana`) per the `C_Item.*` convention. int __fastcall Script_C_Item_IsUsableItem(void *L) { const int itemID = Item::Arg::ResolveItemID(L, 1); - const Usability r = ComputeUsability(L, itemID); + const Usability r = ComputeUsability(itemID); Game::Lua::SetTop(L, 0); Game::Lua::PushBool(L, r.usable); Game::Lua::PushBool(L, r.noMana); diff --git a/src/spell/CastCount.cpp b/src/spell/CastCount.cpp index 80b354ee..49412973 100644 --- a/src/spell/CastCount.cpp +++ b/src/spell/CastCount.cpp @@ -15,16 +15,17 @@ // `C_SpellBook.GetSpellBookItemCastCount(slotIndex, spellBank)` — how many // times a spell can be cast with the reagents the player carries. // -// There is no engine helper to mirror: 1.12's action-button count -// (`Script_GetActionCount` → 0x004E6C70, `Script_IsConsumableAction` → -// 0x004E5250) is ITEM-only — both gate on the action tag `0x80000000` and -// read the item stack cache — so a reagent-based count was never computed -// client-side. This is the server's own cast gate (`Spell::CheckItems` → -// `Player::HasItemCount(reagent, count)`) restated as a count: the minimum -// over the spell's reagent slots of floor(carried / required), where -// "carried" is equipped + bags 0..4 — the inventory the server checks; bank -// contents never satisfy a reagent. Spells with no reagents return 0, -// matching retail's `GetSpellCastCount`. +// 1.12 has no reagent-uses helper (3.3.5's `Spell_C_GetSpellReagentUses`), +// and its action-button count (`Script_GetActionCount` → 0x004E6C70) is +// ITEM-only. 3.3.5's helper is the engine's own cast gate restated as a +// count, and 1.12 has that gate whole: `CheckSpellTotemsAndReagents` +// (0x006E4000) walks the 8 reagent slots, skips empty ones, and compares +// `FUN_INVMGR_COUNT_STACKS_BY_ID(invMgr, reagent, 0)` — no bank — against +// the required count. The count is the minimum over those slots of +// floor(carried / required). Spells with no reagents return 0, matching +// retail's `GetSpellCastCount`. + +#include "CastCount.h" #include "Arg.h" #include "Lookup.h" @@ -37,12 +38,7 @@ namespace Spell::CastCount { -namespace { - -// Reagent-limited casts of `spellID`; 0 for unknown spells and for spells -// with no reagents. Clobbers the Lua stack (the bag walk goes through the -// engine's slot packer), so callers read their arguments first. -int ForSpell(void *L, int spellID) { +int ForSpell(int spellID) { const uint8_t *record = Spell::Lookup::RecordForID(spellID); if (record == nullptr) return 0; @@ -51,20 +47,20 @@ int ForSpell(void *L, int spellID) { Game::Ptr(record, Offsets::OFF_SPELL_REAGENT_COUNT); int casts = -1; for (int i = 0; i < Offsets::SPELL_MAX_REAGENTS; ++i) { - if (ids[i] == 0) - break; // engine convention: the list ends at the first empty slot - if (counts[i] <= 0) + if (ids[i] == 0 || counts[i] <= 0) continue; - const int possible = Item::Count::InInventory(L, ids[i]) / counts[i]; + const int possible = Item::Count::InInventory(ids[i]) / counts[i]; if (casts < 0 || possible < casts) casts = possible; } return casts < 0 ? 0 : casts; } +namespace { + int __fastcall Script_C_Spell_GetSpellCastCount(void *L) { const int spellID = Spell::Arg::ResolveSpellID(L, 1); - const int casts = ForSpell(L, spellID); + const int casts = ForSpell(spellID); Game::Lua::SetTop(L, 0); Game::Lua::PushNumber(L, static_cast(casts)); return 1; @@ -72,7 +68,7 @@ int __fastcall Script_C_Spell_GetSpellCastCount(void *L) { int __fastcall Script_C_SpellBook_GetSpellBookItemCastCount(void *L) { const int spellID = Spell::Lookup::SpellbookItemArgsToID(L, 1, 2); - const int casts = ForSpell(L, spellID); + const int casts = ForSpell(spellID); Game::Lua::SetTop(L, 0); Game::Lua::PushNumber(L, static_cast(casts)); return 1; diff --git a/src/spell/CastCount.h b/src/spell/CastCount.h new file mode 100644 index 00000000..dc0c7f76 --- /dev/null +++ b/src/spell/CastCount.h @@ -0,0 +1,22 @@ +// 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 . + +#pragma once + +namespace Spell::CastCount { + +// Reagent-limited casts of `spellID` — 3.3.5's `Spell_C_GetSpellReagentUses`. +// 0 for an unknown spell and for a spell with no reagents. +int ForSpell(int spellID); + +} // namespace Spell::CastCount diff --git a/src/totem/Tracker.cpp b/src/totem/Tracker.cpp index 7e22ea28..c052345b 100644 --- a/src/totem/Tracker.cpp +++ b/src/totem/Tracker.cpp @@ -373,11 +373,10 @@ int __fastcall Script_GetTotemInfo(void *L) { // Tool presence — independent of the summoned state. The tool item // (resolved from the totem spell's Totem[0] on SPELLS_CHANGED, not - // hardcoded) is checked against the bag. The bag walk reads the Lua - // stack, so it runs before we push any return values (`slot` captured). + // hardcoded) is checked against the bag. const uint32_t tool = g_toolItem[slot - 1]; const bool haveTotem = - tool != 0 && Item::Count::InInventory(L, static_cast(tool)) > 0; + tool != 0 && Item::Count::InInventory(static_cast(tool)) > 0; const Slot &t = g_slots[slot - 1]; if (!t.active) {