mirror of
https://github.com/brues-code/ClassicAPI.git
synced 2026-11-16 08:00:42 +00:00
Single-call kitchen-sink reader for the cached `ItemStats_C` record. Returns a table with ~50 fields covering everything the cache holds: identity (name, description, icon, class/subclass/equipLoc strings), quality + bind type + decoded flag bits (isConjured, isOpenable, isLootable, isWrapper), stacking, economy, requirements, equipment stats (sparse map keyed by statType), resistances, weapon damage arrays, spell slots, and the misc fields (lockID, itemSet, pageText, startQuest, area/map, etc.). Returns nil for uncached / invalid input — passive reader, no cache warming. Caller wanting to ensure load should `RequestLoadItemData` and listen for `ITEM_DATA_LOAD_RESULT`. Implements via existing offsets where available; adds the remaining `ItemStats_C` fields to `Offsets.h` based on VanillaHelpers's full struct layout, anchored against the offsets we'd already verified (`m_stackable@+0x60`, `m_lockID@+0x1AC`, `m_bagFamily@+0x1D0`, etc.).
418 lines
18 KiB
C++
418 lines
18 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 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.
|
|
//
|
|
// You should have received a copy of the GNU Lesser General Public License along with
|
|
// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
// `C_Item.GetItemDataByID(itemInfo)` / `C_Item.GetItemData(itemLocation)`
|
|
// — return a single table containing every field we can extract from
|
|
// the cached `ItemStats_C` record. Convenience for addons that want
|
|
// the kitchen sink without making 15 separate `C_Item.*` calls.
|
|
//
|
|
// Returns `nil` if the item isn't cached (caller should
|
|
// `RequestLoadItemData` and listen for `ITEM_DATA_LOAD_RESULT`).
|
|
// Does not warm the cache itself — this is a passive reader, same as
|
|
// `GetItemInfoInstant`'s contract.
|
|
|
|
#include "Game.h"
|
|
#include "Offsets.h"
|
|
#include "dbc/Lookup.h"
|
|
#include "item/Arg.h"
|
|
#include "item/ID.h"
|
|
#include "item/Location.h"
|
|
#include "item/Spell.h"
|
|
|
|
#include <cstdint>
|
|
#include <cstdio>
|
|
|
|
namespace Item::GetData {
|
|
|
|
namespace {
|
|
|
|
using GetItemRecord_t = const uint8_t *(__thiscall *)(void *cache, uint32_t itemID,
|
|
const uint64_t *guid, void *callback,
|
|
void *userData, bool requestIfMissing);
|
|
|
|
const uint8_t *FetchItemRecord(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, false);
|
|
}
|
|
|
|
int CurrentLocaleIndex() {
|
|
return *reinterpret_cast<int *>(Offsets::VAR_LOCALE_INDEX);
|
|
}
|
|
|
|
// Mirrors the lookup in `Item::Info`. ItemClass.dbc record `+0x0C` is
|
|
// the 9-locale name array; null/empty slots fall back to "".
|
|
const char *LookupClassName(uint32_t classID) {
|
|
const char *s = DBC::LocalizedField(
|
|
Offsets::VAR_ITEMCLASS_RECORDS, Offsets::VAR_ITEMCLASS_COUNT,
|
|
classID, Offsets::OFF_ITEMCLASS_NAMES);
|
|
return (s != nullptr && s[0] != '\0') ? s : "";
|
|
}
|
|
|
|
// ItemSubClass.dbc walker — same fallback chain as Script_GetItemInfo
|
|
// (verbose name first, short name on miss).
|
|
const char *LookupSubClassName(uint32_t classID, uint32_t subClassID) {
|
|
const int count = *reinterpret_cast<int *>(Offsets::VAR_ITEMSUBCLASS_COUNT);
|
|
if (count <= 0)
|
|
return "";
|
|
auto *records = *reinterpret_cast<const uint8_t *const *>(Offsets::VAR_ITEMSUBCLASS_RECORDS);
|
|
if (records == nullptr)
|
|
return "";
|
|
const int locale = CurrentLocaleIndex();
|
|
for (int i = 0; i < count; ++i) {
|
|
const uint8_t *record = records + i * Offsets::OFF_ITEMSUBCLASS_RECORD_STRIDE;
|
|
if (*reinterpret_cast<const uint32_t *>(record + 0x00) != classID)
|
|
continue;
|
|
if (*reinterpret_cast<const uint32_t *>(record + 0x04) != subClassID)
|
|
continue;
|
|
const char *verbose = *reinterpret_cast<const char *const *>(
|
|
record + Offsets::OFF_ITEMSUBCLASS_DISPLAY_NAME + locale * 4);
|
|
if (verbose != nullptr && verbose[0] != '\0')
|
|
return verbose;
|
|
const char *shortName = *reinterpret_cast<const char *const *>(
|
|
record + Offsets::OFF_ITEMSUBCLASS_NAME + locale * 4);
|
|
return (shortName != nullptr && shortName[0] != '\0') ? shortName : "";
|
|
}
|
|
return "";
|
|
}
|
|
|
|
const char *LookupInvType(uint32_t invType) {
|
|
if (invType > Offsets::INVTYPE_TABLE_MAX_INDEX)
|
|
return "";
|
|
auto **table = reinterpret_cast<const char **>(Offsets::VAR_INVTYPE_STRING_TABLE);
|
|
const char *s = table[invType];
|
|
return (s != nullptr && s[0] != '\0') ? s : "";
|
|
}
|
|
|
|
bool BuildIconPath(uint32_t displayInfoID, char *out, size_t outSize) {
|
|
if (out == nullptr || outSize == 0)
|
|
return false;
|
|
out[0] = '\0';
|
|
const char *iconName = DBC::StringField(
|
|
Offsets::VAR_ITEMDISPLAYINFO_RECORDS, Offsets::VAR_ITEMDISPLAYINFO_COUNT,
|
|
displayInfoID, Offsets::OFF_ITEMDISPLAYINFO_ICON);
|
|
if (iconName == nullptr || iconName[0] == '\0')
|
|
return false;
|
|
std::snprintf(out, outSize, "Interface\\Icons\\%s", iconName);
|
|
return true;
|
|
}
|
|
|
|
// Wrath flipped the bagFamily encoding from raw 1-based IDs to a
|
|
// bitmask. We surface the modern shape so backported addons compile
|
|
// cleanly. See `Item::Info::BagFamilyIdToBitmask` for the full story.
|
|
uint32_t BagFamilyIdToBitmask(uint32_t rawId) {
|
|
return (rawId == 0) ? 0 : (1u << (rawId - 1));
|
|
}
|
|
|
|
// Shorthand: read a u32 field from the record at `offset`, push it on
|
|
// the stack as a Lua number, and set `t[key] = value` on the table at
|
|
// stack[-3]. `SetFieldNumber` already handles the push/set; this is
|
|
// just the field-fetch convenience.
|
|
void SetU32(void *L, const uint8_t *record, const char *key, int offset) {
|
|
const uint32_t v = *reinterpret_cast<const uint32_t *>(record + offset);
|
|
Game::Lua::SetFieldNumber(L, key, static_cast<double>(v));
|
|
}
|
|
|
|
void SetI32(void *L, const uint8_t *record, const char *key, int offset) {
|
|
const int32_t v = *reinterpret_cast<const int32_t *>(record + offset);
|
|
Game::Lua::SetFieldNumber(L, key, static_cast<double>(v));
|
|
}
|
|
|
|
void SetF32(void *L, const uint8_t *record, const char *key, int offset) {
|
|
const float v = *reinterpret_cast<const float *>(record + offset);
|
|
Game::Lua::SetFieldNumber(L, key, static_cast<double>(v));
|
|
}
|
|
|
|
// Sets `t[key]` to a sub-array of N consecutive u32 values from the
|
|
// record. Pushes 1-indexed (Lua array convention).
|
|
void SetU32Array(void *L, const uint8_t *record, const char *key,
|
|
int offset, int count) {
|
|
Game::Lua::PushString(L, key);
|
|
Game::Lua::NewTable(L);
|
|
auto *arr = reinterpret_cast<const uint32_t *>(record + offset);
|
|
for (int i = 0; i < count; ++i) {
|
|
Game::Lua::PushNumber(L, static_cast<double>(i + 1));
|
|
Game::Lua::PushNumber(L, static_cast<double>(arr[i]));
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
|
|
void SetI32Array(void *L, const uint8_t *record, const char *key,
|
|
int offset, int count) {
|
|
Game::Lua::PushString(L, key);
|
|
Game::Lua::NewTable(L);
|
|
auto *arr = reinterpret_cast<const int32_t *>(record + offset);
|
|
for (int i = 0; i < count; ++i) {
|
|
Game::Lua::PushNumber(L, static_cast<double>(i + 1));
|
|
Game::Lua::PushNumber(L, static_cast<double>(arr[i]));
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
|
|
void SetF32Array(void *L, const uint8_t *record, const char *key,
|
|
int offset, int count) {
|
|
Game::Lua::PushString(L, key);
|
|
Game::Lua::NewTable(L);
|
|
auto *arr = reinterpret_cast<const float *>(record + offset);
|
|
for (int i = 0; i < count; ++i) {
|
|
Game::Lua::PushNumber(L, static_cast<double>(i + 1));
|
|
Game::Lua::PushNumber(L, static_cast<double>(arr[i]));
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
|
|
// Sparse stats: walks the 10 (statType, statValue) slots and pushes
|
|
// only the populated ones into a map keyed by statType. Modern addons
|
|
// expect `stats[STAT_AGI] = 5`-style access; matching that here avoids
|
|
// callers having to walk the fixed-10 array themselves.
|
|
void SetStatsMap(void *L, const uint8_t *record) {
|
|
Game::Lua::PushString(L, "stats");
|
|
Game::Lua::NewTable(L);
|
|
auto *types = reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_STAT_TYPE);
|
|
auto *values = reinterpret_cast<const int32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_STAT_VALUE);
|
|
for (int i = 0; i < Offsets::ITEMSTATS_STAT_SLOT_COUNT; ++i) {
|
|
if (types[i] == 0 && values[i] == 0)
|
|
continue;
|
|
Game::Lua::PushNumber(L, static_cast<double>(types[i]));
|
|
Game::Lua::PushNumber(L, static_cast<double>(values[i]));
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
|
|
// Spell slots: walks all 5 slots, pushes only entries with a non-zero
|
|
// spellID as `{ id, trigger, charges, cooldown, category,
|
|
// categoryCooldown }` records. Sparse but 1-indexed in declaration
|
|
// order so the slot index is preserved.
|
|
void SetSpellsArray(void *L, const uint8_t *record) {
|
|
Game::Lua::PushString(L, "spells");
|
|
Game::Lua::NewTable(L);
|
|
auto *ids = reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SPELL_ID);
|
|
auto *triggers = reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SPELL_TRIGGER);
|
|
auto *charges = reinterpret_cast<const int32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SPELL_CHARGES);
|
|
auto *cooldowns = reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SPELL_COOLDOWN);
|
|
auto *categories = reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SPELL_CATEGORY);
|
|
auto *catCooldowns = reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SPELL_CATEGORY_CD);
|
|
int written = 0;
|
|
for (int i = 0; i < Offsets::ITEMSTATS_SPELL_SLOT_COUNT; ++i) {
|
|
if (ids[i] == 0)
|
|
continue;
|
|
++written;
|
|
Game::Lua::PushNumber(L, static_cast<double>(written));
|
|
Game::Lua::NewTable(L);
|
|
Game::Lua::SetFieldNumber(L, "id", static_cast<double>(ids[i]));
|
|
Game::Lua::SetFieldNumber(L, "trigger", static_cast<double>(triggers[i]));
|
|
Game::Lua::SetFieldNumber(L, "charges", static_cast<double>(charges[i]));
|
|
Game::Lua::SetFieldNumber(L, "cooldown", static_cast<double>(cooldowns[i]));
|
|
Game::Lua::SetFieldNumber(L, "category", static_cast<double>(categories[i]));
|
|
Game::Lua::SetFieldNumber(L, "categoryCooldown",
|
|
static_cast<double>(catCooldowns[i]));
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
Game::Lua::SetTable(L, -3);
|
|
}
|
|
|
|
// Pushes a single Lua table for `record` onto the stack, populated
|
|
// with every field we can read out of `ItemStats_C`. Caller is
|
|
// responsible for verifying `record` is non-null and pushing the
|
|
// itemID as a setup step.
|
|
void PushItemDataTable(void *L, uint32_t itemID, const uint8_t *record) {
|
|
Game::Lua::NewTable(L);
|
|
|
|
Game::Lua::SetFieldNumber(L, "itemID", static_cast<double>(itemID));
|
|
|
|
// Identity strings
|
|
const char *name = *reinterpret_cast<const char *const *>(
|
|
record + Offsets::OFF_ITEMSTATS_NAME);
|
|
Game::Lua::SetFieldString(L, "name", name);
|
|
const char *description = *reinterpret_cast<const char *const *>(
|
|
record + Offsets::OFF_ITEMSTATS_DESCRIPTION);
|
|
if (description != nullptr && description[0] != '\0')
|
|
Game::Lua::SetFieldString(L, "description", description);
|
|
|
|
// Display
|
|
const uint32_t displayInfoID = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID);
|
|
Game::Lua::SetFieldNumber(L, "displayInfoID", static_cast<double>(displayInfoID));
|
|
char iconPath[260];
|
|
if (BuildIconPath(displayInfoID, iconPath, sizeof(iconPath)))
|
|
Game::Lua::SetFieldString(L, "icon", iconPath);
|
|
|
|
// Quality / classification
|
|
const uint32_t quality = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_QUALITY);
|
|
Game::Lua::SetFieldNumber(L, "quality", static_cast<double>(quality));
|
|
|
|
const uint32_t classID = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_CLASS);
|
|
const uint32_t subClassID = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_SUBCLASS);
|
|
Game::Lua::SetFieldNumber(L, "classID", static_cast<double>(classID));
|
|
Game::Lua::SetFieldNumber(L, "subclassID", static_cast<double>(subClassID));
|
|
Game::Lua::SetFieldString(L, "className", LookupClassName(classID));
|
|
Game::Lua::SetFieldString(L, "subclassName", LookupSubClassName(classID, subClassID));
|
|
|
|
const uint32_t invType = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_INVENTORY_TYPE);
|
|
Game::Lua::SetFieldNumber(L, "inventoryType", static_cast<double>(invType));
|
|
Game::Lua::SetFieldString(L, "equipLoc", LookupInvType(invType));
|
|
|
|
// Bind
|
|
SetU32(L, record, "bindType", Offsets::OFF_ITEMSTATS_BONDING);
|
|
|
|
// Flags: raw + decoded bits.
|
|
const uint32_t flags = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_FLAGS);
|
|
Game::Lua::SetFieldNumber(L, "flags", static_cast<double>(flags));
|
|
Game::Lua::SetFieldBool(L, "isConjured",
|
|
(flags & Offsets::ITEM_FLAG_CONJURED) != 0);
|
|
Game::Lua::SetFieldBool(L, "isOpenable",
|
|
(flags & Offsets::ITEMSTATS_FLAG_OPENABLE) != 0);
|
|
Game::Lua::SetFieldBool(L, "isLootable",
|
|
(flags & Offsets::ITEM_FLAG_LOOTABLE) != 0);
|
|
Game::Lua::SetFieldBool(L, "isWrapper",
|
|
(flags & Offsets::ITEM_FLAG_WRAPPER) != 0);
|
|
|
|
// Stacking / inventory
|
|
SetI32(L, record, "maxStackSize", Offsets::OFF_ITEMSTATS_STACKABLE);
|
|
SetI32(L, record, "maxCount", Offsets::OFF_ITEMSTATS_MAX_COUNT);
|
|
SetU32(L, record, "containerSlots", Offsets::OFF_ITEMSTATS_CONTAINER_SLOTS);
|
|
const uint32_t rawBagFamily = *reinterpret_cast<const uint32_t *>(
|
|
record + Offsets::OFF_ITEMSTATS_BAG_FAMILY);
|
|
Game::Lua::SetFieldNumber(L, "bagFamily",
|
|
static_cast<double>(BagFamilyIdToBitmask(rawBagFamily)));
|
|
|
|
// Economy
|
|
SetU32(L, record, "buyPrice", Offsets::OFF_ITEMSTATS_BUY_PRICE);
|
|
SetU32(L, record, "sellPrice", Offsets::OFF_ITEMSTATS_SELL_PRICE);
|
|
|
|
// Level / requirements
|
|
SetU32(L, record, "itemLevel", Offsets::OFF_ITEMSTATS_ITEM_LEVEL);
|
|
SetU32(L, record, "requiredLevel", Offsets::OFF_ITEMSTATS_REQUIRED_LEVEL);
|
|
SetU32(L, record, "requiredSkill", Offsets::OFF_ITEMSTATS_REQUIRED_SKILL);
|
|
SetU32(L, record, "requiredSkillRank", Offsets::OFF_ITEMSTATS_REQUIRED_SKILL_RANK);
|
|
SetU32(L, record, "requiredSpell", Offsets::OFF_ITEMSTATS_REQUIRED_SPELL);
|
|
SetU32(L, record, "requiredHonorRank", Offsets::OFF_ITEMSTATS_REQUIRED_HONOR_RANK);
|
|
SetU32(L, record, "requiredCityRank", Offsets::OFF_ITEMSTATS_REQUIRED_CITY_RANK);
|
|
SetU32(L, record, "requiredFaction", Offsets::OFF_ITEMSTATS_REQUIRED_FACTION);
|
|
SetU32(L, record, "requiredFactionRank", Offsets::OFF_ITEMSTATS_REQUIRED_FACTION_RANK);
|
|
SetU32(L, record, "allowableClass", Offsets::OFF_ITEMSTATS_ALLOWABLE_CLASS);
|
|
SetU32(L, record, "allowableRace", Offsets::OFF_ITEMSTATS_ALLOWABLE_RACE);
|
|
|
|
// Equipment defenses
|
|
SetU32(L, record, "armor", Offsets::OFF_ITEMSTATS_ARMOR);
|
|
SetU32(L, record, "block", Offsets::OFF_ITEMSTATS_BLOCK);
|
|
SetU32(L, record, "maxDurability", Offsets::OFF_ITEMSTATS_MAX_DURABILITY);
|
|
|
|
// Sparse stats map (statType -> statValue, only populated entries)
|
|
SetStatsMap(L, record);
|
|
|
|
// Resistances
|
|
SetU32(L, record, "resistanceHoly", Offsets::OFF_ITEMSTATS_RES_HOLY);
|
|
SetU32(L, record, "resistanceFire", Offsets::OFF_ITEMSTATS_RES_FIRE);
|
|
SetU32(L, record, "resistanceNature", Offsets::OFF_ITEMSTATS_RES_NATURE);
|
|
SetU32(L, record, "resistanceFrost", Offsets::OFF_ITEMSTATS_RES_FROST);
|
|
SetU32(L, record, "resistanceShadow", Offsets::OFF_ITEMSTATS_RES_SHADOW);
|
|
SetU32(L, record, "resistanceArcane", Offsets::OFF_ITEMSTATS_RES_ARCANE);
|
|
|
|
// Weapon
|
|
SetF32Array(L, record, "damageMin", Offsets::OFF_ITEMSTATS_DAMAGE_MIN,
|
|
Offsets::ITEMSTATS_DAMAGE_SLOT_COUNT);
|
|
SetF32Array(L, record, "damageMax", Offsets::OFF_ITEMSTATS_DAMAGE_MAX,
|
|
Offsets::ITEMSTATS_DAMAGE_SLOT_COUNT);
|
|
SetU32Array(L, record, "damageType", Offsets::OFF_ITEMSTATS_DAMAGE_TYPE,
|
|
Offsets::ITEMSTATS_DAMAGE_SLOT_COUNT);
|
|
SetU32(L, record, "delay", Offsets::OFF_ITEMSTATS_DELAY);
|
|
SetU32(L, record, "ammoType", Offsets::OFF_ITEMSTATS_AMMO_TYPE);
|
|
SetF32(L, record, "rangedModRange", Offsets::OFF_ITEMSTATS_RANGED_MOD_RANGE);
|
|
|
|
// Spell slots (sparse array of records) + ON_USE convenience
|
|
SetSpellsArray(L, record);
|
|
const int useSpellID = Item::Spell::OnUseSpellIDForItemID(itemID);
|
|
if (useSpellID > 0)
|
|
Game::Lua::SetFieldNumber(L, "useSpellID", static_cast<double>(useSpellID));
|
|
|
|
// Lock / item set
|
|
SetU32(L, record, "lockID", Offsets::OFF_ITEMSTATS_LOCK_ID);
|
|
SetU32(L, record, "itemSet", Offsets::OFF_ITEMSTATS_ITEM_SET);
|
|
|
|
// Books / quest / binding
|
|
SetU32(L, record, "pageText", Offsets::OFF_ITEMSTATS_PAGE_TEXT);
|
|
SetU32(L, record, "pageMaterial", Offsets::OFF_ITEMSTATS_PAGE_MATERIAL);
|
|
SetU32(L, record, "languageID", Offsets::OFF_ITEMSTATS_LANGUAGE_ID);
|
|
SetU32(L, record, "startQuest", Offsets::OFF_ITEMSTATS_START_QUEST);
|
|
SetI32(L, record, "material", Offsets::OFF_ITEMSTATS_MATERIAL);
|
|
SetU32(L, record, "sheath", Offsets::OFF_ITEMSTATS_SHEATH);
|
|
SetI32(L, record, "randomProperty", Offsets::OFF_ITEMSTATS_RANDOM_PROPERTY);
|
|
SetU32(L, record, "area", Offsets::OFF_ITEMSTATS_AREA);
|
|
SetU32(L, record, "map", Offsets::OFF_ITEMSTATS_MAP);
|
|
}
|
|
|
|
// Common path for both entry points: take an itemID, peek the cache,
|
|
// build & push the data table or push nil for uncached.
|
|
int PushDataForItemID(void *L, int itemID) {
|
|
if (itemID <= 0) {
|
|
Game::Lua::PushNil(L);
|
|
return 1;
|
|
}
|
|
const uint8_t *record = FetchItemRecord(static_cast<uint32_t>(itemID));
|
|
if (record == nullptr) {
|
|
Game::Lua::PushNil(L);
|
|
return 1;
|
|
}
|
|
PushItemDataTable(L, static_cast<uint32_t>(itemID), record);
|
|
return 1;
|
|
}
|
|
|
|
// `C_Item.GetItemDataByID(itemInfo)` — accepts numeric itemID,
|
|
// `"item:NNN..."` string, or full chat link. Returns the data table
|
|
// or nil for invalid input / uncached items.
|
|
int __fastcall Script_GetItemDataByID(void *L) {
|
|
return PushDataForItemID(L, Item::Arg::ResolveItemID(L, 1));
|
|
}
|
|
|
|
// `C_Item.GetItemData(itemLocation)` — resolves the equipment-slot /
|
|
// bag-slot location to its CGItem, extracts the itemID, then peeks
|
|
// the cache. Returns nil for empty slots, invalid locations, or
|
|
// uncached items.
|
|
int __fastcall Script_GetItemData(void *L) {
|
|
if (!Item::Location::IsLocationArg(L, 1)) {
|
|
Game::Lua::Error(L, "Usage: C_Item.GetItemData(itemLocation)");
|
|
return 0;
|
|
}
|
|
return PushDataForItemID(L, Item::ID::FromCGItem(Item::Location::Resolve(L, 1)));
|
|
}
|
|
|
|
void RegisterLuaFunctions() {
|
|
Game::Lua::RegisterTableFunction("C_Item", "GetItemDataByID", &Script_GetItemDataByID);
|
|
Game::Lua::RegisterTableFunction("C_Item", "GetItemData", &Script_GetItemData);
|
|
}
|
|
|
|
const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
|
|
|
|
} // namespace
|
|
|
|
} // namespace Item::GetData
|