Repository navigation
Expand file tree
/
Copy pathInfo.cpp
More file actions
389 lines (357 loc) · 18.6 KB
/
Copy pathInfo.cpp
File metadata and controls
389 lines (357 loc) · 18.6 KB
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
// 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