// 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 . #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 #include 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(itemID)); const uint8_t *record = Item::PeekRecord(static_cast(itemID)); if (record == nullptr) { for (int i = 0; i < 6; ++i) Game::Lua::PushNil(L); return 7; } const uint32_t classID = Game::Read(record, Offsets::OFF_ITEMSTATS_CLASS); const uint32_t subClassID = Game::Read(record, Offsets::OFF_ITEMSTATS_SUBCLASS); const uint32_t displayInfoID = Game::Read(record, Offsets::OFF_ITEMSTATS_DISPLAY_INFO_ID); const uint32_t invType = Game::Read(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(invType))); Game::Lua::PushString(L, iconPath); Game::Lua::PushNumber(L, static_cast(classID)); Game::Lua::PushNumber(L, static_cast(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(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(itemID)); if (record == nullptr) { Item::Data::WarmCache(static_cast(itemID)); return 0; } const uint32_t displayInfoID = Game::Read( 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(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(itemID)); if (record == nullptr) { Item::Data::WarmCache(static_cast(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(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(itemID)); if (record == nullptr) { Item::Data::WarmCache(static_cast(itemID)); return 0; // nil this call; GET_ITEM_INFO_RECEIVED fires when ready } auto u32 = [record](int off) { return *reinterpret_cast(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( record, Offsets::OFF_ITEMSTATS_NAME); const char *description = Game::Read( 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(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(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(quality)); // 3 itemQuality Game::Lua::PushNumber(L, static_cast(itemLevel)); // 4 itemLevel Game::Lua::PushNumber(L, static_cast(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(stackCount)); // 8 itemStackCount Game::Lua::PushString(L, Item::TypeInfo::InvTypeKey(static_cast(invType))); // 9 itemEquipLoc Game::Lua::PushString(L, iconPath); // 10 itemTexture Game::Lua::PushNumber(L, static_cast(sellPrice)); // 11 sellPrice Game::Lua::PushNumber(L, static_cast(classID)); // 12 classID Game::Lua::PushNumber(L, static_cast(subClassID)); // 13 subclassID Game::Lua::PushNumber(L, static_cast(bindType)); // 14 bindType Game::Lua::PushNumber(L, 0.0); // 15 expansionID (classic) if (setID != 0) Game::Lua::PushNumber(L, static_cast(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