Files
Brues 8de1d08d4b refactor: read every localized DBC string through DBC::LocalizedString
The remaining inline `record + offset + [VAR_LOCALE_INDEX] * 4` reads
(Map, Faction, FactionGroup, ItemSet, SpellItemEnchantment, QuestInfo,
ItemSubClass) now go through DBC::LocalizedString / LocalizedField.

The ItemSubClass.dbc walk and the ItemClass / INVTYPE lookups were
written three times: item/Info.cpp and item/GetData.cpp each carried a
copy of what Item::TypeInfo already exports. Both now call
Item::TypeInfo::ClassName / SubClassName(FindSubClass(...)) /
InvTypeKey; SubClassName accepts a missing row and returns "".

The locale clamps in item/Set, item/EnchantInfo and quest/Details go:
start-up stores VAR_LOCALE_INDEX as a position in the 8-entry locale
name table (0x402562), so it is always 0..7 and in range of every
8-slot name array, and the engine's own enchant-name readers
(FUN_00496170, FUN_00495D60) index without one. EnchantInfo keeps its
enUS fallback for an empty name. ITEMSET_LOCALE_COUNT is dropped and
QuestInfo's name column gets OFF_QUESTINFO_NAME in Offsets.h. Sites that
pushed an empty string as "" keep "".
2026-11-15 15:41:49 -06:00

390 lines
19 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/Arg.h"
#include "item/BagFamily.h"
#include "item/Data.h"
#include "item/ID.h"
#include "item/Icon.h"
#include "item/Link.h"
#include "item/Location.h"
#include "item/Record.h"
#include "item/TypeInfo.h"
#include <cstdint>
#include <cstring>
namespace Item::Info {
static const char *PushedOrEmpty(const char *s) { return (s != nullptr && s[0] != 0) ? s : ""; }
// `GetItemInfoInstant` is the modern "synchronous, never blocks" item
// info call. In modern WoW the trailing 6 fields come from client-side
// `Item-sparse.db2` and so the call always returns the full 7-tuple.
// 1.12 has no client-side item DB — those fields live only in the
// network-fed `DBCache_ItemStats`. We mirror the contract by:
// - always returning the itemID (echoed from input) so callers using
// `GetItemInfoInstant(link_or_id)` as an ID extractor never see nil
// - returning the remaining 6 fields from the cache when present,
// nil when not (preserving the 7-tuple shape)
// - not warming the cache; "Instant" implies no side effects. Callers
// that need the full info should use `GetItemInfo`, which already
// triggers the warmup via the `Script_GetItemInfo` hook.
static int __fastcall Script_GetItemInfoInstant(void *L) {
const int itemID = Item::Arg::ResolveItemID(L, 1);
if (itemID <= 0)
return 0;
Game::Lua::PushNumber(L, static_cast<double>(itemID));
const uint8_t *record = Item::PeekRecord(static_cast<uint32_t>(itemID));
if (record == nullptr) {
for (int i = 0; i < 6; ++i)
Game::Lua::PushNil(L);
return 7;
}
const uint32_t classID =
Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_CLASS);
const uint32_t subClassID =
Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_SUBCLASS);
const uint32_t displayInfoID =
Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID);
const uint32_t invType =
Game::Read<uint32_t>(record, Offsets::OFF_ITEMSTATS_INVENTORY_TYPE);
char iconPath[260];
if (!Item::Icon::PathForDisplayInfoID(displayInfoID, iconPath, sizeof(iconPath)))
iconPath[0] = 0;
Game::Lua::PushString(L, Item::TypeInfo::ClassName(classID));
Game::Lua::PushString(L, Item::TypeInfo::SubClassName(Item::TypeInfo::FindSubClass(classID, subClassID)));
Game::Lua::PushString(L, Item::TypeInfo::InvTypeKey(static_cast<int>(invType)));
Game::Lua::PushString(L, iconPath);
Game::Lua::PushNumber(L, static_cast<double>(classID));
Game::Lua::PushNumber(L, static_cast<double>(subClassID));
return 7;
}
// `C_Item.GetItemIDForItemInfo(itemInfo)` — the itemID alone, from the same
// resolver `GetItemInfoInstant` echoes: an itemID, an `"item:N"` string or an
// item link. ItemMixin:GetItemID falls back to it when GetItemInfoInstant
// returns nothing. Returns nothing for input that names no item.
static const Game::Doc::Field kGetItemIDForItemInfoArgs[] = {
Game::Doc::Req("itemInfo", "ItemInfo"),
};
static const Game::Doc::Field kGetItemIDForItemInfoRets[] = {
Game::Doc::Opt("itemID", "number", nullptr,
"Nil for an item name or input that names no item."),
};
static const Game::Doc::Function kGetItemIDForItemInfo{
"Returns the item ID of an item ID, item string or item link.", kGetItemIDForItemInfoArgs,
kGetItemIDForItemInfoRets};
static int __fastcall Script_GetItemIDForItemInfo(void *L) {
const int itemID = Item::Arg::ResolveItemID(L, 1);
if (itemID <= 0)
return 0;
Game::Lua::PushNumber(L, static_cast<double>(itemID));
return 1;
}
// Pushes the icon path for `itemID` and returns 1, or returns 0 (= nil
// to Lua) if the item isn't cached, the displayInfoID is missing, or
// the icon record's path slot is empty. Shared by all three
// icon-accessor entry points.
static int PushIconForItemID(void *L, int itemID) {
if (itemID <= 0)
return 0;
const uint8_t *record = Item::PeekRecord(static_cast<uint32_t>(itemID));
if (record == nullptr) {
Item::Data::WarmCache(static_cast<uint32_t>(itemID));
return 0;
}
const uint32_t displayInfoID = Game::Read<uint32_t>(
record, Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID);
char iconPath[260];
if (!Item::Icon::PathForDisplayInfoID(displayInfoID, iconPath, sizeof(iconPath)))
return 0;
Game::Lua::PushString(L, iconPath);
return 1;
}
// `GetItemIcon(itemID)` — global, takes a numeric itemID only. Modern
// WoW returns a fileID:number; we surface the icon path string since
// 1.12 has no fileID system. Direct passthrough to
// `texture:SetTexture(...)`.
static int __fastcall Script_GetItemIcon(void *L) {
if (!Game::Lua::IsNumber(L, 1)) {
Game::Lua::Error(L, "Usage: GetItemIcon(itemID)");
return 0;
}
return PushIconForItemID(L, static_cast<int>(Game::Lua::ToNumber(L, 1)));
}
// `C_Item.GetItemIcon(itemLocation)` — table-shape ItemLocation form.
// Routes through `Item::Location::Resolve` → CGItem → itemID, then the
// same cache lookup as the other variants.
static int __fastcall Script_C_Item_GetItemIcon(void *L) {
if (!Item::Location::IsLocationArg(L, 1)) {
Game::Lua::Error(L, "Usage: C_Item.GetItemIcon(itemLocation)");
return 0;
}
const int itemID = Item::ID::FromCGItem(Item::Location::Resolve(L, 1));
return PushIconForItemID(L, itemID);
}
// `C_Item.GetItemIconByID(itemInfo)` — accepts numeric itemID or
// `"item:NN"` string (full chat links work too via the same parser
// `GetItemInfoInstant` uses).
static int __fastcall Script_C_Item_GetItemIconByID(void *L) {
return PushIconForItemID(L, Item::Arg::ResolveItemID(L, 1));
}
// `C_Item.GetItemFamily(item)` — returns the BagFamily bitmask for an
// item (modern encoding: `1 << (ID-1)`), or `nil` if the item isn't
// in the cache. Used by auto-routing addons that decide which
// specialty bag a looted item should land in.
//
// Accepts a numeric `itemID` or a string containing `"item:NNN"` (full
// chat links work) — same parser as `GetItemInfoInstant`.
//
// **Auto-warmup on cache miss.** Returns nil for uncached items but
// kicks off the cache fill in the background, so a follow-up call
// after `GET_ITEM_INFO_RECEIVED` lands the value. Mirrors the
// observed 1.15 behavior (nil first, value after retry) — the engine
// itself triggers the load. We diverge from 1.15 in one detail: we
// fire `GET_ITEM_INFO_RECEIVED` when the data arrives (matching our
// other implicit-warmup paths like `GetItemInfo` and `SetItemByID`),
// whereas 1.15's `GetItemFamily` is a silent fill. Consistency
// within our DLL's event surface > faithful 1.15 mimicry — addons
// that already listen for the event get notified for free.
//
// Modern WoW returns 0 for items the cache lookup fails on; we return
// nil so callers can distinguish "item not cached" from "item exists
// but has family 0 (general-purpose)". Both are safe to treat as "no
// preference" but keeping them distinct helps debugging.
//
// 1.12 vanilla server data leaves the `m_bagFamily` field empty on the
// **bags/quivers** themselves — Soul/Herb/Enchanting/Engineering bags AND
// quivers/ammo pouches all read 0. Individual loot items do carry the
// field reliably (arrows, bullets, shards, herbs return their proper raw
// IDs). For a bag whose field is empty we recover the family from its
// class + subclass (the same signal the "Soul Bag" tooltip line uses), so
// a Felcloth Bag reports the Soul Shard family (0x4), a quiver 0x1, an
// ammo pouch 0x2 — see `Item::BagFamily`.
static int __fastcall Script_C_Item_GetItemFamily(void *L) {
const int itemID = Item::Arg::ResolveItemID(L, 1);
if (itemID <= 0)
return 0;
const uint8_t *record = Item::PeekRecord(static_cast<uint32_t>(itemID));
if (record == nullptr) {
Item::Data::WarmCache(static_cast<uint32_t>(itemID));
return 0;
}
// Family field if populated, else derived from the container subclass
// (Turtle leaves bags' m_bagFamily at 0 — see Item::BagFamily).
Game::Lua::PushNumber(
L, static_cast<double>(Item::BagFamily::BitmaskForRecord(record)));
return 1;
}
// `C_Item.GetItemInfo(itemInfo)` — the full modern info tuple, sourced
// entirely from the cached `ItemStats_C` record (+ the class/subclass/invtype
// DBC name lookups this file already does for `GetItemInfoInstant`). Accepts
// a numeric itemID, an `"item:NNN"` string, or a full chat link — same parser
// as `GetItemInfoInstant`.
//
// Returns (18 values):
// itemName, itemLink, itemQuality, itemLevel, itemMinLevel, itemType,
// itemSubType, itemStackCount, itemEquipLoc, itemTexture, sellPrice,
// classID, subclassID, bindType, expansionID, setID, isCraftingReagent,
// itemDescription
//
// `expansionID` is always 0 (vanilla) and `isCraftingReagent` always false
// (no such flag in 1.12's item data); `setID` is nil when the item has no
// set. On a cache miss it warms the cache and returns nothing (nil) —
// the value lands on a retry after `GET_ITEM_INFO_RECEIVED`,
// matching the modern async contract.
static int __fastcall Script_C_Item_GetItemInfo(void *L) {
const Item::Arg::Resolved arg = Item::Arg::Resolve(L, 1);
const int itemID = arg.itemID;
if (itemID <= 0)
return 0;
const uint8_t *record = Item::PeekRecord(static_cast<uint32_t>(itemID));
if (record == nullptr) {
Item::Data::WarmCache(static_cast<uint32_t>(itemID));
return 0; // nil this call; GET_ITEM_INFO_RECEIVED fires when ready
}
auto u32 = [record](int off) {
return *reinterpret_cast<const uint32_t *>(record + off);
};
const uint32_t quality = u32(Offsets::OFF_ITEMSTATS_QUALITY);
const uint32_t itemLevel = u32(Offsets::OFF_ITEMSTATS_ITEM_LEVEL);
const uint32_t reqLevel = u32(Offsets::OFF_ITEMSTATS_REQUIRED_LEVEL);
const uint32_t classID = u32(Offsets::OFF_ITEMSTATS_CLASS);
const uint32_t subClassID = u32(Offsets::OFF_ITEMSTATS_SUBCLASS);
const uint32_t stackCount = u32(Offsets::OFF_ITEMSTATS_STACKABLE);
const uint32_t invType = u32(Offsets::OFF_ITEMSTATS_INVENTORY_TYPE);
const uint32_t displayInfoID = u32(Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID);
const uint32_t sellPrice = u32(Offsets::OFF_ITEMSTATS_SELL_PRICE);
const uint32_t bindType = u32(Offsets::OFF_ITEMSTATS_BONDING);
const uint32_t setID = u32(Offsets::OFF_ITEMSTATS_ITEM_SET);
const char *name = Game::Read<const char *>(
record, Offsets::OFF_ITEMSTATS_NAME);
const char *description = Game::Read<const char *>(
record, Offsets::OFF_ITEMSTATS_DESCRIPTION);
// Apply the link's random suffix ("... of the Owl") to both the name and
// the reconstructed link when the input carried one (arg.suffix); with no
// suffix these reduce to the base name / plain `item:N:0:0:0` link.
char suffixedName[128];
const char *displayName =
Item::Link::NameFromIDSuffix(static_cast<uint32_t>(itemID), arg.suffix,
suffixedName, sizeof(suffixedName))
? suffixedName
: name;
char iconPath[260];
if (!Item::Icon::PathForDisplayInfoID(displayInfoID, iconPath, sizeof(iconPath)))
iconPath[0] = 0;
char link[256];
const bool haveLink = Item::Link::BasicFromIDSuffix(static_cast<uint32_t>(itemID),
arg.suffix, link, sizeof(link));
Game::Lua::PushString(L, PushedOrEmpty(displayName)); // 1 itemName
if (haveLink)
Game::Lua::PushString(L, link); // 2 itemLink
else
Game::Lua::PushNil(L);
Game::Lua::PushNumber(L, static_cast<double>(quality)); // 3 itemQuality
Game::Lua::PushNumber(L, static_cast<double>(itemLevel)); // 4 itemLevel
Game::Lua::PushNumber(L, static_cast<double>(reqLevel)); // 5 itemMinLevel
Game::Lua::PushString(L, Item::TypeInfo::ClassName(classID)); // 6 itemType
Game::Lua::PushString(L, Item::TypeInfo::SubClassName(Item::TypeInfo::FindSubClass(classID, subClassID))); // 7 itemSubType
Game::Lua::PushNumber(L, static_cast<double>(stackCount)); // 8 itemStackCount
Game::Lua::PushString(L, Item::TypeInfo::InvTypeKey(static_cast<int>(invType))); // 9 itemEquipLoc
Game::Lua::PushString(L, iconPath); // 10 itemTexture
Game::Lua::PushNumber(L, static_cast<double>(sellPrice)); // 11 sellPrice
Game::Lua::PushNumber(L, static_cast<double>(classID)); // 12 classID
Game::Lua::PushNumber(L, static_cast<double>(subClassID)); // 13 subclassID
Game::Lua::PushNumber(L, static_cast<double>(bindType)); // 14 bindType
Game::Lua::PushNumber(L, 0.0); // 15 expansionID (classic)
if (setID != 0)
Game::Lua::PushNumber(L, static_cast<double>(setID)); // 16 setID
else
Game::Lua::PushNil(L);
Game::Lua::PushBool(L, false); // 17 isCraftingReagent
Game::Lua::PushString(L, PushedOrEmpty(description)); // 18 itemDescription
return 18;
}
// --- Documentation ----------------------------------------------------------
static const Game::Doc::Field kItemInfoArgs[] = {
Game::Doc::Req("itemInfo", "ItemInfo", "An item ID, an item string or an item link."),
};
static const Game::Doc::Field kGetItemInfoRets[] = {
Game::Doc::Req("itemName", "cstring", "With the random suffix of the link, if it has one."),
Game::Doc::Opt("itemLink", "cstring"),
Game::Doc::Req("itemQuality", "number", "An Enum.ItemQuality value."),
Game::Doc::Req("itemLevel", "number"),
Game::Doc::Req("itemMinLevel", "number"),
Game::Doc::Req("itemType", "cstring", "The localized item class name."),
Game::Doc::Req("itemSubType", "cstring", "The localized item subclass name."),
Game::Doc::Req("itemStackCount", "number"),
Game::Doc::Req("itemEquipLoc", "cstring",
"An INVTYPE_ key, or \"\" when the item is not worn."),
Game::Doc::Req("itemTexture", "string", "The icon's texture path, not a file ID."),
Game::Doc::Req("sellPrice", "number", "In copper."),
Game::Doc::Req("classID", "number"),
Game::Doc::Req("subclassID", "number"),
Game::Doc::Req("bindType", "number"),
Game::Doc::Req("expansionID", "number", "Always 0."),
Game::Doc::Opt("setID", "number", nullptr, "Nil when the item is not part of a set."),
Game::Doc::Req("isCraftingReagent", "bool", "Always false."),
Game::Doc::Req("itemDescription", "cstring", "\"\" when the item has no description."),
};
static const Game::Doc::Function kGetItemInfo{
"Returns the item's static data; returns nothing and asks the server when the data is not "
"loaded.",
kItemInfoArgs, kGetItemInfoRets};
static const Game::Doc::Field kGetItemInfoInstantRets[] = {
Game::Doc::Req("itemID", "number"),
Game::Doc::Opt("itemType", "cstring", nullptr,
"The localized item class name; nil, like the fields after it, when the "
"item's data is not loaded."),
Game::Doc::Opt("itemSubType", "cstring"),
Game::Doc::Opt("itemEquipLoc", "cstring", nullptr,
"An INVTYPE_ key, or \"\" when the item is not worn."),
Game::Doc::Opt("icon", "string", nullptr, "The icon's texture path, not a file ID."),
Game::Doc::Opt("classID", "number"),
Game::Doc::Opt("subClassID", "number"),
};
static const Game::Doc::Function kGetItemInfoInstant{
"Returns the item's class, slot and icon without asking the server; returns nothing for "
"input that names no item.",
kItemInfoArgs, kGetItemInfoInstantRets};
static const Game::Doc::Field kIconRets[] = {
Game::Doc::Opt("icon", "string", nullptr,
"The icon's texture path; nil when the item's data is not loaded, which also "
"asks the server for it."),
};
static const Game::Doc::Field kGetItemIconGlobalArgs[] = {
Game::Doc::Req("itemID", "number"),
};
static const Game::Doc::Function kGetItemIconGlobal{
"Returns the item's icon.", kGetItemIconGlobalArgs, kIconRets, "ItemGlobals"};
static const Game::Doc::Field kLocationArgs[] = {
Game::Doc::Req("itemLocation", "ItemLocation", "An item location or an item GUID."),
};
static const Game::Doc::Function kGetItemIcon{"Returns the icon of the item at a location.",
kLocationArgs, kIconRets};
static const Game::Doc::Function kGetItemIconByID{"Returns the item's icon.", kItemInfoArgs,
kIconRets};
static const Game::Doc::Field kGetItemFamilyRets[] = {
Game::Doc::Opt("result", "number", nullptr,
"The bag family bitmask, 0 for none; nil when the item's data is not loaded, "
"which also asks the server for it."),
};
static const Game::Doc::Function kGetItemFamily{
"Returns which kinds of special bag the item fits in.", kItemInfoArgs, kGetItemFamilyRets};
static void RegisterLuaFunctions() {
Game::Lua::RegisterTableFunction("C_Item", "GetItemInfo", &Script_C_Item_GetItemInfo,
&kGetItemInfo);
Game::Lua::RegisterTableFunction("C_Item", "GetItemInfoInstant", &Script_GetItemInfoInstant,
&kGetItemInfoInstant);
Game::Lua::RegisterTableFunction("C_Item", "GetItemIDForItemInfo",
&Script_GetItemIDForItemInfo, &kGetItemIDForItemInfo);
Game::Lua::RegisterGlobalFunction("GetItemIcon", &Script_GetItemIcon, &kGetItemIconGlobal);
Game::Lua::RegisterTableFunction("C_Item", "GetItemIcon", &Script_C_Item_GetItemIcon,
&kGetItemIcon);
Game::Lua::RegisterTableFunction("C_Item", "GetItemIconByID", &Script_C_Item_GetItemIconByID,
&kGetItemIconByID);
Game::Lua::RegisterTableFunction("C_Item", "GetItemFamily", &Script_C_Item_GetItemFamily,
&kGetItemFamily);
}
static const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
} // namespace Item::Info