mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-15 23:50:38 +00:00
GetAverageItemLevel
This commit is contained in:
@@ -33,7 +33,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
|
||||
| GameTooltip | `GameTooltip:GetGameObject`, `GameTooltip:GetItem`, `GameTooltip:GetSpell`, `GameTooltip:GetUnitGUID`, `GameTooltip:HasGameObject`, `GameTooltip:HasItem`, `GameTooltip:HasSpell`, `GameTooltip:HasUnit`, `GameTooltip:SetEquipmentSet`, `GameTooltip:SetInventoryItemByID`, `GameTooltip:SetItemByID`, `GameTooltip:SetSpellByID`, `GameTooltip:SetTalentByID`, `GameTooltip:SetUnitAura` |
|
||||
| Hooks | `hooksecurefunc` |
|
||||
| Input | `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
|
||||
| Item | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsLocked`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
|
||||
| Item | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsLocked`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetAverageItemLevel`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
|
||||
| Macros | `GetMacroSpell` |
|
||||
| MerchantFrame | `C_MerchantFrame.GetBuybackItemID`, `C_MerchantFrame.GetItemInfo`, `C_MerchantFrame.GetNumJunkItems`, `C_MerchantFrame.IsMerchantItemRefundable`, `C_MerchantFrame.IsSellAllJunkEnabled`, `C_MerchantFrame.SellAllJunkItems` |
|
||||
| NameCache | `C_CreatureInfo.GetCreatureID`, `C_PlayerCache.GetPlayerInfoByName`, `C_PlayerCache.IsEnabled`, `C_PlayerCache.IsScanEnabled`, `C_PlayerCache.RememberPlayer`, `C_PlayerCache.SetEnabled`, `C_PlayerCache.SetScanEnabled`, `C_PlayerInfo.GUIDIsCreature`, `C_PlayerInfo.GUIDIsGameObject`, `C_PlayerInfo.GUIDIsPet`, `C_PlayerInfo.GUIDIsPlayer`, `GetPlayerInfoByGUID` |
|
||||
|
||||
+54
@@ -157,6 +157,7 @@ build instructions.
|
||||
- [`C_Item.GetItemSetInfo(setID)`](#c_itemgetitemsetinfosetid)
|
||||
- [`C_Item.GetItemSellPrice(itemLocation)` / `C_Item.GetItemSellPriceByID(item)`](#c_itemgetitemsellpriceitemlocation--c_itemgetitemsellpricebyiditem)
|
||||
- [`C_Item.GetCurrentItemLevel(itemLocation)` / `C_Item.GetDetailedItemLevelInfo(item)`](#c_itemgetcurrentitemlevelitemlocation--c_itemgetdetaileditemlevelinfoitem)
|
||||
- [`GetAverageItemLevel()`](#getaverageitemlevel)
|
||||
- [`C_Item.GetItemMaxStackSize(itemLocation)` / `C_Item.GetItemMaxStackSizeByID(item)`](#c_itemgetitemmaxstacksizeitemlocation--c_itemgetitemmaxstacksizebyiditem)
|
||||
- [`C_Item.GetItemLink(itemLocation)`](#c_itemgetitemlinkitemlocation)
|
||||
- [`C_Item.GetItemInventoryType(itemLocation)` / `C_Item.GetItemInventoryTypeByID(item)`](#c_itemgetiteminventorytypeitemlocation--c_itemgetiteminventorytypebyiditem)
|
||||
@@ -3443,6 +3444,59 @@ current level, callers that care about the extra returns will see
|
||||
local ilvl = C_Item.GetCurrentItemLevel({equipmentSlotIndex = INVSLOT_HEAD})
|
||||
```
|
||||
|
||||
### `GetAverageItemLevel()`
|
||||
|
||||
Returns `(avgItemLevel, avgItemLevelEquipped)` — modern WoW's
|
||||
2-tuple shape. `avgItemLevelEquipped` is the arithmetic mean over
|
||||
the player's currently-worn equipment slots; `avgItemLevel` is the
|
||||
same metric but extended to include best-per-slot upgrades found
|
||||
anywhere in the player's bags and bank.
|
||||
|
||||
Slots considered: `INVSLOT_HEAD..INVSLOT_TABARD` (1..19) minus
|
||||
shirt (4) and tabard (19) = 17 candidate slots. Bag-walk uses the
|
||||
same `invType → slotMask` mapping as `GetInventoryItemsForSlot`.
|
||||
|
||||
```lua
|
||||
local overall, equipped = GetAverageItemLevel()
|
||||
-- overall: best-per-slot ilvl across equipped + bags + bank
|
||||
-- equipped: ilvl of currently-worn items only
|
||||
```
|
||||
|
||||
**Fixed denominator.** Empty slots count toward the denominator
|
||||
(contributing 0 to the sum). Removing a piece of gear always
|
||||
lowers `avgItemLevelEquipped` — matches modern's behavior
|
||||
(verified against retail Wow.exe at `552.4375 × 16 = 8839`
|
||||
exactly). Vanilla addons of the GearScore era used populated-only
|
||||
count; this implementation deliberately differs.
|
||||
|
||||
**Max-of-two-divisors fairness.** A 2H weapon wielder has an
|
||||
intentionally empty offhand (slot 17) — counting it as 0 in a
|
||||
17-divisor sum would unfairly penalize them. We compute a second
|
||||
candidate excluding slot 17 from both numerator and denominator
|
||||
(16 slots), and return the max. Sword+shield characters typically
|
||||
win the all-17 path; 2H wielders win the no-OH path. Same trick
|
||||
the 4.3.4 client uses at `FUN_0097E0F0`'s tail.
|
||||
|
||||
**No double-counting.** Each bag/bank item is assigned to **one**
|
||||
candidate slot via greedy fit — a trinket in your bag fills one
|
||||
trinket slot (the empty/lower-best one), not both. Without this
|
||||
gate, moving a trinket from equipped to bag would inflate the
|
||||
"overall" count and drag the average down (because the same item
|
||||
would count for both trinket slots).
|
||||
|
||||
**Bank is walked** even if the bank window has never been opened
|
||||
this session — the GUID array at `invMgr + 0x04` is populated
|
||||
from server data at login. Bypasses the bank-window gate on
|
||||
`GetItemBySlot` the same way `C_Item.GetItemCount` does.
|
||||
|
||||
Limitations:
|
||||
- Items not yet in the ItemStats cache are skipped from the
|
||||
running totals and a warmup is queued; the next call after
|
||||
`ITEM_DATA_LOAD_RESULT` lands picks them up.
|
||||
- The full 4.3.4 weapon `qsort` dance — handling 2H-equipped vs.
|
||||
1H + OH-in-bag comparisons — is not replicated. Edge case in
|
||||
vanilla where you'd notice a difference is narrow.
|
||||
|
||||
### `C_Item.GetItemMaxStackSize(itemLocation)` / `C_Item.GetItemMaxStackSizeByID(item)`
|
||||
|
||||
Returns the item type's max stack size — what you'd find as the 8th
|
||||
|
||||
@@ -0,0 +1,394 @@
|
||||
// This file is part of ClassicAPI.
|
||||
//
|
||||
// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
|
||||
// of the GNU Lesser 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 Lesser General Public License for more details.
|
||||
|
||||
// `GetAverageItemLevel()` → `(avgItemLevel, avgItemLevelEquipped)` —
|
||||
// polyfills the modern 2.4+ global with the same 2-tuple shape as
|
||||
// 4.3.4's `Script_GetAverageItemLevel` (`FUN_0097EE60` in the
|
||||
// Proudmoore client).
|
||||
//
|
||||
// avgItemLevelEquipped — mean of `m_itemLevel` over currently-worn
|
||||
// slots 1..19 (skipping shirt and tabard).
|
||||
// Empty slots count as 0, denominator is
|
||||
// fixed at the considered-slot count, so
|
||||
// removing gear always lowers this value.
|
||||
//
|
||||
// avgItemLevel — same denominator, but each per-slot ilvl
|
||||
// is built up by greedy single-assignment:
|
||||
// equipped items seed each slot, then
|
||||
// bag + bank items are sorted by ilvl
|
||||
// descending and each gets assigned to ONE
|
||||
// candidate slot (the one with the lowest
|
||||
// current best). A trinket in your bag
|
||||
// fills one trinket slot, not both —
|
||||
// without that, an item with a multi-slot
|
||||
// invType would double-count and drag the
|
||||
// mean down when moved off the body.
|
||||
//
|
||||
// Bank IS walked. Vanilla's `GetItemBySlot` gates bank slots on a
|
||||
// banker-GUID that's only set while the bank window is open, but
|
||||
// the underlying GUID array at `invMgr + OFF_INVMGR_GUID_ARRAY` is
|
||||
// populated from server data at login. We bypass the gate the same
|
||||
// way `C_Item.GetItemCount` does — read the GUID array directly,
|
||||
// resolve each via `FUN_OBJECT_RESOLVE_BY_GUID`. Works without the
|
||||
// bank window ever being opened.
|
||||
//
|
||||
// Max-of-two-divisors fairness. A 2H-weapon wielder has an
|
||||
// intentionally empty offhand (slot 17); the fixed-denominator
|
||||
// approach would penalize them. We compute a second average
|
||||
// excluding slot 17 from both numerator and denominator, and
|
||||
// return whichever is higher — same trick the 4.3.4 client uses
|
||||
// at `FUN_0097E0F0`'s tail.
|
||||
//
|
||||
// Slot-mask table below mirrors the one in
|
||||
// `GetInventoryItemsForSlot` — vanilla rules: 2H/MAINHAND confined
|
||||
// to slot 16, no Titan's Grip.
|
||||
|
||||
#include "Game.h"
|
||||
#include "Offsets.h"
|
||||
#include "item/Data.h"
|
||||
#include "item/ID.h"
|
||||
#include "item/Location.h"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstdint>
|
||||
#include <vector>
|
||||
|
||||
namespace Item::AverageLevel {
|
||||
|
||||
namespace {
|
||||
|
||||
using GetItemRecord_t = const uint8_t *(__thiscall *)(void *cache, uint32_t itemID,
|
||||
const uint64_t *guid, void *callback,
|
||||
void *userData, int unused);
|
||||
|
||||
// 1-based slot range used by both walks.
|
||||
constexpr int kFirstSlot = 1;
|
||||
constexpr int kLastSlot = 19;
|
||||
|
||||
// Excluded from the average — shirt (4) and tabard (19) have ilvl 1
|
||||
// and would drag the mean. Modern `GetAverageItemLevel` excludes
|
||||
// these too.
|
||||
bool IsExcludedSlot(int slot) {
|
||||
return slot == 4 || slot == 19;
|
||||
}
|
||||
|
||||
// invType → bitmask of equipment slots the item can occupy (bit N =
|
||||
// 1-based slot N+1). Mirrors `kSlotMaskByInvType` in
|
||||
// `InventoryItemsForSlot.cpp`; kept private here to avoid coupling
|
||||
// two modules through a header that only carries one table.
|
||||
constexpr uint32_t kSlotMaskByInvType[29] = {
|
||||
0x00000000, // 0 NON_EQUIP
|
||||
0x00000001, // 1 HEAD → slot 1
|
||||
0x00000002, // 2 NECK → slot 2
|
||||
0x00000004, // 3 SHOULDER → slot 3
|
||||
0x00000008, // 4 BODY (shirt)
|
||||
0x00000010, // 5 CHEST → slot 5
|
||||
0x00000020, // 6 WAIST → slot 6
|
||||
0x00000040, // 7 LEGS → slot 7
|
||||
0x00000080, // 8 FEET → slot 8
|
||||
0x00000100, // 9 WRIST → slot 9
|
||||
0x00000200, // 10 HANDS → slot 10
|
||||
0x00000C00, // 11 FINGER → slots 11, 12
|
||||
0x00003000, // 12 TRINKET → slots 13, 14
|
||||
0x00018000, // 13 WEAPON (1H) → slots 16, 17
|
||||
0x00010000, // 14 SHIELD → slot 17
|
||||
0x00020000, // 15 RANGED → slot 18
|
||||
0x00004000, // 16 CLOAK → slot 15
|
||||
0x00008000, // 17 2HWEAPON → slot 16 (vanilla — no Titan's Grip)
|
||||
0x00780000, // 18 BAG → slots 20..23
|
||||
0x00040000, // 19 TABARD
|
||||
0x00000010, // 20 ROBE → slot 5
|
||||
0x00008000, // 21 WEAPONMAINHAND
|
||||
0x00010000, // 22 WEAPONOFFHAND
|
||||
0x00010000, // 23 HOLDABLE
|
||||
0x00000000, // 24 AMMO
|
||||
0x00020000, // 25 THROWN → slot 18
|
||||
0x00020000, // 26 RANGEDRIGHT → slot 18
|
||||
0x00000000, // 27 QUIVER
|
||||
0x00020000, // 28 RELIC → slot 18
|
||||
};
|
||||
|
||||
constexpr int kInvTypeMax = static_cast<int>(sizeof(kSlotMaskByInvType) /
|
||||
sizeof(kSlotMaskByInvType[0])) - 1;
|
||||
|
||||
const uint8_t *PeekItemRecord(uint32_t itemID) {
|
||||
auto fn = reinterpret_cast<GetItemRecord_t>(Offsets::FUN_DBCACHE_ITEMSTATS_GET_RECORD);
|
||||
auto *cache = reinterpret_cast<void *>(Offsets::VAR_ITEMDB_CACHE);
|
||||
const uint64_t zeroGuid = 0;
|
||||
return fn(cache, itemID, &zeroGuid, nullptr, nullptr, 0);
|
||||
}
|
||||
|
||||
// Returns (itemLevel, inventoryType) for the CGItem, or (0, 0) if
|
||||
// the itemID is unresolvable or the cache record hasn't loaded.
|
||||
struct ItemInfo {
|
||||
uint32_t itemLevel;
|
||||
uint32_t invType;
|
||||
};
|
||||
|
||||
ItemInfo ReadItemInfo(const uint8_t *cgItem) {
|
||||
if (cgItem == nullptr)
|
||||
return {0, 0};
|
||||
const int itemID = Item::ID::FromCGItem(cgItem);
|
||||
if (itemID <= 0)
|
||||
return {0, 0};
|
||||
const uint8_t *record = PeekItemRecord(static_cast<uint32_t>(itemID));
|
||||
if (record == nullptr) {
|
||||
// Equipped or bagged item with no cache record yet — queue a
|
||||
// warmup so the next call gets populated data. Cheap on cache
|
||||
// hit; fires CMSG_ITEM_QUERY_SINGLE on miss.
|
||||
Item::Data::WarmCache(static_cast<uint32_t>(itemID));
|
||||
return {0, 0};
|
||||
}
|
||||
return {*reinterpret_cast<const uint32_t *>(record + Offsets::OFF_ITEMSTATS_ITEM_LEVEL),
|
||||
*reinterpret_cast<const uint32_t *>(record + Offsets::OFF_ITEMSTATS_INVENTORY_TYPE)};
|
||||
}
|
||||
|
||||
// Bank-walk helpers — bypass the bank-window gate on `GetItemBySlot`
|
||||
// by reading the player's invMgr GUID array directly. Same shape as
|
||||
// `C_Item.GetItemCount`'s bank path.
|
||||
using ResolveUnitToken_t = void *(__fastcall *)(const char *token);
|
||||
using ResolveObjectByGuid_t = void *(__fastcall *)(int type,
|
||||
const char *debugName,
|
||||
uint32_t guidLo,
|
||||
uint32_t guidHi,
|
||||
int priority);
|
||||
using GetBagInvMgr_t = void *(__thiscall *)(void *bag);
|
||||
|
||||
const uint8_t *PlayerInvMgr() {
|
||||
auto resolveUnit = reinterpret_cast<ResolveUnitToken_t>(Offsets::FUN_RESOLVE_UNIT_TOKEN);
|
||||
auto *player = static_cast<uint8_t *>(resolveUnit("player"));
|
||||
if (player == nullptr)
|
||||
return nullptr;
|
||||
return player + Offsets::OFF_PLAYER_INVENTORY_MANAGER;
|
||||
}
|
||||
|
||||
const uint8_t *ResolveByGuid(int type, uint64_t guid) {
|
||||
if (guid == 0)
|
||||
return nullptr;
|
||||
auto fn = reinterpret_cast<ResolveObjectByGuid_t>(
|
||||
Offsets::FUN_OBJECT_RESOLVE_BY_GUID);
|
||||
return static_cast<const uint8_t *>(
|
||||
fn(type, "AverageLevel",
|
||||
static_cast<uint32_t>(guid),
|
||||
static_cast<uint32_t>(guid >> 32),
|
||||
0x172));
|
||||
}
|
||||
|
||||
// Collects a single CGItem into `candidates` if it could equip in
|
||||
// any non-excluded slot. Each item is added once and assigned to a
|
||||
// single slot later (greedy fit) — keeps trinkets/fingers/1H
|
||||
// weapons from double-counting across their two candidate slots.
|
||||
struct Candidate {
|
||||
uint32_t ilvl;
|
||||
uint32_t mask; // bitmask of candidate slots (1-based bit positions)
|
||||
};
|
||||
|
||||
void CollectBagOrBankItem(const uint8_t *cgItem, std::vector<Candidate> &candidates) {
|
||||
const ItemInfo info = ReadItemInfo(cgItem);
|
||||
if (info.itemLevel == 0)
|
||||
return;
|
||||
if (info.invType > static_cast<uint32_t>(kInvTypeMax))
|
||||
return;
|
||||
uint32_t mask = kSlotMaskByInvType[info.invType];
|
||||
// Strip excluded slots (shirt, tabard) from the mask up front.
|
||||
for (int s = kFirstSlot; s <= kLastSlot; ++s) {
|
||||
if (IsExcludedSlot(s))
|
||||
mask &= ~(1u << (s - 1));
|
||||
}
|
||||
if (mask == 0)
|
||||
return;
|
||||
candidates.push_back({info.itemLevel, mask});
|
||||
}
|
||||
|
||||
// Walks a contiguous GUID-array range and feeds each resolved item
|
||||
// through `CollectBagOrBankItem`.
|
||||
void WalkGuidArrayRange(const uint8_t *invMgr, int firstSlot, int lastSlot,
|
||||
std::vector<Candidate> &candidates) {
|
||||
if (invMgr == nullptr)
|
||||
return;
|
||||
auto *guidArray = *reinterpret_cast<const uint64_t *const *>(
|
||||
invMgr + Offsets::OFF_INVMGR_GUID_ARRAY);
|
||||
if (guidArray == nullptr)
|
||||
return;
|
||||
for (int slot = firstSlot; slot <= lastSlot; ++slot) {
|
||||
const uint8_t *item = ResolveByGuid(Offsets::OBJ_TYPE_ITEM, guidArray[slot]);
|
||||
if (item == nullptr)
|
||||
continue;
|
||||
CollectBagOrBankItem(item, candidates);
|
||||
}
|
||||
}
|
||||
|
||||
// Walks each equipped bank bag's contents (slots 63..68 in the
|
||||
// player invMgr hold the bank bags themselves; each bag has its own
|
||||
// invMgr accessed via the bag CGContainer's vtable+0x10 method).
|
||||
void WalkBankBags(std::vector<Candidate> &candidates) {
|
||||
auto *playerInvMgr = PlayerInvMgr();
|
||||
if (playerInvMgr == nullptr)
|
||||
return;
|
||||
auto *playerGuidArray = *reinterpret_cast<const uint64_t *const *>(
|
||||
playerInvMgr + Offsets::OFF_INVMGR_GUID_ARRAY);
|
||||
if (playerGuidArray == nullptr)
|
||||
return;
|
||||
for (int slot = Offsets::INVMGR_BANK_BAG_FIRST_SLOT;
|
||||
slot <= Offsets::INVMGR_BANK_BAG_LAST_SLOT; ++slot) {
|
||||
const uint8_t *bag = ResolveByGuid(Offsets::OBJ_TYPE_CONTAINER,
|
||||
playerGuidArray[slot]);
|
||||
if (bag == nullptr)
|
||||
continue;
|
||||
auto *vtable = *reinterpret_cast<const uint8_t *const *>(bag);
|
||||
auto getInvMgr = reinterpret_cast<GetBagInvMgr_t>(
|
||||
*reinterpret_cast<const uintptr_t *>(vtable + 0x10));
|
||||
auto *bagInvMgr = static_cast<const uint8_t *>(
|
||||
getInvMgr(const_cast<uint8_t *>(bag)));
|
||||
if (bagInvMgr == nullptr)
|
||||
continue;
|
||||
const int bagSlots =
|
||||
static_cast<int>(*reinterpret_cast<const uint32_t *>(bagInvMgr));
|
||||
if (bagSlots <= 0)
|
||||
continue;
|
||||
WalkGuidArrayRange(bagInvMgr, 0, bagSlots - 1, candidates);
|
||||
}
|
||||
}
|
||||
|
||||
static int __fastcall Script_GetAverageItemLevel(void *L) {
|
||||
// Per-slot best ilvl found anywhere in the player's inventory.
|
||||
// Equipped slot ilvls are tracked separately so the second return
|
||||
// value can sum only the equipped path.
|
||||
uint32_t bestPerSlot[20] = {0};
|
||||
uint32_t equippedIlvl[20] = {0};
|
||||
|
||||
// First pass: equipped items. Direct path via `ResolveEquipmentSlot`
|
||||
// — no Lua stack interaction.
|
||||
for (int slot = kFirstSlot; slot <= kLastSlot; ++slot) {
|
||||
if (IsExcludedSlot(slot))
|
||||
continue;
|
||||
const uint8_t *cgItem = Item::Location::ResolveEquipmentSlot(slot);
|
||||
if (cgItem == nullptr)
|
||||
continue;
|
||||
const ItemInfo info = ReadItemInfo(cgItem);
|
||||
if (info.itemLevel == 0)
|
||||
continue;
|
||||
equippedIlvl[slot] = info.itemLevel;
|
||||
bestPerSlot[slot] = info.itemLevel;
|
||||
}
|
||||
|
||||
// Second pass: collect bag + bank items as candidates. `ResolveBag`
|
||||
// stomps the Lua stack on every call — we don't have anything on
|
||||
// the stack we need to keep yet (return-value pushes happen at
|
||||
// the very end).
|
||||
std::vector<Candidate> candidates;
|
||||
for (int bag = 0; bag <= 4; ++bag) {
|
||||
const int slotCount = Item::Location::GetBagSlotCount(bag);
|
||||
for (int bs = 1; bs <= slotCount; ++bs) {
|
||||
CollectBagOrBankItem(Item::Location::ResolveBag(L, bag, bs), candidates);
|
||||
}
|
||||
}
|
||||
// Bank — direct GUID-array reads bypass the bank-window gate so
|
||||
// this works without the player ever having opened the bank this
|
||||
// session — GUIDs are populated from server data at login. Main
|
||||
// bank first (linear slots 39..62 in the player invMgr), then
|
||||
// each equipped bank bag's contents via the per-bag CGContainer.
|
||||
const uint8_t *playerInvMgr = PlayerInvMgr();
|
||||
WalkGuidArrayRange(playerInvMgr,
|
||||
Offsets::INVMGR_BANK_MAIN_FIRST_SLOT,
|
||||
Offsets::INVMGR_BANK_MAIN_LAST_SLOT,
|
||||
candidates);
|
||||
WalkBankBags(candidates);
|
||||
|
||||
// Third pass: greedy assignment. Sort candidates by ilvl
|
||||
// descending; for each, find its candidate slot with the LOWEST
|
||||
// current `bestPerSlot` value and update if the candidate beats
|
||||
// it. Each item is assigned at most once — a trinket in the bag
|
||||
// fills one trinket slot, not both.
|
||||
//
|
||||
// Note on weapons: a 2H weapon (`invType=17`) is masked to slot
|
||||
// 16 only, while a 1H (`invType=13`) gets both slots 16 and 17.
|
||||
// If the player has a 2H equipped and a 1H in the bag, the 1H
|
||||
// will land in slot 17 — effectively "available offhand". Modern
|
||||
// WoW's full assignment includes a 2H-vs-1H+OH comparison; we
|
||||
// skip that optimization (vanilla had no Titan's Grip and the
|
||||
// rare cases where it'd matter aren't worth the complexity).
|
||||
std::sort(candidates.begin(), candidates.end(),
|
||||
[](const Candidate &a, const Candidate &b) {
|
||||
return a.ilvl > b.ilvl;
|
||||
});
|
||||
for (const auto &c : candidates) {
|
||||
int bestSlot = -1;
|
||||
uint32_t bestSlotVal = 0;
|
||||
for (int s = kFirstSlot; s <= kLastSlot; ++s) {
|
||||
if ((c.mask & (1u << (s - 1))) == 0)
|
||||
continue;
|
||||
if (bestSlot < 0 || bestPerSlot[s] < bestSlotVal) {
|
||||
bestSlot = s;
|
||||
bestSlotVal = bestPerSlot[s];
|
||||
}
|
||||
}
|
||||
if (bestSlot >= 0 && c.ilvl > bestSlotVal)
|
||||
bestPerSlot[bestSlot] = c.ilvl;
|
||||
}
|
||||
|
||||
// Fixed denominator = all considered equipment slots (1..19 minus
|
||||
// shirt + tabard = 17 slots). Empty slots contribute 0 to the
|
||||
// sum but still count toward the denominator — matches modern's
|
||||
// fixed-slot-count behavior (verified against retail Wow.exe:
|
||||
// `552.4375 * 16 = 8839` exactly, regardless of populated count).
|
||||
//
|
||||
// Max-of-two-divisors fairness trick: a 2H-weapon wielder has an
|
||||
// intentionally empty offhand (slot 17). Counting that empty
|
||||
// slot as 0 in a 17-divisor sum unfairly penalizes them vs a
|
||||
// sword+shield wielder. We compute a second candidate excluding
|
||||
// slot 17 from both numerator and denominator (16 slots), and
|
||||
// return the max — same trick the 4.3.4 client uses at
|
||||
// `FUN_0097E0F0`'s tail. For sword+shield the OH ilvl is
|
||||
// typically near average so the all-17 path wins; for 2H wielders
|
||||
// the no-OH path wins.
|
||||
uint64_t equippedSum = 0;
|
||||
uint64_t overallSum = 0;
|
||||
int slotCount = 0;
|
||||
for (int s = kFirstSlot; s <= kLastSlot; ++s) {
|
||||
if (IsExcludedSlot(s))
|
||||
continue;
|
||||
equippedSum += equippedIlvl[s];
|
||||
overallSum += bestPerSlot[s];
|
||||
++slotCount;
|
||||
}
|
||||
|
||||
constexpr int kOffhandSlot = 17;
|
||||
|
||||
auto bestAvg = [&](uint64_t sumAll, uint32_t ohContribution) {
|
||||
if (slotCount <= 0)
|
||||
return 0.0;
|
||||
const double allAvg = static_cast<double>(sumAll) / slotCount;
|
||||
const int reducedCount = slotCount - 1;
|
||||
if (reducedCount <= 0)
|
||||
return allAvg;
|
||||
const double noOhAvg =
|
||||
static_cast<double>(sumAll - ohContribution) / reducedCount;
|
||||
return (noOhAvg > allAvg) ? noOhAvg : allAvg;
|
||||
};
|
||||
|
||||
const double equippedAvg = bestAvg(equippedSum, equippedIlvl[kOffhandSlot]);
|
||||
const double overallAvg = bestAvg(overallSum, bestPerSlot[kOffhandSlot]);
|
||||
|
||||
Game::Lua::SetTop(L, 0);
|
||||
Game::Lua::PushNumber(L, overallAvg);
|
||||
Game::Lua::PushNumber(L, equippedAvg);
|
||||
return 2;
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
static void RegisterLuaFunctions() {
|
||||
Game::Lua::RegisterGlobalFunction("GetAverageItemLevel", &Script_GetAverageItemLevel);
|
||||
}
|
||||
|
||||
static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
||||
|
||||
} // namespace Item::AverageLevel
|
||||
Reference in New Issue
Block a user