Files
ClassicAPI/src/Offsets.h
T
Brues c35d883af0 targeting: backport TargetDirection*/TargetNearest* + GetPlayerFacing
Adds the post-vanilla TargetScript selection functions 1.12.1 lacks:

  TargetDirectionEnemy(facing[,cone]) / TargetDirectionFriend
  TargetNearest([reverse])
  TargetNearestEnemyPlayer([reverse]) / TargetNearestFriendPlayer
  GetPlayerFacing()

All five targeting functions reuse the engine's own tab-target core: the
visible-unit enumeration, the per-mode validity predicate FUN_00493e40
(reaction/attackability/alive, modes 1=enemy/2=friend), and the selection
commit. The only new logic is a player-GUID filter for the *Player variants
and the cone geometry for the direction variants. Cycle functions keep a
frozen per-filter snapshot advanced within a ~1s window (no ping-pong).

Target-setting routes through FUN_TARGET_BY_GUID (0x00489A40), which
rejects a GUID that no longer resolves to a live unit rather than
committing it — a stale snapshot GUID would otherwise leave "target"
pointing at freed unit data and crash the next handler that reads it.

GetPlayerFacing reads the CGUnit movement-block orientation at +0x9C4
(located by probing the player object across a known 180-degree turn); it's
the facing source the direction-target functions need.

Not backported (no vanilla equivalent): TargetPriorityHighlightStart/End,
IsTargetLoose, TargetToggle.

New offsets: FUN_TARGET_CANDIDATE_VALID (0x00493E40),
FUN_SET_SELECTION_BY_GUID (0x00493540), VAR_CURRENT_SELECTION_GUID_LO/HI,
OFF_UNIT_FACING (0x9C4).
2026-07-21 00:49:05 -05:00

5564 lines
305 KiB
C
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// 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/>.
#pragma once
enum Offsets {
FUN_FRAME_SCRIPT_INITIALIZE = 0x7039E0,
FUN_INVALID_FUNCTION_PTR_CHECK = 0x42A320,
FUN_LOAD_SCRIPT_FUNCTIONS = 0x490250,
// Fatal-error dispatcher. `__fastcall(uint code)`. Writes `code`
// to `DAT_00882738` and chains into the process-teardown path;
// `FUN_00403BC0` reads the code at exit and shows a localized
// popup keyed off it. Code `10` = "interface files are corrupt"
// — the engine fires this from FrameXML's `FUN_0048FBF0` hash
// mismatch and per-addon `FUN_0051F240` hash mismatch (plus
// other call sites we haven't pinned down by byte pattern).
// Hooked by `Security::FrameXMLBypass` to suppress code 10 so
// our in-memory file modifications (Bindings.xml splice +
// embedded `!!!ClassicAPI` addon) don't trigger termination.
FUN_FATAL_ERROR = 0x00401560,
// Master glue Lua init — clean linear caller of all 5 glue batch
// trampolines (60 main + 11 char-select + 24 char-create + 10 realm
// + 4 frame globals = 109 total). Body: 0x0046ABB0..0x0046ABD2,
// 35 bytes, single caller (FUN_0046A7B0). Runs once per glue boot:
// initial launch and every world→glue return (log out). Post-hook
// is the glue analog of `FUN_LOAD_SCRIPT_FUNCTIONS` — by the time
// it returns, `VAR_LUA_STATE` points at the freshly populated glue
// state, so `FrameScript_RegisterFunction` writes land on it.
FUN_LOAD_GLUE_SCRIPT_FUNCTIONS = 0x0046ABB0,
// GameTooltip script-method prologue helpers (used to resolve self → CFrameScriptObject*).
// Underlying Lua C API names per [[docs/LuaCAPI.md]] are `lua_rawgeti`
// (0x6F3BC0) and `lua_touserdata` (0x6F3740). The Set* method prologue's
// call sequence
// PushObject(L, idx, 0); // == lua_rawgeti(L, idx, 0) — pushes the
// // lightuserdata at table[0]
// GetObject(L, -1); // == lua_touserdata(L, -1) — extracts
// // the raw CFrameScriptObject *
// is the canonical "Lua frame table → C++ object" path. The reverse
// (`GameTooltip:GetOwner` etc.) is just `lua_rawgeti(L, REGISTRY,
// [cobj+OFF_COBJECT_LUA_REGISTRY_REF])` — the engine pre-allocates
// the registry handle when the frame is created from Lua.
FUN_FRAMESCRIPT_PUSH_OBJECT = 0x6F3BC0,
FUN_FRAMESCRIPT_GET_OBJECT = 0x6F3740,
// CFrameScriptObject layout: the registry refkey allocated when the
// engine first exposes the C++ object to Lua. Pushing a frame back
// to Lua is `lua_rawgeti(L, LUA_REGISTRYINDEX, [cobj+0x08])`.
OFF_COBJECT_LUA_REGISTRY_REF = 0x08,
// Within a CGFrame, the embedded LayoutFrame sub-object starts here.
// Engine code that wants to invoke LayoutFrame methods polymorphically
// (anchoring, positioning) stores the LayoutFrame* — i.e.
// `(Frame*)obj + 0x24` — instead of the bare Frame*. Reverse
// lookups (e.g. GameTooltip:GetOwner) subtract this back out.
OFF_FRAME_LAYOUT_SUBOBJECT = 0x24,
// Inner spell-tooltip builder, called from Script_GameTooltip_SetSpell at 0x00532E92.
// __thiscall(spellID, 0, 0, isPet, 0, 0, 0); we always pass isPet=0.
FUN_GAMETOOLTIP_BUILD_SPELL_TOOLTIP = 0x0052E610,
// Existing GameTooltip method-table entries we dispatch to from
// backported convenience methods. Each is `int __fastcall(void *L)`
// expecting the standard self+args layout on the Lua stack.
// (Slot numbers are the method-registry index per `docs/raw_methods.txt`.)
FUN_SCRIPT_GAMETOOLTIP_SET_HYPERLINK = 0x00531FD0, // slot 12
FUN_SCRIPT_GAMETOOLTIP_SET_INVENTORY_ITEM = 0x00532EE0, // slot 19
FUN_SCRIPT_GAMETOOLTIP_SET_UNIT_BUFF = 0x00534AC0, // slot 32
FUN_SCRIPT_GAMETOOLTIP_SET_UNIT_DEBUFF = 0x00534E30, // slot 33
FUN_SCRIPT_GAMETOOLTIP_SET_TALENT = 0x00535170, // slot 34
// Iterator that registers an array of frame-method bindings on a per-frame-type
// method registry (e.g. VAR_GAMETOOLTIP_METHOD_REGISTRY for GameTooltip).
// __fastcall(ecx = MethodEntry table, edx = count, [stack] = context).
FUN_REGISTER_FRAME_METHODS = 0x00701D80,
VAR_GAMETOOLTIP_METHOD_REGISTRY = 0x00C0CF20,
// CGameTooltip line pool (see TODO #97). The engine caps AddLine
// (FUN_00530270) at `numLinesAllocated`, which the XML-OnLoad scan
// (FUN_00529650, vtable slot 9) sets to the count of contiguous
// `<name>TextLeftN`/`TextRightN` FontStrings the template declares
// (30). Tooltip::LinePool grows it: it appends its own C++-created
// FontStrings to the three parallel arrays and bumps this count. Each
// array is a {count@+0x0, cap@+0x4, data@+0x8} descriptor; the
// reallocators realloc `data` to newCount*4 and copy `cap` old elements.
VAR_GAMETOOLTIP_VTABLE = 0x00808F60, // type guard for a resolved tooltip object
OFF_GAMETOOLTIP_NUM_LINES_ALLOC = 0x320, // int — pool size AddLine gates on
OFF_GAMETOOLTIP_TEXTLEFT_DESC = 0x324, // {count,cap,data}; data (+0x8) = CSimpleFontString*[]
OFF_GAMETOOLTIP_TEXTRIGHT_DESC = 0x330, // symmetric right column
OFF_GAMETOOLTIP_WRAPFLAG_DESC = 0x33C, // per-line wrap int[]
FUN_TOOLTIP_REALLOC_PTR_ARRAY = 0x00536C80, // __thiscall(desc, newCount) — pointer arrays
FUN_TOOLTIP_REALLOC_INT_ARRAY = 0x004368C0, // __thiscall(desc, newCount) — wrap-flag array
// GameTooltip:SetHyperlinkCompareItem (Tooltip::Compare) — builds the
// equipped item's tooltip natively (no Lua roundtrip) and appends
// colored stat deltas. FUN_GAMETOOLTIP_BUILD_ITEM is the engine's own
// item-tooltip builder that SetInventoryItem/SetHyperlink call:
// __thiscall(self, itemID, guid*, guid*, a4, a5, a6, headerFlag, a8, a9)
// Proven arg shape from FUN_005353b0/FUN_00535700 (all flags 0 → a clean
// item tooltip). The builder's own headerFlag (param_7) path merges the
// "Currently Equipped" text into the name line and force-wraps it, so we
// build clean (flag 0) and prepend the grey header ourselves by shifting
// the line FontStrings — see FUN_FONTSTRING_SET_* / OFF_FONTSTRING_*.
// FUN_GAMETOOLTIP_ADD_LINE is the raw add-line body (see LinePool notes);
// its color args are pointers to a 4-byte packed color {b,g,r,a} — the
// Lua AddLine handler (FUN_00531630) builds it as 0xFF<rr><gg><bb>, i.e.
// uint32 `0xFF000000 | r<<16 | g<<8 | b` in little-endian memory.
FUN_GAMETOOLTIP_BUILD_ITEM = 0x0052B650,
// OnTooltipSetItem support. FUN_GAMETOOLTIP_SCRIPT_RESOLVER is the
// CGGameTooltip vtable method (vtable 0x00808F60) that maps a script name
// to its handler slot; __thiscall(self, const char *name) -> int* slot,
// 0 if the name isn't a tooltip script. It first delegates to the base
// frame resolver, then checks OnTooltipSetDefaultAnchor(+0x444) /
// OnTooltipCleared(+0x44c) / OnTooltipAddMoney(+0x454) — each an 8-byte
// {handler, context} slot. Vanilla has no OnTooltipSetItem, and the object
// (alloc size 0x460) has no free 8-byte slot, so we co-hook this to hand
// out a C-side per-tooltip cell for that name. FUN_FRAME_INVOKE_SCRIPT is
// the engine's real script invoker __fastcall(handler /*ecx = slot[0]*/,
// frame /*edx*/): it binds the global `this` = frame and runs the handler
// under its own protected lua_pcall (0 args). We call it directly from the
// item-builder co-hook to fire OnTooltipSetItem.
// NOTE: the clear fires OnTooltipCleared via the wrapper FUN_00702690
// (self, &slot), which additionally stamps the global exec-context
// (DAT_00ceeac0) from slot[1]. That context mutation is only valid from
// the engine's top-level frame-script dispatch — firing it from deep in a
// nested Lua->C->Lua stack (e.g. an addon's SetAuctionItem wrapper)
// corrupts the outer script's context and faults. So we skip the wrapper
// and call the inner invoker, which is self-contained.
FUN_GAMETOOLTIP_SCRIPT_RESOLVER = 0x005295D0,
FUN_FRAME_INVOKE_SCRIPT = 0x00704D50,
FUN_GAMETOOLTIP_ADD_LINE = 0x00530270, // __thiscall(self, left, right, lColorBGRA*, rColorBGRA*, wrap)
OFF_GAMETOOLTIP_NUM_LINES = 0x31C, // int — live line count (AddLine index; +0x320 is the cap)
// The displayed item's identity is read via the existing
// OFF_TOOLTIP_ITEM_ID (+0x398) / OFF_TOOLTIP_ITEM_GUID_LO (+0x380) —
// link paths set the itemID, CGItem paths (SetInventoryItem/…) set only
// the GUID (see Tooltip::Compare::TooltipItemID and item/Tooltip.cpp).
// Line-shift primitives for prepending the grey "Currently Equipped"
// header. The per-line CSimpleFontString objects live in the parallel
// arrays at OFF_GAMETOOLTIP_TEXTLEFT/RIGHT_DESC (+8 = data). Each stores
// its text buffer pointer at +0xF0 and its 4-byte {b,g,r,a} color behind
// the pointer at +0xB8 (both verified from the setters below). We read a
// line's text/color and re-apply them one slot down, then set line 0.
FUN_FONTSTRING_SET_TEXT = 0x00771D80, // __thiscall(fs, text, flag=0)
FUN_FONTSTRING_SET_COLOR = 0x0077F750, // __thiscall(fs, colorBGRA*)
OFF_FONTSTRING_TEXT = 0xF0, // char* — current text buffer
OFF_FONTSTRING_COLOR_PTR = 0xB8, // ptr → 4-byte {b,g,r,a} color storage
// A line's FontString is only positioned once shown: set the desired
// flag at +0xC4 then call SHOW (FUN_0077fcb0) / HIDE (FUN_0077fc60) —
// the exact pair AddLine (FUN_00530270) and the clear use. Moving text
// into a previously-empty (hidden) cell without this leaves it
// unpositioned, so the line-shift must replicate it.
FUN_FONTSTRING_SHOW = 0x0077FCB0, // __fastcall(fs) — realizes +0xC4
FUN_FONTSTRING_HIDE = 0x0077FC60, // __fastcall(fs)
OFF_FONTSTRING_SHOWN_FLAG = 0xC4, // int — desired-shown flag
// The per-tooltip clear only HIDES line FontStrings (sets +0xC8 = 0)
// and clears the left text; right-column text buffers are left intact.
// So a shift must decide a cell's content by its actually-shown flag
// (+0xC8), not by whether +0xF0 still holds (stale) text.
OFF_FONTSTRING_VISIBLE = 0xC8, // int — actually-shown flag
// FontString creation primitives used by Tooltip::LinePool to build the
// extra lines entirely in C++ (no addon Lua). Calling conventions and
// offsets mirrored from Script_CreateFontString (0x00773C30),
// Script_SetFontObject (0x0079D1A0 → 0x00770C60), and Script_SetPoint
// (0x007A2540 → 0x00767C70) — see TODO #97's investigation update.
FUN_GAMETOOLTIP_SETUP_LINES = 0x00529650, // vtable slot 9 — the pool scan we co-hook
VAR_SIMPLEFONTSTRING_POOL = 0x00CF4D10, // CSimpleFontString free-list pool (allocator `this`)
VAR_SIMPLEFONTSTRING_CLASS_TAG = 0x00846544, // ".?AVCSimpleFontString@@" (alloc debug tag)
FUN_REGION_POOL_ALLOC = 0x00760450, // __thiscall(pool, zeroInit=0, tag, line=-2) -> raw mem
FUN_SIMPLEFONTSTRING_CTOR = 0x00770D30, // __thiscall(mem, parent, layer, sublayer) -> fs
FUN_REGION_SET_NAME = 0x0076C650, // __thiscall(region, name) — registers _G[name]
FUN_FONTSTRING_SET_FONT = 0x00770C60, // __thiscall(fs + OFF_FONTSTRING_FONT_HOLDER, fontObject)
FUN_REGION_SET_POINT = 0x00767C70, // __thiscall(region+OFF_REGION_ANCHOR, point, relAnchor, relPoint, x, y, flag=1)
OFF_FONTSTRING_FONT_HOLDER = 0xCC, // font-reference sub-object (SetFont `this`)
OFF_FONTSTRING_FONT_OBJECT = 0xD0, // font object pointer (holder + 4)
OFF_REGION_ANCHOR = 0x24, // LayoutFrame anchor sub-object (SetPoint `this` / relativeTo base)
DRAWLAYER_ARTWORK = 2,
FRAMEPOINT_TOPLEFT = 0,
FRAMEPOINT_LEFT = 3,
FRAMEPOINT_RIGHT = 5,
FRAMEPOINT_BOTTOMLEFT = 6,
// FUN_REGION_SET_POINT stores offsets in *internal* coordinates, not
// pixels. Script_SetPoint converts: `internal = pixel * [0x00832A44] /
// ([0x00832A4C] * 1024)` (FUN_0041ae60's factor × input ÷
// (FUN_0041ad70's return × DAT_007ffd68)). Both globals are runtime
// UI-scale floats; passing raw pixels makes offsets ~1000× too large.
VAR_UI_COORD_SCALE_MUL = 0x00832A44, // float numerator
VAR_UI_COORD_SCALE_DIV = 0x00832A4C, // float denominator base
UI_COORD_SCALE_UNIT = 1024, // DAT_007ffd68
// "Currently displayed thing" state fields on a GameTooltip frame
// instance. Each Set* path writes one of these (and zero or two
// others), and the per-tooltip Clear at FUN_00530050 zeroes all of
// them on Hide/before-redraw. The Get* methods are simple reads —
// whichever field is non-zero tells us what kind of tooltip is up.
//
// Verified by decoding the builder functions:
// - BuildItemTooltip (0x0052B650) writes +0x380/+0x384 (item
// GUID, only when there's a real CGItem) and
// +0x398 (itemID) at 0x0052B6CE / 0x0052B6FE.
// - BuildSpellTooltip (0x0052E610) writes +0x39C (spellID) at
// 0x0052E6D5 (param_7==0 branch — skipped for
// the next-rank tooltip side-build).
// - BuildUnitTooltip (FUN_00529FE0) writes +0x368/+0x36C (unit
// GUID) — see SetUnit block below.
// - BuildGameObjectTooltip (0x0052AA20) writes +0x370/+0x374
// (gameobject GUID) at 0x0052AA52 / 0x0052AA59.
// Only call site is the in-world hover handler
// FUN_00492890; no Lua `SetGameObject` method.
// - Clear (FUN_GAMETOOLTIP_CLEAR) zeroes unit(+0x368)/GO(+0x370)/
// itemID(+0x398)/spell(+0x39c) — but NOT the item GUID +0x380/+0x384.
// That omission means the item GUID goes stale across a switch to a
// tooltip that shows no item (SetUnitAura, SetEquipmentSet, …), so
// GameTooltip:GetItem would resolve the *previous* item. We co-hook
// the clear (Tooltip::ClearItemGuid) to zero +0x380/+0x384 too, so
// every fresh tooltip resets it and only the item builder re-sets it.
// All 14 Set*/builder paths route through this clear, so the co-hook
// covers them uniformly. __fastcall(self).
FUN_GAMETOOLTIP_CLEAR = 0x00530050,
OFF_TOOLTIP_ITEM_GUID_LO = 0x380, // 0 for SetItemByID (no CGItem); stale-safe via the clear co-hook
OFF_TOOLTIP_ITEM_GUID_HI = 0x384,
OFF_TOOLTIP_ITEM_ID = 0x398,
OFF_TOOLTIP_SPELL_ID = 0x39C,
// Auction/compare descriptor. Script_GameTooltip_SetAuctionItem
// (0x00535810) has no CGItem instance, so it stashes the listing's
// random-property (suffix) id at tooltip+0x424 and marks the
// compare-descriptor valid by writing the builder's compare flag to
// this[0x110] (tooltip+0x440) = 1 (SetAuctionItem passes param_6=1;
// every other Set* path passes 0, and the builder writes it on each
// param_7==0 build — so +0x440 is a reliable per-build gate, not
// stale). This is 1.12's analog of 3.3.5's `tooltip[0x130]`-gated
// `piVar5[0x2d]` random-property read in GameTooltip:GetItem. GetItem
// reads +0x424 (only when +0x440 is set) to put the suffix in the link.
OFF_TOOLTIP_COMPARE_FLAG = 0x440,
OFF_TOOLTIP_COMPARE_SUFFIX = 0x424,
// Unit GUID written by the inner unit-tooltip builder
// (FUN_00529FE0) when `tooltip:SetUnit(token)` resolves the token
// to a non-zero GUID. Cleared by the same `FUN_00530050` clear
// that handles the item/spell IDs above, so `(lo|hi) == 0` means
// "no unit currently displayed" — same gating pattern HasSpell /
// HasItem use.
OFF_TOOLTIP_UNIT_GUID_LO = 0x368,
OFF_TOOLTIP_UNIT_GUID_HI = 0x36C,
// GameObject GUID written by the in-world hover tooltip populator
// (FUN_0052AA20) — there is no Lua-callable `SetGameObject` method
// in vanilla, so this slot only ever fills when the player mouses
// over a gameobject in the world (nodes, chests, doors, etc.).
// Same clear/gating semantics as the unit GUID slot.
OFF_TOOLTIP_GAMEOBJECT_GUID_LO = 0x370,
OFF_TOOLTIP_GAMEOBJECT_GUID_HI = 0x374,
// Owner frame stored by `tooltip:SetOwner(frame, anchor)` and
// compared by `IsOwned`. Holds `owner_CObject + OFF_FRAME_LAYOUT_SUBOBJECT`
// (i.e. the LayoutFrame*, not the bare Frame*), or 0 if unowned.
// Verified via the helper at 0x0052FFE0 invoked by SetOwner's tail
// (writes `[this+0x314] = arg+0x24`) and Script_GameTooltip_IsOwned
// at 0x00530FE0 (reads `[edi+0x314]` and compares against the same
// `+0x24`-offset value).
OFF_TOOLTIP_OWNER = 0x314,
// CGItem → fully-dressed item link string. __fastcall(ecx = CGItem *)
// → const char *. Reads the item's itemID, quality, permanent
// enchant ID, random-properties seed/factor, and unique ID off the
// CGItem's instance block + descriptor, builds the dressed name via
// FUN_005D8BC0 (handles random-suffix decoration like "Foo of the
// Bear"), then sprintf's into the global buffer at DAT_00C0CF68 and
// returns its address. The returned pointer is to a long-lived
// engine global, safe to read until the next call.
//
// Same helper Script_GetContainerItemLink (0x004F9930) and
// Script_GetInventoryItemLink (0x004C8C10) call after resolving
// their slot-form args. Bypassing them lets us build dressed links
// for tooltips set via SetMerchantItem / SetLootItem / etc. where
// the item isn't in the player's bag/equipment.
FUN_GAMETOOLTIP_BUILD_ITEM_LINK = 0x0052AE00,
// CGItem → decorated instance display name. __thiscall(ecx = CGItem *,
// char *outBuf, uint outSize). Reads the instance's random-suffix ID
// off the descriptor (+0x98, gated on the broken flag) and writes the
// plain — uncolored, unbracketed — display name into outBuf:
// "Ethereum Torque of the Sorcerer" when a suffix is present, the base
// ItemStats name otherwise (via the item cache + ItemRandomProperties
// localized suffix at record +0x1c). This is the inner name builder
// FUN_GAMETOOLTIP_BUILD_ITEM_LINK wraps in brackets, so the name it
// produces matches GetItemLink's bracketed name and modern
// C_Item.GetItemName exactly. Inner formatter FUN_005D8B00.
FUN_ITEM_BUILD_INSTANCE_NAME = 0x005D8BC0,
// Engine's inventory swap-and-send. Same primitive
// `Script_EquipCursorItem` (0x00489660) uses after the cursor's
// source location has been resolved. Sends opcode 0x10D
// (CMSG_SWAP_INV_ITEM) for same-container swaps or 0x10C
// (CMSG_AUTOEQUIP_ITEM) for cross-container, then runs the
// packet through the engine's own send pipeline at FUN_005AB630.
//
// Signature:
// void __thiscall(
// CGPlayer *this,
// u32 srcItemGuidLo, u32 srcItemGuidHi,
// u32 srcContainerGuidLo, u32 srcContainerGuidHi,
// u32 srcLinearSlot,
// u32 dstContainerGuidLo, u32 dstContainerGuidHi,
// u32 dstLinearSlot,
// int flag); // 0 = normal path
//
// Linear-slot encoding for sources/dests in player invMgr:
// 0..18 paperdoll (1-based slot - 1)
// 19..22 equipped bag containers (bag IDs 1..4 themselves)
// 23..38 backpack contents (1-based bag-0 slot S → 22 + S)
// For sources in a CGContainer (equipped bag B = 1..4), the
// container GUID is the bag's own GUID and srcLinearSlot is
// 0-based within that bag (1-based Lua slot - 1).
//
// This call neither reads nor writes the cursor-state globals at
// [0xBE0810] / [0xBE0814]; cursor visibility is purely a side
// effect of the cursor-pickup path that normally precedes it.
// Calling this directly produces a server-side swap with no
// client-side cursor manipulation.
FUN_INVENTORY_SWAP = 0x005E0C40,
// Sister helper to FUN_INVENTORY_SWAP — packet builder for
// `CMSG_SPLIT_ITEM` (opcode 0x10E). Same __thiscall ABI shape;
// the item-GUID args (param_1, param_2) are unused padding for
// ABI parity. Packet wire format:
// [0x10E, srcBag, srcSlot, dstBag, dstSlot, count]
// where srcBag/dstBag are byte-converted from container GUIDs by
// the same `FUN_005e13b0` helper the swap function uses
// (`0xFF` = INVENTORY_SLOT_BAG_0 / player, `19..22` = equipped bags).
//
// Server semantics are all-or-nothing: any failure
// (insufficient source, dest has different item, dest would
// overflow maxStack) leaves source untouched and emits
// `SMSG_INVENTORY_CHANGE_FAILURE`. No cursor involvement on send
// or response.
//
// Signature:
// void __thiscall(
// CGPlayer *this,
// u32 unused1, u32 unused2, // ABI padding
// u32 srcContainerLo, u32 srcContainerHi,
// u32 srcLinearSlot, // only low byte hits the wire
// u32 dstContainerLo, u32 dstContainerHi,
// u32 dstLinearSlot, // only low byte
// u32 count); // only low byte
FUN_INVENTORY_SPLIT = 0x005E1210,
// Registers a single global Lua function. __fastcall(name, func).
FUN_FRAMESCRIPT_REGISTER_FUNCTION = 0x00704120,
// `FrameScript_Object::ScriptRegister(this, name)` — `__thiscall`,
// `this` = a `CFrameScriptObject *`. On first call (when `this+0x04`
// is zero) builds a Lua wrapper table `{[0] = lightuserdata(this)}`
// with `_G["__framescript_meta"]` as metatable, `luaL_ref`s it into
// the registry, stores the refkey at `this+0x08`. Always increments
// `this+0x04` (the Lua-side refcount). Optional `name` argument
// installs `_G[name] = wrapper` for engine-named frames.
//
// We call this in `PushNamePlateFrame` so the engine and our own
// C_NamePlate getters operate on the **same** wrapper table —
// every push through `lua_rawgeti(REGISTRY, this+0x08)` (the
// canonical engine path) lands on the same Lua object pfUI
// received in `NAME_PLATE_CREATED`, so addon-set fields
// (`plate.nameplate = decoratedButton`) survive engine-side
// re-fetches. Earlier note in `Info.cpp` warned about pinning the
// refcount; for pool-managed nameplates the engine never
// un-registers them anyway, so the pin is benign.
FUN_FRAMESCRIPT_OBJECT_SCRIPT_REGISTER = 0x00701BD0,
// `this+0x04` Lua refcount, incremented by `ScriptRegister`. We
// read it as a "has the engine ever exposed this CObject to Lua"
// probe — equivalent to checking `this+0x08 > 0` but more direct.
OFF_COBJECT_LUA_REFCOUNT = 0x04,
// Direct cvar lookup — `__fastcall(const char *name) → CVar* | NULL`.
// Hash-table by-name lookup over the CVar registry; same call
// `Script_GetCVar` makes internally before the engine wraps the
// result in lua_pushstring + a "CVar doesn't exist" error path.
// Calling it directly lets us skip both the Lua roundtrip and the
// unknown-cvar error — we coerce NULL to false instead, matching
// modern `C_CVar.GetCVarBool` semantics.
//
// The returned struct holds the value string at `+0x20` (read by
// `Script_GetCVar` at `0x00488BF9` as `mov edx, [eax+0x20]; call
// lua_pushstring`). The value is the raw `char *` the engine
// stores; reading it directly is safe for the lifetime of the
// cvar (vanilla cvars don't get re-allocated outside `/console
// set` flows, which we don't race here).
FUN_FIND_CVAR = 0x0063DEC0,
OFF_CVAR_VALUE_STR = 0x20,
// Internal CVar registrar — what `Script_RegisterCVar` calls after a
// `FindCVar` miss (the call at `0x00488B8A`). `__fastcall`; ECX=name,
// EDX is a second string slot the script path leaves 0, then six
// stack args: flags, defaultValue, changeCallback, categoryId,
// hiddenBool, userData. Dedups by name (re-registering OR-merges
// flags + updates the callback), so it's idempotent across `/reload`.
// The new-cvar branch forces flags bit 0 on (`puVar3[7] = flags | 1`),
// which is what makes script-registered cvars persist to Config.wtf.
// See `CVar::Factory` for the wrapper.
FUN_REGISTER_CVAR = 0x0063DB90,
// Internal "apply value" — `__fastcall(cvar /*ecx*/, value, a3, a4,
// a5, a6)`, called by `Script_SetCVar` at `0x00488CA8`. Fires the
// change callback at `[cvar+0xBC]` as
// `char __fastcall(cvar /*ecx*/, prevValue /*edx*/, newValue /*stack*/,
// userData /*stack*/)` — return 0 to REJECT the change, nonzero to
// accept (verified at `0x0063DF7D`).
FUN_SET_CVAR_VALUE = 0x0063DF50,
// CVar struct fields (beyond the value string at +0x20 above).
OFF_CVAR_FLAGS = 0x1C,
OFF_CVAR_CALLBACK = 0xBC,
OFF_CVAR_USERDATA = 0xC0,
// The categoryId the script path passes as the registrar's 6th stack
// arg (the `PUSH 9` in `Script_RegisterCVar`). Cosmetic console
// grouping; we reuse it so our cvars behave like script-registered ones.
CVAR_SCRIPT_CATEGORY = 9,
// Engine-side Lua C functions backing the in-game CVar globals.
// Standard `int __fastcall(void *L)` ABI. We don't register them
// ourselves in-game — the engine already does at boot — but we
// re-register the same pointers on the glue Lua state so login /
// char-select GlueXML can read and write CVars too (vanilla 1.12
// exposes none of these in glue by default). CVar storage is
// process-global, so a write from either state is visible to the
// other.
FUN_SCRIPT_REGISTER_CVAR = 0x00488B00,
FUN_SCRIPT_GET_CVAR = 0x00488BA0,
FUN_SCRIPT_SET_CVAR = 0x00488C10,
FUN_SCRIPT_GET_CVAR_DEFAULT = 0x00488CF0,
// `Script_RunScript` — the C function backing `_G.RunScript(code)`
// in-game. `int __fastcall(void *L)`. Mirrored onto the glue Lua
// state in `src/script/Run.cpp` so GlueXML can also `RunScript("...")`
// — useful for slash-command-style debug helpers at the login /
// realm / char-select screens.
FUN_SCRIPT_RUN_SCRIPT = 0x0048B980,
// Game::ResolveUnitToken — __fastcall(ecx = const char *token) → CGUnit_C *.
// Returns the unit pointer for "player", "target", "party1", etc. Use this
// rather than the global at 0x00B41414 — that global holds something
// related (its +0xC0 has the player GUID) but is NOT the same CGPlayer_C
// pointer the inventory routines expect.
FUN_RESOLVE_UNIT_TOKEN = 0x00515940,
// Set the player's current target to a GUID —
// `__fastcall(uint64_t *guid)`. Validates the GUID resolves to a unit
// (typemask 8) then commits the selection (CMSG_SET_SELECTION +
// client-side target). This is what `Script_TargetUnit` (0x004899D0)
// calls after resolving its token→GUID; we call it directly with a
// GUID we already have (e.g. a totem creature). NOTE: reads `guid[0]`
// (lo) and `guid[1]` (hi) through the pointer.
FUN_TARGET_BY_GUID = 0x00489A40,
// Tab-targeting internals, shared with our backported TargetNearest* /
// TargetDirection* family (`target/Nearest.cpp`).
//
// `FUN_TARGET_CANDIDATE_VALID` (0x00493E40) — the engine's per-mode
// candidate validity predicate used by the native `TargetNearestEnemy`
// / `TargetNearestFriend` cycle. `__fastcall(CGUnit *player /*ecx*/,
// CGUnit *candidate /*edx*/, int mode) → int` (nonzero = valid). Modes:
// 1 = enemy (attackable + alive + not-critter), 2 = friend (assistable +
// alive), 3 = party, 4 = raid. Wraps the reaction cores
// `FUN_00606980` (can-attack) / `FUN_006066f0` (can-assist), so calling
// it gives us the engine's exact hostility semantics for free.
FUN_TARGET_CANDIDATE_VALID = 0x00493E40,
// `FUN_SET_SELECTION_BY_GUID` (0x00493540) — canonical target setter the
// native tab-cycle commits through. `__cdecl(uint32_t guidLo, uint32_t
// guidHi)`. Validates + fires CMSG_SET_SELECTION + client target +
// event 0xC3, and maintains the current-selection globals below.
// Passing {0,0} clears the target.
FUN_SET_SELECTION_BY_GUID = 0x00493540,
// Current target-selection GUID (lo/hi), written by
// `FUN_SET_SELECTION_BY_GUID`. We read it to detect whether the player's
// target changed out from under an in-progress tab-cycle.
VAR_CURRENT_SELECTION_GUID_LO = 0x00B4E2D8,
VAR_CURRENT_SELECTION_GUID_HI = 0x00B4E2DC,
// Local-player CGObject-like global. Not the same pointer as
// ResolveUnitToken("player") returns — that one's the canonical
// CGPlayer_C used by inventory etc. This pointer's +0xC0 field
// holds the local player's 64-bit GUID, and the visible-object
// iterator at FUN_CLNT_OBJ_MGR_ENUM_VISIBLE_OBJECTS walks its
// +0xAC list. Useful for "is this GUID me?" checks without
// round-tripping through Lua. Also a NULL-check proxy for "is
// the object manager initialised" — engine iterators deref this
// unconditionally on entry, so callers must skip on the glue /
// character-select screen.
VAR_LOCAL_PLAYER_PTR = 0x00B41414,
OFF_LOCAL_PLAYER_GUID = 0xC0,
// `__fastcall(ecx = const char *token) → uint64_t GUID` — the
// inner token-to-GUID step that `FUN_RESOLVE_UNIT_TOKEN` calls
// before doing the active-object lookup. Returns the unit's
// GUID without depending on the unit being visible / loaded as
// a CGObject, so `partyN` / `raidN` resolve correctly even when
// the member is out of range or on a different continent
// (`Script_UnitName` uses this path too; that's why `UnitName`
// already works for OOR party members in vanilla).
//
// Internal dispatch:
// - "player" → `[localPlayer + 0x08]` (GUID ptr)
// - "target" → `DAT_00B4E2D8`/`DAT_00B4E2DC` globals
// - "mouseover" → `DAT_00B4E2C8`/`DAT_00B4E2CC` globals
// - "partyN" → `FUN_004E81A0(slot)` → `[VAR_PARTY_GUIDS + slot*8]`
// - "raidN" → `FUN_00491940(slot)` → raid GUID array
// - "partypetN", "raidpetN" similar (pet-slot variants)
// - "<arbitrary name>" → raises "Unknown unit name: %s" via
// the engine's error helper (so this
// still errors on bad tokens — same
// semantics as the existing
// `UnitGUID` documented behavior).
//
// Don't use this from code paths that need to handle literal
// character names — see CLAUDE.md "Resolving input to a name"
// for the `lua_pcall(UnitName)` workaround. For pure unit-token
// input it's the right primitive.
FUN_TOKEN_TO_GUID = 0x00515970,
// `SStrCmpI(a, b, n)` — Storm's case-insensitive memcmp-style
// comparator. **`int __stdcall(const char *a, const char *b, int n)`**
// — the function ends with `ret 0xc`, so the callee pops the
// 3-arg stack frame. Declaring it as `__cdecl` and calling makes
// MSVC emit a redundant `add esp, 12` post-call, drifting ESP
// upward by 12 per call and corrupting the caller's stack frame
// — manifested as a deep-Lua crash whose `L` pointer landed in
// `.text`. Returns 0 when the first `n` characters match
// (ignoring case) or both strings end before `n`.
FUN_SSTR_CMP_I = 0x0064A4C0,
// UNIT_FIELD_TARGET within `m_objectFields` — 64-bit GUID at byte
// offsets +0x28 (lo) / +0x2C (hi). Verified by disassembling
// `FUN_TOKEN_TO_GUID`'s suffix walker at `0x00515A1C-A2C`:
// `mov eax, [obj + 0x110]; mov edi, [eax + 0x28]; mov ebx, [eax + 0x2c]`
// — reads the target GUID to chain `targettarget`-style tokens.
// Distinct from the higher field offsets in the
// `OFF_UNIT_FIELD_*` block; UNIT_FIELD_TARGET is one of the few
// 1.12 offsets that matches the CMaNGOS-documented vanilla
// layout.
OFF_UNIT_FIELD_TARGET = 0x28,
// Owner/controller GUID fields within `m_objectFields`, each a 64-bit
// GUID (lo/hi). Both byte-verified from engine readers:
// CHARMEDBY +0x10 — `Script_UnitIsCharmed`
// (`mov ecx,[eax+0x10]; or ecx,[eax+0x14]; jz`).
// CREATEDBY +0x20 — the unit owner/title builder `FUN_0052FD30`
// reads `[desc+0x20]`/`[+0x24]` as the summoner GUID.
// A pet/guardian/totem's owner lives in CREATEDBY; a charmed unit's in
// CHARMEDBY. `Unit::Pet` reads these to find a minion's player owner.
// (The engine uses only these two for ownership — there's a GUID slot
// at +0x18 too, but nothing reads it as an owner, so it's left out.)
OFF_UNIT_FIELD_CHARMEDBY = 0x10,
OFF_UNIT_FIELD_CREATEDBY = 0x20,
// Pet-vs-minion discriminator for an owned unit: `int __fastcall(unit)`.
// `0x00605570` is really the engine's **creature-type resolver** — it's
// `Script_UnitCreatureType`'s (`0x0051A280`) inner helper and returns the
// `CreatureType.dbc` id (1=Beast, 3=Demon, 7=Humanoid, …), via three
// paths in order: a display-override at descriptor `+0x212`, then the
// creature-cache type at `[unit+0xB30]+0x18`, then the player-race type
// at `ChrRaces[[unit+0x110]+0x78]+0x24`. `FUN_UNIT_CREATURE_TYPE` is the
// canonical name; `FUN_UNIT_PET_MINION_CLASS` is a historical alias for
// the same address.
//
// The pet/minion use: the unit-title builder `FUN_0052FD30` calls it as
// `(fn(unit) != 1) + 1` → 1 = "X's Pet" title, 2 = "X's Minion". That
// works because it's really testing "is this a Beast (type 1)": hunter
// pets are Beasts, warlock minions are Demons (type 3) — so `!= 1`
// cleanly separates them, which neither the GUID (pets and guardians
// share the 0xF14… prefix) nor UNIT_FLAG_PLAYER_CONTROLLED reliably does.
FUN_UNIT_PET_MINION_CLASS = 0x00605570,
FUN_UNIT_CREATURE_TYPE = 0x00605570,
// Party / raid roster counts and the party GUID array referenced
// in the `FUN_TOKEN_TO_GUID` dispatch comment above. Used by
// `UnitTokenFromGUID` to cap its candidate iteration — solo
// players skip all 88 group tokens; a 5-person party scans 4
// slots instead of 40.
//
// - `VAR_PARTY_GUIDS` — 4-slot QWORD array (one GUID per party
// member, low+high dwords). Walked by `Script_GetNumPartyMembers`
// (`FUN_004E86D0`) at `0x004E86D0` to compute the count.
// - `VAR_RAID_MEMBER_COUNT` — single int maintained by the
// engine's raid-roster handler. Read directly by
// `Script_GetNumRaidMembers` (`FUN_004BB530`).
VAR_PARTY_GUIDS = 0x00BC6F48,
PARTY_MAX_SLOTS = 4,
VAR_RAID_MEMBER_COUNT = 0x00B713E0,
RAID_MAX_SLOTS = 40,
// Chat-event dispatcher — single choke point through which all
// CHAT_MSG_* events fire after the SMSG_MESSAGECHAT packet handler
// (opcode 0x96 → FUN_0049D560) parses the wire data. Called with
// the sender GUID as stack args 9 and 10 (lo, hi).
//
// Calling convention: `__fastcall` with 10 args — ECX = sender
// name string, EDX = chat type, then 8 stack args ending in the
// GUID pair. Called from:
// - FUN_0049D560 directly for live (non-throttled) chat
// - The pending-chat queue processor (`__AUPENDINGCHAT`) for
// messages buffered via FUN_0049CAE0 when the engine flag at
// 0x008435FC is set
// - Many synthetic chat synthesizers throughout the codebase
// (system notifications, arena team membership changes, etc.)
// which pass 0 / NULL for the GUID args
//
// Hooked by `Chat::CurrentGUID::ChatDispatch_h` to capture the
// GUID into a global for `GetCurrentChatGUID()` to read during an
// addon's CHAT_MSG_* OnEvent.
FUN_CHAT_DISPATCH = 0x0049A870,
// Per-player inventory manager lives at this offset on the player object.
// +0x00 = u32 slot count (OFF_INVMGR_SLOT_COUNT), +0x04 = u64* GUID
// array (see OFF_INVMGR_GUID_ARRAY below for the slot-range map).
OFF_PLAYER_INVENTORY_MANAGER = 0x1D38,
OFF_INVMGR_SLOT_COUNT = 0x00,
// --- Descriptor-field observer system --------------------------------
// The engine's generic "watch a descriptor field range for changes"
// mechanism (nodes tagged "__AUCMirrorHandler__", 0x30 bytes). The
// registrar attaches a node to the object's per-field observer anchors;
// each node keeps a private MIRROR of the watched bytes, seeded from
// the live value at registration. During SMSG_UPDATE_OBJECT processing
// the dispatcher FUN_00465570 memcmps live vs mirror and invokes the
// callback only on a real change (the mirror is then re-synced by
// FUN_004667A0). Firing engine events from the callback is sanctioned —
// the engine's own bag observer does exactly that.
//
// Registrar — __fastcall(int bank /*ecx*/, uint32_t fieldOffset /*edx*/,
// uint32_t guidLo, uint32_t guidHi, int size, const void *callback,
// void *userArg1, void *userArg2). `guid` selects the watched OBJECT
// (player, item, container, …); `bank` selects its field bank
// (1 = ITEM, 2 = CONTAINER, 4 = PLAYER — the engine's per-bag
// manager FUN_004F91A0 registers bank-2 observers on each equipped
// bag's CGContainer); `fieldOffset` is BANK-relative (container
// SLOT_1 = 8, not its descriptor-absolute 0x20). The engine's
// inventory setup FUN_004F8CC0 registers the player's bag/backpack/
// bank/keyring GUID ranges this way — but NOT equipment.
FUN_DESC_OBSERVER_REGISTER = 0x00467E70,
// Unregister — __fastcall(int bank /*ecx*/, uint32_t fieldOffset
// /*edx*/, uint32_t guidLo, uint32_t guidHi, const void *callback,
// void *userArg1). Removes the node matching (callback, userArg1)
// from that object+field's observer list; harmless no-op when
// nothing matches. What FUN_004F91A0 calls for an unequipped bag.
FUN_DESC_OBSERVER_UNREGISTER = 0x00467FB0,
// Observer callback ABI (verified from the dispatcher's call site at
// 0x004655DC + the engine callback FUN_004F8DB0's RET 0x10):
// int __fastcall cb(uint32_t fieldOffset /*ecx, as registered*/,
// uint32_t size /*edx*/,
// uint32_t guidLo, uint32_t guidHi,
// const uint32_t *oldValue /*the node's mirror*/,
// void *userArg1) → return 1, callee cleans 0x10.
// The live (new) value is NOT passed — read it from the object (the
// engine's bag callback reads the invMgr GUID array).
// The engine's inventory observer setup — registers the bag-slot
// GUID-field observers above, once per enter-world (sole caller is the
// enter-world initializer FUN_004908C0, latched by DAT_00B4B424).
// Player::Equipment co-hooks it to register the equipment-slot
// observers the engine never installs; the co-hook inherits the exact
// engine timing + lifetime (nodes die with the player object).
FUN_INV_OBSERVER_SETUP = 0x004F8CC0,
// PLAYER_FIELD_INV_SLOT_HEAD — first of the 19 equipment-slot u64 GUID
// fields in the player descriptor (0x4A8..0x538, stride 8; 0x540 is
// the first equipped-bag slot). 0-based slot = (offset - 0x4A8) >> 3;
// Lua inventory slot (GetInventoryItemLink etc.) = that + 1.
OFF_DESC_PLAYER_EQUIP_FIRST = 0x4A8,
DESC_PLAYER_EQUIP_SLOTS = 19,
DESC_OBSERVER_BANK_PLAYER = 4,
// ITEM_FIELD_DURABILITY, ITEM-bank-relative: descriptor-absolute
// +0xA0 (field index 0x28, which counts the 6 OBJECT fields) minus
// the 0x18-byte OBJECT prefix. u32.
//
// DEAD END — bank-1 (ITEM field) observers register without error but
// are NEVER invoked: item values-updates demonstrably arrive
// (verified by probing the values pre-pass FUN_00465330) and
// player-bank observers fire in the same session, yet item-bank
// callbacks stay silent. Registration arithmetic was fully verified
// (bank base FUN_00465690(1)=0x18, next-bank walk FUN_004656E0
// item: 0→1→2, anchors match dispatch), so the suspect is the
// registrar's internal wrapper lookup (FUN_00464890 — the observer
// registry, NOT the object manager) silently no-op'ing for item
// objects. UPDATE_INVENTORY_DURABILITY is instead backed by
// FUN_INVENTORY_ALERTS_RECOMPUTE below. Constants kept for the
// investigation trail.
DESC_OBSERVER_BANK_ITEM = 1,
OFF_DESC_ITEM_DURABILITY = 0x88,
// The engine's inventory-alerts recompute — walks the equipment
// slots, reads each item's ITEM_FIELD_DURABILITY / MAXDURABILITY /
// broken flag from the descriptor, fills the per-slot alert table at
// [DAT_00B71F60], and UNCONDITIONALLY fires UPDATE_INVENTORY_ALERTS
// (event 501) at the end. The engine calls it whenever an owned
// item's fields change (the item post-update handler FUN_005D9A90 —
// which also fires UNIT_INVENTORY_CHANGED and the bag-update chain —
// routes every item values-update through it) plus equip and
// enter-world paths. That makes it the engine's own "durability may
// have changed" signal: Player::Equipment co-hooks it and diffs a
// {guid, durability} snapshot per slot to back
// UPDATE_INVENTORY_DURABILITY. void __fastcall(), no args.
FUN_INVENTORY_ALERTS_RECOMPUTE = 0x004C7EE0,
// ItemMgr::GetItemBySlot — __thiscall(this, slot) → CGItem* (NULL if empty).
// Slot is the engine's linearized slot index, not bagID/slot tuple.
FUN_ITEMMGR_GET_ITEM_BY_SLOT = 0x006228A0,
// CGUnit visible-items helper used by `Script_GetInventoryItemLink` for
// non-player units (target/party/inspect targets). __thiscall(this=unit,
// int 0-based slot) → visible-item entry*, or NULL if slot is out of
// [0, 18]. Reads `[unit + 0xE68]` (visible-items array base for the
// unit) and indexes `base + 0x118 + slot * 0x30`. Each 0x30-byte entry
// holds the itemID at `+0x08`; the engine reads it back exactly that
// way before feeding it to `_GetRecord` for hyperlink construction
// (verified in `Script_GetInventoryItemLink` at `0x004C8D05`-`0x4C8D34`).
//
// **Crash hazard**: `[unit + 0xE68]` is uninitialized for NPCs
// (CGCreature_C objects). The helper has no NULL check — it computes
// `garbage + 0x118 + slot*0x30` and returns that as a valid pointer.
// The engine relies on callers to gate this with `UnitPlayerControlled`
// first; we do the same in `Item::InventoryID`.
FUN_UNIT_GET_VISIBLE_ITEM = 0x005F0D60,
OFF_VISIBLE_ITEM_ITEM_ID = 0x08,
// CGUnit m_objectFields pointer offset. Different from CGItem's
// descriptor at +0x114 — these are sibling classes under CGObject
// with class-specific descriptor offsets.
OFF_UNIT_DESCRIPTOR = 0x110,
// CGCreature client-side creature-data cache row. Populated by the
// engine when an NPC GUID becomes visible (the same row the
// `CreatureCache` SMSG fills with the templated NPC's name,
// subname, etc.). NULL for unsynced units or for player CGUnits
// (players don't have a row in this cache — their name comes from
// the SMSG_NAME_QUERY_RESPONSE-fed name cache at `0x00C0E228`).
//
// Layout of the cache row:
// +0x00 ?
// +0x0C name C-string ptr (alias of UNIT_NAME for creatures)
// +0x10 subName C-string ptr ("Innkeeper", "<Master Trainer>", etc.)
// +0x1C CreatureFamily id (→ CreatureFamily.dbc), 0 = none
//
// Used by `Script_UnitName`'s creature path and by VanillaMinimapTracking's
// subname-based blip filter (`src/Blips.cpp::ExtractUnitSubName`).
OFF_UNIT_CREATURE_CACHE_ROW = 0xB30,
OFF_CREATURE_CACHE_SUB_NAME = 0x10,
// CreatureFamily id within the +0xB30 cache row — the value the engine's
// `Script_UnitCreatureFamily` (`0x0051A310`) reads via its family helper
// `FUN_006055e0` (`[unit+0xB30] ? [row+0x1C] : 0`) before mapping it
// through `CreatureFamily.dbc` for the localized name. `UnitCreatureFamilyID`
// returns the raw id. Same field as `OFF_CREATURE_FAMILY` in the creature
// cache data block, reached through the unit here.
OFF_CREATURE_CACHE_FAMILY = 0x1C,
// Pointer to the CGUnit's 8-byte GUID at `*(CGUnit + 0x08)`. Verified
// in `Script_GetInventoryItemLink` at `0x004C8CB0`-`0x004C8CB5`:
// `mov eax, [esi+8]; mov edi, [eax]; mov ecx, [eax+4]` reads the
// GUID's lo+hi dwords through this indirection. CGItem uses the same
// offset for its instance block (also containing a GUID + itemID),
// so the layout is consistent across CGObject subclasses — but the
// contents differ per class.
OFF_UNIT_GUID_PTR = 0x08,
// UNIT_FIELD_FLAGS within m_objectFields. Bit 3 (`0x08`) is
// `UNIT_FLAG_PLAYER_CONTROLLED`, which `Script_UnitPlayerControlled`
// (`0x00516410`) tests via `mov eax, [m_objectFields + 0xA0];
// shr eax, 3; test al, 1`.
// CGUnit m_objectFields current/max stat offsets, **verified
// empirically** on Turtle WoW (1.12.1) by `_classicapi_DescDump`
// searching for the live `UnitMana` value at descriptor offsets:
//
// +0x40 HEALTH (current)
// +0x44 POWER1 (current mana — verified at multiple values)
// +0x48 POWER2 (current rage)
// +0x4C POWER3 (current focus)
// +0x50 POWER4 (current energy)
// +0x54 POWER5 (current happiness)
// +0x58 MAXHEALTH (= 807 at full HP in test data)
// +0x5C MAXPOWER1 (max mana — stays at 1435 even when current = 443)
// +0x60..+0x6C MAXPOWER2..5
// +0x70 LEVEL (= 26 in test data)
// +0xA0 FLAGS (verified separately via `Script_UnitPlayerControlled`)
//
// **The 1.12.1 layout is offset 0x18 (= 6 fields) earlier than the
// CMaNGOS-documented vanilla layout** (which puts HEALTH at field
// 0x16 = +0x58). My initial implementation read MAXHEALTH/MAXMANA
// when I wanted current values — caused `IsUsableSpell` to falsely
// return usable even when mana was below cost. Trust the binary
// (and `_classicapi_DescDump` if you ever need to re-verify), not
// external emulator field tables.
OFF_UNIT_FIELD_HEALTH = 0x40,
OFF_UNIT_FIELD_POWER1 = 0x44,
// POWER1..5 are 4 bytes each, contiguous from +0x44:
// +0x44 mana / +0x48 rage / +0x4C focus / +0x50 energy / +0x54 happiness.
OFF_UNIT_FIELD_MAXHEALTH = 0x58,
OFF_UNIT_FIELD_MAXPOWER1 = 0x5C,
// MAXPOWER1..5 are 4 bytes each, contiguous from +0x5C (same
// mana/rage/focus/energy/happiness order as POWER1..5). Vanilla
// 1.12 has 5 power types; the WotLK additions (Runes / Runic Power)
// don't exist in this descriptor layout.
UNIT_POWER_MIN_TYPE = 0,
UNIT_POWER_MAX_TYPE = 4, // happiness; types 5/6 only valid post-WotLK
// Per-power-type display divisor. Raw descriptor values get
// divided by this before they're surfaced through Lua. Vanilla
// 1.12 stores rage as 0..1000 (internally) and divides by 10 to
// show 0..100; happiness is stored at 1000x scale and divides
// by 1000. Engine reads from `Script_UnitMana` at
// `0x006E7130 + type * 4` (= `0x0086F978`). Same trick the
// 3.3.5/4.x clients use; the table is per-client, the design is
// stable.
//
// [0] = 1 MANA
// [1] = 10 RAGE
// [2] = 1 FOCUS
// [3] = 1 ENERGY
// [4] = 1000 HAPPINESS
VAR_UNIT_POWER_DIVISOR_TABLE = 0x0086F978,
OFF_UNIT_FIELD_LEVEL = 0x70,
// UNIT_FIELD_BYTES_0 dword at +0x78; byte 3 (= +0x7B) is the unit's
// primary power type (one of UNIT_POWER_MIN_TYPE..MAX_TYPE).
// Verified at `0x005179E6` in vanilla's `Script_UnitPowerType`:
// mov edx, [eax + 0x110]
// movzx eax, byte ptr [edx + 0x7B]
OFF_UNIT_DESCRIPTOR_POWER_TYPE_BYTE = 0x7B,
// UNIT_FIELD_STAT0..4 — the fully-computed (base+item+buff) primary
// stats, broadcast in the descriptor. Order Str/Agi/Sta/Int/Spirit;
// STAT4 (Spirit) = fieldIndex 0x94 → +0x250 (from the UpdateField name
// table; cross-checked in-game: descriptor +0x250 read 173→182 when a
// +9-Spirit item was equipped). What GetStat(STAT_SPIRIT) returns
// server-side; used by GetSpellBonusHealing for the Spiritual-Guidance
// (aura 175) spirit→healing conversion.
OFF_UNIT_FIELD_STAT_SPIRIT = 0x250,
// UNIT_FIELD_RESISTANCES[0] = armor (the fully-computed total), fieldIndex
// 0x95 → +0x254 (7 resistances: armor, then the 6 magic schools). What
// GetArmor() / GetResistance(SPELL_SCHOOL_NORMAL) returns; used by
// GetSpellBonusHealing for Turtle's Ironclad (aura 199) armor→healing.
OFF_UNIT_FIELD_RESISTANCE_ARMOR = 0x254,
OFF_UNIT_FIELD_FLAGS = 0xA0,
UNIT_FLAG_PLAYER_CONTROLLED = 0x08,
// Bit 19 of UNIT_FIELD_FLAGS — `Script_UnitAffectingCombat` at
// `0x00517E4A`-`0x517E5C` tests it via `mov eax, [fields+0xA0];
// shr eax, 19; test al, 1`. We use it for `InCombatLockdown`,
// which in 1.12 collapses to "is the local player in combat" — no
// secure-frame system here, so the modern lockdown semantics
// reduce to a plain combat flag check.
UNIT_FLAG_IN_COMBAT = 0x00080000,
// Bit 29 of UNIT_FIELD_FLAGS — set by the engine when the player is
// feigning death (Hunter's `Feign Death`). Standard vanilla
// `UNIT_FLAG_FEIGN_DEATH = 0x20000000` per emulator source. Tested
// by `UnitIsFeignDeath(unit)` — works on any unit since
// UNIT_FIELD_FLAGS is broadcast in object updates.
UNIT_FLAG_FEIGN_DEATH = 0x20000000,
// Bit 24 of UNIT_FIELD_FLAGS — set by the engine when a player is
// possessed (priest's `Mind Control`, warlock's `Subjugate Demon`).
// Standard vanilla `UNIT_FLAG_POSSESSED = 0x01000000` per emulator
// source (CMaNGOS/TrinityCore). Read by `UnitIsPossessed(unit)`.
UNIT_FLAG_POSSESSED = 0x01000000,
// `UNIT_FIELD_CHANNEL_OBJECT` lo/hi (64-bit GUID of the object the
// unit is currently channeling onto — bobber for fishing, lock for
// lockpicking, etc.). CMaNGOS vanilla field 20 (= 0x50) minus the
// 1.12.1 -0x18 unit-fields shift = 0x38. Verified empirically by
// diffing the player descriptor during fishing: 0x38/0x3C went
// `0 → bobber GUID` (high half `0xF110xxxx` = the vanilla
// GameObject-GUID prefix), back to 0 on cast end.
//
// Note: not every channel populates this. The warlock's Ritual of
// Summoning channel leaves it at 0 — that channel binds to the
// participants via the spell, not via UNIT_CHANNEL_OBJECT.
OFF_UNIT_FIELD_CHANNEL_OBJECT = 0x38,
// `UNIT_FIELD_CHANNEL_SPELL` (u32 spell ID the unit is currently
// channeling, or 0). CMaNGOS vanilla field 144 (= 0x240) minus the
// -0x18 shift = 0x228. Verified empirically: the warlock's diff
// shows `0x228 = 0 → 0x2BA` (698 = Ritual of Summoning) for the
// duration of his channel; same value appears on every clicker
// participating in the ritual; fishing populates it with 7620
// (Fishing spell ID). Broadcast UpdateField, so it's readable for
// any visible unit, not just the local player.
OFF_UNIT_FIELD_CHANNEL_SPELL = 0x228,
// Aura arrays in the unit's `m_objectFields` descriptor (at `unit
// + OFF_CGUNIT_OBJECT_FIELDS`). 48 total auras packed as two
// parallel sub-ranges (32 buffs, then 16 debuffs) sharing the
// flags / levels / applications side-arrays indexed by absolute
// slot (0..47). Derived by decompiling `Script_UnitBuff`
// (`0x00519500`) and `Script_UnitDebuff` (`0x005198F0`):
//
// Script_UnitBuff iterates desc[+0xA4 .. +0x124) step 4 (slots 0..31)
// Script_UnitDebuff iterates desc[+0x124 .. +0x164) step 4 (slots 32..47)
// Both read flag nibble at desc[+0x164 + slot/2] >> ((slot&1)*4) & 0xF
// and gate on `(nibble & 0x0E) != 0` (visibility)
// Both read stacks at desc[+0x1AC + slot] and display as `byte + 1`
//
// For our purposes we don't decode individual flag bits — we
// distinguish helpful vs harmful by absolute slot range, and we
// derive `dispelName` from `Spell.dbc[+0x10]` (see
// `OFF_SPELL_DISPEL_TYPE` below), not from the flags nibble.
OFF_UNIT_FIELD_AURA = 0xA4, // u32 spell ID per slot, 48 slots total
OFF_UNIT_FIELD_AURAFLAGS = 0x164, // 4 bits per aura, 2 per byte, covers all 48
OFF_UNIT_FIELD_AURALEVELS = 0x17C, // u8 caster level per aura, 48 bytes
OFF_UNIT_FIELD_AURAAPPLICATIONS = 0x1AC, // u8 (stacks-1) per aura, display value = byte+1
UNIT_AURA_BUFF_COUNT = 32, // slot range 0..31 (helpful)
UNIT_AURA_DEBUFF_COUNT = 16, // slot range 32..47 (harmful)
UNIT_AURA_TOTAL = 48,
UNIT_AURA_VISIBLE_MASK = 0x0E, // nibble mask used by the engine's visibility gate
// PLAYER_FIELD_MOD_DAMAGE_DONE_POS/NEG — the player's per-school spell
// damage bonus. Offsets from the engine's own UpdateField name/index
// table in `.rdata` (20-byte entries `{char* name, u32 fieldIndex, u32
// count, ...}` at VA 0x83B6C8): POS = fieldIndex 0x3F5 count 7 → byte
// offset fieldIndex*4 = 0xFD4; NEG = 0x3FC → 0xFF0. Seven int32 each,
// one per school (0 physical .. 6 arcane); net bonus = POS − NEG.
//
// **Read these off `[player + OFF_CGPLAYER_INFO]` (the +0xE68 CGPlayer
// sub-struct), NOT the broadcast descriptor at +0x110.** The descriptor
// copy is never sent to the client and reads zero (verified in-game: the
// whole post-skills PLAYER descriptor region is zero on a geared L60 —
// vanilla never displayed spell power, so the server doesn't broadcast
// it). The +0xE68 struct holds the client's fully-computed value
// (gear + enchants + buffs + talents + sets baked in). Same base +
// offsets nampower's GetSpellPower uses; verified 613 generic / 647 Fire
// on a geared mage. Read by GetSpellBonusDamage in [src/spell/BonusDamage.cpp].
// (No MOD_HEALING_DONE equivalent — vanilla lacks the field entirely;
// GetSpellBonusHealing is derived instead.)
OFF_PLAYER_FIELD_MOD_DAMAGE_DONE_POS = 0xFD4,
OFF_PLAYER_FIELD_MOD_DAMAGE_DONE_NEG = 0xFF0,
// Reusable "is this spell record a user-visible aura" predicate.
// `__fastcall(spellRecord*) -> bool`. Checks Spell.dbc Attributes
// (high bit of byte at +0x18 must be clear), AttributesEx bit
// 0x10000000 must be clear, has a non-trivial effect (effects at
// +0x16C..+0x174 must contain at least one not in {0x2C, 0x2D,
// 0x97}), and a mechanic-vs-player-immunity-bitmap gate via
// `+0x2B0`. Both `Script_UnitBuff` and `Script_UnitDebuff` call
// it to filter their aura iteration; we call it the same way.
FUN_SPELL_IS_VISIBLE_AURA = 0x00519860,
// Player-only aura timing tables. Unlike UNIT_FIELD_AURA (which is
// populated for any unit but has no timing info), these are the
// local player's own buffs/debuffs with full duration data — the
// server broadcasts cast/duration only for the player's own auras.
//
// VAR_PLAYER_BUFF_TABLE: 48-entry array, 16 bytes each.
// +0x00 (int) slotCode: -1 = empty; 0..31 = buff entry;
// 32..47 = debuff entry. Doubles as the index
// into the expiration table.
// +0x04 (int) spellID — verified via `Script_GetPlayerBuffTexture`
// at `0x004E4740`, which reads `[entry+0x4]` and
// bounds-checks against `[VAR_SPELL_RECORD_COUNT]`.
// +0x0A (byte) flags: bit 0x1 = cancelable
// +0x0C (int) untalented rank — the value `GetPlayerBuff`
// returns as its second result. Not the spellID.
//
// VAR_PLAYER_BUFF_EXPIRATION_TABLE: parallel `int[]` of absolute
// expiration timestamps in ms. Same epoch as `FUN_OS_TICKCOUNT_MS`
// and (verified) Lua's `GetTime()` (which multiplies tickcount by
// 0.001) — so converting `expirationMs * 0.001` gives an absolute
// seconds-value that's directly comparable to `GetTime()` on the
// Lua side. No epoch reconciliation needed.
//
// Sourced from `Script_GetPlayerBuff` (`0x004E45D0`) /
// `Script_GetPlayerBuffTimeLeft` (`0x004E4930`); the
// `FUN_004E4450(buffID)` inner helper does the
// `expirationTable[entry.slotCode] - currentMs` math we mirror.
VAR_PLAYER_BUFF_TABLE = 0x00BC6040,
VAR_PLAYER_BUFF_EXPIRATION_TABLE = 0x00BC5F68,
PLAYER_BUFF_TABLE_COUNT = 48,
PLAYER_BUFF_ENTRY_STRIDE = 16,
OFF_PLAYER_BUFF_SLOT_CODE = 0x00,
OFF_PLAYER_BUFF_SPELL_ID = 0x04,
// CMSG_CANCEL_AURA sender — `__fastcall(int spellID)`. Builds an
// opcode-0x136 packet (`{opcode=0x136, spellID}`) and ships it.
// Used directly by `CancelSpellByID` / `CancelSpellByName` to
// skip `Script_CancelPlayerBuff`'s client-side gates (the
// per-entry cancelable flag at `[+0x0A]` and the fallback
// AttributesEx `0x04` check) and let the server be the source
// of truth for what's cancelable.
//
// **Crash hazard**: bounds-checks `spellID` against Spell.dbc
// count and sets the record pointer to NULL on OOR, then
// unconditionally dereferences `[record + 0x1C]`. Callers MUST
// pre-validate via `Spell::Lookup::RecordForID(spellID)` (which
// also catches empty record slots) before calling.
FUN_CANCEL_AURA_SEND = 0x006E7040,
// `GetTickCount`-style millisecond counter the engine uses as its
// time source. Same value Lua's `GetTime()` reads (scaled by
// 0.001 to seconds). `__fastcall void → uint32_t` (no args, ms
// tick count in EAX).
FUN_OS_TICKCOUNT_MS = 0x0042B790,
// Effective cast time (ms) for a spell, fully resolved:
// `__fastcall uint32_t(int spellID, int unit /*0 = local player*/,
// int flag /*0 = clamp negatives to 0*/)`. Computes
// SpellCastTimes base + level scaling, applies the cast-time
// SpellMod (op 10, via FUN_006e6af0), then multiplies by the
// caster's cast-speed/haste mod (descriptor +0x22c). This is the
// exact helper the engine's own cast-start path (FUN_006ec910)
// uses for the cast-bar end time, so reading it keeps our
// UnitCastingInfo end time in lockstep with the engine. 0 for
// instant / no-cast-time spells.
FUN_GET_CAST_TIME = 0x006E3340,
// Effective power cost (mana/rage/energy/…) for a spell:
// `__fastcall uint32_t(int spellID, int unit /*0 = local player*/)`.
// Computes ManaCost base + per-level + ManaCostPercent-of-resource,
// applies the descriptor power-cost modifiers, then the cost
// SpellMod (op 0xE / 14). 0xFFFFFFFF on invalid input / no player.
// Read by C_Spell.GetSpellPowerCost (the full helper, like the cast
// time one — beats replicating op 14 via Spell::Mod since it also
// folds in the descriptor cost mods).
FUN_GET_SPELL_COST = 0x006E31B0,
// Full spell-castability check for the LOCAL player:
// `char __fastcall(const uint8_t *spellRecord /*ecx*/,
// int *outNoMana /*edx*/)`.
// Resolves the local player internally (no unit arg), then gates
// on casting state, stun/confuse flags, mechanic immunities,
// shapeshift/form + required stances, aura-state requirements,
// combo points (finishers), spell RequiredSkill, and finally the
// power check: `cost(FUN_GET_SPELL_COST) <= currentPower` → usable,
// else sets `*outNoMana = 1`. Returns nonzero (low byte) when
// usable. Does NOT check spell knowledge — so it's valid to feed
// an item's on-use spell record (which the player never "knows").
// This is the helper the action-usability recompute uses for
// player spell slots; `Item::Usable` reuses it for item on-use
// spells. Returns 0 cleanly pre-world (no player).
FUN_SPELL_IS_USABLE = 0x006E3D60,
// Effective spell/channel duration (ms):
// `__fastcall int(const void *spellRecord, int unit /*0 = player,
// nonzero = pet*/, int skipMod /*0 = apply mods*/)`. SpellDuration
// base + level scaling (capped at the row's max), then the duration
// SpellMod (op 1). Same `unit` selector as the cast-time/cost helpers.
// Used for UnitChannelInfo's channel end time. Note: takes the spell
// RECORD pointer, not a spellID.
FUN_GET_SPELL_DURATION = 0x006EA000,
// Pure spell range check against a target:
// `char __fastcall(void *caster /*ecx*/, void *target /*edx*/,
// int spellID, char *outMinMaxFlag)`.
// Computes the spell's min/max range via `FUN_006e3480` (which folds
// in the target's bounding radius), reads both objects' world
// positions (GetPosition, vtable+0x14), and compares center-to-center
// squared distance. Returns low byte 1 = in range, 0 = out (too close
// OR too far); `*outMinMaxFlag` is set to 1 on a max-range (too far)
// failure so the caller can pick a "too close" vs "out of range" error
// string — we ignore it. Both objects must be non-null (it dereferences
// the GetPosition result without a null check). This is the geometric
// core the action-button range coloring uses: `Script_IsActionInRange`
// (`0x004E7550`) → `FUN_004E56F0` → `FUN_006E4440` → here. We call it
// directly for `C_Spell.IsSpellInRange` rather than `FUN_006E4440`,
// which additionally gates on target type and folds "range N/A" into
// the same truthy return as "in range" (so it can't yield true/false/
// nil cleanly).
FUN_SPELL_RANGE_CHECK = 0x006E47B0,
// Spell.dbc `m_durationIndex` field — pointer into SpellDuration.dbc.
// Verified via `FUN_004E44B0` (`0x004e44b0`) and `FUN_006EA000`
// (`0x006ea000`), both of which read `[spellRec + 0x78]` and use
// the result as a SpellDuration.dbc index.
OFF_SPELL_DURATION_INDEX = 0x78,
// Spell.dbc `m_baseLevel` — the spell level used as the anchor in
// `(effLevel - baseLevel) * perLevel + base` scaling. Same offset
// `0x70` as CGUnit's UNIT_FIELD_LEVEL but in a different struct.
OFF_SPELL_BASE_LEVEL = 0x70,
// SpellDuration.dbc — class instance at `0x00C0D820`, records at
// `0x00C0D828`, count at `0x00C0D82C`. Record layout matches the
// SpellCastTimes.dbc shape:
// +0x00 (int) id
// +0x04 (int) base duration ms (signed; negative + perLevel=0
// means "no real duration" / infinite aura)
// +0x08 (int) per-level duration scaling ms
// +0x0C (int) max duration ms (cap)
VAR_SPELLDURATION_RECORDS = 0x00C0D828,
VAR_SPELLDURATION_COUNT = 0x00C0D82C,
OFF_SPELLDURATION_BASE_MS = 0x04,
OFF_SPELLDURATION_PER_LEVEL_MS = 0x08,
OFF_SPELLDURATION_MAX_MS = 0x0C,
// `SMSG_SPELL_GO` inner handler — `void __fastcall(uint64_t *itemGUID,
// uint64_t *casterGUID, uint32_t spellId, CDataStore *packet)`. The
// engine has already decoded item/caster/spell into args; the packet
// read cursor sits at the post-header body (castFlags, hit/missed
// target lists, target mask). This is the ONLY place the client sees
// an aura's *caster* — the unit aura array stores spell IDs but never
// who applied them. `Aura::Source` co-hooks this (alongside nampower,
// which detours the same function) to cache `(targetGuid, spellId) →
// casterGuid` for `C_UnitAuras` sourceUnit + non-player expiration.
// Packet layout mirrored from nampower's SpellGoHook (verified on the
// same Octo/Turtle 1.12.1 client). Per-cast frequency, not per-frame.
FUN_SPELL_GO = 0x006E7A70,
// SMSG packet handler that processes `SMSG_SPELL_START` (opcode
// `0x131`) among others — `int __fastcall(uint32_t unk, uint32_t
// opCode, uint32_t unk2, CDataStore *packet)`. For `0x131` the body is
// `itemGuid(packed), casterGuid(packed), spellId(u32), castFlags(u16),
// castTime(u32), targetMask, …`. This is the only place the client sees
// *another* unit's cast with a server-authoritative cast time, so
// `Spell::Cast` co-hooks it (gated on `opCode == 0x131`) to back
// remote-unit `UnitCastingInfo` / `UnitChannelInfo`. Mirrored from
// nampower's SpellStartHandlerHook.
FUN_SPELL_START_HANDLER = 0x006E7640,
// `SMSG_SPELL_DELAYED` handler — `int __stdcall(uint32_t *opCode,
// CDataStore *packet)`. Body: `guid(u64), delayMs(u32)`. The server
// only sends this to the affected caster — empirically confirmed on
// Turtle (melee-pushback test: only the victim's client received it) —
// so remote units' pushback is NOT recoverable client-side; only the
// local player's cast pushback is trackable. `Spell::Cast` co-hooks it
// to extend the tracked cast's end time so the bar reflects pushback.
// Mirrored from nampower's SpellDelayedHook.
FUN_SPELL_DELAYED = 0x006E74F0,
// `MSG_CHANNEL_START` handler — `int __stdcall(uint32_t *opCode,
// CDataStore *packet)`. Body: `spellId(u32), durationMs(u32)`. Sent
// only to the caster when their channel begins, with the server-
// authoritative duration. `Spell::Cast` co-hooks it to stamp the
// player's channel — required for cast-then-channel spells (Mind
// Control: 3 s cast then 60 s channel), whose SMSG_SPELL_START only
// covers the cast phase. Address + layout mirrored from nampower's
// SpellChannelStartHandlerHook (they hook it too — accepted co-hook
// collision, per-channel-start frequency).
FUN_SPELL_CHANNEL_START = 0x006E7550,
// `SMSG_SPELL_FAILED_OTHER` handler — `int __stdcall(uint32_t *opCode,
// CDataStore *packet)`, same shape as FUN_SPELL_DELAYED. Body:
// `casterGuid(u64, plain), spellId(u32)`. In (v)mangos cores this is
// broadcast to observers when a started cast aborts (interrupt, death,
// movement, fizzle) — but Turtle's core does NOT send it (verified
// in-game: interrupts arrive with neither this nor SMSG_SPELL_FAILURE;
// observers learn of the abort via SuperWoW instead — see
// FUN_UNIT_CLEAR_CASTING_SPELL). `Spell::Cast` co-hooks it anyway as a
// backstop for servers that do send it, invalidating the matching
// remote-cast cache entry (and the player's own server-stamped chained
// recast). Address + packet layout mirrored from nampower's
// SpellFailedOtherHandlerHook.
FUN_SPELL_FAILED_OTHER = 0x006E8E40,
// `SMSG_SPELL_FAILURE` handler — same `int __stdcall(uint32_t *opCode,
// CDataStore *packet)` shape. Body: `casterGuid(u64, plain),
// spellId(u32), result(u8)` — a superset of FAILED_OTHER's with a
// trailing result byte. Decompiled at 0x006E8D80: resolves the caster
// unit (FUN_00468460 typemask 8) and stops its cast visual via the SAME
// unit methods FAILED_OTHER's handler calls (FUN_0060d040 +
// FUN_00614150), plus extra channel/visual cleanup. Servers derived
// from (v)mangos broadcast BOTH packets from Spell::SendInterrupted,
// but which one a given core actually emits per abort path varies —
// `Spell::Cast` co-hooks this one alongside FAILED_OTHER so a remote
// interrupt evicts the cast cache regardless of which sibling arrives.
// nampower calls this SpellFailedHandler (offsets.hpp) but doesn't
// hook it.
FUN_SPELL_FAILURE = 0x006E8D80,
// `CGUnit_C::ClearCastingSpell` — `__thiscall void(CGUnit *unit,
// int spellID, char notify, char cleanup)` (nampower names the offset
// but never hooks it). THE engine choke point for "this unit stopped
// casting": gated on `spellID == [unit+0xC8C]` (the unit's live
// current-cast spellID, set by SMSG_SPELL_START processing), it zeros
// that field and clears the casting flag (bit 0x400 at [unit+0xD58]).
// Ten callers converge here: both failure-packet handlers, the
// SPELL_GO handler (natural completion), the movement handler
// (0x006018f0 — moving units aren't casting), the health-diff handler
// (0x006046f0, death), the unit animation-event dispatcher
// (0x0060e0a0), the local cancel path (0x006e7040, sends
// CMSG_CANCEL_CAST), and Spell_C_SpellFailed. Hooking THIS instead of
// individual packets makes remote-cast eviction independent of which
// packet the server actually sends — load-bearing on Turtle, whose
// core does NOT broadcast SMSG_SPELL_FAILURE / SMSG_SPELL_FAILED_OTHER
// on interrupt (verified: neither handler fires while the victim's
// cast visual demonstrably stops).
FUN_UNIT_CLEAR_CASTING_SPELL = 0x0060D040,
// CGUnit field: the unit's current-cast spellID (0 = not casting).
// The regular-cast analog of OFF_UNIT_FIELD_CHANNEL_SPELL — but a
// plain CGUnit member, NOT a descriptor UpdateField (client-derived
// from SMSG_SPELL_START, not server-broadcast state).
OFF_UNIT_CAST_SPELL = 0xC8C,
// NetClient message dispatch — `__thiscall void(void *conn, uint32_t
// arg, CDataStore *packet)`. Reads the u16 opcode off the packet
// cursor, then invokes `[conn + opcode*4 + 0x74]` (the handler table
// FUN_005ab650 / FUN_00537a60 register into; per-handler userParam
// parallel table at +0xD64). EVERY server message the client processes
// funnels through here (the raw-ingress sibling at 0x00537B10 only
// special-cases 0x1DD compressed-moves before queueing into this).
// Useful as a temporary whole-protocol sniff point: co-hook, peek the
// u16 at the cursor, restore, log.
FUN_NET_MESSAGE_DISPATCH = 0x00537AA0,
// NetClient send — `__thiscall void(void *conn, CDataStore *packet)`.
// The outgoing counterpart of FUN_NET_MESSAGE_DISPATCH: every CMSG the
// client sends funnels through it (the argless wrapper `FUN_005AB630`,
// nampower's ClientServices_Send, resolves the connection singleton
// with the packet in ECX and calls this). The packet's leading u32 is
// the opcode; `m_size - m_read` is what goes on the wire.
// `Aura::ComboDuration` co-hooks it to snapshot combo points the
// moment CMSG_CAST_SPELL leaves — before the server consumes them —
// which also covers nampower-queued casts (they re-enter the engine's
// cast path and send normally, unlike a Spell_C_CastSpell co-hook,
// which nampower's trampoline re-entry would bypass).
FUN_NET_SEND = 0x005379A0,
// Outgoing opcode: CMSG_CAST_SPELL. Body: `spellId(u32),
// targetFlags(u16), <target per flags>`.
OP_CMSG_CAST_SPELL = 0x12E,
// Spell.dbc DurationIndex (column 30) — row into SpellDuration.dbc.
// Offset = 30*4, consistent with the verified neighbors
// (CastingTimeIndex col 18 = +0x48, PowerType col 31 = +0x7C).
OFF_SPELL_RECORD_DURATION_INDEX = 0x78,
// SpellDuration.dbc — records/count slots per docs/DBCs.md. Record:
// `{id@+0, baseMs@+4 (i32), perLevelMs@+8 (i32), maxMs@+0xC (i32)}`.
// Combo-point finishers are exactly the rows with base != max: the
// server computes `base + (max - base) * comboPoints / 5`
// ((v)mangos CalculateSpellDuration — verified against the DBC:
// Rupture 6000/16000 = 6+2*CP, Kidney Shot 1000/6000 = 1+1*CP,
// Slice and Dice 6000/21000 = 6+3*CP, Expose Armor 30000/30000 =
// fixed). NOTE: rows can dangle — Turtle's client DBC has no record
// for Rip's DurationIndex 87 (records[87] == NULL), which is why
// Rip reads duration 0 client-side there.
VAR_SPELL_DURATION_RECORDS = 0x00C0D828,
VAR_SPELL_DURATION_COUNT = 0x00C0D82C,
// Combo points, within the CGPlayer `+0xE68` sub-struct (see
// OFF_CGPLAYER_INFO). Verified from Script_GetComboPoints
// (0x0051A190): CP count byte at `[player+0xE68]+0x1029`, the combo
// TARGET's guid (u64) at `[player+0xE68]+0x838` (compared against
// the current-target global 0x00B4E2D8 before the Lua function
// reports a non-zero count).
OFF_CGPLAYER_COMBO_POINTS = 0x1029,
OFF_CGPLAYER_COMBO_TARGET = 0x838,
// ---- Frame-method registries beyond GameTooltip's ------------------
// Same per-type registry mechanism as VAR_GAMETOOLTIP_METHOD_REGISTRY
// (docs/BlizzardScriptAPI.md "Frame types & their methods" has the
// full 23-table catalogue). The dispatcher resolves methods through
// the type hierarchy, so a method added to the REGION base registry
// (the 19-entry core-layout table: GetWidth/SetPoint/…) is callable
// on every region type — frames, buttons, textures, fontstrings.
// `Frame::Modern` uses these to backport modern API (SetSize,
// SetShown, SetResizeBounds).
VAR_REGION_METHOD_REGISTRY = 0x00CF54B4,
VAR_FRAME_METHOD_REGISTRY = 0x00CF4D38,
VAR_TEXTURE_METHOD_REGISTRY = 0x00CF5434,
VAR_FONTSTRING_METHOD_REGISTRY = 0x00CF5400,
// Engine Script_* method implementations `Frame::Modern` delegates to
// (each `int __fastcall(void *L)`, reading self at stack index 1).
// Addresses from the docs/raw_methods.txt catalogue. Show/Hide are
// PER-BRANCH (Frame vs Texture vs FontString each register their own
// script function with its own object typecheck), so SetShown is
// registered per branch with the matching delegates.
FUN_SCRIPT_REGION_SETWIDTH = 0x007A1F20,
FUN_SCRIPT_REGION_SETHEIGHT = 0x007A2150,
FUN_SCRIPT_REGION_GETWIDTH = 0x007A1E00,
FUN_SCRIPT_REGION_GETHEIGHT = 0x007A2030,
FUN_SCRIPT_FRAME_SHOW = 0x00775750,
FUN_SCRIPT_FRAME_HIDE = 0x00775810,
FUN_SCRIPT_FRAME_SETMINRESIZE = 0x00776020,
FUN_SCRIPT_FRAME_SETMAXRESIZE = 0x007762A0,
FUN_SCRIPT_FRAME_GETSCRIPT = 0x00774780,
FUN_SCRIPT_FRAME_SETSCRIPT = 0x007748D0,
FUN_SCRIPT_TEXTURE_SHOW = 0x0079B770,
FUN_SCRIPT_TEXTURE_HIDE = 0x0079B830,
FUN_SCRIPT_FONTSTRING_SHOW = 0x0079CDB0,
FUN_SCRIPT_FONTSTRING_HIDE = 0x0079CE70,
// ---- World map overlay data (WorldMapOverlay.dbc + WorldMapArea.dbc)
// Backs `C_Map.GetMapOverlays`. Instance VAs per docs/DBCs.md;
// schemas verified against the extracted DBCs AND the engine's own
// reader `Script_GetMapOverlayInfo` (0x004A8A00), which reads the
// same fields for its 7 returns.
//
// WorldMapArea.dbc record (8 fields, 0x20 bytes):
// {ID@+0, mapID@+4, areaID@+8 (AreaTable, 0 for continent rows),
// name@+0xC (char*, the map directory name GetMapInfo returns),
// locLeft/locRight/locTop/locBottom floats}
VAR_WORLDMAP_AREA_RECORDS = 0x00C0D5BC,
VAR_WORLDMAP_AREA_COUNT = 0x00C0D5C0,
OFF_WMA_MAP_ID = 0x04,
OFF_WMA_AREA_ID = 0x08,
OFF_WMA_NAME = 0x0C,
OFF_WMA_LOC_LEFT = 0x10, // world Y at the map's left edge (max Y)
OFF_WMA_LOC_RIGHT = 0x14, // world Y at the map's right edge (min Y)
OFF_WMA_LOC_TOP = 0x18, // world X at the map's top edge (max X)
OFF_WMA_LOC_BOTTOM = 0x1C, // world X at the map's bottom edge (min X)
// AreaTrigger.dbc record (10 fields, 0x28 bytes) — instance cataloged
// in docs/DBCs.md (records slot 0x00C0E034, count 0x00C0E038). The
// client loads it but exposes NO geometry to Lua, which is why map
// addons (pfQuest et al.) ship hand-scraped trigger tables. Schema:
// {ID@+0, mapID@+4 (Map.dbc — continent or instance),
// x@+8, y@+0xC, z@+0x10 (continent-space world coords),
// radius@+0x14 (sphere trigger; 0 => box trigger),
// boxLength@+0x18, boxWidth@+0x1C, boxHeight@+0x20, boxYaw@+0x24}
VAR_AREATRIGGER_RECORDS = 0x00C0E034,
VAR_AREATRIGGER_COUNT = 0x00C0E038,
OFF_AT_MAP_ID = 0x04,
OFF_AT_X = 0x08,
OFF_AT_Y = 0x0C,
OFF_AT_Z = 0x10,
OFF_AT_RADIUS = 0x14,
OFF_AT_BOX_LENGTH = 0x18,
OFF_AT_BOX_WIDTH = 0x1C,
OFF_AT_BOX_HEIGHT = 0x20,
OFF_AT_BOX_YAW = 0x24,
// WorldMapOverlay.dbc record (17 fields, 0x44 bytes):
// {ID@+0, worldMapAreaID@+4 (-> WorldMapArea row),
// areaID[4]@+8..+0x14 (AreaTable ids the overlay reveals),
// mapPointX@+0x18, mapPointY@+0x1C, textureName@+0x20 (char*,
// bare name), textureWidth@+0x24, textureHeight@+0x28,
// offsetX@+0x2C, offsetY@+0x30, hitRect@+0x34..+0x40}
// The engine's Lua surface only exposes EXPLORED overlays: the
// discovered-overlay ID list at 0x00B6E630 (count 0x00B6E6B4) gates
// Script_GetMapOverlayInfo. Reading the DBC directly bypasses the
// exploration gate — every overlay of a zone, explored or not.
VAR_WORLDMAP_OVERLAY_RECORDS = 0x00C0D594,
VAR_WORLDMAP_OVERLAY_COUNT = 0x00C0D598,
OFF_WMO_WORLDMAP_AREA = 0x04,
OFF_WMO_AREA_ID = 0x08, // areaID[4] @ +0x08..+0x14 (AreaTable ids revealed)
OFF_WMO_MAP_POINT_X = 0x18,
OFF_WMO_MAP_POINT_Y = 0x1C,
OFF_WMO_TEXTURE_NAME = 0x20,
OFF_WMO_TEXTURE_WIDTH = 0x24,
OFF_WMO_TEXTURE_HEIGHT = 0x28,
OFF_WMO_OFFSET_X = 0x2C,
OFF_WMO_OFFSET_Y = 0x30,
OFF_WMO_HITRECT_TOP = 0x34, // hit rect in world-map canvas px (~1002x668):
OFF_WMO_HITRECT_LEFT = 0x38, // the tight clickable bounds of the landmass,
OFF_WMO_HITRECT_BOTTOM = 0x3C, // used for subzone-center placement (pfQuest's
OFF_WMO_HITRECT_RIGHT = 0x40, // pfDB["zones"] was scraped from these)
// Current world-map view selection — the globals the engine's
// current-map-name resolver (FUN_004a6cf0, behind GetMapInfo) reads:
// continent index, zone index (-1 = whole continent), the default
// WorldMapArea row used when no continent is selected, and the
// per-continent data blob (base ptr; stride 0x10024 per continent,
// continent's own WMA row at +0x04, per-zone WMA row array ptr at
// +0x10).
VAR_WORLDMAP_CONTINENT_INDEX = 0x0084506C,
VAR_WORLDMAP_ZONE_INDEX = 0x00845070,
VAR_WORLDMAP_DEFAULT_AREA_ROW = 0x00845074,
VAR_WORLDMAP_CONTINENT_DATA = 0x00B6E668,
WORLDMAP_CONTINENT_STRIDE = 0x10024,
// `Script_SetPoint` — the ONE SetPoint implementation, registered in
// the Region base table and inherited by every region type. Vanilla's
// parser accepts (point, region), (point, region, relPoint[, x, y]),
// (point, x, y), and even an explicit nil region — but NOT the bare
// one-arg form (`fs:SetPoint("RIGHT")`): a fully-omitted arg 3 is
// LUA_TNONE, which fails the string/table/number/nil check and raises
// the usage error. Modern clients accept it (anchor to parent at the
// same point, zero offsets). `Frame::Modern` co-hooks this and
// normalizes the one-arg call to (point, 0, 0) — the vanilla
// (point, x, y) form, which is parent-relative and thus exactly the
// modern semantic.
FUN_SCRIPT_REGION_SETPOINT = 0x007A2540,
// `CGUnit_C::OnAuraAdded` — `__thiscall void(CGUnit *unit, uint32_t
// slot, uint32_t spellId)` (i.e. `__fastcall(unit /*ecx*/, edx_unused,
// slot, spellId)`). Fires for EVERY aura that lands on a tracked unit,
// including proc/triggered auras that never produce an `SMSG_SPELL_GO`
// (Shadow Weaving, etc.). `Aura::Source` co-hooks it to stamp
// expiration for those — it carries no caster, so it fills timing only
// and never overwrites an entry `SpellGo` already owns. Per-aura-change
// frequency. nampower hooks the same function (its BUFF/DEBUFF events).
FUN_ON_AURA_ADDED = 0x006123F0,
// `CGUnit_C::OnAuraStacksChanged` — `__thiscall void(CGUnit *unit, int
// slot, uint8_t stackCount)` (`__fastcall(unit, edx_unused, slot,
// stackCount)`). Fires when an existing aura's stack count changes
// without a fresh add — e.g. Shadow Weaving climbing 2→3. The slot's
// spellID is read from the unit aura array (`OnAuraAdded` gets it as an
// arg; here only the slot is given). `Aura::Source` co-hooks it to
// re-stamp expiration so stacking-DoT refreshes are picked up.
FUN_ON_AURA_STACKS_CHANGED = 0x00612450,
// `CGUnit_C::OnAuraRemoved` — same ABI as `OnAuraAdded`
// (`__fastcall(unit /*ecx*/, edx_unused, slot, spellId)`; the disassembly
// of the diff dispatcher `FUN_00604d00` at the call site `0x00604dc4`
// shows `ECX = unit`, stack `[slot, spellId]`). The sibling of
// `OnAuraAdded`: `FUN_00604d00` fires this when a descriptor aura slot
// goes from occupied to empty — a genuine removal (fell off, dispelled,
// or replaced by a higher rank, which fires Removed(old)+Added(new)).
// `Aura::Source` co-hooks it to EVICT the cached entry so the
// `GetAuraDataByIndex` fallback can't resurrect a superseded/dispelled
// aura that's still inside its computed duration window.
FUN_ON_AURA_REMOVED = 0x00612320,
// Group-loot roll packet handlers (the inner display functions in
// LootRoll.cpp). Each is `__fastcall`; the deserialized 0x48-byte
// PendingLootRoll message struct is fully populated at entry and freed
// at exit, so read its fields BEFORE calling the original. The register
// the message arrives in differs per handler (matched in
// loot/History.cpp): ROLL passes it in ECX, WON / ALL_PASSED in EDX.
// Backs the C_LootHistory backport (loot/History.cpp) — 1.12 has no
// loot-history store, so we reconstruct one from these packets.
FUN_LOOT_ROLL_HANDLER = 0x0061C0B0, // SMSG_LOOT_ROLL (msg=ECX)
FUN_LOOT_ROLL_WON_HANDLER = 0x0061B9E0, // SMSG_LOOT_ROLL_WON (msg=EDX)
FUN_LOOT_ALL_PASSED_HANDLER = 0x0061B640, // SMSG_LOOT_ALL_PASSED (msg=EDX)
// SMSG_LOOT_START_ROLL (opcode 0x2A1) handler — `__fastcall(ECX = packet)`,
// RET 0. The result packets (ROLL/WON/PASSED) carry 0 for the item's
// random suffix/seed; only START_ROLL does. It deserializes a fresh
// PendingLootRoll node (same 0x20/0x24 field offsets as the message) and
// publishes it as the store head at VAR_LOOTROLL_STORE_HEAD, so we read
// the suffix straight off that node right after the original runs.
FUN_LOOT_START_ROLL_HANDLER = 0x0061B310,
VAR_LOOTROLL_STORE_HEAD = 0x00C4DC00, // PendingLootRoll* — newest node
// PendingLootRoll message field offsets, derived from the SMSG_LOOT_ROLL
// deserializer FUN_0061BFA0 (reads GUID/u32/byte fields off the packet).
OFF_LOOTROLL_SOURCE_GUID = 0x10, // u64 looted-object GUID (roll identity)
OFF_LOOTROLL_SLOT = 0x18, // u32 loot slot
OFF_LOOTROLL_ITEM_ID = 0x1C, // u32 itemID
// Random-enchant fields for the item link `item:id:enchant:suffix:unique`.
// +0x20 is the suffix/random-property ID the engine's item-name builder
// FUN_005D8B00 uses (indexes the random-properties DBC for the "of the X"
// name); +0x24 is the paired seed/unique value.
OFF_LOOTROLL_ITEM_SUFFIX = 0x20, // i32 random suffix / property ID
OFF_LOOTROLL_ITEM_SEED = 0x24, // u32 random seed (link unique field)
OFF_LOOTROLL_ROLLER_GUID = 0x30, // u64 roller / winner GUID
OFF_LOOTROLL_ROLL_NUM = 0x38, // u8 roll (1..100); high bit = didn't roll
OFF_LOOTROLL_ROLL_TYPE = 0x40, // u32 rollType: 0 = need, 2 = greed
// CGPlayer-side sub-struct, allocated for any player-controlled
// unit (local self, target, party, raid, inspect targets — all of
// them). Holds player-specific data that's *not* in the broadcast
// UpdateField descriptor:
//
// +0x08 uint32 PLAYER_FLAGS (AFK = bit 1, DND = bit 2,
// RESTING = bit 5)
// +0x118 + slot*0x30 visible-items table (slots 0..18,
// walked by FUN_UNIT_GET_VISIBLE_ITEM)
//
// Same offset works for any player; the visible-items helper and
// `UnitIsAFK`-style flag readers share the same `[unit + 0xE68]`
// pointer. NPCs / CGCreature_C objects have this slot
// *uninitialized* — reading without a `UNIT_FLAG_PLAYER_CONTROLLED`
// gate is a known crash path (helper does `garbage + 0x118 +
// slot*0x30` then derefs).
//
// Flag bits verified by:
// - `Script_IsResting` (`0x00516EA0`): `[CGPlayer + 0xE68] +
// 0x08`, `shr 5; test 1` → bit 5 = RESTING (0x20).
// - Nameplate AFK renderer (`0x005EC9E0`): `[unit + 0xE68] +
// 0x08`, `test [+8], 2` → bit 1 = AFK (0x02). Works for ANY
// unit, not just local player — confirmed by user testing
// `<AFK>` rendering above other players' heads on stock 1.12.
// - DND bit by symmetry with chat-flag protocol; confirmed in-game.
//
// PLAYER_FLAGS being out-of-band (in this sub-struct rather than a
// broadcast UpdateField) is a vanilla-only quirk — modern WoW
// (3.0+) added PLAYER_FLAGS as a UpdateField at descriptor +0x228.
// In 1.12, descriptor +0x228 is repurposed as UNIT_CHANNEL_SPELL
// (see OFF_UNIT_FIELD_CHANNEL_SPELL below); PLAYER_FLAGS only
// exists on the +0xE68 sub-struct here.
OFF_CGPLAYER_INFO = 0xE68,
// Explored-areas bitfield inside the CGPlayer info sub-struct
// (`[player+0xE68] + 0xE6C`): bit `AreaBit` set == that AreaTable area
// is explored. 0x100 bytes. Read by the discovered-overlay rebuild
// FUN_004a67a0 as `bits[AreaBit>>3] & (1 << (AreaBit&7))`.
OFF_PLAYER_EXPLORED_BITS = 0xE6C,
// PvP rank fields within the CGPlayer +0xE68 sub-struct (siblings of
// the combo-point byte at +0x1029). Read by the item tooltip's
// "Requires <rank>" / PVP_MEDAL red-text logic (FUN_0052B650) and
// mirrored by C_PlayerInfo.CanUseItem:
// +0x102B u8 current PvP honor rank (compared >= item
// RequiredHonorRank).
// +0x1034 u32 earned PvP-medal/rank bitmask (item RequiredCityRank
// R passes when bit (R-1) is set).
OFF_CGPLAYER_HONOR_RANK = 0x102B,
OFF_CGPLAYER_PVP_MEDALS = 0x1034,
// CGObject's `GetPosition` virtual — vtable slot 5 (offset 0x14).
// Signature: `__thiscall(this, float outBuf[3]) → float *position`.
// The returned float* may equal outBuf (the object filled it
// directly) or point at a cached position field on the object
// (CGPlayer keeps its own copy). Either way, dereference the
// pointer for x/y/z. Used by `Script_CheckInteractDistance` for
// its squared-distance compute; same vtable layout for CGUnit,
// CGPlayer, CGGameObject, etc. since they share the CGObject
// base. Bytes verified via the call-site disassembly at
// `0x0048BACF` / `0x0048BADC`.
OFF_CGOBJECT_VTBL_GET_POSITION = 0x14,
// CGUnit movement-block orientation (facing) in radians, 0..2*pi. Lives
// right after the {x,y,z} position block (at +0x9B8), i.e. pos+0xC. The
// `GetPosition` virtual copies only x/y/z into the caller's buffer, so
// read facing off the object directly. Backs `GetPlayerFacing`. Empirically
// located by probing the player object across a known 180-degree turn
// (value flipped by ~pi, stayed in range); mirrored at +0x9F8 / +0xC98
// (last-sent / render copies) — +0x9C4 is the authoritative one.
OFF_UNIT_FACING = 0x9C4,
// CGObject `m_objectType` field — 0 = (base) object, 1 = item,
// 2 = container, 3 = unit, 4 = player, 5 = gameobject, … Read as
// `*(int *)(obj + 0x14)`. (Distinct from GET_POSITION above, which
// is a *vtable* byte-offset that happens to also be 0x14.)
OFF_CGOBJECT_TYPE_ID = 0x14,
OBJECT_TYPE_UNIT = 3,
OBJECT_TYPE_PLAYER = 4,
// World line-segment collision test (client-side LoS core):
// `char __fastcall(const Vec3 *start /*ecx*/, const Vec3 *end /*edx*/,
// int unused, Vec3 *hitOut, float *tOut, uint32 flags)`.
// Returns nonzero if the ray hit world geometry; `*tOut` is the hit
// fraction along start→end (t in [0,1] ⇒ hit lies between the two
// points ⇒ blocked; t outside [0,1] or no hit ⇒ clear). `flags`
// selects geometry: 0x100111 = terrain + WMO (the LoS combo;
// 0x100171 also tests M2 doodads but crashes in some dungeons per
// UnitXP_SP3). Thin `__fastcall` shim that tail-calls the real
// intersect `FUN_0069BFF0`; verified in-binary and cross-checked
// against UnitXP_SP3's `CWorld_Intersect` (same VA + flags).
FUN_CWORLD_INTERSECT = 0x00672170,
// Collision-box height of a unit, read from its CMovement sub-struct
// (`[unit + OFF_UNIT_MOVEMENT_INFO_PTR]`) at `+0xB4`. Used as the
// eye-height offset for LoS so foot-to-foot traces don't false-block
// on terrain. (CMovement pointer offset 0x118 = OFF_UNIT_MOVEMENT_INFO_PTR.)
OFF_CMOVEMENT_COLLISION_BOX_HEIGHT = 0xB4,
// Quest list array inside the `+0xE68` sub-struct. 20 fixed
// slots of 0xC (12) bytes each — `questID` at slot+0x00, and
// some flags/state in the remaining 8 bytes. Walked by
// `Script_IsUnitOnQuest` (`0x004DFE10`) which iterates by byte
// offset over `[0, 0xF0)` with `0xC` stride and compares each
// entry's `+0` against the target questID. The engine writes
// this from `SMSG_QUESTGIVER_QUEST_DETAILS` / quest sync packets,
// so it covers any synced player-controlled unit (self + nearby
// party / raid in sync range), not just the local player.
//
// **Crash hazard**: same as visible items at `+0x118` — for NPCs
// (CGCreature_C objects) the `+0xE68` slot is uninitialized.
// Callers MUST gate on `UNIT_FLAG_PLAYER_CONTROLLED` before
// dereferencing. The engine's `Script_IsUnitOnQuest` is protected
// because its GUID-by-type filter (`FUN_00468460(0x10, ...)`)
// rejects non-player GUIDs upstream; `FUN_RESOLVE_UNIT_TOKEN`
// doesn't have that filter, so we gate explicitly.
OFF_CGPLAYER_INFO_QUEST_LIST = 0x28,
CGPLAYER_INFO_QUEST_LIST_STRIDE = 0xC,
CGPLAYER_INFO_QUEST_LIST_MAX = 20,
OFF_PLAYER_INFO_FLAGS = 0x08,
PLAYER_FLAG_AFK = 0x02,
PLAYER_FLAG_DND = 0x04,
// Guild-key field on the CGPlayer sub-struct. Verified by
// disassembling `Script_GetGuildInfo` at `0x004C9330`: after
// resolving the unit and checking the GUID-is-player bit, the
// function reads `mov ecx, [edi+0xE68]; mov ecx, [ecx+0x0C]` —
// if the value is 0, returns nil; otherwise passes it as the
// first arg to the guild cache lookup at `0x00560D30`. Two
// players in the same guild end up with the same value here
// (the cache key uniquely identifies a guild record), so
// `UnitIsInMyGuild` can compare this field between `"player"`
// and the input unit when the data is loaded — sidestepping the
// roster fetch requirement entirely for visible units.
//
// Populated immediately for the local player on guild join, and
// for any other player-controlled unit whose `+0xE68` sub-struct
// the engine has synced (party members, raid members, the
// current target, etc.). For unsynced units it reads 0.
OFF_PLAYER_INFO_GUILD_KEY = 0x0C,
// Guild roster — the per-character cache populated by
// SMSG_GUILD_ROSTER. `[VAR_GUILD_ROSTER_PTR]` is `GuildMember **`
// (a heap-allocated array of pointers), indexed `[0..total-1]` where
// total = `[VAR_GUILD_ROSTER_TOTAL_COUNT]`. Includes offline
// members — the "show offline" UI toggle controls what
// `GetNumGuildMembers()` returns by default and how the roster
// panel renders, but the underlying array always holds every
// member the server sent. Entries can still be NULL for other
// reasons (e.g. pending refresh), so null-check per entry.
//
// Verified by disassembling `Script_GetGuildRosterInfo` at
// `0x004D1200`:
// mov ecx, [0x00B73118] ; count
// cmp eax, ecx; jae bail
// mov edx, [0x00B72704] ; roster base
// mov edi, [edx+eax*4] ; entry = roster[idx]
// test edi, edi; je bail
// lea edx, [edi+8]; call lua_pushstring ; name at +0x08 (inline char[])
//
// Other GuildMember fields the engine pushes from the same loop:
// +0x38 int level
// +0x3C int classIndex
// +0x44 int rankIndex
// (We don't read these, but they're verified in the same function.)
//
// The companion `[0x00B7311C]` global is the online-only count
// (returned by `GetNumGuildMembers()` when called with no args).
// The roster array spans the full total — both counts share the
// same backing storage; online vs. total only affects the iteration
// bound the Lua API uses, not the underlying array.
VAR_GUILD_ROSTER_PTR = 0x00B72704,
VAR_GUILD_ROSTER_TOTAL_COUNT = 0x00B73118,
OFF_GUILD_MEMBER_NAME = 0x08,
// PackBagSlot — __fastcall(L, void **outInvMgr, int *outLinearSlot, int *outUnused) → bool.
// Reads bagID at Lua stack[1] and slot at stack[2], validates them, and
// returns the inventory manager + linear slot ready to feed into GetItemBySlot.
FUN_PACK_BAG_SLOT = 0x004F9820,
// Equipped-bag container-GUID getter — `uint64 __fastcall(uint bagIndex0)`
// where `bagIndex0` is 0-based (Lua bagID 1..4 → 0..3; 4..9 are bank bags,
// gated on the bank-open globals). Returns the CGContainer GUID of the bag
// equipped in that slot, or 0 if none. This is the internal PackBagSlot
// uses to resolve bags 1..4: get the bag GUID here, resolve the container
// via FUN_OBJECT_RESOLVE_BY_GUID(OBJ_TYPE_CONTAINER, guid), then call the
// container's vtable[+OFF_CONTAINER_GET_INVENTORY] to get the inventory
// object GetItemBySlot indexes. Lets us enumerate bag contents in pure C++
// without PackBagSlot's Lua-stack coupling. (Reads GUID arrays at
// 0x00BDD060 lo / 0x00BDD064 hi, stride 8.)
FUN_GET_EQUIPPED_BAG_GUID = 0x004F93E0,
// CGContainer vtable slot (byte offset into the vtable) whose method
// returns the container's inventory object — `void* __thiscall(container)`.
// The inventory object's slot count lives at its +0x00 (OFF_INVMGR_SLOT_COUNT).
OFF_CONTAINER_GET_INVENTORY = 0x10,
// Backpack (bagID 0) linear-slot base in the player invMgr GUID/item
// arrays: a 1-based backpack slot S maps to linear (S - 1) + 23. Matches
// PackBagSlot's `*param_3 += 0x17` for the backpack branch.
BACKPACK_LINEAR_BASE = 23,
// Player inventory manager layout — used for direct GUID-array reads
// that bypass `GetItemBySlot`'s bank gate at `0x006228C1`.
// +0x00 uint32 max slot count
// +0x04 uint64* pointer to a flat GUID array, indexed by linear slot
// (8 bytes per slot — low dword + high dword)
// +0x10 uint8 "bank-aware mode" flag (engine-internal; gates the
// slot-range checks in `GetItemBySlot`'s validation
// path)
// Slot ranges, matching `PackBagSlot`'s linearization:
// 0..22 equipment / paperdoll
// 23..38 backpack (16 slots)
// 39..62 main bank (24 slots)
// 63..68 bank bag SLOTS (the bag items themselves; the bag CONTENTS
// live in each equipped bag's own invMgr, reachable via the
// bag's vtable +0x10)
// 81+ keyring
//
// **Bank slots are populated from server data at login** (verified
// empirically on Turtle WoW: fresh login + cleared WDB folder shows
// bank GUIDs already populated in slots 39..62, with the gate at
// `VAR_BANK_GATE_GUID` = 0). The gate doesn't hide data missing —
// it hides data that's present from boot. Reading the GUID array
// directly recovers it without ever opening the bank window.
OFF_INVMGR_GUID_ARRAY = 0x04,
INVMGR_BANK_MAIN_FIRST_SLOT = 39,
INVMGR_BANK_MAIN_LAST_SLOT = 62,
INVMGR_BANK_BAG_FIRST_SLOT = 63,
INVMGR_BANK_BAG_LAST_SLOT = 68,
// Engine's `ObjectMgr::Get`-style resolver — given a type and GUID,
// returns the resolved CGObject pointer (or null). Same function the
// engine itself uses inside `GetItemBySlot` (called at `0x00622904`)
// and `PackBagSlot` (called at `0x004F98E2`). We invoke it directly
// for bank slots so we sidestep the banker-GUID gate that
// `GetItemBySlot` applies for slots 39..68 — the GUIDs in
// `invMgr+0x04` are populated at login, only the gate gets toggled
// by bank-window state.
//
// __fastcall(int type, const char *debugName, u32 guidLo,
// u32 guidHi, int priority) → void *
//
// Type values: 2 = item (returns CGItem*), 4 = container/bag
// (returns CGContainer*). Engine passes `"ItemMgr"` as debugName
// and `0x172` as priority for both call sites we've decoded.
FUN_OBJECT_RESOLVE_BY_GUID = 0x00468460,
// The type arg is a bitmask of object-type bits, not an enum
// index — `1<<1` for items, `1<<2` for containers, `1<<3` for
// units, matching what `FUN_00529FE0` passes for SetUnit (`ECX=8`).
OBJ_TYPE_ITEM = 2,
OBJ_TYPE_CONTAINER = 4,
OBJ_TYPE_UNIT = 8,
OBJ_TYPE_PLAYER = 0x10, // what the engine's bag observer FUN_004F8DB0 passes
OBJ_TYPE_GAMEOBJECT = 0x20, // 1<<5; passed by FUN_0052AA20 (hover-tooltip populator).
// `CGObject::GetName` — returns the display-name `const char *` for
// a resolved CGObject (CGUnit / CGPlayer / CGCreature). Internally
// does a NameCache lookup for players and reads the creature-info
// cache for NPCs; falls back to `"UNKNOWNOBJECT"` / `"Unknown Being"`
// when neither resolves. The same path `FUN_00609370` (the wrapped
// "name + PvP-rank decoration" helper used by the SetUnit tooltip
// builder) calls internally.
//
// __thiscall const char *(void *obj, int *outFlags /* may be 0 */)
//
// Caller-owned `outFlags` receives metadata about the lookup; we
// pass `nullptr` since we just want the name.
FUN_OBJECT_GET_NAME = 0x00609210,
// `CGGameObject_C::GetName` — gameobject-specific name getter.
// Returns `*(obj+0x214)+0x08` (the cached GameObjectStats_C record's
// name field) if the record has loaded, or the engine's empty-string
// sentinel `DAT_00882748` otherwise. Used by the hover tooltip
// populator at FUN_0052AA20.
//
// __fastcall const char *(void *gameObject)
//
// The polymorphic `FUN_OBJECT_GET_NAME` above is unit-cache-only
// (routes through NameCache / creature cache) and returns the
// "UNKNOWNOBJECT" sentinel for gameobjects.
FUN_GAMEOBJECT_GET_NAME = 0x005F8100,
// Bank gate. The engine writes the active banker NPC's GUID here
// when the bank window opens (8-byte qword) and zeroes it on close.
// `GetItemBySlot` returns null for slots 39..68 if this GUID is zero,
// even though the slot data in `invMgr+0x04` remains populated.
// Bypassed in the direct-read bank path; informational only otherwise.
VAR_BANK_GATE_GUID = 0x00BDD038,
// `Script_UseContainerItem` Lua C function — `__fastcall(void *L)`.
// Reads bagID at Lua stack[1] and slot at stack[2], dispatches to the
// engine's item-use machinery (same path the secure
// `tooltip:Click()` / `UseContainerItem(...)` flow takes from
// Lua). We invoke this from `C_Container.UseHearthstone` after
// locating the hearthstone in bags.
FUN_SCRIPT_USE_CONTAINER_ITEM = 0x004FA0E0,
// Vanilla 1.12 hearthstone is always itemID 6948 and uses spell 8690
// ("Hearthstone" - 10-second cast, teleport to bind). Modern WoW
// recognizes many hearthstone-equivalent toys (Garrison, Dalaran,
// etc.) but those items don't exist in 1.12. Custom servers
// (Turtle WoW and similar) sometimes ship alternate hearthstone
// items that reuse spell 8690 as their on-use, so the hearthstone
// matcher OR's `itemID == HEARTHSTONE_ITEM_ID` against
// `OnUseSpellIDForItemID(itemID) == HEARTHSTONE_SPELL_ID` to catch
// both shapes.
HEARTHSTONE_ITEM_ID = 6948,
HEARTHSTONE_SPELL_ID = 8690,
// `Script_PickupContainerItem` Lua C function — `__fastcall(void *L)`.
// Reads bagID at Lua stack[1] and slot at stack[2]; if an item is
// present there, it goes onto the cursor (or, if cursor already holds
// an item, swaps with the bag slot). Used by `EquipItemByName` to
// pick up the source item before dispatching to the equip helpers.
FUN_SCRIPT_PICKUP_CONTAINER_ITEM = 0x004F9B30,
// Container-content cursor-pickup PRIMITIVE — the plain-pickup branch
// inside `Script_PickupContainerItem`'s state machine, called directly
// (no Lua stack, no state-machine modes).
// void __fastcall(uint linearSlot, int count, uint itemGuidLo,
// uint itemGuidHi, uint containerGuidLo,
// uint containerGuidHi, int flag)
// Self-resolves the player, sets the cursor-state globals
// (VAR_CURSOR_ITEM_GUID_*, cursor type = 1) and fires the cursor-update
// event itself. Does NOT apply the cursor-empty / item-lock guards the
// Script wrapper does — callers replicate those (Item::Cursor::PickupBagItem).
FUN_CURSOR_PICKUP_ITEM = 0x00494B60,
// `CGItem::UseItem` — the engine's actual "use this item" primitive.
// It's the fallback dispatch in `Script_UseContainerItem` (the call
// site at 0x004FA430 after every special-cursor-mode branch is
// skipped), and the function `Script_UseContainerItem` ends up at
// for normal hearthstone-style / potion / food / scroll use. We
// call it directly from `UseItemByName` so we don't pay a
// Lua-stack roundtrip just to re-find the item the engine already
// points us at.
//
// Internally dispatches by item flags / fields:
// - off-target-pickup items (flag 0x200) → FUN_005EDEA0/FUN_005EDD60
// - bind-on-pickup confirmation needed → FUN_004E32E0
// - food items (flag 0x4) → FUN_005EDC80
// - quiver/ammo (flag 0x2000) → FUN_005EEF40
// - default (potions, hearthstone, scrolls, …) → FUN_006E5A90
//
// __thiscall uint(CGItem *item, const uint64_t *targetGuid,
// int flag)
//
// `targetGuid` is a pointer to a 64-bit GUID — for self-use items
// the engine substitutes the player itself even if a different
// target is passed, so passing zero (no target) is fine for most
// items. `flag` is 0 in every Script_UseContainerItem call site.
FUN_ITEM_USE = 0x005D8D00,
// `CGPlayer::AutoEquipCursorItem` — `__thiscall(CGPlayer *this, int flag)`.
// The engine-internal helper that `Script_AutoEquipCursorItem`
// (`0x0048A040`) is a thin wrapper around: that wrapper just
// resolves the local player and calls this with `flag = 0`.
// Equips the cursor item to its natural slot (engine picks based
// on inventory type) and clears the cursor. No-op if cursor is
// empty.
FUN_AUTO_EQUIP_CURSOR_ITEM = 0x005E1480,
// Per-item descriptor block (object/item-field array) lives at this offset
// on the CGItem instance.
OFF_ITEM_DESCRIPTOR = 0x114,
// Within the descriptor, ITEM_FIELD_FLAGS is at +0x3C (a single dword).
// Bit 0 = soulbound, bit 3 = broken (see GetInventoryItemBroken at 0x4C8626
// which tests `[descriptor+0x3C] & 0x08`). Confirmed empirically by dumping
// descriptor bytes for a worn-and-bound item.
OFF_DESCRIPTOR_FLAGS = 0x3C,
ITEM_FLAG_SOULBOUND = 0x01,
// Within the descriptor, the item's random-property index
// (ITEM_FIELD_RANDOM_PROPERTIES_ID) is at +0x98 — this is the live
// instance's suffix, indexing ItemRandomProperties.dbc the same way
// StatAccum::ApplyRandomSuffix expects. Derived from the item-tooltip
// builder's `[descriptor + 0x26*4]` read (FUN_0052B650 @ ~0x52b7xx),
// which feeds it straight into `ItemRandomProperties[idx]`.
OFF_DESCRIPTOR_RANDOM_PROPERTY = 0x98,
// Bit 2 — instance is "unlocked", i.e. the lock referenced by
// `ItemStats.LockID` has been opened (rogue Pick Lock, key item,
// etc.). For unlockable items, the engine gates the
// `<Right Click to Open>` tooltip on this bit: a fresh lockbox
// has it clear (priest sees no openable affordance), a picked
// lockbox has it set. Items with `LockID == 0` (clams, simple
// sacks) never need the bit.
ITEM_FLAG_UNLOCKED = 0x04,
// Client-side "in-transaction" lock — set when the engine puts an
// item on the cursor / mail-attaches it / trade-attaches it, cleared
// when the SMSG_UPDATE_OBJECT post-processor (`FUN_005D8440`)
// confirms the transaction OR a cursor-cancel sweep
// (`FUN_00495460`) clears all locks.
//
// This is NOT in m_objectFields — it's a per-CGItem instance flag
// at byte offset 0x314, lowest bit (mask 0x01). Bit 1 of the same
// dword is a separate "cache-coherence" flag set by the SMSG
// post-processor. We only expose bit 0 here.
//
// The matching setter / clearer the engine uses:
// FUN_004953E0(guidLo, guidHi) — set: `[item+0x314] |= 1` + fire ITEM_LOCK_CHANGED
// FUN_00495420(guidLo, guidHi) — clear: `[item+0x314] &= ~1` + fire ITEM_LOCK_CHANGED
// FUN_00495460() — sweep: walk all bags/items, clear all locks
//
// Vanilla fires `ITEM_LOCK_CHANGED` (engine event 0xBC = 188) on
// every set / clear; no payload.
OFF_ITEM_CLIENT_LOCK = 0x314,
ITEM_CLIENT_LOCK_BIT = 0x01,
// `__stdcall(uint guidLo, int guidHi)` — sets bit 0 at `[item+0x314]`
// for the resolved item and fires ITEM_LOCK_CHANGED. Mirror of
// FUN_ITEM_UNLOCK_BY_GUID below. Engine's normal trigger is the
// optimistic-lock step inside pickup/equip/attach paths (cursor
// packets are sent immediately after).
FUN_ITEM_LOCK_BY_GUID = 0x004953E0,
// `__stdcall(uint guidLo, int guidHi)` — clears bit 0 at
// `[item+0x314]` for the resolved item and fires ITEM_LOCK_CHANGED.
// Resolves the item by GUID internally via FUN_00468460; safe to
// call with the GUID of an item that's already gone (event still
// fires but no-op on state). The engine's normal trigger for this
// is the SMSG_UPDATE_OBJECT post-processor (`FUN_005D8440`) when
// the server confirms a transaction.
FUN_ITEM_UNLOCK_BY_GUID = 0x00495420,
// `__cdecl()` — walks every CGItem the engine knows about (bag
// containers + their contents) and clears the lock bit on each.
// Fires a single ITEM_LOCK_CHANGED at the end. The engine itself
// only calls this from the PLAYER_LEAVING_WORLD cleanup path
// (`FUN_005FEF70` → fires event 0x112 right after); we expose it
// to addons as a stuck-lock recovery primitive.
FUN_ITEM_UNLOCK_ALL = 0x00495460,
// ITEM_FIELD_STACK_COUNT — single dword. Verified by decoding
// `Script_GetContainerItemInfo` (`0x004F9670`): after resolving the
// descriptor, `mov eax, [esi+0x114]; fild [eax+0x20]` is the count
// return. Field index 0x8 in 1.12's item-field layout, which puts
// STACK_COUNT *before* the contained/creator GUIDs (0x9..0xE) —
// different from the more common documented layout that places
// STACK_COUNT after them. Trust the binary, not external docs.
OFF_DESCRIPTOR_STACK_COUNT = 0x20,
// ITEM_FIELD_SPELL_CHARGES[0] — first of five signed dwords. Field
// indices 10..14 (fields 8..9 are STACK_COUNT and DURATION; field 15
// is FLAGS at +0x3C, which gives a tight sandwich around the
// SPELL_CHARGES range). Derived from the descriptor-field name table
// builder at `FUN_0047f840`, which consumes a list of `{ name_ptr,
// ?, count, ?, ? }` entries starting at `0x0083a328` (14 items) —
// summing the `count` field in declaration order gives each name's
// starting dword index. STACK_COUNT/FLAGS/DURABILITY/MAX_DURABILITY
// landing on their known offsets cross-checks the derivation. The
// tooltip "X Charges" text in `FUN_0052b650` reads from the
// *enchantment*-charges range at +0x48 (slot N + 0x8) which is a
// different field (ITEM_FIELD_ENCHANTMENT, fields 16..36).
//
// Value is signed: positive = rechargeable (wand recovers charges
// on use? no — they decrement; positive means "doesn't destroy on
// last use"). Negative = single-use, destroyed when count hits 0.
// `GetItemCount(includeUses=true)` uses abs() for the multiplier.
OFF_DESCRIPTOR_SPELL_CHARGES_0 = 0x28,
// ITEM_FIELD_ENCHANTMENT block (fields 16..36, per the +0x48
// enchant-charges note above) — 7 enchant slots, 3 dwords each
// `{enchantID, duration, charges}`. Slot 0 = permanent enchant,
// slot 1 = temporary (weapon oils / sharpening stones). The
// enchant ID indexes SpellItemEnchantment.dbc. Block base = field
// 16 = +0x40 (field 15 FLAGS at +0x3C precedes it); slot stride
// 0x0C, enchant ID at slot+0x00. Used by spell/BonusDamage.cpp to
// fold enchant-granted spell power into GetSpellBonusDamage.
OFF_DESCRIPTOR_ENCHANTMENT_ID = 0x40,
DESCRIPTOR_ENCHANTMENT_SLOT_STRIDE = 0x0C,
// ITEM_FIELD_DURABILITY (current) and ITEM_FIELD_MAXDURABILITY (max) live
// adjacent to each other in the descriptor as plain dwords. Verified in
// `Script_GetInventoryItemBroken` (`0x004C8590`): after resolving the
// descriptor, it reads `[ecx+0xA4]` for max and `[eax+0xA0]` for cur,
// and treats the item as broken when `max > 0 && cur == 0`. Items with
// no durability concept (consumables, materials) have both fields 0.
OFF_DESCRIPTOR_DURABILITY = 0xA0,
OFF_DESCRIPTOR_MAX_DURABILITY = 0xA4,
// Per-instance "readable text" id (letters / mail-scroll items carry a
// server-assigned text id here). Drives the `readable` return of
// `Script_GetContainerItemInfo` (`0x004F9670`): at `0x004F97C1` it reads
// `[descriptor+0x9C]` and, when non-zero, reports the slot as readable
// even when the static ItemStats page-text is 0. Field index 0x27.
OFF_DESCRIPTOR_READABLE_TEXT_ID = 0x9C,
// Per-item repair-cost helper used by Script_GameTooltip_SetInventoryItem
// (3rd return value). __fastcall(ecx = CGItem *) -> int copperCost.
// Returns 0 for null/broken/no-durability/fully-repaired items, otherwise
// the cost in copper, with the merchant discount applied IFF a merchant
// window is currently open.
//
// Internals: FUN_005DA330 is the raw calculator; FUN_004FAF30 is the
// discount wrapper that calls it. The raw side:
// 1. Look up the item's ItemStats record via DBCache_ItemStats_C_GetRecord
// (callback=NULL → returns NULL for uncached items).
// 2. Index DurabilityCosts.dbc by `subClass` to get the per-class row.
// 3. Branch on inventoryType: weapon (2) uses cols at row+4..row+0x54,
// armor (4) uses cols at row+0x58..row+0x78.
// 4. Multiply by DurabilityQuality.dbc's quality multiplier (indexed
// by `quality * 2 + 1`).
// 5. Round to nearest int; clamp 0 → 1 if there was any cost at all.
//
// The discount wrapper:
// - Resolves the local player object via FUN_00468550 (returns the
// player's GUID from [0x00B41414 + 0xC0]).
// - Resolves the current-merchant object via the GUID stored in
// DAT_00BDDFA0 / DAT_00BDDFA4. Those globals are set by
// FUN_004FACF0 on SMSG_LIST_INVENTORY (merchant frame opens) and
// zeroed by FUN_004FAC50 when the merchant frame closes.
// - If both lookups succeed, calls FUN_00612B80(merchant, player)
// to compute (factionDiscount + pvpRankDiscount). Faction
// contribution: 0% below Friendly, +base% (5%) at Friendly and
// above. PvP rank contribution: +5% for PvP rank > 5
// (Sergeant Major+), another +5% for rank > 7
// (Knight-Lieutenant+).
// - Otherwise (no merchant context) the multiplier stays at 1.0
// and the raw cost is returned undiscounted.
//
// So this helper produces the merchant's displayed cost ONLY when
// the player has a vendor open; called from anywhere else (HUD
// refresh, idle check) it returns the raw base cost.
FUN_ITEM_REPAIR_COST = 0x004FAF30,
// CGItem has TWO descriptor-like pointers and they hold different things:
// +0x114 = m_objectFields (the UpdateField array we read FLAGS from at
// +0x3C). For item instances, OBJECT_FIELD_ENTRY in this array
// is empirically 0 — don't try to read itemID from here.
// +0x08 = a separate identification block. Contains the item's GUID at
// +0x00 (qword) and the itemID at +0x0C (dword).
// The canonical "look up the cache record for this item" sequence is:
// item = GetItemBySlot(invMgr, slot)
// id = *(uint32_t *)(*(void **)(item + 0x08) + 0x0C)
// _GetRecord(cache, id, ...)
// Verified at 0x004C8B1F-2D (inventory→cache lookup right after a
// GetItemBySlot call). The same shape appears in many other inventory
// sites that call _GetRecord.
OFF_ITEM_INSTANCE_BLOCK = 0x08,
OFF_INSTANCE_BLOCK_ITEM_ID = 0x0C,
// Item stats cache (the client-side cache of ItemSparse-style records that
// gets populated by SMSG_ITEM_QUERY_SINGLE_RESPONSE). The cache instance
// lives directly at this VA — `_GetRecord`'s `this` argument is the literal
// address `0xC0E2A0`, not a pointer to it. See Script_GetItemInfo at
// 0x0048E070 which calls `mov ecx, 0xC0E2A0` before the call.
VAR_ITEMDB_CACHE = 0x00C0E2A0,
// `Script_GetItemInfo` Lua C function. We hook this to auto-warm the
// item cache on miss — vanilla 1.12's stock behavior is "return nil
// for uncached items and don't fire any query"; modern WoW (5.x+)
// auto-fires the load and emits `GET_ITEM_INFO_RECEIVED` when data
// arrives. The hook makes `GetItemInfo(uncached_id)` return nil
// first call but kick off the query, so subsequent calls work.
FUN_SCRIPT_GET_ITEM_INFO = 0x0048E070,
// ItemStats_C *(__thiscall *)(void *cache, uint32_t itemID,
// const uint64_t *guid /*may point to zero*/,
// void *callback, void *userData,
// bool requestIfMissing).
// With `requestIfMissing=false`, returns NULL if not in cache (no server
// round-trip) — exactly the "instant" semantics we want.
FUN_DBCACHE_ITEMSTATS_GET_RECORD = 0x0055BA30,
// Item-cache response handler — the function called from
// `0x00555140` (success path for `SMSG_ITEM_QUERY_SINGLE_RESPONSE`)
// and `0x00555160` (failure path). Parses one or more itemIDs out
// of the packet, looks up (or creates) the cache entry per ID,
// copies the item data block via `FUN_007c9640` to `entry+0x18`,
// sets `[entry+0x1F0]=1` (the loaded byte), then walks the entry's
// pending callback list at `[entry+0x1FC]` and invokes each with
// `(userData, success)`. High-bit-on itemID in the packet signals
// a per-item failure for the batch.
//
// We hook this to observe any item-cache fill the engine performs
// — covers the engine's natural inventory prefetch and any
// addon-triggered queries without having to register our own
// engine callbacks. Lets `RequestLoadItemData` be purely passive:
// we track itemIDs, the engine (or whoever) issues the query, we
// see the fill via this hook and fire `ITEM_DATA_LOAD_RESULT`.
//
// Signature: `__thiscall(void *cache, void *packetReader, int flag)`.
// `cache` is the same `VAR_ITEMDB_CACHE` we already use.
FUN_ITEMSTATS_CACHE_RESPONSE = 0x0055BDB0,
// ItemStats_C field offsets we read. Full struct layout in
// VanillaHelpers's `Game.h` (`struct ItemStats_C`); we only need these.
OFF_ITEMSTATS_CLASS = 0x00,
OFF_ITEMSTATS_SUBCLASS = 0x04,
// `char *m_name[4]` per VanillaHelpers's `struct ItemStats_C`. Only
// m_name[0] is the primary localized item name (e.g., "Linen Cloth");
// m_name[1..3] are random-property suffix slots that are typically
// null for non-randomized items. Used by `C_Item.IsEquippedItem`'s
// name-string match form.
OFF_ITEMSTATS_NAME = 0x08,
OFF_ITEMSTATS_DISPLAY_INFO_ID = 0x18,
OFF_ITEMSTATS_QUALITY = 0x1C, // u32 — 0=Poor … 5=Legendary
// Item-quality color-prefix table. Array of 7 `const char *`
// pointers, indexed by quality 0..6 (POOR..ARTIFACT); each
// points to a `"|cffRRGGBB"` markup string used by the engine's
// own link builder. Discovered via the inner color helper at
// `0x0052AD90` which does `(&table)[quality]` with a fallback
// to white (`"|cffffffff"`, the index-1 entry) for quality > 6.
// Quality 7 (Heirloom) doesn't exist in vanilla; consumers
// should mirror the engine's fallback for safety.
VAR_QUALITY_COLOR_TABLE = 0x00854124,
QUALITY_COLOR_TABLE_SIZE = 7,
// `m_flags` — item-class flags bitfield. Bits we read:
// `ITEMSTATS_FLAG_OPENABLE` (`0x4`, bit 2): freely right-click-
// openable container (sack, clam, simple chest, quest box).
// The tooltip line `<Right Click to Open>` (`ITEM_OPENABLE`
// string) renders for items with this bit set, gated on the
// player's lock skill when the item also carries a non-zero
// LockID. Same bit modern WoW's `C_Item.IsItemOpenable`
// surfaces.
// Other documented bits (`0x1` = BIND_ON_PICKUP, `0x2` = CONJURED,
// `0x10` = LOOTABLE, `0x200` = WRAPPER, etc.) live in the same
// field but we don't read them here. Add named constants as
// consumers materialize.
// Reader at `0x0052E323` (the tooltip-builder's openable branch in
// `FUN_0052B650`) does `(ItemStats[+0x20] & 0x4)` against this
// field; verified by checking the field offset matches the
// 5-DWORD-per-row layout `puVar4[8]` resolves to in the decompile.
OFF_ITEMSTATS_FLAGS = 0x20,
ITEMSTATS_FLAG_OPENABLE = 0x4,
OFF_ITEMSTATS_SELL_PRICE = 0x28,
// `m_lockID` — references `Lock.dbc`. Zero means "no lock"; any
// nonzero value gates the openable interaction on the player
// successfully unlocking the item (instance flag bit 2 in
// `ITEM_FIELD_FLAGS`). Same field the tooltip builder reads as
// `ItemStats[+0x1AC]` (puVar4[0x6b]) when deciding whether the
// `<Right Click to Open>` line should require the lock to be
// picked first.
OFF_ITEMSTATS_LOCK_ID = 0x1AC,
OFF_ITEMSTATS_INVENTORY_TYPE = 0x2C,
OFF_ITEMSTATS_ITEM_LEVEL = 0x38, // u32 — base ilvl from ItemSparse
// `m_stackable` — max stack size for this item type (1 for non-
// stackable; 5/20/200/etc. for stackable). The instance-level
// current stack count is a different field (`OFF_DESCRIPTOR_STACK_COUNT`
// at +0x20 on the CGItem's m_objectFields descriptor — see
// `Item::Count.cpp`).
OFF_ITEMSTATS_STACKABLE = 0x60,
// Bag-only fields. `m_containerSlots` (slot count) and `m_bagFamily`
// (the BagFamily bitfield — quiver=1, ammo pouch=2, soul bag=4 in
// vanilla) live deep in the record. Offsets derived from
// VanillaHelpers's `struct ItemStats_C` (full layout, sizeof =
// ~0x1D4); cross-check by counting fields up through `m_stackable`
// at +0x60 (which we already use) — `m_containerSlots` is the next
// u32 at +0x64. `m_bagFamily` is the last u32, at +0x1D0.
OFF_ITEMSTATS_CONTAINER_SLOTS = 0x64,
// `m_bagFamily` is a **raw 1-based ID** in 1.12, not the modern
// bitmask. Vanilla data: arrow=1, bullet=2, soul shard=3, herb=6,
// etc. Wrath flipped the encoding to `1 << (ID-1)` (so soul shard
// became 4, herb became 32, …) and addons from Wrath onward expect
// the bitmask form. Reader functions must convert via
// `bitmask = id ? (1 << (id - 1)) : 0` to maintain modern API
// parity. Verified empirically on Turtle WoW: Soul Shard (6265)
// returns raw 3 here, which is `1 << 2 = 0x4` in modern encoding.
//
// Field offset verified by decoding the engine's own
// `GetItemBagFamily(itemID)` helper at `0x005DA050` — calls
// `_GetRecord` (`0x0055BA30`) on the item cache (`0x00C0E2A0`),
// tests the result for null, then `mov eax, [eax+0x1D0]; ret`.
// (Found via xref scan for `mov reg, [reg+0x1D0]` in `.text`.)
OFF_ITEMSTATS_BAG_FAMILY = 0x1D0,
// `m_itemSet` — ItemSet.dbc row ID for items that belong to an
// armor / equipment set. 0 for items not part of any set.
// Position derived by counting fields up through `m_block` per
// VanillaHelpers's `ItemStats_C` (m_block at +0x1BC; m_itemSet
// is the next u32). Verified against `m_bagFamily` already
// confirmed at +0x1D0 — m_itemSet sits 16 bytes earlier with
// `m_maxDurability`, `m_area`, `m_map` between the two.
OFF_ITEMSTATS_ITEM_SET = 0x1C0,
// Item-spell tables — five parallel arrays starting at +0x11C in
// each `ItemStats_C` record. Each item has up to 5 spell slots
// (vanilla server data uses ≤2 for most items: e.g. Hearthstone
// 6948 uses slot 0 for spell 8690 with trigger 0 = `ON_USE`).
//
// Field offsets computed by summing struct members in
// VanillaHelpers's `ItemStats_C` definition; verified empirically
// against the Hearthstone case (spellID 8690, trigger 0).
//
// Trigger enum (CMaNGOS `ITEM_SPELLTRIGGER_*`):
// 0 = ON_USE (potions, trinkets, scrolls, hearthstone)
// 1 = ON_EQUIP (passive proc auras on equipped gear)
// 2 = CHANCE_ON_HIT (weapon proc effects)
// 4 = SOULSTONE (soulstone-style on-death effect)
// 5 = ON_USE_NO_DELAY
// 6 = LEARN_SPELL (recipe items)
//
// `GetItemSpell` matches modern WoW semantics — returns the
// ON_USE (trigger=0) entry only, ignoring ON_EQUIP procs / weapon
// procs / recipes. Walks all 5 slots since the ON_USE entry isn't
// always at index 0 (some Turtle WoW custom items put it later).
OFF_ITEMSTATS_SPELL_ID = 0x11C, // u32[5] — spell ID per slot
OFF_ITEMSTATS_SPELL_TRIGGER = 0x130, // u32[5] — trigger code per slot
OFF_ITEMSTATS_SPELL_CHARGES = 0x144, // i32[5] — charges per slot (-1 = infinite)
OFF_ITEMSTATS_SPELL_COOLDOWN = 0x158, // u32[5] — cooldown ms per slot
OFF_ITEMSTATS_SPELL_CATEGORY = 0x16C, // u32[5] — category (groups shared cooldowns)
OFF_ITEMSTATS_SPELL_CATEGORY_CD = 0x180, // u32[5] — category cooldown ms
ITEMSTATS_SPELL_SLOT_COUNT = 5,
ITEM_SPELLTRIGGER_ON_USE = 0,
// `ItemStats_C.m_maxCount` — max number of this item the player can
// hold in inventory at once. `0` = unlimited, `1` = unique, higher
// values are caps like "5x bandage type". Vanilla 1.12 doesn't have
// modern "unique-equipped category" semantics; this is the only
// uniqueness signal the client has. Derived by summing struct
// members in VanillaHelpers's `ItemStats_C` definition.
OFF_ITEMSTATS_MAX_COUNT = 0x5C,
// Remaining `ItemStats_C` fields used by `C_Item.GetItemData(ByID)`.
// Offsets derived from VanillaHelpers's `struct ItemStats_C`
// definition (`C:\Git\VanillaHelpers\src\Game.h`), sized to match
// the verified anchors above (`+0x60 m_stackable`, `+0x1D0
// m_bagFamily`, `+0x1AC m_lockID`, etc.). Block follows the same
// ordering as the struct so it's easy to cross-reference.
OFF_ITEMSTATS_BUY_PRICE = 0x24, // u32
OFF_ITEMSTATS_ALLOWABLE_CLASS = 0x30, // u32 — class bitmask, -1 = all
OFF_ITEMSTATS_ALLOWABLE_RACE = 0x34, // u32 — race bitmask, -1 = all
OFF_ITEMSTATS_REQUIRED_LEVEL = 0x3C, // u32
OFF_ITEMSTATS_REQUIRED_SKILL = 0x40, // u32 — SkillLine.dbc row
OFF_ITEMSTATS_REQUIRED_SKILL_RANK = 0x44, // u32
OFF_ITEMSTATS_REQUIRED_SPELL = 0x48, // u32 — Spell.dbc row
OFF_ITEMSTATS_REQUIRED_HONOR_RANK = 0x4C, // u32
OFF_ITEMSTATS_REQUIRED_CITY_RANK = 0x50, // u32
OFF_ITEMSTATS_REQUIRED_FACTION = 0x54, // u32 — Faction.dbc row
OFF_ITEMSTATS_REQUIRED_FACTION_RANK = 0x58, // u32 — Friendly/Honored/etc.
OFF_ITEMSTATS_STAT_TYPE = 0x68, // u32[10] — ItemModType enum per slot
OFF_ITEMSTATS_STAT_VALUE = 0x90, // i32[10] — magnitude per slot
ITEMSTATS_STAT_SLOT_COUNT = 10,
OFF_ITEMSTATS_DAMAGE_MIN = 0xB8, // f32[5]
OFF_ITEMSTATS_DAMAGE_MAX = 0xCC, // f32[5]
OFF_ITEMSTATS_DAMAGE_TYPE = 0xE0, // u32[5] — schools per damage slot
ITEMSTATS_DAMAGE_SLOT_COUNT = 5,
OFF_ITEMSTATS_ARMOR = 0xF4, // u32
OFF_ITEMSTATS_RES_HOLY = 0xF8, // u32 (six resists contiguous)
OFF_ITEMSTATS_RES_FIRE = 0xFC,
OFF_ITEMSTATS_RES_NATURE = 0x100,
OFF_ITEMSTATS_RES_FROST = 0x104,
OFF_ITEMSTATS_RES_SHADOW = 0x108,
OFF_ITEMSTATS_RES_ARCANE = 0x10C,
OFF_ITEMSTATS_DELAY = 0x110, // u32 — weapon swing time (ms)
OFF_ITEMSTATS_AMMO_TYPE = 0x114, // u32 — ammo subclass for ranged
OFF_ITEMSTATS_RANGED_MOD_RANGE = 0x118, // f32 — range modifier on bows/guns
OFF_ITEMSTATS_BONDING = 0x194, // u32 — 0=none, 1=BoP, 2=BoE, 3=BoU, 4=Quest
OFF_ITEMSTATS_DESCRIPTION = 0x198, // char * — flavor text (locale-applied)
OFF_ITEMSTATS_PAGE_TEXT = 0x19C, // u32 — PageText.dbc row (readable books)
OFF_ITEMSTATS_LANGUAGE_ID = 0x1A0, // u32 — language for book text
OFF_ITEMSTATS_PAGE_MATERIAL = 0x1A4, // u32 — book material
OFF_ITEMSTATS_START_QUEST = 0x1A8, // u32 — questID started by right-click
OFF_ITEMSTATS_MATERIAL = 0x1B0, // i32 — material type
OFF_ITEMSTATS_SHEATH = 0x1B4, // u32 — weapon sheath style
OFF_ITEMSTATS_RANDOM_PROPERTY = 0x1B8, // i32 — random property template
OFF_ITEMSTATS_BLOCK = 0x1BC, // u32 — shield block value
OFF_ITEMSTATS_MAX_DURABILITY = 0x1C4, // u32
OFF_ITEMSTATS_AREA = 0x1C8, // u32 — bound area (AreaTable.dbc)
OFF_ITEMSTATS_MAP = 0x1CC, // u32 — bound map (Map.dbc)
// `m_flags` bits we surface as decoded booleans. The OPENABLE bit
// (0x4) is verified by the tooltip-builder's reader at 0x0052E323;
// the others are documented in the standard 1.12 protocol
// (CMaNGOS / TrinityCore `ITEM_FLAG_*`) and exposed as-is. Add
// verification anchors as consumers materialize.
ITEM_FLAG_CONJURED = 0x2,
ITEM_FLAG_LOOTABLE = 0x10,
ITEM_FLAG_WRAPPER = 0x200,
// `Spell.dbc` `Name[9]` field at record +0x1E0 (9-locale string
// array, indexed by `[VAR_LOCALE_INDEX]`). Used by `GetItemSpell`
// to push the spell name half of its return.
OFF_SPELL_NAMES = 0x1E0,
// First character-pane bag-slot index. INVSLOT_BAG1 = 20, BAG2 = 21,
// BAG3 = 22, BAG4 = 23. Used to map a Lua bagID (1..4) onto the
// equipment slot the bag occupies: `equipSlot = INVSLOT_BAG1 + bagID - 1`.
INVSLOT_BAG1 = 20,
BACKPACK_NUM_SLOTS = 16,
// ItemClass.dbc — standard 5-DWORD class shape. Records is an array of
// record pointers indexed directly by classID. Each record has a 9-slot
// localized name array at +0x0C (4 bytes per locale).
VAR_ITEMCLASS_RECORDS = 0x00C0DC24,
VAR_ITEMCLASS_COUNT = 0x00C0DC28,
OFF_ITEMCLASS_NAMES = 0x0C,
// ItemSubClass.dbc — class instance at 0x00C0DB90 has the standard 5-DWORD
// shape (records at +0x08, count at +0x0C, per the reset at 0x53B700), but
// the engine ALSO maintains a parallel (records, count) pair in the first
// two unused slots (+0x00, +0x04) for fast compound-key iteration.
// Script_GetItemInfo and three other callers all read from this parallel
// pair, NOT the standard slots — verified by greping every reader of
// 0xC0DB94. Records there is a flat array of 0x74-byte structs (not the
// standard array-of-pointers); linear scan keyed by (classID, subClassID)
// at record +0x00 / +0x04.
//
// Each record has TWO localized name string arrays:
// +0x28 short name (e.g. "Sword") — 9 locale ptrs, stride 4
// +0x4C verbose/display name (e.g. "One-Handed Swords") — same shape
// Engine pattern: try verbose first; if that locale's slot is empty,
// fall back to short. Many subclasses (e.g. Miscellaneous→Junk) only
// populate the short array, so the fallback matters.
VAR_ITEMSUBCLASS_RECORDS = 0x00C0DB90,
VAR_ITEMSUBCLASS_COUNT = 0x00C0DB94,
OFF_ITEMSUBCLASS_RECORD_STRIDE = 0x74,
OFF_ITEMSUBCLASS_NAME = 0x28,
OFF_ITEMSUBCLASS_DISPLAY_NAME = 0x4C,
// record +0x00 = classID, +0x04 = subClassID (the compound key the
// linear scan matches on). Flags field at +0x10; bit 0x200 marks the
// subclasses whose items display by inventory slot rather than by
// subclass name — set on exactly the armor material types (Misc / Cloth
// / Leather / Mail / Plate), clear on weapons, shields, librams, etc.
// This is `C_Item.GetItemSubClassInfo`'s `subClassUsesInvType` return.
// Derived by dumping ItemSubClass.dbc (see docs/DBCs.md dump oracle).
OFF_ITEMSUBCLASS_CLASS_ID = 0x00,
OFF_ITEMSUBCLASS_SUBCLASS_ID = 0x04,
OFF_ITEMSUBCLASS_FLAGS = 0x10,
ITEMSUBCLASS_FLAG_USES_INVTYPE = 0x200,
// ItemDisplayInfo.dbc — standard layout. Icon path char* at record +0x14
// (per the helper at 0x005D88B0 that Script_GetItemInfo uses).
VAR_ITEMDISPLAYINFO_RECORDS = 0x00C0DC10,
VAR_ITEMDISPLAYINFO_COUNT = 0x00C0DC14,
OFF_ITEMDISPLAYINFO_ICON = 0x14,
// ItemSet.dbc — armor/equipment set definitions referenced by
// `ItemStats_C::m_itemSet`. Standard 5-DWORD class shape at
// 0x00C0DBB8 (records-ptr at +0x08, count at +0x0C). 45 columns,
// 0xB4-byte record stride. Field layout derived from the per-
// record reader at `FUN_0057BBA0`:
//
// +0x00 (4) ID
// +0x04 (32) Name[8] — localized strings, 8 LOCALES (not 9
// like Spell.dbc / ChrRaces.dbc — clamp
// VAR_LOCALE_INDEX to 0..7 before reading)
// +0x24 (4) unused / flags
// +0x28 (68) ItemID[17] — items in the set (zero = empty slot)
// +0x6C (32) SetSpellID[8] — bonus spells granted by the set
// +0x8C (32) SetThreshold[8] — pieces needed for each SetSpellID
// (e.g. {2, 4, 6, 8, 0, 0, 0, 0})
// +0xAC (4) RequiredSkill — skill line ID, 0 for none
// +0xB0 (4) RequiredSkillRank
VAR_ITEMSET_RECORDS = 0x00C0DBC0,
VAR_ITEMSET_COUNT = 0x00C0DBC4,
OFF_ITEMSET_NAMES = 0x04,
OFF_ITEMSET_ITEM_IDS = 0x28,
OFF_ITEMSET_SPELL_IDS = 0x6C,
OFF_ITEMSET_THRESHOLDS = 0x8C,
OFF_ITEMSET_REQUIRED_SKILL = 0xAC,
OFF_ITEMSET_REQUIRED_SKILL_RANK = 0xB0,
ITEMSET_MAX_ITEMS = 17,
ITEMSET_MAX_BONUSES = 8,
ITEMSET_LOCALE_COUNT = 8,
// INVTYPE_* string table — array of char* indexed by m_inventoryType.
// Index 0 is empty (0=INVTYPE_NON_EQUIP), indices 1..28 are valid
// INVTYPE_HEAD..INVTYPE_RELIC, index 29 is empty (sentinel), and indices
// 30+ are unrelated combat-log strings (MISS/WOUND/DODGE/...). Always
// bound-check before indexing.
VAR_INVTYPE_STRING_TABLE = 0x0083DDB0,
INVTYPE_TABLE_MAX_INDEX = 28,
// Faction "displayed list" — the engine maintains a sorted/visible list
// of factions the player has rep with. `Script_GetNumFactions` (at
// 0x004D64C0) returns `[VAR_FACTION_DISPLAY_COUNT]` (the primary list
// count). `Script_GetFactionInfo` (at 0x004D64F0) maps its 1-based
// index by calling the resolver below, which accepts a slightly wider
// 0-based range bounded by `[VAR_FACTION_VISIBLE_MAX_INDEX]`. The two
// ranges differ because the displayed list also exposes the "Inactive"
// / collapsed-category rows past the primary count.
//
// The resolver `FUN_RESOLVE_FACTION_INDEX` is __fastcall(ecx = 0-based
// index) → factionID (Faction.dbc record ID), or 0 for headers and
// empty entries. The internal bounds-check is `cmp ecx, [maxIdx]; jbe`
// — i.e., 0..maxIdx inclusive is valid. Out of range returns 0 too,
// so we must bound-check ourselves to distinguish "header" (0 in
// range) from "no such index" (out of range → nil).
//
// We re-use the resolver for `GetFactionIDByIndex` directly, and for
// `GetFactionInfoByID` we walk it to find the displayed-index of a
// given factionID, then replace Lua arg 1 and tail-call
// `Script_GetFactionInfo` to produce all 11 returns.
// ChrClasses.dbc — class metadata. Standard 5-DWORD class shape.
// Records is a flat array of record pointers indexed by classID
// (records[0] unused, records[1..count]).
FUN_RESOLVE_FACTION_INDEX = 0x004D5FA0,
FUN_SCRIPT_GET_FACTION_INFO = 0x004D64F0,
//
// Per-record fields used by `FillLocalizedClassList`, derived from
// `Script_GetSelectedClass` (`0x004716E0`):
// +0x14 char *Name[9] — localized class names (locale-indexed)
// +0x38 char *Filename — class token ("WARRIOR", "MAGE", etc.)
//
// Vanilla 1.12 has no separate female-name array — `Name[9]` is
// exactly the 36 bytes between `+0x14` and `+0x38`, so the
// `isFemale` arg of `FillLocalizedClassList` is a no-op for this
// client (and matches the male names that English/most locales
// use anyway).
VAR_CHRCLASSES_RECORDS = 0x00C0DEF4,
VAR_CHRCLASSES_COUNT = 0x00C0DEF8,
OFF_CHRCLASSES_NAMES = 0x14,
OFF_CHRCLASSES_FILENAME = 0x38,
// SpellFamilyName for the class — the gate the SpellMod system
// matches a spell's OFF_SPELL_RECORD_FAMILY_NAME against. Read by
// FUN_006e6ca0 (`DAT_00cecaac = ChrClasses[classID] + 0x3c`).
OFF_CHRCLASSES_SPELL_FAMILY = 0x3C,
// ChrRaces.dbc — standard 5-DWORD class shape at 0x00C0DED8,
// records-pointer at +0x08, count at +0x0C. 29 columns,
// 0x74-byte record stride. Field offsets verified by decoding
// `Script_UnitRace` (registration entry at 0x00850580, function at
// 0x00518200): the function loads `[VAR_CHRRACES_RECORDS]` →
// `records[raceID]` → reads `+0x44 + locale*4` for the localized
// race name and `+0x3C` for the non-localized file string (e.g.
// `"Human"`, `"NightElf"`, `"Scourge"`), pushes both as Lua
// returns. The two offsets are what we mirror to populate
// `GetPlayerInfoByGUID`'s `localizedRace` / `englishRace` slots.
VAR_CHRRACES_RECORDS = 0x00C0DEE0,
VAR_CHRRACES_COUNT = 0x00C0DEE4,
OFF_CHRRACES_FILENAME = 0x3C,
OFF_CHRRACES_NAMES = 0x44,
// CreatureFamily.dbc — pet/beast family metadata. Standard 5-DWORD
// class shape (instance 0x00C0DE74; records 0x00C0DE7C, count
// 0x00C0DE80 — the same globals `Script_UnitCreatureFamily`
// (`0x0051A310`) bounds-checks/indexes). 72-byte stride, familyID-keyed
// and sparse (10/13/14/22/… are unused). Localized `Name[]` at +0x20
// (the engine reads `record + 0x20 + locale*4`), `IconFile` texture-path
// string at +0x44 (last field; empty for warlock-pet families). Backs
// `C_CreatureInfo.GetCreatureFamilyInfo` / `GetCreatureFamilyIDs`.
VAR_CREATUREFAMILY_RECORDS = 0x00C0DE7C,
VAR_CREATUREFAMILY_COUNT = 0x00C0DE80,
OFF_CREATUREFAMILY_NAMES = 0x20,
OFF_CREATUREFAMILY_ICON = 0x44,
// CreatureType.dbc — pet/NPC classification (1=Beast … 11=Totem;
// contiguous ids, 11 rows). Records 0x00C0DE2C, count 0x00C0DE30 (the
// globals `Script_UnitCreatureType` (`0x0051A280`) bounds-checks/indexes),
// localized `Name[]` at +0x04 (engine reads `record + 0x04 + locale*4`).
// Backs `C_CreatureInfo.GetCreatureTypeInfo` / `GetCreatureTypeIDs`;
// `UnitCreatureTypeID` returns the id `FUN_UNIT_CREATURE_TYPE` resolves.
VAR_CREATURETYPE_RECORDS = 0x00C0DE2C,
VAR_CREATURETYPE_COUNT = 0x00C0DE30,
OFF_CREATURETYPE_NAMES = 0x04,
// Race → faction group, mirroring the player branch of
// `Script_UnitFactionGroup` (`0x00516630`) — backs
// `C_CreatureInfo.GetFactionInfo(raceID)`. Chain:
// ChrRaces[race] + 0x08 → FactionTemplate id
// FactionTemplate[id] + 0x0C → group mask (ourMask)
// scan FactionGroup for the row whose bit is set (and whose
// localized name is non-empty — that non-empty test is what
// skips the always-set "Player" bit and lands on Alliance/Horde)
// push { groupTag = row+0x08 (english), name = row+0x0C+locale*4 }
// FactionTemplate is a pointer-array DBC (records[id]); FactionGroup
// is stored CONTIGUOUSLY (records-base + i*stride, direct field reads,
// NOT a pointer array), so iterate it by hand rather than via DBC::Record.
// FactionTemplate globals match docs/DBCs.md; the FactionGroup
// records-base/count globals are the ones the engine actually
// dereferences per the disassembly (0x00C0DD5C / 0x00C0DD60), which
// differ from DBCs.md's standard-shape tabulation for this table.
OFF_CHRRACES_FACTION_TEMPLATE = 0x08,
VAR_FACTIONTEMPLATE_RECORDS = 0x00C0DD3C,
VAR_FACTIONTEMPLATE_COUNT = 0x00C0DD40,
OFF_FACTIONTEMPLATE_GROUP_MASK = 0x0C,
VAR_FACTIONGROUP_RECORDS = 0x00C0DD5C,
VAR_FACTIONGROUP_COUNT = 0x00C0DD60,
FACTIONGROUP_STRIDE = 0x30,
OFF_FACTIONGROUP_BIT = 0x04,
OFF_FACTIONGROUP_ENGLISH = 0x08,
OFF_FACTIONGROUP_NAMES = 0x0C,
// AreaTable.dbc — used by `Script_GetCharacterInfo` to resolve
// each character's last-known-area to a localized zone name.
// Same shape as the other DBCs (records pointer + count globals,
// 9-slot locale-string array at the per-record offset).
VAR_AREATABLE_RECORDS = 0x00C0E048,
VAR_AREATABLE_COUNT = 0x00C0E04C,
OFF_AREATABLE_NAMES = 0x2C,
// AreaBit @ +0x0C: index into the player's explored-areas bitfield
// (OFF_PLAYER_EXPLORED_BITS). Gate @ +0x28: when < 0 the area needs no
// exploration (always counts explored); when >= 0 the AreaBit check
// applies. Source: the discovered-overlay rebuild FUN_004a67a0.
OFF_AREATABLE_AREA_BIT = 0x0C,
OFF_AREATABLE_EXPLORE_GATE = 0x28,
// TaxiNodes.dbc (16 fields, 0x40 bytes) — flight points. records/count
// per docs/DBCs.md. mapID @ +0x04 is the Map.dbc continent; x/y/z floats;
// Name[8] localized @ +0x14; the two MountCreatureID columns are
// [Horde @ +0x38, Alliance @ +0x3C] (0 = that faction has no flight
// master at this node — both 0 = a transport/system waypoint).
VAR_TAXINODES_RECORDS = 0x00C0D6C0,
VAR_TAXINODES_COUNT = 0x00C0D6C4,
OFF_TAXINODE_MAP_ID = 0x04,
OFF_TAXINODE_X = 0x08,
OFF_TAXINODE_Y = 0x0C,
OFF_TAXINODE_Z = 0x10,
OFF_TAXINODE_NAME = 0x14,
OFF_TAXINODE_HORDE_MOUNT = 0x38,
OFF_TAXINODE_ALLIANCE_MOUNT = 0x3C,
// Live taxi session — the open flight master's reachable node list,
// populated between TAXIMAP_OPENED/CLOSED (count 0 otherwise). Backs the
// legacy NumTaxiNodes/TaxiNodeName/TaxiNodePosition/TaxiNodeGetType Lua
// globals. Node slots are 0x20-stride records at VAR_TAXI_NODE_ARRAY:
// +0x00 = pointer to the node's TaxiNodes.dbc record (id @ +0, name @
// +0x14), +0x04 = flight-map x (0-1 float), +0x08 = y. Count at
// VAR_TAXI_NODE_COUNT. Derived from Script_TaxiNode* (FUN_004dc380 name,
// FUN_004dc3b0 position); the reachability type comes from
// FUN_TAXI_NODE_TYPE.
VAR_TAXI_NODE_COUNT = 0x00BB4AA8,
VAR_TAXI_NODE_ARRAY = 0x00BB4F10,
TAXI_NODE_STRIDE = 0x20,
OFF_TAXI_SLOT_RECORD = 0x00,
OFF_TAXI_SLOT_X = 0x04,
OFF_TAXI_SLOT_Y = 0x08,
// __fastcall(uint slot0Based) -> const char* ("CURRENT" / "REACHABLE" /
// "DISTANT" / other) — the node's reachability for the open session.
FUN_TAXI_NODE_TYPE = 0x004DC4E0,
// TaxiPath.dbc (4 fields, 0x10 bytes): {id, fromNode@+0x04, toNode@+0x08,
// cost}. A real flight master is a node some flight path connects to;
// Northshire Abbey / spurious duplicate rows / standalone markers are not
// endpoints and so are filtered out of GetTaxiNodesForMap.
VAR_TAXIPATH_RECORDS = 0x00C0D698,
VAR_TAXIPATH_COUNT = 0x00C0D69C,
OFF_TAXIPATH_FROM = 0x04,
OFF_TAXIPATH_TO = 0x08,
// Engine player-info cache — populated by the
// SMSG_NAME_QUERY_RESPONSE handler (opcode 0x51) at 0x005551A0,
// which reads (GUID, name[48], realm[256], race, sex, class) from
// the packet and writes them into an entry via the cache method
// at 0x0055F310. Used by chat, raid frames, guild events — any
// engine code that needs name/class/race for a GUID. NOT limited
// to visible objects (an earlier note in TODO #35 was wrong — the
// visible-only cache at 0x00CE870C is a different smaller one
// used for chat name resolution).
//
// Lookup primitive at `FUN_PLAYER_INFO_LOOKUP`:
// `__thiscall uint8_t *(this=cache, guid_lo, guid_hi, &cookie,
// callback, userData, retryFlag)`
//
// Returns:
// - `nullptr` if the GUID isn't loaded (cache miss, or pending
// response from a prior request).
// - Pointer to the entry's data block (= entry +0x20) if loaded.
//
// Side effect: if `callback != nullptr` AND the entry isn't yet
// allocated, the engine builds a CDataStore, writes the GUID, and
// calls `FUN_005AB630` to send CMSG_NAME_QUERY (opcode 0x50). The
// callback fires with `(userData, success)` when the response
// arrives (`__stdcall void(void *, int)`, same shape as the item
// cache callback).
//
// For pure cache reads (our `GetPlayerInfoByGUID`), pass
// `callback=nullptr, userData=nullptr, retryFlag=0` and a dummy
// 8-byte cookie buffer. We don't fire the request from the read
// path — addons that want to trigger one can layer a
// `C_PlayerInfo.RequestLoadPlayerByID`-style helper on top later.
VAR_PLAYER_NAME_CACHE = 0x00C0E228,
FUN_PLAYER_INFO_LOOKUP = 0x0055F080,
// NameCache write entry — `__thiscall(this = cache, packetData,
// guidLo, guidHi)` at 0x0055F310. Called once per
// SMSG_NAME_QUERY_RESPONSE after the engine's opcode handler
// builds a `packetData` buffer with the layout:
// +0x000 name[48]
// +0x030 realm[256]
// +0x130 unknown[8] (probably (charGuidLo, charGuidHi))
// +0x138 race (u32)
// +0x13C sex (u32, 0/1 wire)
// +0x140 class (u32)
// Writes that data into the cache entry and dispatches any
// pending callbacks. Decoded by Ghidra; field offsets verified
// against the `*(uint*)(param_2 + N)` reads in the function body.
//
// Hooking here gives us a single chokepoint covering every name-
// query response the engine processes — chat, group/raid sync,
// guild roster, visible-object resolution. The hook runs after
// the engine has settled the entry, so reading from the cache
// post-hook is safe.
FUN_PLAYER_INFO_CACHE_WRITE = 0x0055F310,
// Entry-data offsets. The lookup returns `entry + 0x20`, so these
// are relative to that pointer (not to the entry's hash-table
// header). Field layout verified by decoding the cache writer
// FUN_0055F310 at 0x0055F32D-0x0055F365:
// - copy 48 bytes from packet[+0] into entry+0x20 (name)
// - copy 256 bytes from packet[+0x30] into entry+0x50 (realm)
// - copy 4 bytes from packet[+0x138] into entry+0x158 (race)
// - copy 4 bytes from packet[+0x13C] into entry+0x15C (sex)
// - copy 4 bytes from packet[+0x140] into entry+0x160 (class)
OFF_PLAYER_INFO_NAME = 0x000, // 48-byte inline C string
OFF_PLAYER_INFO_REALM = 0x030, // 256-byte inline C string
OFF_PLAYER_INFO_RACE = 0x138, // u32 (race ID 1..8)
OFF_PLAYER_INFO_SEX = 0x13C, // u32 (0=male, 1=female on wire)
OFF_PLAYER_INFO_CLASS = 0x140, // u32 (class ID 1..11)
// Visible-object iterator. Walks the engine's linked list of
// currently-in-range CGObjects (the same list the minimap blip
// renderer uses). __fastcall(ecx = callback, edx = context).
// Callback signature: __fastcall(ecx = context, edx unused, [stack] = uint64_t guid).
// Callback returns 0 to stop iteration, 1 to continue.
// Verified by disassembling the iterator body at 0x00468380 —
// ECX/EDX preserved into ESI/EDI, ECX restored to context before
// each callback invocation, guidLo/guidHi pushed as 8 stack bytes.
FUN_CLNT_OBJ_MGR_ENUM_VISIBLE_OBJECTS = 0x00468380,
// GUID → CGObject resolver. __fastcall with this signature:
// CGObject *(__fastcall *)(uint32_t typeMask, void *unused,
// uint64_t guid, int unused2);
// typeMask filters to specific object types; returns NULL if the
// GUID isn't loaded or its type doesn't match the mask.
FUN_CLNT_OBJ_MGR_OBJECT_PTR = 0x00468460,
// Type-mask flags accepted by FUN_CLNT_OBJ_MGR_OBJECT_PTR. Single-bit
// flags can be OR'd together.
TYPEMASK_OBJECT = 0x01,
TYPEMASK_ITEM = 0x02,
TYPEMASK_CONTAINER = 0x04,
TYPEMASK_UNIT = 0x08,
TYPEMASK_PLAYER = 0x10,
TYPEMASK_GAMEOBJECT = 0x20,
TYPEMASK_DYNAMICOBJECT = 0x40,
TYPEMASK_CORPSE = 0x80,
// CGUnit_C.m_objectFields slot. Different from CGItem's +0x114 —
// sibling classes use class-specific descriptor offsets. Inside the
// descriptor at +0x79 lives the class byte (UNIT_FIELD_BYTES_0
// field's second byte). Verified at 0x005183FE-0x00518404 in
// Script_UnitClass's general-unit-token path:
// mov edx, [eax + 0x110] ; descriptor
// movzx eax, byte [edx + 0x79] ; class
OFF_CGUNIT_OBJECT_FIELDS = 0x110,
// UNIT_FIELD_BYTES_0 packs race/class/sex/powerType into one dword
// at descriptor +0x78. Individual bytes:
OFF_UNIT_DESCRIPTOR_RACE_BYTE = 0x78,
OFF_UNIT_DESCRIPTOR_CLASS_BYTE = 0x79,
OFF_UNIT_DESCRIPTOR_SEX_BYTE = 0x7A,
// The local player's UNIT_FIELD_BYTES_0 race/class/sex bytes, mirrored
// into a login-time global that is populated at character-enter —
// BEFORE the in-world CGUnit/descriptor exists. Script_UnitClass
// (0x00518350) and Script_UnitRace special-case the literal "player"
// token to read these (Script_UnitClass calls FUN_005abde0 →
// `return DAT_00c27e81`), which is why UnitClass("player") resolves at
// addon-load while a descriptor read returns nil until the player
// object spawns. Getters: race FUN_005abdd0, class FUN_005abde0,
// sex FUN_005abdf0.
VAR_PLAYER_RACE_BYTE = 0x00C27E80,
VAR_PLAYER_CLASS_BYTE = 0x00C27E81,
VAR_PLAYER_SEX_BYTE = 0x00C27E82,
// SkillLineAbility.dbc — maps each (class, race) pair to its
// learnable spell list with skill-rank gating. Indexed by record
// ID; reads via the standard `records[id]` pattern. Used by
// `GetCurrentLevelSpells` to filter the global spell set down to
// entries our class/race can learn.
//
// Class instance VA `0x00C0D94C` per docs/DBCs.md. Standard 5-DWORD
// class shape so the records-array pointer slot sits at +0x08 and
// the count slot at +0x0C.
VAR_SKILL_LINE_ABILITY_RECORDS = 0x00C0D954,
VAR_SKILL_LINE_ABILITY_COUNT = 0x00C0D958,
// Record-internal offsets, vanilla 1.12 layout (CMaNGOS-canonical):
// +0x00 id
// +0x04 skillId (→ SkillLine.dbc; e.g. 44 = "Swords")
// +0x08 spellId (→ Spell.dbc — the spell taught by this entry)
// +0x0C raceMask (bit `1 << (race - 1)`; 0 = all races)
// +0x10 classMask (bit `1 << (class - 1)`; 0 = all classes)
// +0x14 excludeRace (bitmask of races this entry does NOT apply to)
// +0x18 excludeClass (bitmask of classes this entry does NOT apply to)
// +0x1C minSkillRank
// ... (more fields)
OFF_SLA_SKILL_ID = 0x04,
OFF_SLA_SPELL_ID = 0x08,
OFF_SLA_RACE_MASK = 0x0C,
OFF_SLA_CLASS_MASK = 0x10,
OFF_SLA_EXCLUDE_RACE = 0x14,
OFF_SLA_EXCLUDE_CLASS = 0x18,
// Skill-up threshold ranks (grey / green) at record fields 10/11.
// A row with either nonzero is a craftable recipe; profession
// rank-up / passive rows have both zero. Empirically: the
// Blacksmithing skill line has 343 SLA rows, 334 with a nonzero
// threshold — the 9 excluded are the Apprentice..Artisan rank
// spells and skill grants. This is the discriminator
// `TradeSkill::Link` uses to build the canonical recipe universe.
OFF_SLA_TRIVIAL_SKILL_HIGH = 0x28,
OFF_SLA_TRIVIAL_SKILL_LOW = 0x2C,
// SkillLine.dbc — the skill/category each SLA row points into via
// its `skillId` field. Each record carries a 9-locale localized
// name array (the user-facing tab name in the spellbook, profession
// header, weapon-skill name, etc.) plus a SpellIcon ID at +0x54.
// Standard 5-DWORD class instance at `0x00C0D924`; records-array
// pointer at `0x00C0D92C`, count at `0x00C0D930`.
//
// Record layout (verified against `Script_GetSpellTabInfo` at
// `0x004B3CE0`):
// +0x00 id
// +0x0C `Name[9]` — locale string pointers, indexed via the
// global locale at `0x00C0E080` (read as
// `*(char **)(record + 0x0C + locale * 4)`)
// +0x54 SpellIcon.dbc ID (looked up via `SpellIcon` for the
// spellbook tab/profession icon)
VAR_SKILL_LINE_RECORDS = 0x00C0D92C,
VAR_SKILL_LINE_COUNT = 0x00C0D930,
OFF_SKILL_LINE_NAME = 0x0C,
// Player's known-skills table — separate from the DBC. Populated
// by the engine on login from server data; entries are pointers
// to per-skill records. Each record's `+0x00` is the
// `SkillLine.dbc` row (or `0` for header / category rows), and
// `+0x10` is the current skill rank (other rank/modifier fields
// follow). Source: `Script_GetSkillLineInfo` at `0x004D3610`,
// which walks this array indexed by the Lua arg.
VAR_PLAYER_SKILL_LIST = 0x00B7318C,
VAR_PLAYER_SKILL_COUNT = 0x00B731B8,
OFF_PLAYER_SKILL_LINE_ID = 0x00,
OFF_PLAYER_SKILL_RANK = 0x10,
// Live per-skill current/max rank. These are NOT in
// `VAR_PLAYER_SKILL_LIST` (that entry's `+0x10` is numTempPoints) —
// the real ranks live in the CGPlayer `+0xE68` sub-struct
// (`OFF_CGPLAYER_INFO`). `FUN_SKILL_LINE_TO_SLOT`
// (`__thiscall(player, skillLineID) -> slot`) maps a SkillLine.dbc
// row to its slot; the slot indexes a `SKILL_INFO_STRIDE`-byte
// record at `[player+0xE68] + OFF_SKILL_INFO_TABLE + slot*stride`:
// current `+0x0`, max `+0x2`, rank bonus `+0x6` (all u16 — add the
// bonus when the base value is nonzero). Source: `Script_GetTradeSkillLine`
// (`0x004FDD40`) / `Script_GetSkillLineInfo` (`0x004D3610`). Verified
// in-game vs. those functions (Tailoring 261/300, Enchanting 186/240).
FUN_SKILL_LINE_TO_SLOT = 0x005EA3F0,
OFF_SKILL_INFO_TABLE = 0x84C,
SKILL_INFO_STRIDE = 0xC,
OFF_SKILL_INFO_CUR = 0x0,
OFF_SKILL_INFO_MAX = 0x2,
OFF_SKILL_INFO_BONUS = 0x6,
// Per-itemClass proficiency bitmap maintained by the engine.
// 17 u32 entries (indexed by Item.dbc `m_class`, 0..16). Each
// entry is a bitmask where bit N is set if the player has
// proficiency in subclass N of that item class — i.e.
// `table[4] & (1 << 3)` = "can wear Mail" (armor=class 4,
// mail=subclass 3).
//
// Populated by SMSG_SET_PROFICIENCY's handler at
// `FUN_005E7B70`, which writes `table[itemClass] = mask`
// verbatim from the packet. Same source the engine itself uses
// for equip eligibility (the tooltip "Mail" red-text logic
// and the cursor-drop-on-paperdoll check both read this). Note:
// covers **weapons too** (class 2), making it strictly more
// general than walking the per-skill-line table for individual
// armor proficiencies.
VAR_PROFICIENCY_TABLE = 0x00C4D4A0,
// Spell.dbc `BaseLevel` — the level a spell becomes available
// (trainer offers it, quest reward grants it, etc.). Distinct
// from `SpellLevel` at +0x74 which is the effective level used
// for damage scaling and resistance math. Per CMaNGOS-canonical
// 1.12 Spell.dbc layout; cross-checked against known fields at
// ±a few offsets (PowerType at +0x7C is verified).
OFF_SPELL_RECORD_BASE_LEVEL = 0x70,
// `UNIT_BYTES_1` (CMaNGOS field 132 in the 1.12.1 layout). 32-bit
// composite field; the low byte is the standstate (standing /
// sitting / sleeping / kneeling / etc.), the upper bytes hold
// PetTalents / VisFlag / AnimTier per CMaNGOS docs (uncalibrated
// for 1.12). Broadcast field, so the standstate works for any
// synced unit (player, target, party/raid, inspect targets) —
// not local-only.
//
// Verified via the `IsAssistingRitual` development session by
// observing `0xEE00 → 0xEE05` on `/sit` over a chair (the medium-
// chair sit value 5).
//
// Byte 3 (the AnimTier / misc-flags byte, mask 0x02000000 on the
// u32) is the **stealth / sneak flag**: set while the unit is in
// the sneaking anim tier (Rogue Stealth, Druid Prowl, Shadowmeld),
// which is what drives the client's semi-transparent render of a
// stealthed unit. Verified via `_classicapi_DiffAll`: a Prowl
// toggle from a Cat-Form baseline flips byte 3 `0x00 → 0x02` while
// every other descriptor change is aura-array slot metadata — so
// this is the only standalone broadcast bit that means "stealthed".
// Read by `IsStealthed()`.
OFF_UNIT_FIELD_BYTES_1 = 0x210,
UNIT_BYTES_1_STEALTH_FLAG = 0x02000000,
// `__fastcall(void)` engine helper that refreshes the bonus
// action bar from the local player's current shapeshift form
// (byte 2 of `UNIT_BYTES_1`, descriptor `+0x212`). Reads the form
// byte, looks up SpellShapeshiftForm.dbc's `bonusActionBar`
// column, stores it into `DAT_00BC6E88`, and fires
// `UPDATE_BONUS_ACTIONBAR` (event id `0xD9`).
//
// Called from two sites: once during post-login init from
// `FUN_004908C0`, and on every relevant UNIT_BYTES_1 broadcast
// update (the unrooted call at `0x005DE01B`, inside the
// local-player UpdateField dispatch). Hooked to synthesize
// modern `UPDATE_SHAPESHIFT_FORM` — the cached-byte gate in our
// hook filters out the non-form recomputes (this fires for any
// UNIT_BYTES_1 update, not just form changes).
FUN_BONUS_ACTIONBAR_UPDATE = 0x004E4FC0,
// Inner watched-faction setter — `__fastcall(ecx = factionID) → void`.
// The engine's `Script_SetWatchedFactionIndex` (0x004D6B60) is a
// thin Lua-side wrapper that takes a 1-based displayed-list index,
// resolves it to a factionID via FUN_RESOLVE_FACTION_INDEX, and
// forwards to this. Going through the wrapper requires a round-
// trip through the resolver (and excludes unencountered factions),
// so for `C_Reputation.SetWatchedFactionByID` we call this
// directly with the user-supplied factionID. factionID == 0
// clears the watched faction (the engine handles 0 as "no
// watched"). Updates `[player+0xE68]+0x10C4` and persists the
// value via the engine's CVar / event machinery.
FUN_PLAYER_SET_WATCHED_FACTION = 0x004D6240,
VAR_FACTION_DISPLAY_COUNT = 0x00B73764,
VAR_FACTION_VISIBLE_MAX_INDEX = 0x00B73760,
// Faction.dbc — standard 5-DWORD class shape, records pointer at +0x08
// and count at +0x0C of the class instance at 0x00C0DD48. Records is an
// array of `FactionRec *` indexed directly by factionID (1-based;
// records[0] is unused). We read it on the slow path of
// `GetFactionInfoByID` for factions the player has never encountered
// (i.e. not in the displayed reputation list), where the engine's
// `Script_GetFactionInfo` can't help us.
//
// Record name/description offsets verified by disassembling
// `Script_GetFactionInfo` at 0x004D6562 / 0x004D6573:
// mov edx, [edi+ecx*4+0x4C] ; Name[locale]
// mov edx, [edi+edx*4+0x70] ; Description[locale]
// Each is a 9-entry array of locale string pointers, indexed by
// `[VAR_LOCALE_INDEX]` (0..8).
VAR_FACTION_DBC_RECORDS = 0x00C0DD50,
VAR_FACTION_DBC_COUNT = 0x00C0DD54,
// RepListIndex on the Faction.dbc record. Maps factionID to the
// 0..63 slot in `VAR_PLAYER_REP_SLOTS`. Read by the engine's
// factionID→repListID helper at `0x004D5600` (called by
// FUN_FACTION_GET_AT_WAR / GET_CAN_TOGGLE_AT_WAR / IS_WATCHED).
// -1 means the faction has no rep slot (it's a category header).
OFF_FACTION_REP_LIST_INDEX = 0x04,
OFF_FACTION_PARENT_ID = 0x48,
OFF_FACTION_NAMES = 0x4C,
OFF_FACTION_DESCRIPTIONS = 0x70,
// Displayed-list category headers. `VAR_FACTION_HEADER_LIST` is a
// flat int32 array of header factionIDs (max 32 — engine bounds
// it at `0x1f`). `VAR_FACTION_HEADER_COUNT` is the live count.
// Special sentinel factionIDs `0` (FACTION_OTHER) and `-1`
// (FACTION_INACTIVE) may appear in this list for the "Other" and
// "Inactive" pseudo-rows.
//
// `VAR_FACTION_COLLAPSED_BITMASK` is a 32-bit mask where bit `i`
// SET means the header at `VAR_FACTION_HEADER_LIST[i]` is
// **expanded** (NOT collapsed) — bit CLEAR = collapsed. Default
// state at login is all-clear (all categories collapsed).
VAR_FACTION_HEADER_LIST = 0x00B736C0,
VAR_FACTION_HEADER_COUNT = 0x00B736B0,
VAR_FACTION_COLLAPSED_BITMASK = 0x0084A0A4,
MAX_FACTION_HEADERS = 32,
// Who-query (the /who system).
//
// `Script_SendWho` (0x005AD3B0) is a 32-byte wrapper:
// - validate arg1 is a string via lua_isstring
// - load WhoSystem singleton from `[VAR_WHO_SYSTEM]`
// - if non-NULL, lua_tostring(L, 1) for the query string
// - tail-call `FUN_WHO_SYSTEM_SEND_QUERY` with
// `__thiscall(this = WhoSystem, queryStr)`
//
// The query string follows the engine's standard /who filter syntax
// (`"n-Bob"`, `"r-Alliance"`, `"c-Warlock"`, etc.); the inner
// function at `FUN_WHO_SYSTEM_SEND_QUERY` (~1.5KB) does the
// parse + CMSG_WHO build + network send.
//
// `Script_SetWhoToUI` (0x005AD870) is even smaller — 13 bytes that
// store arg1 (as int, default 0) to `[VAR_WHO_TO_UI_FLAG]`. The
// SMSG_WHO response handler at ~0x005ADF80 reads the flag at
// `0x005ADF9C` to decide whether the results buffer into the
// engine's WhoList (flag != 0 → list path, friends-frame fires
// WHO_LIST_UPDATE; flag == 0 → results go to chat as
// `"Found N players matching..."`).
//
// Server-side cooldown for CMSG_WHO is ~5 seconds — a faster
// client gets silent-dropped, so any client-side gating just
// matches that.
VAR_WHO_SYSTEM = 0x00C28168,
VAR_WHO_TO_UI_FLAG = 0x00C2A12C,
FUN_WHO_SYSTEM_SEND_QUERY = 0x005AEBB0,
// SMSG_WHO opcode handler — opcode 0x63 (99) per the registration
// in `FUN_005adc50`: `FUN_005ab650(99, FUN_005adf60, 0)`. Reads
// `VAR_WHO_TO_UI_FLAG` mid-function (at `0x005ADF9C`) to decide
// between WhoList + WHO_LIST_UPDATE vs the chat-count printer.
//
// We hook post-original to restore the flag after each response
// so the routing override only affects responses we initiated.
// Otherwise a user-typed `/who` inheriting our flag=1 stays
// silent (no chat-count message, no FriendsFrame popup) when the
// user actually wanted both.
FUN_SMSG_WHO_RESPONSE = 0x005ADF60,
// Per-faction current standing — `__fastcall(ecx = factionID) → int`.
// Returns `base + delta` where the two values are stored at
// `+0x08` / `+0x0C` of the player's rep slot (slot stride 0x10,
// 64 slots at `0x00B73290`). Returns 0 for factionIDs not in the
// player's reputation list (i.e. unencountered). Used by the
// FACTION_STANDING_CHANGED event firing to push the live total
// after the engine's setter has written the new delta.
FUN_REPUTATION_GET_STANDING = 0x004D6370,
// Reaction-band classifier — `__fastcall(ecx = factionID) → int`.
// Internally calls `FUN_REPUTATION_GET_STANDING` and maps the total
// through the 7-band threshold ladder (Hated..Exalted). Returns
// 0..7 (0=Hated, 7=Exalted); `Script_GetWatchedFactionInfo` pushes
// this `+ 1` to produce the 1..8 standingID Lua addons see.
FUN_REPUTATION_GET_REACTION_BAND = 0x004D63A0,
// Reputation-list slots — the player's 64-entry per-faction rep
// store. Stride `0x10`; layout per entry:
// +0x00 i32 factionID (0 if slot unused)
// +0x04 u8 flags (bit 1 = atWar, bit 4 = canToggleAtWar)
// +0x08 i32 base standing
// +0x0C i32 delta standing
// Slot index = RepListID = Faction.dbc record `+0x04`. Indexed by
// `FUN_004D5600(factionID) → repListID`. Reverse direction is
// `FUN_004D5620(repListID) → factionID`.
VAR_PLAYER_REP_SLOTS = 0x00B73290,
REP_SLOT_STRIDE = 0x10,
OFF_REP_SLOT_FACTION_ID = 0x00,
OFF_REP_SLOT_FLAGS = 0x04,
OFF_REP_SLOT_BASE_STANDING = 0x08,
OFF_REP_SLOT_DELTA_STANDING = 0x0C,
REP_SLOT_FLAG_AT_WAR = 0x02,
// "Peace forced" — when SET, the player CAN'T toggle this faction
// to/from at-war (e.g. your own home cities, certain quest
// factions). Decoded from `FUN_FACTION_GET_CAN_TOGGLE_AT_WAR` at
// `0x004D61E0`, which reads bit `0x10` of the flags byte and
// `Script_GetFactionInfo` pushes `canToggleAtWar=false` when set.
// Note: the bit's MEANING is "can't toggle" — `canToggleAtWar` is
// its inverse, NOT its value.
REP_SLOT_FLAG_PEACE_FORCED = 0x10,
// INACTIVE flag — set by `Script_SetFactionInactive` (the "Inactive"
// collapsible category in FactionFrame). Toggles via
// `FUN_FACTION_SET_INACTIVE`; same byte as AT_WAR and PEACE_FORCED.
REP_SLOT_FLAG_INACTIVE = 0x20,
MAX_REP_SLOTS = 64,
// Static reaction-band threshold tables, indexed by reaction band
// 0..7 (returned by `FUN_REPUTATION_GET_REACTION_BAND`). The pair
// gives the `[min, max)` standing range that defines each band —
// currentReactionThreshold / nextReactionThreshold for modern
// `C_Reputation.GetWatchedFactionData`-style table fields.
VAR_REACTION_MIN_TABLE = 0x0080928C,
VAR_REACTION_MAX_TABLE = 0x00809290,
// `[player +0xE68] + 0x10C4` — the RepListID (rep-slot index) of
// the faction currently being watched (the one shown above the XP
// bar). Written by `FUN_PLAYER_SET_WATCHED_FACTION` after
// translating the user-supplied factionID via
// `FUN_004D5600 → RepListID`. Negative or out-of-range means "no
// watched faction", which `Script_GetWatchedFactionInfo` checks
// against `FUN_004D5620(slot)`'s return.
OFF_CGPLAYER_INFO_WATCHED_REP_LIST_ID = 0x10C4,
// `FactionSetAtWar(factionID, newState)` — `__fastcall(ecx = factionID,
// edx = char newState)`. The sole worker behind
// `Script_FactionToggleAtWar` (`0x004D6950`); the script wrapper just
// reads the current at-war flag, negates it, and tail-calls here.
//
// Validates (only when turning OFF) that current standing ≥ -3000,
// resolves factionID → repListID, bails if the player is in a loot
// session (UNIT_FIELD_FLAGS bit `0x80000`, error code `0x1A1`),
// mutates the rep-slot flag byte (`AT_WAR` gated by `PEACE_FORCED`),
// and sends `CMSG_SET_FACTION_ATWAR` (opcode `0x125`).
//
// **Does NOT fire `UNIT_FACTION`** — a vanilla engine omission. 3.3.5
// added a `FUN_0071F8F0(player, 0)` call here, whose inner
// `FUN_0060BF10(playerGUID, UNIT_FACTION_id)` dispatches the event
// for every unit token referencing the player. We polyfill by
// hooking this function and firing `UNIT_FACTION("player")` post-
// original (see `src/faction/UnitFactionPolyfill.cpp`).
FUN_FACTION_SET_AT_WAR = 0x004D5FD0,
// `FactionSetInactive(factionID, newState)` — `__fastcall(ecx = factionID,
// edx = char newState)`. Inner setter behind `Script_SetFactionInactive`
// (`0x004D69B0`, sets INACTIVE bit) and `Script_SetFactionActive`
// (`0x004D6A00`, clears it) — both script wrappers tail-call here.
//
// Resolves factionID → repListID via `FUN_004D5600`, mutates the
// rep-slot flag byte (sets/clears `INACTIVE` = `0x20`), writes via
// `FUN_004D5FC0`, sends `CMSG_SET_FACTION_INACTIVE` (opcode `0x317`),
// then calls `FUN_004D5C40` (recompute displayed-list, fire
// `UPDATE_FACTION` event `0x174`).
//
// **Does NOT fire `UNIT_FACTION`** — same engine omission as the at-
// war setter. Polyfilled in `src/faction/UnitFactionPolyfill.cpp`.
FUN_FACTION_SET_INACTIVE = 0x004D60F0,
// SMSG_SET_FACTION_ATWAR handler — `__stdcall(uint32_t opcode,
// void *packet)`. Fires when the server force-changes the player's
// at-war state on a faction (e.g., a flag the player can't toggle
// changes server-side, or faction reset). Reads `(u32 repListID,
// u8 flags)`, mutates AT_WAR on the slot accordingly, writes via
// `FUN_004D5FC0`, then fires `UPDATE_FACTION` (event `0x174`).
//
// **Does NOT fire `UNIT_FACTION`** — 3.3.5 does (unconditionally
// after the byte write). Polyfilled in
// `src/faction/UnitFactionPolyfill.cpp`.
FUN_SMSG_SET_FACTION_ATWAR = 0x004D56B0,
// SMSG_INITIALIZE_FACTIONS handler — `__stdcall(uint32_t opcode,
// void *packet)`. Fires once at login from the SMSG dispatcher. Reads
// a count, then loops `(u8 flags, i32 standing)` pairs into the
// 64-entry rep slot array: `FUN_004D5FC0(slot, flags)` +
// `FUN_004D6330(slot, standing, 0 /*notify*/)`. Trailing
// `FUN_004D5430` rebuilds the displayed-list snapshot, then fires
// `UPDATE_FACTION` (event `0x174`).
//
// **Does NOT fire `UNIT_FACTION`** — modern WoW does. Addons that
// observe UNIT_FACTION miss the initial sync entirely in vanilla.
// Polyfilled in `src/faction/UnitFactionPolyfill.cpp`.
FUN_SMSG_INITIALIZE_FACTIONS = 0x004D5640,
// SMSG_SET_FACTION_STANDINGS handler — `__stdcall(uint32_t opcode,
// void *packet)`. Fires once per server-pushed rep change (kills,
// quest turn-ins, etc.). Reads count, loops `(flags, standing)`
// pairs, calling `FUN_004D6330(slot, standing, 1 /*notify*/)` which
// routes through `FUN_REPUTATION_FIRE_NOTIFY` for the
// `CHAT_MSG_COMBAT_FACTION_CHANGE` dispatch.
//
// Also mutates AT_WAR / VISIBLE flag bits as standing crosses
// thresholds (e.g., recovering to -2999 clears the force-set AT_WAR
// from "below Hated"). **Vanilla doesn't fire `UNIT_FACTION` for
// these side-effect flag flips**; modern 3.3.5 does. Polyfilled in
// `src/faction/UnitFactionPolyfill.cpp` — snapshots the 64-entry
// flag-byte array before/after and fires a single
// `UNIT_FACTION("player")` if any bit changed.
FUN_SMSG_SET_FACTION_STANDINGS = 0x004D5760,
// `__fastcall(ecx = factionID, edx = signedDelta)`. This is the
// engine's "reputation changed, fire the chat event" notify
// helper — it formats the localized chat message and dispatches
// `CHAT_MSG_COMBAT_FACTION_CHANGE`. Called from `FUN_004D6330`
// (the per-slot setter) at `0x004D635C`, only when:
// 1. The stored standing value actually changed for this slot.
// 2. The setter's `notify` arg was non-zero (i.e. the call
// came from the per-update SMSG handler, not the bulk init
// handler that runs at login).
// Hooking here matches modern WoW's `FACTION_STANDING_CHANGED`
// semantics: fires once per real reputation change, skipping the
// initial faction sync at login. ECX/EDX layout means the hook
// can read factionID + delta in registers; for the modern
// `(factionID, newStanding)` payload, call
// `FUN_REPUTATION_GET_STANDING(factionID)` from inside the hook
// (the setter has already written the new value by this point,
// so it returns the updated total).
FUN_REPUTATION_FIRE_NOTIFY = 0x0062C5F0,
// Quest static-info cache (the client-side cache of QUEST_QUERY_RESPONSE
// payloads — descriptions, objectives, reward text). Same five-arg
// `_GetRecord` shape as the item cache, keyed by questID. Verified by
// tracing `Script_GetQuestLogQuestText` (`0x004DFF20`):
// 1. `[VAR_QUEST_LOG_SELECTED_QUEST_ID]` is the *questID* of the
// selected entry (not a pointer) — populated from
// `mov eax, [esi + 0x00BB71C0]` which reads field +0 of a
// `VAR_QUEST_LOG_ENTRIES` row, i.e. the questID itself.
// 2. That value is passed as the `key` arg to `_GetRecord`, then
// hashed via `key & cache.mask` and matched with `cmp [bucket], key`.
//
// Cache-hit-already-loaded shortcut: if `[entry+0x18F8]` is set, the
// function returns `entry+0x18` immediately and does NOT invoke the
// queued callback. Modules that want a notification regardless of
// cache state must fire it themselves (see `Item::Data` for the same
// pattern).
//
// Callback shape verified at the dispatch sites near 0x00562EEB et al.:
// `mov ecx, [entry+0x18]; push 1; push ecx; call [entry+8]`
// → `__stdcall(void *userData, int success)` where `userData` is
// `arg4` we passed to `_GetRecord` (engine stores it at
// `entry+0x18` and replays it without dereferencing).
VAR_QUEST_CACHE = 0x00C0E1B0,
FUN_DBCACHE_QUEST_GET_RECORD = 0x00562A40,
VAR_QUEST_LOG_SELECTED_QUEST_ID = 0x00BB7480,
// Creature cache (creaturecache.wdb, SMSG_CREATURE_QUERY_RESPONSE).
// One instance of the generic client query-cache class; constructed
// by the cache factory (FUN_00554b40 -> FUN_00556060 with sig
// 'BOMW', "creaturecache.wdb", recordSize 0x60).
VAR_CREATURE_CACHE = 0x00C0E354,
// Creature-cache `_GetRecord` — `__thiscall(cache, id, const u64 *guid,
// void *callback, void *userData, char dedup)`. Returns the data
// block (entry+0x18) when loaded; with `callback==0` it only peeks
// (no query), with a non-null callback it fires the network query on
// a miss. Class-specific (reads the loaded flag at entry+0x50);
// gameobjects are a sibling class with a different layout and their
// own `_GetRecord` (FUN_GAMEOBJECT_GET_RECORD). Verified via
// FUN_00604600 (`FUN_00556aa0(creatureID, &guid, cb, 0, 0)`).
FUN_CREATURE_GET_RECORD = 0x00556AA0,
// Creature-cache response parser — `__thiscall(cache, packetReader,
// flag)`. Fills the entry data block, sets the loaded flag (entry+0x50),
// and walks the entry's pending-callback list. The creature SMSG
// handler `FUN_005550E0` calls it with ecx=the creature cache.
// `Cache::QueryLoad` hooks it to fire CREATURE_DATA_LOAD_RESULT. The
// item/quest caches have their own parsers, so it's conflict-free.
FUN_CREATURE_QUERY_RESPONSE = 0x00556E20,
// Creature-query record field offsets, within the data block returned
// by FUN_CREATURE_GET_RECORD. Anchored by rank@+0x20 (read by the
// classification helper FUN_00605620 as `[block+0x20]`) and the
// wire/WDB field order (Name[4], SubName, typeFlags, type, family,
// rank, unk, petSpellDataId, displayId), cross-checked against real
// creaturecache.wdb rows (Misthoof Stag 61332 -> type 1; Nordrassil
// Nymph 61582 -> type 7, rank 1). Strings are char* (the fixed 0x60
// block holds pointers, not the WDB's inline strings).
OFF_CREATURE_NAME = 0x00, // char *Name[4]; [0] is the primary name
OFF_CREATURE_SUBNAME = 0x10, // char *SubName (title); "" if none
OFF_CREATURE_TYPE = 0x18, // CreatureType (1=Beast, 7=Humanoid, ...)
OFF_CREATURE_FAMILY = 0x1C, // CreatureFamily
OFF_CREATURE_RANK = 0x20, // 0=normal,1=elite,2=rareelite,3=worldboss,4=rare
OFF_CREATURE_DISPLAYID = 0x2C, // creature model display ID
// GameObject cache (gameobjectcache.wdb, SMSG_GAMEOBJECT_QUERY_RESPONSE).
// Sibling cache class to creature (constructed by FUN_00554B90 ->
// FUN_00557bd0, sig 'BOGW', recordSize 0x5E) — same struct shape but a
// different vtable (0x0080913C) and a LARGER entry (loaded flag at
// entry+0x98, not +0x50), so it has its own `_GetRecord` and parser.
VAR_GAMEOBJECT_CACHE = 0x00C0E318,
// GO `_GetRecord`, same signature as the creature one. Verified via
// FUN_0062dc10 (`FUN_00558560(goEntry, &guid, 0,0,0)` then reads the
// GO name at `[block+0x08]`).
FUN_GAMEOBJECT_GET_RECORD = 0x00558560,
// GO response parser — `__thiscall(cache, packetReader, flag)`. The GO
// SMSG handler `FUN_00555100` calls it with ecx=the GO cache. Distinct
// from the creature parser (sets loaded flag at entry+0x98), so
// `Cache::QueryLoad` hooks it separately to fire GAMEOBJECT_DATA_LOAD_RESULT.
FUN_GAMEOBJECT_QUERY_RESPONSE = 0x005588E0,
// GO-query record field offsets, within the data block returned by
// FUN_GAMEOBJECT_GET_RECORD. Wire/WDB order: type, displayId, Name[4],
// then a 24-int data[] array. name@+0x08 verified (FUN_0062dc10 reads
// `[block+0x08]` as the name); type@+0x00 / displayId@+0x04 follow from
// the field order, cross-checked against real gameobjectcache.wdb rows
// (Windrunner type 15 displayId 7087; Mesa Elevator 47297 type 11
// displayId 360).
OFF_GAMEOBJECT_TYPE = 0x00, // GameObjectType (0=door,3=chest,…)
OFF_GAMEOBJECT_DISPLAYID = 0x04, // model display ID
OFF_GAMEOBJECT_NAME = 0x08, // char *Name[4]; [0] is the primary name
// Action bar slot table — `uint[120]` (max slot index `< 0x78`).
// Each entry is a packed action descriptor; top 4 bits are the type
// tag, low 28 bits are the payload. Tags:
//
// 0x00000000 spell action; payload = spellID
// 0x40000000 bag-item or macro action; payload `entry & 0xBFFFFFFF`
// is a 36-entry slot key. Disambiguate by checking the
// macro-slot map at `VAR_MACRO_SLOT_MAP` — if the
// payload matches any entry there, the slot is a macro
// (and the matching index is its 1-based macro slot);
// otherwise it's a bag-item reference. SuperWoWhook's
// modified `GetActionText` uses exactly this walk to
// surface macros to Lua.
// 0x80000000 item-by-ID action; payload (entry & 0x7FFFFFFF) IS
// the itemID. Queries the global item cache directly.
//
// `entry == 0` means empty. Engine bounds-checks `slot < 0x78` in
// every reader (verified at `Script_HasAction = 0x004E70D0`, helpers
// at `0x004E5A50`, `0x004E6A50`).
VAR_ACTION_TABLE = 0x00BC6980,
ACTION_TABLE_MAX_SLOTS = 0x78,
// Engine helper used by every action reader to extract the spellID
// associated with a slot (spells return directly; bag-items return
// their triggered spell; item-by-ID returns the first valid
// m_spells[N].SpellID from the item cache). Pet/spell discriminator
// returned via the second arg.
// __fastcall uint(uint slot0Based, uint *outPetFlag)
FUN_ACTION_SLOT_TO_SPELL = 0x004E5A50,
ACTION_TYPE_MASK = 0xF0000000,
ACTION_TYPE_SPELL = 0x00000000,
// 0x40000000 entries are ambiguous: they're either a bag item or a
// macro. Discriminator: walk the 36-entry macro-slot map and check
// whether `entry & 0xBFFFFFFF` matches one of those macro IDs. This
// is exactly what SuperWoWhook's modified `GetActionText` does to
// surface macros to Lua. Engine helper `FUN_004F0EC0` does the same
// walk and returns slot-index or -1.
ACTION_TYPE_BAG_OR_MACRO = 0x40000000,
ACTION_TYPE_ITEM_BY_ID = 0x80000000,
ACTION_PAYLOAD_MASK_BAG_OR_MACRO = 0xBFFFFFFF,
ACTION_PAYLOAD_MASK_ITEM_BY_ID = 0x7FFFFFFF,
// Per-character macro-slot map (uint[36]). Entry N holds the macroID
// of the macro in slot N (0 = empty slot). The same memory is used
// to look up macros by hash in `FUN_004F0E40` (Script_GetMacroInfo)
// and by slot in `FUN_004F0EC0` (linear search for "is this entry
// value a known macro?").
VAR_MACRO_SLOT_MAP = 0x00BDCC60,
MACRO_SLOT_MAP_COUNT = 0x24,
// Macro slot → `MacroEntry *` resolver — `__fastcall(uint slot0Based)`.
// Returns the MacroEntry struct pointer for the given 0-based slot,
// or NULL when the slot is empty / out of range. Same accessor
// `Script_GetMacroInfo` uses; we call it directly to read the
// engine's cached primary-spell ID at `entry + OFF_MACRO_PRIMARY_SPELL`
// without re-parsing the body. See `Macro::Spell::Script_GetMacroSpell`.
FUN_MACRO_SLOT_TO_ENTRY = 0x004F0E40,
// Macro-icon database. Populated lazily by `FUN_LOAD_MACRO_ICONS`
// on the first `GetNumMacroIcons` call — enumerates `Interface\Icons\`
// for `*.blp` files plus a wildcard match, sorts, and de-dupes. Each
// entry is the basename (e.g. `"Ability_Kick"`) without the
// `Interface\Icons\` prefix; vanilla's `Script_GetMacroIconInfo`
// joins the prefix via sprintf before pushing. Verified by reading
// `Script_GetNumMacroIcons` (`0x004F19F0`) and
// `Script_GetMacroIconInfo` (`0x004F1A30`).
//
// Vanilla's loader has 3 enumeration passes, each with a per-file
// callback. The first two (`FUN_MACRO_ICON_CB_DISK`,
// `FUN_MACRO_ICON_CB_USER_MPQ`) prefix-filter on `"Ability_"` and
// `"Spell_"` — anything else (including `INV_*` item icons) is
// rejected. The third (`FUN_MACRO_ICON_CB_INSTALL_MPQ`) reads as
// extension-only filter in the disassembly (any `.blp`/`.tga` is
// accepted), but the engine's main icon DB ends up with zero
// `INV_*` entries regardless (`GetNumMacroIcons() == 746`, all
// `Ability_*`/`Spell_*`). Best guess: a check inside the
// `SStrDup`/array-append helpers downstream of all three callbacks
// filters them out — but the per-file callbacks themselves DO see
// `INV_*` filenames (verified by hook capture: 5,226 unique
// `INV_*` basenames flow through the callbacks per session).
//
// For `C_Macro::GetMacroItemIcons` we hook each callback at its
// entry, capture any `INV_*` filename into a DLL-owned side array,
// then forward to the original — dodges whichever downstream
// filter the engine applies and matches the parallel item-icon
// array 4.3.4 exposes (via `Script_GetMacroItemIcons`).
VAR_MACRO_ICON_COUNT = 0x00BDCC1C, // uint32 count of loaded icons
VAR_MACRO_ICON_ARRAY = 0x00BDCC20, // char ** — pointer to flat array of icon-name C strings (4-byte stride)
FUN_LOAD_MACRO_ICONS = 0x004F0090, // `__cdecl()` lazy populate; no-op if already loaded
FUN_MACRO_ICON_CB_DISK = 0x004F0220, // disk enumerator callback — `__fastcall(const char *fullPath)` — prefix-filtered
FUN_MACRO_ICON_CB_USER_MPQ = 0x004F0350, // user-MPQ enumerator callback — `__fastcall(MpqRecord *r)` — prefix-filtered
FUN_MACRO_ICON_CB_INSTALL_MPQ = 0x004F04F0, // install-MPQ enumerator callback — `__fastcall(MpqRecord *r)` — extension-only filter
// Quest log: 16-byte-stride entry array and active count.
// Field +0 of each entry is the questID for real quests (a category index
// for headers); field +8 is the header indicator: non-NULL = header,
// NULL = real quest. Verified by Script_GetQuestLogTitle's isHeader push
// at 0x004DF9A9 and by the helper at 0x004DF150 used by IsUnitOnQuest.
VAR_QUEST_LOG_ENTRIES = 0x00BB71C0,
VAR_QUEST_LOG_ENTRY_COUNT = 0x00BB7478,
OFF_QUEST_LOG_ENTRY_STRIDE = 0x10,
OFF_QUEST_LOG_ENTRY_QUEST_ID = 0x0,
OFF_QUEST_LOG_ENTRY_HEADER_PTR = 0x8,
// The single chokepoint that rebuilds the quest log from the
// player's authoritative quest-slot data at `[CGPlayer + 0xE68 +
// 0x28]` (a 0xF0-byte block holding the engine's quest sync state).
// Called by the engine after every quest state change that needs
// the Lua-visible log refreshed — accept, abandon, completion,
// objective updates, login bulk sync. Signature:
//
// __fastcall void FUN_QUEST_LOG_REBUILD(int param_1)
//
// If `param_1 == 0`, the function just fires QUEST_LOG_UPDATE
// (event ID 0x134) via `FUN_00703E50` and returns — a no-op
// rebuild signal. If non-zero, it `memset`s the entry array,
// walks the player's slot data, repopulates `VAR_QUEST_LOG_ENTRIES`
// / `VAR_QUEST_LOG_ENTRY_COUNT`, then fires QUEST_LOG_UPDATE.
//
// Hooked by `Quest::LogEvents` to snapshot the log pre-/post-rebuild
// and fire `QUEST_ACCEPTED(logIndex, questID)` / `QUEST_REMOVED(questID)`
// for the diff. Single quiet target in the `0x004DExxx` quest region —
// no known DLL collisions.
FUN_QUEST_LOG_REBUILD = 0x004DE510,
// Player and pet spellbooks — flat int32 arrays indexed by 0-based slot.
// Each entry is a spellID (0 for unused slots). Engine bounds-checks
// each slot against an absolute max of `SPELLBOOK_MAX_SLOTS = 0x400`
// before indexing (see `Script_GetSpellName` at `0x004B3FE0` and the
// `cmp eax, 0x400; jb` guard at `0x004B4018`); the actual populated
// count is much smaller, but slots past the populated range simply
// hold 0, which we surface to Lua as nil.
//
// Used by `Spell::Lookup::SpellbookSlotToID` to support the
// `GetSpellInfo(slot, bookType)` overload.
VAR_PLAYER_SPELLBOOK = 0x00B700F0,
VAR_PET_SPELLBOOK = 0x00B6F098,
SPELLBOOK_MAX_SLOTS = 0x400,
// Player-spell-knowledge bitmap — `[VAR_PLAYER_SPELL_BITMAP]` is a
// pointer to a dword bitmap covering all spellIDs the player has
// learned, including talent passives, racials, profession recipes,
// and anything else granted via SMSG_LEARNED_SPELL / set in
// SMSG_INITIAL_SPELLS. One bit per spellID:
//
// bit set ⟺ player knows this spellID
// bitmap[spellID >> 5] & (1 << (spellID & 31))
//
// Verified by decoding the engine helper at `0x0060C740` (called
// from `Script_GetTalentInfo`'s currentRank-derivation loop). Matches
// the same bitmap pattern 5.4.8 uses for its `IsPlayerSpell`
// (instance moved to `[0x011C25D8]` in that build).
//
// Bitmap covers spellIDs 0..VAR_SPELL_RECORD_COUNT inclusive — the
// size matches Spell.dbc's row count. Pre-login the slot is NULL.
VAR_PLAYER_SPELL_BITMAP = 0x00B710FC,
// Player spell-knowledge writers — the two functions that mutate the
// bitmap above. Learn (`FUN_004b25b0`) sets the bit, rebuilds the
// spellbook arrays, and fires SPELLS_CHANGED; unlearn (`FUN_004b2c50`)
// clears the bit and removes the spell. Both `__fastcall`: learn is
// (uint spellID, int notify, uint replacedSpellID), unlearn is
// (uint spellID, int). Co-hooked (spell/Info.cpp) to bump
// Player::StatSignal so a talent respec invalidates GetSpellBonusHealing's
// talent-conversion cache. They fire at login (SMSG_INITIAL_SPELLS) and on
// each learn/unlearn — never per-frame, so cool hook targets.
FUN_LEARN_SPELL = 0x004B25B0,
FUN_UNLEARN_SPELL = 0x004B2C50,
// Spell-rank-chain knowledge check — `char __thiscall(player /*ecx*/,
// spellID)`. Walks `spellID`'s forward rank chain (the class/race-
// resolved chain via `0x0060C7C0`) and returns nonzero if the player
// knows any *higher* rank than `spellID` (each node tested through the
// bitmap helper `0x0060C740`). The item tooltip's "Requires <spell>"
// gate is `bitmap(spellID) OR this(spellID)`; C_PlayerInfo.CanUseItem
// mirrors that so a RequiredSpell satisfied by a higher known rank
// still passes. Does NOT test `spellID` itself — that's the caller's
// direct bitmap check.
FUN_SPELL_RANK_CHAIN_KNOWN = 0x0060C8D0,
// Per-spell cooldown query. `__fastcall(int spellID, int bookType,
// int *outDuration, int *outStart, int *outEnable)`. Same path
// `Script_GetSpellCooldown` (`0x004B40A0`) uses internally after
// resolving the (slot, bookType) Lua args to a spellID — we
// bypass the slot resolution and pass spellID directly with
// `bookType=0` (player) since that's the standard
// `IsUsableSpell(spellID)` use case. `outDuration > 0` means the
// spell is currently on cooldown.
//
// **Argument order**: verified via `Script_C_Spell_GetSpellCooldown`
// round-trip test (Blink, spellID 1953) — the third arg receives
// the cooldown duration (e.g. 15000 ms for Blink), the fourth
// receives the engine tick count at start (`FUN_OS_TICKCOUNT_MS`).
// Both are 0 when no cooldown is active. The CMaNGOS-leaning
// documentation in other emulator projects has these reversed —
// don't trust it for this entry.
FUN_SPELL_QUERY_COOLDOWN = 0x006E2EA0,
// Per-item cooldown query — `bool __fastcall(uint itemID,
// int *outDuration, int *outStart, uint *outEnable)`. Looks up
// the item's `ItemStats_C` record via the cache, finds the slot
// with trigger = ON_USE (`OFF_ITEMSTATS_SPELL_TRIGGER[i] == 0`),
// and queries that spell's cooldown via the shared
// `FUN_006E13E0` against the player-spell manager
// (`DAT_00CECAEC`). Returns `true` when a cooldown is active.
//
// Same `(*outDuration, *outStart, *outEnable)` order as
// `FUN_SPELL_QUERY_COOLDOWN`, so the unit conversion is
// identical: multiply both by 0.001 to convert engine ms →
// `GetTime()`-compatible seconds.
//
// **Calling convention gotcha**: the Ghidra decomp labels the
// first arg `uint *` because the ItemStats cache lookup uses
// it both as a hash key and as the cached-entry field-0 match
// target (a `uint *` typed slot). The actual fastcall value is
// the itemID integer itself, NOT a pointer to it — passing
// `&itemID` makes ItemStats interpret the stack address as the
// itemID and the lookup silently fails.
FUN_ITEM_QUERY_COOLDOWN = 0x006E2ED0,
// Spell.dbc reagent fields. Reagent[8] (itemIDs) at +0xA8;
// ReagentCount[8] (counts) at +0xC8. Verified empirically by
// decompiling `BuildSpellTooltip` at 0x0052E610 — its reagent-
// loop iterates `localSpellRec + 0x2A` (dword arithmetic, byte
// +0xA8) as itemIDs and indexes `[+8]` (dword 0x32, byte +0xC8)
// for counts. Walked by both the tradeskill / craft scraper's
// `Spell::Lookup::NthRecipeReagentItemID` and `IsUsableSpell`'s
// reagent gate.
//
// **Don't trust CMaNGOS for these offsets.** A prior version of
// this entry placed reagents at +0x110 / +0x130 per CMaNGOS
// vanilla `SpellEntry`, but 1.12.1's actual record layout
// diverges from CMaNGOS for reagent fields — those offsets read
// unrelated data that's always 0 for normal spells, so
// IsUsableSpell's reagent check silently passed every spell.
// The "verified previously" PowerType=+0x7C / ManaCost=+0x80
// CMaNGOS alignment held for earlier fields but breaks before
// the reagent block.
OFF_SPELL_REAGENT_ID = 0xA8,
OFF_SPELL_REAGENT_COUNT = 0xC8,
SPELL_MAX_REAGENTS = 8,
// Per-spell *runtime* state cache, indexed by spellID via a hash
// table (mask at `[VAR_SPELL_STATE_HASH_MASK]`, base at
// `[VAR_SPELL_STATE_HASH_BASE]`). The engine maintains the cache as
// player state changes — cooldown, silence, GCD, mana balance, etc.
// each update flips the relevant byte. The action-bar usability
// path at `0x004E5BA0` reads `+0x564` (usable) and `+0x568`
// (noMana) directly off this cache; we do the same to back
// `IsUsableSpell` / `C_Spell.IsSpellUsable`.
//
// `FUN_SPELL_LOOKUP_STATE` is `__fastcall(int spellID) → void *`
// — the hash-walking helper. Returns null for spells the player
// doesn't know (cache only holds known spellIDs) or pre-login
// (when `[VAR_SPELL_STATE_HASH_MASK]` is `-1`).
FUN_SPELL_LOOKUP_STATE = 0x004F0F40,
OFF_SPELL_STATE_USABLE = 0x564,
OFF_SPELL_STATE_NO_MANA = 0x568,
// Spell description format helper. Reads the locale-resolved description
// string from `record[+0x228 + locale*4]` and walks it character-by-
// character substituting `$s1`/`$d`/`$o`/etc. placeholders with values
// computed from the spell record. Engine has 8 callers (the spell
// tooltip builder at 0x52F717, the talent UI, the trainer, ...). The
// global cursor at `0x00BE0B80` is the helper's parser state; it sets
// and walks it internally, so callers don't manage it.
//
// Calling convention (verified at 0x52F717 et al.):
// void __fastcall(
// void *spellRecord, // ecx — Spell.dbc record ptr
// char *outputBuffer, // edx — caller-provided, null-terminated on return
// int bufLen, // [ebp+0x08]
// int contextFlag, // [ebp+0x0C] — small int the talent/trainer paths
// // compute from a UI-state global; 0 is the safe
// // "no scaling context" default
// int reserved3, // [ebp+0x10] — always 0 across the 8 callers
// int useToolTipText, // [ebp+0x14] — 0=description (+0x228),
// // non-zero=ToolTip (+0x24C with fallback to +0x228)
// int reserved5, // [ebp+0x18] — always 1 across the 8 callers
// int reserved6 // [ebp+0x1C] — always 0 across the 8 callers
// );
FUN_FORMAT_SPELL_DESCRIPTION = 0x005075F0,
// The currently-auto-repeating spellID (0 when nothing is
// auto-repeating). Same dword backs Shoot/Wand/Auto-Shot — no
// per-class branching. Written by the cast-start path at
// `FUN_006E54F0` (line `DAT_00ceac30 = *piVar5;` where `piVar5` is
// the Spell.dbc record) and cleared on logout/world unload. Read by
// `Script_IsAutoRepeatAction`'s inner helper at `0x004E55B0` and
// exposed as a 1-line getter at `0x006E9FD0`.
VAR_ACTIVE_AUTO_REPEAT_SPELL = 0x00CEAC30,
// Currently-casting spellID. Written by the cast-start helper at
// `FUN_006E4AD0` (`__fastcall(spellID, targetState)`) — when a
// new cast begins, the function pushes the previous active
// spellID into `VAR_QUEUED_CAST_SPELL` and writes the new one
// here. Read by `Script_SpellStopCasting` via its
// `is-currently-casting` predicate at `FUN_006E3D30` (returns
// `DAT_00CECA88 != 0`) and the spellID-returning getter at
// `FUN_006E3D10`. Non-zero means "the cast bar is showing this
// spell"; cleared to 0 when the cast finishes or is cancelled.
VAR_CURRENT_CAST_SPELL = 0x00CECA88,
// The cast-start state writer — `__fastcall(int spellID, int
// targetState)`. Sets `VAR_CURRENT_CAST_SPELL` (pushing any current
// spell into `VAR_QUEUED_CAST_SPELL`; `spellID == 0` restores the queued
// one). `Spell::Cast` co-hooks it for lag-free, client-side detection of
// NORMAL player casts (stamps from the spellID arg before the original).
// It does NOT fire for a chained same-spell recast: the caller
// `Spell_C_CastSpell` (`0x006E4B60`) short-circuits at `spellID ==
// VAR_CURRENT_CAST_SPELL` *before* reaching here, so those never run the
// client cast path — they're caught by the `SMSG_SPELL_START` backstop
// instead. nampower hooks the higher Spell_C_CastSpell, not this inner
// writer, so contention is low.
FUN_CAST_START_SET = 0x006E4AD0,
// Previous / queued cast — holds the spellID that was active
// before the latest one superseded it (mid-GCD queueing in
// vanilla). When the current cast ends, `FUN_006E4AD0(0, ...)`
// restores this into `VAR_CURRENT_CAST_SPELL`. Modern
// `C_Spell.IsCurrentSpell` covers both "casting now" and "queued
// to cast next", so we check this slot too.
VAR_QUEUED_CAST_SPELL = 0x00CECAA8,
// Spell-placement state bitmask. Non-zero when the engine is
// waiting on user input for an in-progress cast — the AoE reticle,
// unit-target cursor, trade-target cursor, etc. Bits encode what
// kind of input is needed; the engine's click handlers read this
// to decide whether a click was relevant. Read by
// `Script_SpellIsTargeting` via `FUN_006E48A0` (returns
// `state != 0`). Bits the engine OR-sets via `FUN_006E5250` when
// entering placement (subset relevant to us):
// - `0x20` source world location needed
// - `0x40` dest world location needed
// The `0x60` mask therefore identifies "ground-target placement"
// (vs. unit-target, trade-target, etc.). See `Spell::AtCursor`.
VAR_SPELL_PLACEMENT_STATE = 0x00CECAC0,
SPELL_PLACEMENT_GROUND_MASK = 0x60,
// `FUN_006E60F0(float *xyz)` — commits the in-flight ground-target
// placement at the given world position. Reads three contiguous
// floats from `xyz`; checks the placement-state mask
// (`VAR_SPELL_PLACEMENT_STATE`) to decide whether this is a
// source-coord (`0x20`) or dest-coord (`0x40`) commit; clears the
// matching bit and stores the coords into engine globals which the
// cast-finalize path then reads. Self-gates when neither bit is
// set — safe no-op for unit-target placement. Called by the engine
// itself when a player left-clicks ground while the reticle is up.
FUN_COMMIT_PLACEMENT_COORDS = 0x006E60F0,
// `FUN_006E4900()` — cancels in-flight placement mode. Internally
// checks `VAR_SPELL_PLACEMENT_STATE != 0` and, if so, fires the
// cast-cancel path via `FUN_006E4940(0x1C)`. Safe to call when no
// placement is active (no-ops). Wraps the action behind
// `Script_SpellStopTargeting`.
FUN_STOP_PLACEMENT = 0x006E4900,
// `*VAR_WORLDFRAME_CLICK_INFO` is a pointer to the engine's
// CWorldFrame "click info" struct — the data block where the input
// dispatcher stashes "what is the cursor pointed at right now"
// after every mouse motion. Allocated at world enter, populated
// continuously by the rendering pipeline (viewport bounds and
// camera position at fixed offsets) and the OS message pump
// (cursor screen pos). NULL when not in world.
// - `+0x350` (uint32) click type after last raycast:
// `0` = no hit
// `1` = world / terrain hit
// `2` = unit / object hit
// - `+0x360..+0x368` (3 floats) hit world position (when type == 1)
VAR_WORLDFRAME_CLICK_INFO = 0x00B4B2BC,
OFF_CLICK_INFO_TYPE = 0x350,
OFF_CLICK_INFO_COORDS = 0x360,
// `FUN_00481F00(void *clickInfo)` — refreshes the cursor's "what
// am I pointed at?" state on demand. Internally reads cursor
// screen pos from input state at `[clickInfo+0xA0]+0x1118/+0x111C`,
// calls the screen→world ray builder at `FUN_004813B0` (uses
// viewport bounds at `[clickInfo+0x390..+0x39C]` plus camera
// position at `[clickInfo+0x65B8]+8/+0xC/+0x10`), then raycasts
// via `FUN_0069BFF0` (terrain + WMO intersection). Writes click
// type to `[clickInfo+0x350]` and hit coords to
// `[clickInfo+0x360..+0x368]`. Safe to call from arbitrary code
// as long as the player is in-world.
FUN_REFRESH_CURSOR_RAYCAST = 0x00481F00,
// `Script_CastSpellByName` — engine's Lua wrapper for the
// `CastSpellByName(name [, onSelf])` global. `int __fastcall(void *L)`
// — standard Lua C function ABI. Reads `name` from stack[1] (string)
// and `onSelf` from stack[2] (boolean), resolves the name (with
// optional `(Rank N)` suffix) through `FUN_004B3950`, then dispatches
// to the engine's cast path at `FUN_004B3300`. Returns 0 (no Lua
// results). Callable directly from C++ — push args on stack, call.
FUN_SCRIPT_CAST_SPELL_BY_NAME = 0x004B4AB0,
// Inner spell-cast dispatcher — `__fastcall(slot, bookType, targetGuidLo,
// targetGuidHi)`. `Script_CastSpellByName` calls this after resolving
// the spell name to a spellbook slot. For ground-target spells, the
// engine enters placement mode (sets `VAR_SPELL_PLACEMENT_STATE`)
// and returns; placement is resolved later by mouse-click or
// programmatically via `FUN_COMMIT_PLACEMENT_COORDS`. Passing (0, 0)
// for the GUID is the "no implicit target" form — engine falls back
// to the player's current selected target.
FUN_SPELL_CAST_DISPATCH = 0x004B3300,
// Macro "primary spell" parser — `__fastcall(MacroEntry *entry)`.
// Walks the macro body (stored at `entry + OFF_MACRO_BODY`) line
// by line, looking for `/cast <name>`, `/castsequence <name>`,
// etc. (via the engine's `SLASH_CAST%d` registry) and the
// `CastSpellByName("<name>")` Lua pattern. On first hit, resolves
// the name to a spellID via `FUN_004B3BC0` and writes it to
// `entry + OFF_MACRO_PRIMARY_SPELL`. Writes `0xFFFFFFFF` when a
// pattern matched but the name didn't resolve (unknown spell);
// writes `0` when no line matched any pattern. Called from macro
// create/edit/refresh paths.
//
// Hooked by `Spell::CastNoToggle` to teach the engine to recognize
// `CastSpellNoToggle("<name>")` as a primary-spell pattern, so
// macros using it get tagged in the spell-state cache the same
// way `CastSpellByName` macros do. Without this, `IsAutoRepeatAction`
// returns false for macro slots whose only cast is via our function
// (the engine's parser doesn't know to look for our identifier),
// breaking action-bar highlighting in pfUI etc.
FUN_MACRO_PARSE_PRIMARY_SPELL = 0x004EFE00,
// Engine's "spell name → spellbook-resolved spellID" helper.
// `__fastcall(const char *name, int *outIsPet)`. Internally calls
// `FUN_004B3950` (the rank-stripping name-with-`(Rank N)` parser)
// to get a spellbook slot, then returns
// `[VAR_PLAYER_SPELLBOOK][slot]` (or `[VAR_PET_SPELLBOOK][slot]`
// when `*outIsPet` is set on entry). Returns 0 if the name doesn't
// resolve to a known spellbook entry. This is the resolver the
// engine's macro parser uses — name → spellID lookup that respects
// the player's known spell list.
FUN_RESOLVE_SPELL_NAME_TO_BOOK_ID = 0x004B3BC0,
// The single name → spellbook-slot resolver underneath everything
// spell-cast related. `__fastcall(const char *name, void *out) ->
// int slot` (or `-1`). Strips a trailing `(Rank N)` suffix, then
// calls `FUN_004B3A10` for the actual lookup. Called by
// `Script_CastSpellByName` (every Lua cast) AND by
// `FUN_RESOLVE_SPELL_NAME_TO_BOOK_ID` (which the macro parser
// uses). Hooking here makes one change to both the runtime cast
// path AND the macro-tagging path — useful for accepting numeric
// spellID input as if it were a name (the `Spell::CastByID`
// module does this to enable `/cast 5019`-style macros).
FUN_RESOLVE_SPELL_NAME_TO_SLOT = 0x004B3950,
// `__fastcall(uint slot, int bookType) -> int isActive`. Returns 1
// if the spell at the given (slot, bookType) is currently producing
// an active aura on the player (bookType=0) or pet (bookType=1).
// Walks the unit descriptor's aura-spellID array at `+0xA4` (48
// slots) and checks the active-bit at `+0x164`. The engine's
// toggle-aware cast path (`FUN_004B3300`) consults this to decide
// whether `/cast Shoot` should send CMSG_CAST_SPELL or
// CMSG_CANCEL_AURA. Used by `Spell::CastNoToggle` to suppress the
// toggle-off side of `CastSpellNoToggle` on shapeshift / aspect /
// stance forms — anything that creates a self-aura.
FUN_SPELL_IS_TOGGLE_AURA_ACTIVE = 0x004B36F0,
// MacroEntry struct offsets (verified by tracing FUN_004EFE00).
// The macro body is an inline null-terminated string at `+0x164`;
// line breaks are `\n`. The primary-spell cache (what
// `IsAutoRepeatAction` ultimately reads via the spell-state hash
// lookup at `[0x00C0E2A0]`) is at `+0x564`.
OFF_MACRO_BODY = 0x164,
OFF_MACRO_PRIMARY_SPELL = 0x564,
// Spell.dbc and friends. Pointer-to-records-array + record-count pairs.
// Used by Script_GetSpellName/Texture and BuildSpellTooltip.
VAR_SPELL_RECORDS = 0x00C0D788, // SpellRecord *records[spellID]
VAR_SPELL_RECORD_COUNT = 0x00C0D78C, // max spellID
// SpellMechanic.dbc — maps a SpellMechanic ID to its localized
// name. Standard 5-DWORD DBC instance at 0x00C0D7BC; records ptr at
// +0x08, count at +0x0C (see docs/DBCs.md). Records are 1-based
// (records[mechanicID]); the engine only ever uses the table for
// existence/bounds checks (FUN_006e9ca0, FUN_00612df0, FUN_006e8eb0
// case 0x8d all do `records[id] != 0`), never reading the name — so
// the name offset below follows the canonical 2-column
// (ID + localized Name) DBC schema rather than an engine-reader anchor.
VAR_SPELLMECHANIC_RECORDS = 0x00C0D7C4, // SpellMechanicRecord *records[mechanicID]
VAR_SPELLMECHANIC_COUNT = 0x00C0D7C8, // max mechanic ID
OFF_SPELLMECHANIC_NAME = 0x04, // char *name[9], locale-indexed
// SpellItemEnchantment.dbc — the table a weapon/item enchant ID
// (e.g. the enchantID from `C_Item.GetWeaponEnchantInfo`) indexes.
// Records-ptr at instance +0x08, count at +0x0C (instance 0x00C0D7D0).
// 24-DWORD records (recordSize 0x60). Layout fully verified by
// parsing the on-disk SpellItemEnchantment.dbc against known records
// (Crusader 1900: Type[0]=1, Arg[0]=20007 "Holy Strength";
// Sharpened+3 id 13: Type[0]=2, Amount[0]=3; Reinforced Armor+8 id 15:
// Type[0]=4, Amount[0]=8). OFF_..._NAME (+0x34) is cross-confirmed by
// two engine readers (FUN_00496170 / FUN_00495d60) that push
// `[rec + 0x34 + VAR_LOCALE_INDEX*4]` as the display name.
// Type[i] : ITEM_ENCHANTMENT_TYPE — 1=combat-proc spell,
// 2=damage, 3=equip spell, 4=resistance, 5=stat,
// 6=totem, 7=use spell. 0 = empty slot.
// Amount[i] : magnitude for damage/resist/stat types (min; vanilla
// min==max). 0 for spell types (value lives in the spell).
// Arg[i] : spellID for spell types (1/3/7); stat index for STAT.
VAR_SPELLITEMENCHANT_RECORDS = 0x00C0D7D8, // SpellItemEnchantmentRecord *records[enchantID]
VAR_SPELLITEMENCHANT_COUNT = 0x00C0D7DC, // max enchant ID
OFF_SPELLITEMENCHANT_TYPE = 0x04, // int Type[3]
OFF_SPELLITEMENCHANT_AMOUNT = 0x10, // int Amount[3] (EffectPointsMin)
OFF_SPELLITEMENCHANT_ARG = 0x28, // int EffectArg[3]
OFF_SPELLITEMENCHANT_NAME = 0x34, // char *name[8], locale-indexed
// ItemRandomProperties.dbc — the table a random-suffix ID (the third
// field of an `item:id:enchant:suffix:unique` link) indexes to get
// the SpellItemEnchantment IDs that apply the "of the Bear"-style
// bonus. Standard 5-DWORD DBC instance at 0x00C0DBCC; records-ptr at
// +0x08, count at +0x0C (see docs/DBCs.md). Verified by parsing the
// on-disk ItemRandomProperties.dbc: 16-field / 0x40 records, field 0
// = ID, field 1 = internal name string, and the enchant IDs occupy
// fields 2..6 (offset +0x08, five contiguous u32 slots — only the
// first few are used; the rest are 0). Field 7 duplicates the name
// string offset, so it is NOT an enchant slot — do not read past
// slot 5.
VAR_ITEMRANDOMPROP_RECORDS = 0x00C0DBD4, // ItemRandomPropertiesRecord *records[suffixID]
VAR_ITEMRANDOMPROP_COUNT = 0x00C0DBD8, // max suffix ID
OFF_ITEMRANDOMPROP_ENCHANT = 0x08, // u32 Enchantment[5]
ITEMRANDOMPROP_ENCHANT_SLOT_COUNT = 5,
// Spell.dbc School field — 0-based integer at record +0x04.
// Verified empirically against Fireball (133) → School=2 (Fire)
// and Frostbolt (116) → School=4 (Frost) on Octo 1.12.1. Vanilla
// doesn't use the multi-bit SchoolMask form (TBC+); a spell
// belongs to exactly one school. Mapping:
// 0 = Physical 1 = Holy 2 = Fire 3 = Nature
// 4 = Frost 5 = Shadow 6 = Arcane
OFF_SPELL_SCHOOL = 0x04,
SPELL_SCHOOL_COUNT = 7,
// Spell.dbc DispelType field — u32 at record +0x10, indexes into
// `SpellDispelType.dbc` (`VAR_SPELLDISPEL_RECORDS` below). 0 =
// not dispellable. Verified by decompiling `Script_UnitDebuff`,
// which reads `*(int*)(spellRecord + 0x10)` and feeds it into
// the DispelType DBC to produce the third return value (the
// dispel-type name string).
OFF_SPELL_DISPEL_TYPE = 0x10,
VAR_SPELL_RANGE_RECORDS = 0x00C0D79C, // SpellRange.dbc
VAR_SPELL_RANGE_COUNT = 0x00C0D7A0,
VAR_SPELL_ICON_RECORDS = 0x00C0D7EC, // SpellIcon.dbc
VAR_SPELL_ICON_COUNT = 0x00C0D7F0,
VAR_SPELL_CAST_TIMES_RECORDS = 0x00C0D878, // SpellCastTimes.dbc
VAR_SPELL_CAST_TIMES_COUNT = 0x00C0D87C,
// SpellRadius.dbc — AOE radius records, indexed by a spell's
// EffectRadiusIndex (see OFF_SPELL_RECORD_EFFECT_RADIUS_INDEX). Record
// shape: { id@+0, radius@+4 (f32), radiusPerLevel@+8 (f32), ... }.
// Verified by decompiling FUN_006e6350 (the engine's effective-radius
// helper), which reads `radiusRec[+4]` as the base radius and
// `radiusRec[+8] * casterLevel` as the per-level term. Read by
// GetSpellRadius (base radius only — no level scaling).
VAR_SPELL_RADIUS_RECORDS = 0x00C0D7B0,
VAR_SPELL_RADIUS_COUNT = 0x00C0D7B4,
OFF_SPELL_RADIUS_VALUE = 0x04, // base radius, f32
// SpellMod (talent / item) accumulators for the LOCAL PLAYER. Two
// parallel tables of int32, indexed [familyFlagBit][op]: flat adds at
// VAR_SPELLMOD_FLAT_TABLE, percent adds at VAR_SPELLMOD_PCT_TABLE.
// Per-bit stride is 0x74 (29 ops); the op is the dword index (op*4
// within a slot). A spell's per-effect value is modified by summing,
// over the bits set in its SpellFamilyFlags, flat[bit][op] and
// pct[bit][op], then `value = (value + flat) * (100 + pct) * 0.01`.
// Gated on the spell's SpellFamilyName matching the player's class
// family. Decompiled from FUN_006e6b30 / FUN_006e6bf0 (the engine's
// ApplySpellMod), which the radius helper FUN_006e6350 invokes with
// op 6. These are single global instances = the local player's mods
// (vanilla only tracks spell mods for the local player).
VAR_SPELLMOD_FLAT_TABLE = 0x00CEAD60,
VAR_SPELLMOD_PCT_TABLE = 0x00CECB30,
SPELLMOD_SLOT_STRIDE = 0x74, // bytes per familyFlagBit row
SPELLMOD_SLOT_COUNT = 64, // SpellFamilyFlags is 64-bit
SPELLMOD_OP_RADIUS = 6, // op index for spell radius
SPELLMOD_OP_DURATION = 1, // op index for aura duration
// SpellDispelType.dbc — maps dispel-type IDs (1..N) to localized
// names like "Magic", "Curse", "Disease", "Poison". Used by
// `Script_UnitDebuff` to fill its third return value. Standard
// 5-DWORD class instance shape; records array at +0x08, count at
// +0x0C of the instance. Records themselves have a "has-name"
// gate at +0x28 (non-zero means the name slot is populated) and
// the locale-applied string pointer at +0x2C. The engine's
// accessor does the locale lookup before exposing the pointer
// here, so we get a ready-to-use string with no further indexing.
VAR_SPELLDISPEL_RECORDS = 0x00C0D83C,
VAR_SPELLDISPEL_COUNT = 0x00C0D840,
OFF_SPELLDISPEL_HAS_NAME = 0x28,
OFF_SPELLDISPEL_NAME = 0x2C,
// Map.dbc — instance/zone metadata. Standard 5-DWORD class instance
// shape; records and count are catalogued in `docs/DBCs.md`. Record
// schema (vanilla, derived from `FUN_00495c90` IsInInstance helper
// and `FUN_0049e1c0` raid-instance warning handler):
// +0x08 uint32 instance type (0=world, 1=dungeon, 2=raid, 3=BG)
// +0x10..+0x30 9 locale-string ptrs (localized display name)
// No max-players column in vanilla — that data was added in TBC via
// MapDifficulty.dbc.
VAR_MAP_RECORDS = 0x00C0DAA8,
VAR_MAP_COUNT = 0x00C0DAAC,
OFF_MAP_INSTANCE_TYPE = 0x08,
OFF_MAP_NAME = 0x10,
// Currently-loaded map ID (the Map.dbc ID for the zone/instance the
// player is in). Written by the map-transition handler
// `FUN_00495d10`; read by `FUN_00495c90` (the helper backing
// `Script_IsInInstance`).
VAR_CURRENT_MAP_ID = 0x00B4E378,
// Local player's current AreaTable.dbc area ID (u32 storage; only
// the low 16 bits are used — the value is broadcast over the wire
// as a u16 in `SMSG_PARTY_MEMBER_STATS`). Written by the zone-change
// handler `FUN_00494780(areaID, parentAreaID, zoneName, subzone,
// realZone, eventID)`; read by `Script_GetRealZoneText` and the
// outbound party-stats builder `FUN_005f0880`.
VAR_PLAYER_AREA_ID = 0x00B4E314,
// Unified party/raid member stats lookup —
// `__fastcall(GUID *guidPair) -> uint8_t *`. Returns a pointer to
// the member's stats data on hit, NULL on miss. Tail-jumps from
// party storage (`FUN_004e8820`, 4 slots at `0x00BC70B0`) to raid
// storage (`FUN_004bb0f0`, 40-slot pointer array at `0x00B712A8`).
// Both sub-calls return pointers where the field at `+0x14` is the
// u16 areaID (AreaTable.dbc ID) — for party that's at struct +0x14
// directly, for raid it's at `*raidArr[i] + 0x10 + 0x14`. Caller
// doesn't need to distinguish the two cases.
//
// Within the returned stats block: `+0x08` status flags, `+0x09`
// powerType, `+0x0A..+0x10` HP/maxHP/power/maxPower, `+0x12` level,
// `+0x14` u16 areaID, `+0x16/+0x18` position. Verified from the
// outbound stats builder `FUN_005f0880` (mirrors inbound packet
// shape from SMSG_PARTY_MEMBER_STATS_FULL).
FUN_GROUP_MEMBER_STATS_LOOKUP = 0x00496400,
OFF_GROUP_MEMBER_AREA_ID = 0x14,
// `+0x08` status-flags byte of the stats block (see field map above);
// bit 0 is the online flag `Script_UnitIsConnected` tests. Sibling
// `FUN_GROUP_MEMBER_SLOT_LOOKUP` (`0x00496420`, `__fastcall(u64 *guid)
// → member slot*`) is the presence fallback UnitIsConnected consults
// when no stats block exists — a non-null slot means the member is
// present (and thus connected). Both take a pointer to the 64-bit GUID.
OFF_GROUP_MEMBER_STATUS_FLAGS = 0x08,
GROUP_MEMBER_STATUS_ONLINE = 0x1,
FUN_GROUP_MEMBER_SLOT_LOOKUP = 0x00496420,
// Per-slot GUID tables — used to map party/raid token strings
// ("party1", "raid17") to GUIDs without going through
// `FUN_RESOLVE_UNIT_TOKEN`, which only resolves to a local CGUnit
// and returns NULL for group members in other zones.
//
// Party: 4 entries × 8 bytes (lo + hi). `guids[i]` corresponds to
// "partyN" where N = i+1.
//
// Raid: 40 entries × 4 bytes — each is a `RaidMember *`. GUID is
// at `*member + 0` (lo) and `*member + 4` (hi). Verified from
// `FUN_004bb0f0`. Slot may be NULL (empty / offline raid member).
VAR_PARTY_MEMBER_GUIDS = 0x00BC6F48,
VAR_RAID_MEMBER_PTRS = 0x00B712A8,
VAR_LOCALE_INDEX = 0x00C0E080, // 0..8, picks one of the 9 localized strings
LUA_IS_NUMBER = 0x6F34D0,
LUA_IS_STRING = 0x6F3510,
LUA_TO_NUMBER = 0x6F3620,
LUA_TO_BOOLEAN = 0x6F3660,
LUA_TO_STRING = 0x6F3690,
LUA_PUSH_NUMBER = 0x6F3810,
LUA_PUSH_NIL = 0x6F37F0,
LUA_PUSH_BOOLEAN = 0x6F39F0,
LUA_PUSH_STRING = 0x6F3890,
// `lua_pushlstring(L, ptr, len)` — binary-safe push. Same TValue
// tag as `pushstring` but takes an explicit length so the string
// can contain NULs.
LUA_PUSH_LSTRING = 0x6F3840,
// `lua_strlen(L, idx)` — returns the byte length of the string
// value at `idx`. Pairs with `lua_tostring` for binary-safe
// string reads.
LUA_STR_LEN = 0x6F36E0,
// Verified empirically via `_classicapi_PushValueProbe` —
// pushes a number then dups via PushValue, checks GetTop tracks.
// **Doc note:** `docs/LuaCAPI.md` reports `0x6F30D0` as lua_pushvalue
// and `0x6F32B0` as lua_remove; both are wrong. `0x6F30D0` is
// actually `lua_remove` (has the shift-down loop and `decr_top`),
// and `0x6F3350` is `lua_pushvalue` (index-resolve → TValue copy
// to L->top → `add [ecx+8], 0x10` incr_top). `0x6F32B0` is
// `lua_replace` (single TValue copy + decr_top).
LUA_PUSH_VALUE = 0x6F3350,
// `luaL_ref(L, t)` — pops the top, stores it in the table at `t`
// at a freshly-allocated integer key, returns the key. Use with
// `LUA_REGISTRY_INDEX` to stash Lua values across C-side scopes;
// pair with `LUA_REF_UNREF` to release. Verified by decompiling
// `FUN_006f5310`: classic luaL_ref shape — nil-top early-out
// returning `LUA_REFNIL = -1`, FREELIST_REF chain pop (pushvalue +
// tonumber on table[0]), else objlen-based new slot, finally
// table[ref] = popped value.
LUA_REF_REF = 0x6F5310,
// `luaL_unref(L, t, ref)` — releases a ref previously returned
// by `luaL_ref`, freeing the slot for future allocations. Verified
// by decompiling `FUN_006f5400`: `ref >= 0` guard (skips
// `LUA_NOREF = -2` / `LUA_REFNIL = -1`), reads current FREELIST_REF
// head, writes it to `table[ref]`, then updates FREELIST_REF = ref
// — the canonical freelist-link operation.
LUA_REF_UNREF = 0x6F5400,
LUA_PUSH_CCLOSURE = 0x6F3920,
LUA_NEW_TABLE = 0x6F3C90,
LUA_GET_TABLE = 0x6F3A40, // (was 0x6F3EA0, which is lua_rawset)
LUA_RAW_GET = 0x6F3B00,
LUA_SET_TABLE = 0x6F3E20,
LUA_RAW_SET = 0x6F3EA0,
LUA_INSERT = 0x6F31A0,
LUA_REMOVE = 0x6F30D0, // (was 0x6F32B0, which is lua_replace)
LUA_REPLACE = 0x6F32B0,
LUA_TYPE = 0x6F3400,
LUA_GET_TOP = 0x6F3070,
LUA_SET_TOP = 0x6F3080,
LUA_CALL = 0x6F4180,
LUA_PCALL = 0x6F41A0,
// `lua_next(L, idx)` — pops a key, pushes (newKey, value) for the
// next pair in the table at `idx`. Returns 0 when iteration is
// done. Documented in `docs/LuaCAPI.md`; calls `luaH_next` at
// `0x006FA2A0` internally.
LUA_NEXT = 0x6F4450,
LUA_ERROR = 0x6F4940,
// `lua_xmove(from, to, n)` — moves the top `n` TValues from one
// thread to another. Decrements `from->top` by `n*16`, copies each
// 16-byte TValue, increments `to->top`. Needed by the `coroutine.*`
// trampolines to shuttle args/returns between the main state and a
// suspended coroutine.
LUA_X_MOVE = 0x6F2F80,
// `lua_newthread(L)` — does GC check, calls inner `luaE_newthread`
// at `0x006F6B10` to allocate a new state, pushes it onto L's stack
// with type tag 8 (LUA_TTHREAD). Ghidra reports the return as
// `void` (decompiler limitation — the inner call's eax flows
// through), so callers should retrieve the new state via
// `ToPointer(L, -1)` rather than relying on the return value.
LUA_NEW_THREAD = 0x6F3030,
// `lua_resume(L_co, nargs)` — runs a coroutine. Zero internal
// callers in the engine (coroutine library was stripped from the
// standard-library registration tables at build time); linker
// kept the symbol so it's callable from C. Goes through
// `luaD_rawrunprotected` at `0x006F5DAC` for setjmp/longjmp
// safety; inner static `resume` helper lives at `0x006F67B0`.
LUA_RESUME = 0x6F6620,
// `lua_yield(L, nresults)` — flags the current CallInfo to yield
// and returns -1. Sets a `0x10` bit on the CI->state field rather
// than writing `L->status` directly in this build. Zero internal
// callers (same reason as `lua_resume`). Errors with
// "attempt to yield across metamethod/C-call boundary" or
// "cannot yield a C function" when called from the wrong context.
LUA_YIELD = 0x6F6860,
// `lua_topointer(L, idx)` — returns the pointer value of a
// pointer-valued TValue: type 5 (table), 6 (function), 8 (thread)
// return `tvalue[2]` directly; type 2 (lightuserdata) returns its
// value; type 7 (userdata) returns the userdata payload (record +
// 0x10). Returns 0 for anything else. We use it as `lua_tothread`
// — for a known-thread TValue, returns the embedded `lua_State *`.
LUA_TO_POINTER = 0x6F3790,
// `luaL_argerror(L, narg, msg)` — formats "bad argument #%d to
// '%s' (%s)" (or "calling '%s' on bad self (%s)" for method-style
// calls) and calls `lua_error`. Doesn't return.
LUAL_ARG_ERROR = 0x6F4810,
// `luaL_setn(L, t, n)` — Lua 5.0 auxlib table-length setter
// (verified: `FUN_006f4ea0`, __fastcall L/ecx, t/edx, n/stack,
// RET 4). Matches 5.0.2 `luaL_setn`: sets `t.n = n` if a numeric
// `n` field exists, else `sizes[t] = n` in the registry's weak
// LUA_SIZES table. Found via `table.insert` (`FUN_007fb6b0`), which
// calls it to record the new length; `luaL_getn` is `FUN_006f5050`.
// Needed by `table.wipe` to reset the length after clearing keys —
// the length is out-of-band from the keys, so a `lua_next` +
// `rawset(nil)` clear leaves it stale and subsequent `table.insert`
// appends past the wiped slots.
LUAL_SETN = 0x6F4EA0,
// `lua_checkstack(L, n)` — `int __fastcall(L /*ecx*/, n /*edx*/)`.
// Ensures room for `n` more stack values, growing if needed; returns 0
// (without growing) when `(top-base)/16 + n` would exceed LUA_MAXCSTACK
// (0x800 = 2048), 1 otherwise. Verified by the `cmp reg, 0x800` overflow
// test at 0x006F2F43. Needed by any C function that pushes an unbounded
// number of results (e.g. `strsplit`) — pushing past the ~20-slot
// C-call guarantee without growing corrupts the stack.
LUA_CHECK_STACK = 0x006F2F30,
// `str_find` — the Lua 5.0 string-library `string.find` C function
// (`int __fastcall(void *L)`), entry in the strlib luaL_reg table at
// `0x00822dd0`. Returns `1` (nil pushed, no match), `2` (start, end),
// or `2 + ncaptures`. `string.match` (a Lua 5.1 addition, missing here)
// shares the exact same pattern engine — it's `find` that yields the
// captures / whole match instead of the indices — so `BaseLib::StringLib`
// calls this and transforms the result rather than reimplementing the
// matcher. Verified by decoding the function at this address.
FUN_LUA_STR_FIND = 0x007FC3B0,
// `str_gfind` — the Lua 5.0 `string.gfind` C function (strlib entry at
// `0x00822dd8`). 5.1 renamed it to `string.gmatch` with identical
// behaviour (returns a stateful iterator closure over the matches), so
// `BaseLib::StringLib` registers `string.gmatch` as a direct alias of
// this function pointer — no wrapper.
FUN_LUA_STR_GFIND = 0x007FCFA0,
// `math_fmod` — the Lua 5.0 `math.mod` C function (mathlib entry at
// `0x00822cb0`): `luaL_checknumber(1/2)` → `fmod(x, y)` → `lua_pushnumber`.
// 5.1 renamed the Lua-facing name to `math.fmod` with the identical C
// implementation, so `BaseLib::MathLib` registers `math.fmod` as a direct
// alias of this function pointer — no wrapper. Verified by decode.
FUN_LUA_MATH_FMOD = 0x007FAFD0,
// `lua_iscfunction(L, idx)` — returns 1 if value is a function
// closure with the `isC` byte set (`Closure.c.isC == 1`), 0
// otherwise. Used by `coroutine.create` to reject C functions
// (Lua 5.0 only allows Lua-defined functions as coroutine bodies).
LUA_IS_C_FUNCTION = 0x6F34A0,
// `lua_tothread(L, idx)` — returns the embedded `lua_State *` for
// type-8 (LUA_TTHREAD) TValues, NULL for anything else. Used by
// the `coroutine` library to extract the coroutine pointer from a
// stack slot.
LUA_TO_THREAD = 0x6F3770,
// Global `lua_State *`. The engine keeps one main thread state here; we
// read it on demand in helpers that run outside a Lua callback (e.g.
// RegisterTableFunction during LoadScriptFunctions).
VAR_LUA_STATE = 0x00CEEF74,
// zlib 1.2.2, statically linked into WoW.exe (version string at
// `0x008745F0`, copyright banners at `0x00815528`/`0x00815608`).
//
// One-shot helpers (always Zlib-format with adler32 trailer):
// int compress2(dest, *destLen, source, sourceLen, level)
// int uncompress(dest, *destLen, source, sourceLen)
//
// Lower-level streaming API — needed for Gzip and raw Deflate
// formats since the one-shots only do Zlib format. The `Init2_`
// variants take an explicit `windowBits` which selects format:
// +15 = Zlib (default)
// +15 + 16 = Gzip
// -15 = raw Deflate (no header, no checksum)
// +15 + 32 = auto-detect (decode only; Zlib or Gzip)
//
// Call signatures (all `__fastcall`, callee cleans the stack):
// int deflateInit2_(strm[ECX], level[EDX],
// stack: method, windowBits, memLevel,
// strategy, version, stream_size)
// int deflate(strm[ECX], flush[EDX])
// int deflateEnd(strm[ECX])
// int inflateInit2_(strm[ECX], windowBits[EDX],
// stack: version, stream_size)
// int inflate(strm[ECX], flush[EDX])
// int inflateEnd(strm[ECX])
//
// Return codes match zlib's: 0 = Z_OK, 1 = Z_STREAM_END,
// -3 = Z_DATA_ERROR, -4 = Z_MEM_ERROR, -5 = Z_BUF_ERROR.
FUN_ZLIB_COMPRESS2 = 0x00730BC0,
FUN_ZLIB_UNCOMPRESS = 0x00734810,
FUN_ZLIB_DEFLATE_INIT2 = 0x00732A70,
FUN_ZLIB_DEFLATE = 0x00733040,
FUN_ZLIB_DEFLATE_END = 0x00733650,
FUN_ZLIB_INFLATE_INIT2 = 0x00730D60,
FUN_ZLIB_INFLATE = 0x00730EA0,
FUN_ZLIB_INFLATE_END = 0x00732320,
// The version string deflateInit2_/inflateInit2_ checks against
// (compile-time mismatch returns Z_VERSION_ERROR). Same string the
// one-shot helpers pass through.
VAR_ZLIB_VERSION_STRING = 0x008745F0,
ZLIB_STREAM_SIZE = 0x38, // sizeof(z_stream) in 1.2.2 build
// Static event-name "table" at runtime VA `0x00BE11D8` — this is what
// `C_EventUtils.IsEventValid` walks. It is NOT the structure that
// `frame:RegisterEvent` and the dispatcher actually use; that lives at
// `[VAR_EVENT_TABLE_BASE_PTR]` (see below) with 16-byte entries. The
// table at 0x00BE11D8 is sufficient for an existence check, but firing
// or registering custom events requires the real structure.
VAR_EVENT_NAME_TABLE = 0x00BE11D8,
EVENT_NAME_TABLE_MAX_SLOTS = 1024,
// The REAL event registration data structure used by the engine. An
// `EventEntry` array, 16 bytes per entry:
// +0x00 char *name event name string ptr
// +0x04 ? used by the chain allocator at 0x7052D0
// +0x08 ?
// +0x0C SubscriberNode *head head of the subscribed-frames chain
// Allocated/populated at engine boot. `[VAR_EVENT_TABLE_BASE_PTR]`
// dereferences to the array base; `[VAR_EVENT_TABLE_COUNT]` is the
// entry count. `Frame::RegisterEvent` at 0x00702140 case-insensitively
// strcmps the input event name against each entry's `+0x00` and inserts
// the frame into the matching entry's chain.
VAR_EVENT_TABLE_BASE_PTR = 0x00CEEF68,
VAR_EVENT_TABLE_COUNT = 0x00CEEF64,
EVENT_ENTRY_STRIDE = 0x10,
OFF_EVENT_ENTRY_NAME = 0x00,
OFF_EVENT_ENTRY_HEAD = 0x0C,
// Subscriber-chain node layout — the linked list hanging off each
// entry's +0x0C head, derived from Frame::RegisterEvent
// (FUN_00702140): each node is `{ ?, next@+0x04, frame@+0x08 }`, where
// `frame` is the CFrameScriptObject* subscriber. A node value with its
// low bit set (or null) is the end/empty sentinel. Walked by
// Frame:IsEventRegistered to test membership.
OFF_EVENT_NODE_NEXT = 0x04,
OFF_EVENT_NODE_FRAME = 0x08,
// `Frame::RegisterEvent` — the C++ helper called by the Lua
// `frame:RegisterEvent(eventName)` method (`Script_RegisterEvent` at
// `0x00774A40`). `__thiscall` with `(this=frame, eventName)`. Walks
// the entry array at `[VAR_EVENT_TABLE_BASE_PTR]`, case-insensitively
// strcmps against each entry's name, and appends `frame` to the
// matching entry's chain.
FUN_FRAME_REGISTER_EVENT = 0x00702140,
// `RebuildEventTable` — the engine's bulk event-table population
// routine. `__fastcall(const char **names, int count) -> void`
// (ECX = names array, EDX = count). Tears down any existing table
// (calling the per-entry teardown helper at 0x00701A40 + freeing
// the base pointer via SMemFree), allocates a fresh table of size
// `count * 16`, then loops `names[0..count-1]` and for each
// non-empty entry calls `SStrDup(name, file, line)` to allocate
// an engine-owned copy at `entry+0x00`.
//
// Called twice during boot (with two different name arrays — 26
// entries at 0x00B41E70, then 549 entries at 0x00BE1198) and once
// per `/reload`. We **don't hook this** — third-party DLLs
// (SuperWoWhook, transmogfix, nampower, etc.) all hook here too, and
// chaining their modifications to the `(names, count)` args makes the
// final table size unreliable (crashes seen with count → buffer-size
// mismatch). Instead, `Event::Custom` claims NULL slots from the live
// table after the rebuild settles. Kept for reference.
FUN_REBUILD_EVENT_TABLE = 0x00703D90,
// `FireEvent` — the engine's event dispatcher. 149 callers in the
// binary. `__cdecl void(int eventID, const char *format, ...)`.
// Indexes into `[VAR_EVENT_TABLE_BASE_PTR] + eventID * 0x10` and walks
// the subscriber chain at `+0x0C`. Format codes match printf:
// %s = const char *
// %d = int
// %u = unsigned int
// %f = float (promoted to double on the stack)
// No `%b` for boolean — pass `%d` with 0/1; the engine has no native
// bool concept here. No bounds check on eventID; pass valid indices.
FUN_FIRE_EVENT = 0x00703F50,
// Event name strings live in `.data` (mostly clustered around
// 0x00851000..0x00855000); event-name string pointers also reach into
// `.rdata` (starts at 0x007FF000) for some entries. Bound the dereference
// range conservatively to "static-data section" — addresses outside this
// window cannot be valid string pointers in this binary, so we treat
// them as NULL during the walk.
EVENT_TABLE_VALID_PTR_LO = 0x007FF000,
EVENT_TABLE_VALID_PTR_HI = 0x00C00000,
// Storm allocator — Blizzard's internal C utility library. `SMemAlloc`
// wraps every block with bookkeeping (header magic + size + caller
// file:line, footer magic, plus a global registered-block list); the
// matching `SMemFree` validates against all of that and panics with
// `ERROR #124 SMem3: Pointer does not refer to a valid allocated block
// of memory` if the pointer didn't come from `SMemAlloc`.
//
// Both are `__stdcall`, 4 args, `ret 0x10`. Verified via disassembly
// at the function bodies (push order matches arg order; `ret 0x10`
// pops the 4 stack args). The Storm allocator instance both wrap is
// the singleton at `0x00C51C58`.
//
// void *__stdcall SMemAlloc(size_t size, const char *file, int line,
// int flags); // flags: bit 3 (0x08) = zero-fill
// int __stdcall SMemFree (void *ptr, const char *file, int line,
// int flags); // returns 1
//
// We use `SMemAlloc` for event-name storage in `Event::Custom` so the
// engine's reload teardown loop (which `SMemFree`s every event entry's
// name) doesn't trip its safety check on our injected pointers.
FUN_STORM_SMEM_ALLOC = 0x006462E0,
FUN_STORM_SMEM_FREE = 0x00646430,
// Engine's main file-content reader. Used by the TOC parser at
// `FUN_TOC_PARSER` to slurp addon `.toc` files and by the addon
// load pass for `.lua` source. Allocates a Storm buffer via
// `FUN_STORM_SMEM_ALLOC`, writes the file content + `extraBytes`
// trailing zeros, hands the buffer to the caller. Caller frees
// via `FUN_STORM_SMEM_FREE`.
//
// __stdcall int FileRead( // callee cleans 28 bytes (RET 0x1C);
// // NOT __cdecl — see src/addons/Embedded.cpp
// int archive, // 0 = merged VFS; or an archive
// // handle to read from one MPQ
// // (e.g. FUN_00648FB0 reads its
// // "(listfile)" this way)
// const char *path, // "Interface\AddOns\X\Y.lua"
// void **outBuf, // Storm-allocated content
// size_t *outSize, // optional, may be NULL
// size_t extraBytes, // trailing zero-fill (1 for nul-term)
// int flag1, // always 1 from TOC parser
// int flag2); // 0
// Returns 1 on success, 0 on failure.
//
// We hook this to redirect reads of `Interface\AddOns\!!!ClassicAPI\*`
// to embedded buffers (see src/addons/Embedded.cpp). Allocating via
// the same Storm allocator the engine uses means the caller's
// normal `SMemFree` works without us tracking lifetime.
FUN_FILE_READ = 0x00648620,
// MPQ file enumerator — walks every mounted archive's `(listfile)`
// and invokes a callback for each entry whose path begins with a
// given prefix. This is the engine's flat, recursive name walk (the
// `SFileEnumFiles` analog), NOT a per-directory find. It's the
// function the macro-icon loader `FUN_LOAD_MACRO_ICONS` uses to
// surface MPQ-baked icons under `Interface\Icons\`.
//
// void __fastcall MpqEnumFiles(
// int archiveSelector, // ecx — archive-set selector;
// // the loader passes 6.
// // Covers the primary
// // mounted archives plus
// // one selected extra.
// const char *pathPrefix, // edx — e.g. "Interface\" —
// // only listfile entries
// // under this prefix are
// // reported.
// FileCb callback, // per-file callback (below)
// void *userParam); // loader passes 0
//
// The callback is `int __fastcall(const char *fullPath /*ecx*/)`;
// `fullPath` is the entry's full archive-relative path (e.g.
// "Interface\FrameXML\Foo.lua"). Returning 0 STOPS enumeration —
// return non-zero to keep going (note: the OPPOSITE of the disk
// find at `FindFirstFileW`). The continue/stop sense is verified in
// the per-archive walker `FUN_00648FB0`, whose loop does
// `if (... && callback() == 0) break;`.
//
// Internally: `FUN_00401470` loops the archive-handle array
// (`DAT_008826BC`, count `DAT_00882740`) calling the per-archive
// listfile walker `FUN_00648FB0`, which reads each archive's
// `(listfile)` via `FUN_FILE_READ`, splits on CR/LF, prefix-filters
// via a trampoline, and dispatches the callback. Used by
// `Interface::Export` (`ExportInterfaceFiles`).
//
// NB: the sibling `FUN_0042AD10` is a DISK-only walker (it resolves
// to kernel32 `FindFirstFileW` and never sees MPQ contents) — don't
// confuse the two. The macro `Icons.cpp` callback labels have the
// disk/MPQ roles swapped; this entry is the authoritative note.
FUN_MPQ_ENUM_FILES = 0x00401470,
// Console-command registrar — the vanilla equivalent of 4.3.4's
// `FUN_00654c90`. Registers a developer-console command (the `~`
// console you get when launching with `-console`).
//
// int __fastcall RegisterConsoleCommand(
// const char *name, // ecx — command name; stored BY
// // POINTER (no copy), so must
// // have static lifetime
// Handler handler, // edx — see below
// int category, // help-grouping category id
// const char *description);// help text, or NULL
// Returns 1 on success, 0 if a command with that name already
// exists (dedup-safe — repeat calls are harmless no-ops). The
// command node is never freed for a static-literal name, so we
// don't need SStrDup the way the event table does.
//
// The handler is `int __fastcall(void *unused /*ecx*/, const char
// *args /*edx*/)`; `args` is the text after the command name
// (`*args == '\0'` when invoked bare). Return 1. Categories seen in
// the binary: graphics=1, help=2, misc=5 (we use 5, matching
// 4.3.4's `ExportInterfaceFiles`); the value is cosmetic (only
// affects `help` grouping) and unvalidated by the registrar.
//
// Self-initializes the command hash table on first use, so it is
// safe to call any time after the engine's own console subsystem
// boots (well before our glue / load-script hooks fire). Verified
// via the bulk graphics registrar `FUN_0066F6C0` and the `help`
// command's own registration in `FUN_006400E0`.
FUN_CONSOLE_COMMAND_REGISTER = 0x0063F9E0,
// `ConsoleWrite(const char *line /*ecx*/, int colorFlag /*edx*/)` —
// appends a line to the developer console's output buffer. No-ops
// cleanly when the console isn't active (gated on the console-init
// globals `DAT_00C4EC1C` / `DAT_00C4EC34`), so it's safe to call
// unconditionally from a console-command handler. `colorFlag` 0 =
// default. Used by `Interface::Export` for "wrote N files" feedback.
FUN_CONSOLE_WRITE = 0x0063CB50,
// TOC parser — `__fastcall(this=addonName)`. Already documented in
// CLAUDE.md under "AddOn registry & hot-reload". Dedup-safe: if
// the addon is already in the hash table, returns immediately
// without re-parsing. Reads the TOC file via `FUN_FILE_READ`. We
// call this from the post-`FUN_ADDON_INIT` hook to register the
// embedded `!!!ClassicAPI` addon — the dedup behavior means our
// call is a no-op when the user has the addon installed on disk.
FUN_TOC_PARSER = 0x0051C9B0,
// AddOn registry init — `__fastcall(accountName)`. Documented in
// CLAUDE.md ("AddOn registry & hot-reload"). Hooked post-call so
// we can splice the embedded addon entry into the freshly-populated
// registry before the load pass.
FUN_ADDON_INIT = 0x0051C740,
// Generic intrusive-list insert/move helper used by `FUN_TOC_PARSER`
// to thread new addon entries into the registry's doubly-linked
// list. Signature (`__thiscall`):
// `(ListCtrl *this, void *entry, int position, int anchor)`
// Where:
// - `this` — list-control struct (for the addon registry,
// this is `&VAR_ADDON_LIST_CTRL`).
// - `entry` — entry to insert. If already linked, the
// function removes it from its current
// position first.
// - `position` — `1` = insert at head, anything else (engine
// passes `2`) = insert at tail.
// - `anchor` — `0` = anchor against the list sentinel
// (default), nonzero = anchor relative to
// another entry's link field at that offset.
//
// Used by `Addons::Embedded` to move our injected `!!!ClassicAPI`
// entry from the tail (where `FUN_TOC_PARSER` puts it) to the head
// — vanilla's addon load pass at `FUN_0051F600` walks the linked
// list in insertion order, so without this fix our addon would
// load *last*, breaking dependent addons that expect our globals
// to be ready in their main chunk.
FUN_INTRUSIVE_LIST_INSERT = 0x00521AD0,
// Addon-registry intrusive-list control. Layout
// (`__thiscall`-friendly, generic across all intrusive lists in the
// binary):
// +0x00 (= `0x00BE1B64`) — `int` next-pointer offset within each
// entry (= `0xC` at runtime; entries
// store their next-link at
// `entry+0xC..0x10`).
// +0x04 (= `0x00BE1B68`) — sentinel `next` field
// (points back into &sentinel+1 when
// the list is empty).
// +0x08 (= `0x00BE1B6C`) — list head (alias for sentinel `prev`
// when treated as circular).
//
// `VAR_ADDON_LIST_CTRL` is just the address of the control struct
// (i.e., `0x00BE1B64`). Pass `&VAR_ADDON_LIST_CTRL` as the `this`
// arg to `FUN_INTRUSIVE_LIST_INSERT`.
VAR_ADDON_LIST_CTRL = 0x00BE1B64,
// `SStrDup(const char *src, const char *file, int line)`. `__stdcall`.
// Storm's string-copy wrapper around `SMemAlloc` — used by the engine
// itself to populate event entry names. We use it from `Event::Custom`
// so the engine's reload-teardown `SMemFree` sees blocks that came
// from `SMemAlloc` (which it requires).
FUN_STORM_SSTRDUP = 0x0064A620,
// Talent system — per-player talent state populated at login from
// (class, race) + Talent.dbc / TalentTab.dbc. The engine maintains
// one `TabInfo *` per talent tab in the array at
// `[VAR_TALENT_TAB_INFO_ARRAY]`, with the count at
// `[VAR_TALENT_TAB_COUNT]` (= 3 for all vanilla classes).
// Verified by `Script_GetTalentTabInfo` (`0x004F3040`),
// `Script_GetNumTalents` (`0x004F3160`), and `Script_GetTalentInfo`
// (`0x004F3200`) — all three read the same pair of globals.
//
// TabInfo struct:
// +0x00 int TalentTab.dbc rowID
// +0x04 int pointsSpent
// +0x08 int numTalents (in this tab)
// +0x0C TalentEntry * talents (array, 0-indexed)
//
// TalentEntry, stride 0x54:
// +0x00 uint32 talentID (Talent.dbc primary key)
// +0x04..+0x0F other fields (tier, column, ...)
// +0x10..+0x33 uint32 SpellRank[9] (rank-N spellID at index N-1)
// +0x34..+0x53 prereqs / flags / other
//
// Vanilla 1.12 talents have at most 5 ranks, so SpellRank[5..8] are
// always zero; engine reserves 9 slots, we expose the same range.
//
// SpellRank offset verified by tracing the engine's currentRank-
// derivation loop in `Script_GetTalentInfo`: it `lea edx, [ebx+0x30]`
// (cur = highest slot) then walks **downward** with `sub ecx, 4`
// (visible at 0x004F3305) for 9 iterations, ending at +0x10. So
// SpellRank[0] (rank 1's spellID) is at +0x10, SpellRank[8] (rank 9
// sentinel) at +0x30. Confirmed empirically: a debug build reading
// `[entry+0x30]` returned 0 for Inner Focus (rank 1, 14751); the
// value is at `[entry+0x10]`.
VAR_TALENT_TAB_COUNT = 0x00BDCD24,
VAR_TALENT_TAB_INFO_ARRAY = 0x00BDCD28,
OFF_TABINFO_NUM_TALENTS = 0x08,
OFF_TABINFO_TALENT_ARRAY = 0x0C,
OFF_TALENT_SPELL_RANK = 0x10,
TALENT_ENTRY_STRIDE = 0x54,
TALENT_MAX_RANKS = 9,
// Talent.dbc — standard 5-DWORD class shape, records pointer at
// `+0x08` and count at `+0x0C` of the class instance at
// `0x00C0D6E0`. Records is an array of `TalentRec *` indexed
// directly by talentID (sparse — many slots NULL since talent IDs
// skip across classes). Used by `GameTooltip:SetTalentByID` to
// resolve cross-class talents that aren't in the local player's
// loaded TabInfo arrays.
//
// Record layout (verified standard vanilla Talent.dbc schema):
// +0x00 uint32 ID
// +0x04 uint32 TabID
// +0x08 uint32 TierID (row, 0-based)
// +0x0C uint32 ColumnIndex (0-based)
// +0x10 uint32 SpellRank[0..8] — rank-1 spellID at +0x10
//
// The per-player `TalentEntry` (in `TabInfo->talents[]`) shares
// the same SpellRank offset, which is why we can reuse
// `OFF_TALENT_SPELL_RANK` here without redefining it.
VAR_TALENT_DBC_RECORDS = 0x00C0D6E8,
VAR_TALENT_DBC_COUNT = 0x00C0D6EC,
// Engine's `Script_GetTalentInfo` Lua C function. We call it from
// `GetTalentSpellID` to derive the player's currentRank without
// re-implementing the spell-knowledge checks at `0x0060C740` /
// `0x0060C8D0`. Signature: `int __fastcall(void *L)` — reads tab and
// talent index from Lua stack[1] and stack[2], pushes 6 returns
// (name, icon, tier, column, currentRank, maxRank). Errors (calls
// lua_error) on invalid input or pre-login state, so callers must
// pre-validate.
FUN_SCRIPT_GET_TALENT_INFO = 0x004F3200,
// Game-time struct populated by SMSG_LOGIN_VERIFY_WORLD /
// SMSG_LOGIN_SETTIMESPEED. The engine maintains it as the current
// server clock, advanced by an internal tick handler. `Script_GetGameTime`
// (`0x00515EE0`) reads `[+0x04]` and `[+0x00]` directly via `fild`,
// and the engine's "to days-since-epoch" helper at `0x00642320`
// builds a `struct tm` from `[+0x0C..+0x14]` and calls `_mkgmtime`,
// confirming the field layout.
//
// +0x00 int minute 0..59
// +0x04 int hour 0..23
// +0x08 ? (uncertain — possibly seconds, treated as
// 0 by the engine's known consumers)
// +0x0C int day 0-based; engine `inc`s before storing as
// tm_mday (which is 1-based)
// +0x10 int month 0-based (0=Jan, matches tm_mon directly)
// +0x14 int year full year (e.g. 2026), engine normalizes
// via `(year % 100) + 100` for tm_year
//
// Pre-login the struct is BSS-zero; year=0 is the "uninitialized"
// sentinel we check for.
VAR_GAMETIME_STRUCT = 0x00CE8538,
OFF_GAMETIME_MINUTE = 0x00,
OFF_GAMETIME_HOUR = 0x04,
OFF_GAMETIME_DAY = 0x0C,
OFF_GAMETIME_MONTH = 0x10,
OFF_GAMETIME_YEAR = 0x14,
// AddOn registry. The engine keeps a flat 4-byte-stride array of
// `AddOnEntry *` at `[VAR_ADDON_ARRAY]`, with the in-use count at
// `[VAR_ADDON_COUNT]`. Each entry's first 12 bytes are an inline
// null-terminated name buffer, so an `AddOnEntry *` can be passed
// directly to `lua_pushstring` to push the addon's name (which is
// exactly what `Script_GetAddOnInfo` does for ret1).
//
// Per-field accessors (all `__fastcall(ecx=name) → char* or NULL`):
// each one looks up the addon by name in the engine's hash table,
// then reads a single hardcoded field from the addon's metadata
// hash table and returns its string value (NULL if the addon
// doesn't exist or the field is missing). The `name` arg can be
// either a real C string OR an `AddOnEntry *` — the entry's
// first 12 bytes are an inline null-terminated name, so it
// doubles as a valid `const char *`.
//
// We use these directly in the `C_AddOns.*` wrappers to avoid
// dispatching to `Script_GetAddOnInfo` (which pushes a 7-tuple
// when we only want one field, and worse, errors via `lua_error`
// for out-of-range numeric indices).
FUN_ADDON_GET_BY_INDEX = 0x0051DF00, // (idx0Based) → AddOnEntry* or NULL
FUN_ADDON_GET_TITLE_BY_NAME = 0x0051DF20, // (name) → title string or NULL
FUN_ADDON_GET_NOTES_BY_NAME = 0x0051E050, // (name) → notes string or NULL
// `__fastcall(const char *nameOrEntry) → AddOnEntry*+0x48 or NULL`.
// Hash-table lookup by name (accepts an entry pointer too — its
// first 12 bytes are the inline name), returning a pointer to the
// matched record's RequiredDeps descriptor (`record + 0x48`), or
// NULL on a miss. Stock `Script_GetAddOnDependencies` (`0x0048E5E0`)
// calls this then reads count@+4 / data@+8 off the return to walk
// the required deps. We reuse it only to recover the record base for
// string input: `record = resolve(name) - OFF_ADDON_REQDEPS_DESC`.
FUN_ADDON_RESOLVE_REQ_DEPS = 0x0051E350,
// AddOnEntry dependency-array descriptors are `{cap, count, data,
// quantum}` (each field 4 bytes) laid out 0x10 apart, parsed by the
// TOC parser `FUN_0051c9b0`:
// OptionalDeps desc@+0x38 (count@+0x3C, data@+0x40)
// RequiredDeps desc@+0x48 (count@+0x4C, data@+0x50) ← stock walks
// LoadWith desc@+0x58
// Optional offsets verified against the parser's append site at
// `0x0051CDBA` (`mov esi,[rec+0x3C]` count, `lea edi,[rec+0x38]`);
// required desc@+0x48 confirmed by `FUN_ADDON_RESOLVE_REQ_DEPS`'s
// `lea eax,[rec+0x48]` return.
OFF_ADDON_REQDEPS_DESC = 0x48,
OFF_ADDON_OPTIONALDEPS_COUNT = 0x3C,
OFF_ADDON_OPTIONALDEPS_ARRAY = 0x40,
// Per-field accessors `Script_GetAddOnInfo` calls internally for
// returns 5 (loadable), 6 (reason string), 7 (security category).
// We dispatch to these directly so the wrappers don't need to
// bounce through `Script_GetAddOnInfo` and unwind 7 returns.
//
// IS_LOADED `__fastcall(entry) → byte`
// Hash-table lookup in the addon registry. Returns the byte
// at `entry+0x18`, which the addon loader (`FUN_0051F240`)
// writes `1` to when the addon has finished loading. Non-zero
// ⇒ the addon is loaded.
//
// CAN_LOAD `__fastcall(entry, char fullCheck=1, int *outStatus,
// int *outDepHandle, const char *accountName) → byte`
// Recursive load-check that resolves all forward `## Dependencies`.
// On `0` return, writes one of 8 status codes into `*outStatus`
// (see `VAR_ADDON_LOADABLE_REASON_TABLE` for the index→string
// mapping). `outDepHandle` carries a dep-pointer when status is 0
// ("DEP: %s" path), unused otherwise. We pass `&zeroDep` for
// `outDepHandle` — we don't render the dep-name into the reason
// since the modern API gives just the status enum.
//
// GET_REASON_STRING `__thiscall(int statusCode, char *buf, uint cap)`
// Copies the status-code's static string into `buf`, or formats
// `"DEP: <name>"` when `this == 0`. We bypass this entirely and
// index the table directly (see `VAR_ADDON_LOADABLE_REASON_TABLE`).
//
// GET_SECURITY_INDEX `__fastcall(entry) → uint`
// Hash-table lookup that returns the security category index
// (0=SECURE, 1=INSECURE, 2=BANNED). Defaults to `1` (INSECURE)
// when the entry isn't in the override table.
FUN_ADDON_IS_LOADED = 0x0051E6F0,
FUN_ADDON_CAN_LOAD = 0x0051E780,
FUN_ADDON_GET_SECURITY_INDEX = 0x0051E990,
// Returns a pointer to the inline-stored login account name buffer
// at `0x00C27D88`, or NULL if no character is logged in yet.
// `Script_GetAddOnInfo` feeds this into the loadable + enabled
// checks; same convention.
FUN_GET_LOGIN_ACCOUNT_NAME = 0x005ABDC0,
// Two parallel `const char *[]` tables in `.data` covering every
// string `Script_GetAddOnInfo`'s returns 6 + 7 can produce.
//
// LOADABLE_REASON_TABLE — 8 entries indexed by the status code
// `FUN_ADDON_CAN_LOAD` writes:
// 0 LOADABLE (only emitted for the DEP fallback)
// 1 MISSING
// 2 DISABLED
// 3 BANNED
// 4 CORRUPT
// 5 INSECURE
// 6 NOT_DEMAND_LOADED
// 7 INTERFACE_VERSION
//
// SECURITY_TABLE — 3 entries indexed by the value
// `FUN_ADDON_GET_SECURITY_INDEX` returns. Lives at
// `LOADABLE_REASON_TABLE + 8 * sizeof(char *)` — the two
// tables are physically contiguous in the binary.
// 0 SECURE
// 1 INSECURE
// 2 BANNED
VAR_ADDON_LOADABLE_REASON_TABLE = 0x0085365C,
VAR_ADDON_SECURITY_TABLE = 0x0085367C,
VAR_ADDON_ARRAY = 0x00BE1B94,
VAR_ADDON_COUNT = 0x00BE1B90,
// NOTE: an earlier revision defined OFF_PLAYER_FIELD_VIS_BYTES /
// PLAYER_VIS_BIT_STEALTH here at 0x17C, believing bit 0x02 was a
// "stealth bit". That was wrong: 0x17C is UNIT_FIELD_AURALEVELS
// (per-slot caster-level bytes; see OFF_UNIT_FIELD_AURALEVELS above),
// and the old read only appeared to work by coincidence (a caster-
// level byte that happened to have bit 0x02 set on the test char;
// at level 60 = 0x3C it doesn't, so it read false). The real stealth
// flag is UNIT_FIELD_BYTES_1 byte 3 (UNIT_BYTES_1_STEALTH_FLAG); see
// that field above. IsStealthed reads it.
// Mount display ID — the creature display ID the engine renders
// under the mounted player. Zero when not mounted, non-zero
// (typically a 4-digit creature display ID like 0x4306) when
// mounted. Broadcast in UpdateFields, so works for any unit's
// descriptor — though we only expose `IsMounted()` for the
// player to match modern API semantics.
OFF_UNIT_FIELD_MOUNTDISPLAYID = 0x1FC,
// Local player movement-flags u32. Lives directly on the
// CGPlayer object (not the broadcast descriptor) — this is
// client-side state the engine maintains for outbound
// MSG_MOVE_* packets, never visible for remote units. Found
// empirically by diffing _classicapi_PlayerLog snapshots
// (standing/swimming/falling).
//
// Bit values match vanilla MOVEFLAG_* protocol constants —
// verified by matching observed values to the documented
// 1.12 movement-flag set:
// 0x0001 FORWARD 0x2000 FALLING (in-air, moving down)
// 0x4000 FALLING_FAR (extended fall)
// 0x8000 PENDING_STOP
// 0x200000 SWIMMING
// 0x1000000 FLYING (no flying mounts in vanilla, but the bit
// exists for druid Flight Form etc.)
OFF_PLAYER_MOVEMENT_FLAGS = 0x9E8,
MOVEFLAG_FORWARD = 0x1,
MOVEFLAG_BACKWARD = 0x2,
MOVEFLAG_STRAFE_LEFT = 0x4,
MOVEFLAG_STRAFE_RIGHT = 0x8,
// 0x10 / 0x20 are TURN_LEFT / TURN_RIGHT — turn-in-place, not
// translational movement. Excluded from "moving" semantics
// because modern `PLAYER_STARTED_MOVING` doesn't fire for them.
MOVEFLAG_JUMPING = 0x1000,
MOVEFLAG_FALLING = 0x2000,
MOVEFLAG_FALLING_FAR = 0x4000,
MOVEFLAG_SWIMMING = 0x200000,
// CGPlayer-local pointer to the GameObject the current spell cast
// is targeting. Holds a heap pointer (high bits in the user-mode
// range, e.g. `0x42908708` / `0x52FA1A08`) while the player is
// casting/channeling onto a GameObject; cleared on cast end or
// movement break. Local-only — does NOT broadcast.
//
// Empirically distinct from UNIT_FIELD_CHANNEL_OBJECT — the engine
// uses one or the other depending on the cast shape:
//
// - **Set** during: clicking a warlock summoning portal (channel-
// spell that doesn't populate UNIT_CHANNEL_OBJECT); mining
// (regular spell cast on an ore node).
// - **0** during: warlock channeling a spell (no GO target);
// fishing (uses UNIT_CHANNEL_OBJECT for the bobber GUID);
// herb gathering (no spell, pure GO-loot mechanism); mailbox /
// gossip / sit / NPC interaction (instant, no animation).
//
// Used together with UNIT_FIELD_CHANNEL_SPELL to detect ritual
// participation — see `IsAssistingRitual()` in `unit/State.cpp`.
// The combined check `channelSpell != 0 && castGameObject != 0`
// uniquely identifies the portal-clicker state in 1.12 (mining
// fails `channelSpell != 0`; warlock/fishing fail
// `castGameObject != 0`).
OFF_CGPLAYER_CAST_GAMEOBJECT_PTR = 0xB4,
// No `MOVEFLAG_FLYING` constant intentionally. Vanilla 1.12
// doesn't flip a flying bit during taxi flights (verified
// empirically: `IsFlying()` checking 0x01000000 stayed false
// throughout a flightpath on which `UnitOnTaxi("player")`
// correctly returned 1). Server-driven splines drive taxi
// animation directly without touching the local movement-
// flags word. Use `UnitOnTaxi` for taxi detection.
// Equipment-slot index for the off-hand. Slots 1..19 are the
// character-pane equipment slots (1=head … 19=tabard); 17 is
// the off-hand slot the engine uses when looking up shields,
// off-hand weapons, and held items via `ItemMgr::GetItemBySlot`.
INVSLOT_OFFHAND = 17,
// INVTYPE values that count as "weapon" for `OffhandHasWeapon`.
// INVTYPE_WEAPON (13) covers any one-handed weapon equippable in
// either hand (sword, axe, mace, dagger, fist). INVTYPE_WEAPONOFFHAND
// (22) covers weapons that can ONLY go in the off-hand. Shields
// (14), Holdables (23 — tomes/orbs), and empty slots all return
// false. INVTYPE_2HWEAPON (17) is excluded because two-handers
// occupy the main-hand slot exclusively.
INVTYPE_WEAPON = 13,
INVTYPE_WEAPONOFFHAND = 22,
// Character-pane equipment slot range: 1..19 (head=1, neck=2, …,
// tabard=19). Used by `C_Item.IsEquippedItem` to walk every slot
// looking for a matching item.
EQUIPMENT_SLOT_FIRST = 1,
EQUIPMENT_SLOT_LAST = 19,
// CGItem instance block GUID — qword at +0x00 of the instance block
// (which sits behind the pointer at CGItem +0x08). Sibling of
// OFF_INSTANCE_BLOCK_ITEM_ID at +0x0C in the same block.
OFF_INSTANCE_BLOCK_GUID = 0x00,
// `Script_ClearCursor` / `Script_PickupInventoryItem` Lua C
// functions — both `__fastcall(void *L)`. ClearCursor takes no
// args, drops anything held on the cursor. PickupInventoryItem
// reads a 1-based character-pane slot at Lua stack[1] and lifts
// that equipped item onto the cursor (or swaps with the existing
// cursor contents). Used by `C_EquipmentSet.UseEquipmentSet` to
// assemble the pickup→equip chain for each set item.
FUN_SCRIPT_CLEAR_CURSOR = 0x004895B0,
FUN_SCRIPT_PICKUP_INVENTORY_ITEM = 0x004C8DA0,
// Equipment/bag-slot pickup PRIMITIVE behind Script_PickupInventoryItem
// (`FUN_004C8DA0` is just `FUN_004C7300(arg - 1)`). Called directly:
// void __fastcall(uint slot0Based)
// Self-contained — resolves the player, applies its own cursor/lock
// guards, and handles the drop case (slot == 0xFFFFFFFF). Covers the
// 0-based equipment (0..18) and equipped-bag (19..22) slots; container
// contents go through FUN_CURSOR_PICKUP_ITEM instead. Modern
// `equipmentSlotIndex` is 1-based, so pass `equipmentSlotIndex - 1`.
FUN_PICKUP_INVENTORY_SLOT = 0x004C7300,
// Bag-update fire sites — see TODO #67 for the full Ghidra
// investigation. Hook these three to detect BAG_UPDATE fires and
// emit BAG_UPDATE_DELAYED once per frame in which any fired.
// Pattern-search confirms only three fire sites for `0x148`
// (the BAG_UPDATE event ID) exist in 1.12.1's `.text`, and we
// cover all three.
//
// FUN_BAG_SLOT_DIFF (`0x004F91A0`) — __cdecl `void()` (zero
// args, ends with plain `RET`). Walks linear slots `0x13..0x16`
// (player bags 1..4) and `0x3B..0x44` (bank bags 5..10),
// comparing each against a cached GUID snapshot at
// `DAT_00BDD060`. Fires `BAG_UPDATE(bagID)` for each slot
// whose GUID changed. Called from per-session init
// (FUN_004F8CC0) and a packet handler (FUN_004F8EC0) — 2
// callers total, very quiet hook target.
//
// FUN_BAG_ITEM_TO_BAG (`0x004F9370`) — __stdcall
// `void(int guidLo, int guidHi)` (ends with `RET 0x8`).
// Given an item GUID, searches the bag cache for which bag
// contains it. Fires `BAG_UPDATE(0)` for backpack,
// `BAG_UPDATE(N)` for bag N, returns silently if not in any
// bag. **Most common BAG_UPDATE path** — every per-item
// field-change goes through here. 3 callers, all within the
// bag subsystem at `0x004F9xxx`.
//
// FUN_BAG_KEYRING_DESC_CHANGE (`0x004F8DB0`) — __thiscall
// `unsigned(void *bagDesc, uint a1, uint a2, uint a3, uint a4)`.
// Ends with `RET 0x10` — four 4-byte stack args, callee cleans
// 16 bytes. (Ghidra showed three stack args; the Octo binary
// actually uses four. Mismatching this leaks 4 bytes of stack
// per call and crashes after a few descriptor updates.)
// Bag descriptor update callback. Computes the slot index
// from `((int)this - 0x4a8) >> 3`; for slots `0x51..0x70` (the
// keyring range) fires `BAG_UPDATE` directly. For non-keyring
// slots it delegates to `FUN_BAG_ITEM_TO_BAG`, so we'd
// double-count if we naively hooked both — the keyring branch
// is the only path here that doesn't already go through our
// other hook. Hooking is safe because the `g_pending` drain
// is idempotent (the flag stays true until WorldTick clears it).
FUN_BAG_SLOT_DIFF = 0x004F91A0,
FUN_BAG_ITEM_TO_BAG = 0x004F9370,
FUN_BAG_KEYRING_DESC_CHANGE = 0x004F8DB0,
// World-subsystem per-frame update — runs exactly once per frame
// as part of the main world tick (`FUN_00482EA0`). Only one caller
// in the entire binary; deep in the rendering/world pipeline,
// nowhere near the chat/cast/transmog code regions that other
// DLLs (SuperWoWhook / nampower / transmogfix) hook. We hook the
// tail of this function to drain `BAG_UPDATE_DELAYED`'s pending
// flag — exact per-frame coalescing matching modern WoW.
//
// Calling convention: `__fastcall(int ecx, int edx, int stackArg)`,
// `RET 0x4` (callee cleans the one stack arg).
FUN_WORLD_TICK = 0x0066FD50,
// SMSG_BINDPOINTUPDATE handler. The server sends this packet on
// initial login (to sync the player's current bind) and again
// every time the player binds at a new innkeeper. The handler
// deserializes `float x, y, z; uint32 mapID; uint32 areaID` into
// the corresponding globals below and sets `VAR_BIND_POINT_VALID`
// to 1.
//
// __fastcall(void *packetBuffer)
//
// Single caller (the packet dispatcher's jump table for opcode
// 0x155) — quiet hook target, no contention with other DLLs.
// Hooked by `Player::HearthstoneBound` to fire `HEARTHSTONE_BOUND`
// every time the user re-binds at an innkeeper. Gating off the
// bind-valid flag's transition distinguishes "initial sync" (the
// one we suppress) from "user rebound at an inn" (the one we
// fire on — even when the area string stays the same, since the
// bind ACTION is what fires the event).
FUN_BINDPOINT_UPDATE_HANDLER = 0x005ED3C0,
// "Bind point is valid" flag. Set to 1 by the BINDPOINTUPDATE
// handler after the packet has been fully parsed. Zeroed by
// `FUN_005E2510` (the per-character-entry init routine).
// Reading this BEFORE the handler runs distinguishes initial
// sync (`== 0`) from a real re-bind (`== 1`).
VAR_BIND_POINT_VALID = 0x00C4D4E0,
// SMSG_QUESTGIVER_QUEST_COMPLETE handler (opcode 0x191). Server
// sends this after the client claims a quest reward via CMSG_QUESTGIVER_CHOOSE_REWARD
// (opcode 0x18E, sent from `Script_GetQuestReward` → `FUN_005EADC0`).
// Packet body, read in order via `FUN_PACKET_READ_UINT32`:
// [0] questID
// [1] unknown / flags
// [2] xpReward
// [3] moneyReward
// [4] numItems (plus per-item itemID/count for each)
//
// __thiscall(void *player, void *packetStream)
//
// Registered via `FUN_005AB650(0x191, ...)` alongside 8 other quest
// opcodes that all dispatch through `FUN_005E59B0`'s switch — we
// hook the per-opcode handler directly to keep our gate narrow.
// Hooked by `Quest::TurnedIn` to fire `QUEST_TURNED_IN(questID, xp, money)`.
FUN_QUEST_GIVER_QUEST_COMPLETE_HANDLER = 0x005DC400,
// Packet-stream uint32 reader. `__thiscall(stream, uint32 *out)` —
// reads 4 bytes from `stream + base + cursor`, advances cursor by
// 4. Cursor lives at `stream + OFF_PACKET_STREAM_CURSOR`; save and
// restore it to peek without consuming. Same reader the engine's
// own packet handlers (FUN_005DC400, FUN_005ED3C0, etc.) use.
FUN_PACKET_READ_UINT32 = 0x00418E30,
OFF_PACKET_STREAM_CURSOR = 0x14,
// Engine session globals used by `EquipmentSet::Storage` to build
// the per-character WTF path. Same layout VanillaMinimapTracking
// uses for its own persistence file. Account is the value WoW
// writes the per-character WTF directory under — NOT the saved-
// credentials CVAR. Character name is an inline buffer (NUL byte
// at index 0 means "no active character yet"). Realm name lives
// inside a struct one indirection in.
VAR_ACCOUNT_NAME_PTR = 0x00BE1C0C,
VAR_CHARACTER_NAME = 0x00C27D88,
VAR_REALM_INFO_PTR = 0x00C28130,
OFF_REALM_INFO_NAME = 0x20,
// Player body yaw (orientation in radians, 0..2π) — the
// character's facing direction in the world. Inline float on
// CGPlayer; mirrored at `+0x9F8` (current vs last-broadcast).
// Verified empirically: a clean 180° RMB-drag swings this by
// ~π rad, and LMB-only camera orbits leave it untouched.
// Used by `PLAYER_STARTED_TURNING` to detect actual character
// rotation (vs the mouselook button merely being held).
OFF_PLAYER_BODY_YAW = 0x9C4,
// Camera object pointer chain. The game-state singleton lives
// at `*0x00B4B2BC`; the camera object hangs off it at `+0x65B8`.
// Verified via `Script_CameraZoomIn` (`0x0050B400`) which loads
// this chain to call `FUN_0050FC60` on the camera. Returns the
// camera struct or `nullptr` if the game state isn't yet
// initialized (pre-login).
VAR_GAME_STATE_PTR = 0x00B4B2BC,
OFF_GAME_STATE_CAMERA_PTR = 0x65B8,
// Camera yaw, relative to the character (radians). `0` =
// camera-behind-character default. Accumulates as the user
// LMB-orbits; stays at `0` during RMB-mouselook (camera rotates
// *with* the character, so relative offset doesn't change).
// Verified empirically: clean 180° LMB orbit moves this from
// `0` to `~π`. Mirrored at `+0x210` and `+0x214` (smoothing /
// last-applied buffers); we read the primary at `+0xF0`.
OFF_CAMERA_RELATIVE_YAW = 0xF0,
// UI input controller — heap-allocated struct holding the
// engine's master input-state bitfield (mouselook / free-look /
// turn-key / autorun / strafe-modifier / etc.). The slot at
// `0x00BE1148` is a pointer; deref it to reach the controller,
// which lives until the client tears down (rare in practice).
// NULL during pre-login.
VAR_UI_INPUT_CONTROLLER = 0x00BE1148,
// Master input flags. Single u32 at `+0x04` of the controller,
// touched by the engine's button-press/release handlers
// (`FUN_00514840` / `FUN_00514B70`) on every mouse-button or
// input-key transition.
OFF_UI_INPUT_FLAGS = 0x04,
// Bit 0 — `Script_IsMouselooking` checks this. Set when the
// user is in mouselook mode (RMB-drag, or `MouselookStart`
// called from Lua). Turning the character follows mouselook.
INPUT_FLAG_MOUSELOOK = 0x01,
// Bit 1 — set when the user is in free-look mode (LMB-drag).
// Camera-only rotation; character doesn't turn.
INPUT_FLAG_FREE_LOOK = 0x02,
// Bits 4-7 — WASD movement-key state. Each `MoveForwardStart`
// / `StrafeLeftStart` / etc. pushes one of these as the bit
// mask into the engine's button-press handler. Bit `0x1000` is
// the autorun-active flag (set by `ToggleAutoRun`).
// `INPUT_FLAGS_MOVING_ANY` is the engine's own "is the user
// currently inputting translational movement via keys/autorun"
// mask, used to drive `PLAYER_STARTED_MOVING` — matches modern's
// "STOPPED fires on key release, even mid-air" semantics because
// no physics/airborne bit is involved.
//
// NOTE: the "hold both mouse buttons to run forward" gesture is
// NOT in this mask. The button handler (`FUN_00514840`) drives
// that forward move directly via `FUN_005103e0` and explicitly
// *clears* the autorun bit when both buttons go down. Detect it
// from `INPUT_FLAG_MOUSELOOK & INPUT_FLAG_FREE_LOOK` both held
// instead — see `Player::InputEvents`.
INPUT_FLAG_MOVE_FORWARD = 0x10,
INPUT_FLAG_MOVE_BACKWARD = 0x20,
INPUT_FLAG_STRAFE_LEFT = 0x40,
INPUT_FLAG_STRAFE_RIGHT = 0x80,
INPUT_FLAG_AUTORUN = 0x1000,
INPUT_FLAGS_MOVING_ANY =
INPUT_FLAG_MOVE_FORWARD | INPUT_FLAG_MOVE_BACKWARD |
INPUT_FLAG_STRAFE_LEFT | INPUT_FLAG_STRAFE_RIGHT |
INPUT_FLAG_AUTORUN,
// CGUnit -> MovementInfo pointer. Holds the unit's per-instance
// position / orientation / movement-flags / per-direction-speed
// block. Both the local player and synced remote units carry
// valid pointers here (NPCs included, when they exist as
// CGUnits). Verified at multiple call sites that pass
// `[unit + 0x118]` to `FUN_MOVEMENT_GET_EFFECTIVE_SPEED` — e.g.
// `0x00511920` (sprint-jump motion calculator).
OFF_UNIT_MOVEMENT_INFO_PTR = 0x118,
// Inside the MovementInfo block:
OFF_MOVEMENT_FLAGS = 0x40, // u32 — engine's MOVEFLAG_* bits
OFF_MOVEMENT_WALK_SPEED = 0x88,
OFF_MOVEMENT_RUN_SPEED = 0x8C,
OFF_MOVEMENT_RUN_BACK_SPEED = 0x90,
OFF_MOVEMENT_SWIM_SPEED = 0x94,
OFF_MOVEMENT_SWIM_BACK_SPEED = 0x98,
// Effective-speed selector. `__thiscall float(this = MovementInfo,
// int forceWalk) → float`. Returns the speed the engine would
// apply to this frame's movement step — accounts for movement
// flags (walking, swimming, backward), taxi paths, and the
// walk/run/swim selection. Returns 0 when the unit isn't
// moving (movement-flag bits 0..3 all clear). Used by 1.12's
// movement-prediction loop; we call it to provide modern's
// `currentSpeed` first return from `GetUnitSpeed`.
FUN_MOVEMENT_GET_EFFECTIVE_SPEED = 0x007C4C90,
// ------------------------------------------------------------------
// Get*ItemID companions to the engine's Get*ItemLink functions.
// Each offset block is the data path the corresponding
// `Script_Get*ItemLink` reads from before calling
// `FUN_DBCACHE_ITEMSTATS_GET_RECORD` — same source, just stop at
// the itemID instead of building the link string.
// ------------------------------------------------------------------
// Loot rolls: an intrusive linked list of in-progress group loot
// rolls. `FUN_LOOT_ROLL_FROM_ID(rollID) → entry *` walks it.
// `Script_GetLootRollItemLink` reads the itemID at `entry+0x1C`.
FUN_LOOT_ROLL_FROM_ID = 0x0061B2E0,
OFF_LOOT_ROLL_ITEM_ID = 0x1C,
// Loot slots: flat array indexed by `slot-1`, 0x1C-byte stride.
// `LOOTABLE_FLAG` mirrors the engine's `[VAR_LOOT_LOOTABLE]` test
// that drives whether slot indices are 1-based or 0-based; we
// match the engine's `dec` behavior. itemID is at `entry+0`.
VAR_LOOT_SLOTS = 0x00B7196C,
VAR_LOOT_GUID_LO = 0x00B71B48,
VAR_LOOT_GUID_HI = 0x00B71B4C,
VAR_LOOT_LOOTABLE = 0x00B71BA0,
LOOT_SLOT_STRIDE = 0x1C,
LOOT_MAX_SLOTS = 0x10,
// Per-slot field offsets within a `VAR_LOOT_SLOTS + slot * 0x1C`
// entry. Decoded from `Script_GetLootSlotInfo` and the populator
// at `FUN_004C1CB0`:
// +0x00 itemID (Script_GetLootSlotInfo's first push)
// +0x04 displayInfoID (icon lookup via DBC index)
// +0x08 count (FUN_004C22E0 reads `[base+0x8]`)
// +0x0C ?
// +0x10 ?
// +0x14 wire-slot byte (the server-side slot index — what
// `CMSG_LOOT_ITEM` expects; differs from the local
// densely-packed index when the response had gaps)
OFF_LOOT_SLOT_COUNT = 0x08,
OFF_LOOT_SLOT_WIRE_INDEX = 0x14,
// `__fastcall(uint userFacingSlot, char *outBuf, int bufSize) →
// const char *outBuf` — builds the loot-slot hyperlink string
// (e.g. `|cff1eff00|Hitem:12345:0:0:0|h[Item Name]|h|r`) and
// copies it into `outBuf`. Returns the buffer pointer on success,
// `NULL` if no loot window is open, the slot is empty, or the
// item's cache record isn't loaded yet. Used by
// `Script_GetLootSlotLink` at `0x004C2D20`.
//
// `userFacingSlot` is the post-`__ftol`-decrement slot index — the
// same shape Lua's `LootSlot(slot)` produces internally after
// `dec eax`:
// - When coin is present (`VAR_LOOT_LOOTABLE != 0`), input `0`
// is the coin slot itself and returns NULL; subsequent
// internal items live at `userFacingSlot = internal_slot + 1`
// (the function dec's again inside).
// - When no coin, `userFacingSlot = internal_slot` directly.
// The internal `_GetRecord` call inside uses `callback = NULL`, so
// the link is a pure cache hit — no network request gets queued
// when the cache is cold, just a NULL return.
FUN_LOOT_SLOT_LINK_BUILDER = 0x004C2670,
// `__stdcall(uint8_t slotByte)` — sends `CMSG_LOOT_ITEM` (opcode
// `0x108`) carrying the wire-protocol slot byte for the currently-
// open loot window. Built directly from the engine's packet
// primitives — bypasses the `Script_LootSlot` Lua wrapper at
// `FUN_004C2790`, which routes through a `param_2 != 0`
// BoP-confirm-after-dialog branch that's of no use to us. The
// server cheerfully takes whatever slot you send for the current
// loot session; no client-side BoP confirmation gate.
//
// **Calling convention matters.** The callee reads its arg from
// `[ebp+8]` (stack) and ends with `ret 4`. Mis-typedef'ing as
// `__fastcall` produces a stack-corrupting caller — symptoms are
// delayed crashes on unrelated vtable reads.
FUN_CMSG_LOOT_ITEM = 0x005E1AD0,
// UNIT_DYNAMIC_FLAGS within `m_objectFields`. Standard
// server-driven dynamic-state bitmask. Empirically verified by
// cross-referencing three `Script_*` accessors that all read
// bytes at `[m_objectFields + 0x224]`:
// - `Script_UnitIsTapped` (`0x00519C90`): `test [eax+0x224], 0x04`
// - `Script_UnitIsTappedByPlayer` (`0x00519D00`): `test [eax+0x224], 0x08`
// - `Script_UnitIsDead` (`0x00517AC0`): `[eax+0x224] >> 5 & 1`
// Bit values match CMaNGOS conventions: 0x01 LOOTABLE,
// 0x02 TRACK_UNIT, 0x04 TAPPED, 0x08 TAPPED_BY_PLAYER,
// 0x10 SPECIALINFO, 0x20 DEAD, 0x40 REFER_A_FRIEND_LINKED,
// 0x80 ZONE_OUT. The +0x224 offset is significantly later than
// CMaNGOS-doc'd vanilla (which puts DYNAMIC_FLAGS at field 0x46
// = +0x118) — yet another non-uniform shift in 1.12.1's actual
// UNIT_FIELD layout. Direct empirical read is the authority.
OFF_UNIT_FIELD_DYNAMIC_FLAGS = 0x224,
UNIT_DYNFLAG_LOOTABLE = 0x01,
UNIT_DYNFLAG_DEAD = 0x20,
// UNIT_FIELD_BOUNDINGRADIUS within m_objectFields — single
// float, the unit's interact-radius in world yards. Both
// `FUN_005EC110` (interact-state check) and `FUN_005DF130`
// (CMSG_LOOT sender) compute the interaction-range threshold
// as `target_radius + player_radius + INTERACT_REACH`, clamped
// to a floor of `MIN_INTERACT_RANGE`. Verified at `0x005EC1A4`
// where the function reads
// `[(target_m_objectFields) + 0x1F0]`.
OFF_UNIT_FIELD_BOUNDING_RADIUS = 0x1F0,
// `__thiscall(player, target, useDistanceCheck)` — engine's
// CMSG_LOOT sender for **dead mobs** (CGCreature_C with
// DYNFLAG_LOOTABLE set). Pre-checks: `FUN_005EC110` interact
// validity + `FUN_006003A0` lootability (target dead + bit 0 of
// `m_objectFields[+0x224]` set) + local player not in a state
// that forbids interaction. Releases any open loot window before
// sending the new request.
//
// `useDistanceCheck` is the auto-walk gate:
// - `1` (engine default): if target out of range, start
// walking toward it and *don't* send CMSG_LOOT. If in range,
// send normally.
// - `0`: skip the range check; send immediately. The server
// enforces server-side range, so OOR sends silently fail
// rather than walking the player toward distant corpses —
// the right pick for AoE-loot-style callers.
//
// Engine callsite at `FUN_0060FA20` (right-click world handler)
// resolves the target via
// `ClntObjMgrObjectPtr(TYPEMASK_UNIT, ..., guid)` first, same as
// we do.
//
// Distinct from the sibling sender at `0x005DF130`, which gates
// on `FUN_CGCORPSE_IS_LOOTABLE` (player corpses only) instead of
// the mob path. The CGCorpse helper is documented immediately
// below.
FUN_CMSG_LOOT_UNIT = 0x005DF2A0,
// `__fastcall(int loot_response_struct, undefined4 coin, int unk)`
// — master loot-window state controller. Called by the
// `SMSG_LOOT_RESPONSE` handler tail (via `FUN_0048F3A0`) and by
// `CloseLoot`-inner (via `FUN_0048F200(0, 0, 0)`). Two phases:
// - **Close prior**: if `VAR_LOOT_GUID_LO/HI != 0`, clears
// them, releases item-cache callbacks for the prior slots,
// fires `LOOT_CLOSED` (event id `0x10D`).
// - **Open new**: if `param_1 != 0`, copies the GUID from
// `[param_1 + 8]` into `VAR_LOOT_GUID_LO/HI`, zeroes
// `VAR_LOOT_SLOTS`, walks 16 slots populating itemID via
// `FUN_005EBC90(slot)` and sibling helpers, sets
// `VAR_LOOT_LOOTABLE = param_2` (coin), then fires
// `LOOT_OPENED` (event id `0x10B`).
// Both event fires go through `FUN_FIRE_EVENT_NO_ARGS` —
// intercepting that function lets a caller swallow the events
// without touching this one.
FUN_LOOT_CONTROLLER = 0x004C1CB0,
// `__fastcall(int eventID)` — engine's no-args event dispatcher,
// the lighter-weight sibling of `FUN_FIRE_EVENT` (variadic).
// Called from ~100 sites across the engine, including the
// `LOOT_OPENED` / `LOOT_CLOSED` fires inside
// `FUN_LOOT_CONTROLLER`. Hooking it lets us conditionally swallow
// specific event ids while leaving the rest untouched — the
// mechanism we use to do silent scan loops without flickering
// the `LootFrame`. Fan-in is wide but call frequency is
// event-driven (state changes only), not per-frame, so per-call
// overhead from a hooked predicate is negligible.
FUN_FIRE_EVENT_NO_ARGS = 0x00703E50,
// `__fastcall(int sendRelease, char earlyReturnOnGameObject,
// char showError)` — engine's "close the current loot window"
// inner. Behavior keyed off args:
// - `sendRelease` (ECX): if non-zero, builds and sends
// `CMSG_LOOT_RELEASE` (opcode `0x15F`) for the current loot
// target before clearing client state.
// - `earlyReturnOnGameObject` (EDX): if non-zero, bails early
// when the loot target is a game object that's been
// interacted with in a particular way (fishing-style?).
// - `showError` (stack): if non-zero, calls `FUN_00496720(0x87)`
// to display a "cannot close loot" error.
// Side effects: clears `[player + 0x1D28/+0x1D2C]` (the player's
// prior-interact GUID slots), then calls `FUN_004C1CB0(0, 0, 0)`
// which clears `VAR_LOOT_GUID_LO/HI`, zeroes `VAR_LOOT_SLOTS`,
// and fires the `LOOT_CLOSED` event (`0x10D`). Use
// `(1, 0, 0)` for a clean release + clear.
FUN_CLOSE_LOOT_INNER = 0x0048F200,
// `CGCorpse::IsLootable(this)` — `__fastcall(corpse) → uint`,
// tests bit 0 of `[corpse_m_objectFields + 0x78]`. Specific to
// `TYPEMASK_CORPSE` (player corpses) — `+0x78` of a CGCorpse_C's
// m_objectFields holds dynamic flags with bit 0 = LOOTABLE. The
// same offset in CGUnit_C / CGPlayer_C's m_objectFields holds
// BYTES_0 (race / class / gender / power type), so this helper
// returns nonsense for live units (e.g. it returns 1 for Human
// players because race=1 has bit 0 = 1). Used by the engine's
// right-click-on-corpse handler at `FUN_005D6BF0` to gate
// CMSG_LOOT for player corpses, and from `FUN_005DF130` (one of
// two CMSG_LOOT senders) for the same corpse path. Don't reuse
// for live-unit lootability — use `OFF_UNIT_FIELD_DYNAMIC_FLAGS`
// bit 0 against a CGUnit instead.
FUN_CGCORPSE_IS_LOOTABLE = 0x005D6E20,
// Merchant inventory: flat array at `0xBDD118`, stride 0x1C,
// itemID at `entry+4`. The "flag" globals are actually the
// merchant NPC's 64-bit GUID lo/hi — both zero when no merchant
// is open, which is the engine's gate (`mov a, [LO]; or a, [HI];
// jz no_merchant`). Same globals also drive whether the buyback
// slots are populated.
VAR_MERCHANT_ITEMS = 0x00BDD118,
VAR_MERCHANT_NPC_GUID_LO = 0x00BDDFA0,
VAR_MERCHANT_NPC_GUID_HI = 0x00BDDFA4,
VAR_MERCHANT_COUNT = 0x00BDDFA8,
MERCHANT_STRIDE = 0x1C,
OFF_MERCHANT_ITEM_ID = 0x04,
// Additional 28-byte-entry offsets decoded from
// `Script_GetMerchantItemInfo` at `0x004FB150`:
// +0x0C uint32 numAvailable (-1 = unlimited stock)
// +0x10 uint32 price in copper
// +0x18 uint32 stack quantity per purchase
OFF_MERCHANT_NUM_AVAILABLE = 0x0C,
OFF_MERCHANT_PRICE = 0x10,
OFF_MERCHANT_STACK_COUNT = 0x18,
// Buyback storage. `VAR_BUYBACK_SLOTS` is a 4-byte-stride array
// of inventory-slot indices into the player's invMgr GUID array
// (the engine keeps sold items alive in a per-character buyback
// pool indexed through normal inventory storage). 12 fixed slots
// in vanilla; `VAR_BUYBACK_COUNT` is the live count of populated
// entries. Same merchant-open gate as `VAR_MERCHANT_NPC_GUID_*`.
VAR_BUYBACK_SLOTS = 0x00BDDF24,
VAR_BUYBACK_COUNT = 0x00BDDFAC,
// CMSG_SELL_ITEM dispatcher. Engine's
// `Script_UseContainerItem` merchant branch reaches it with this
// shape; calling it directly bypasses the use-vs-sell dispatch
// and any addon hooks on `UseContainerItem`.
//
// __fastcall(count[ECX],
// merchantGuidLo, merchantGuidHi,
// itemGuidLo, itemGuidHi)
//
// `count = 0` sells the whole stack — same as what
// `Script_UseContainerItem` passes. Callee cleans (`ret 0x10`).
FUN_MERCHANT_SELL_ITEM = 0x005E1D50,
// Quest item resolver — used by `GetQuestItem`. Walks the active
// quest-offer "reward"/"choice" arrays. Returns itemID directly
// (no follow-up cache lookup needed by the caller).
// `__fastcall(ECX = const char *type, EDX = int index0) → itemID`.
// Returns 0 on bad type, OOR index, or empty slot.
FUN_QUEST_ITEM_RESOLVER = 0x00501920,
// Quest log record fields (within the data block returned by
// `Quest::Cache::Lookup`). Reward and choice arrays each hold up
// to N inline itemIDs (4 bytes per entry).
OFF_QUEST_RECORD_REWARD_ITEMS = 0x3C, // 4 entries (0..3)
OFF_QUEST_RECORD_CHOICE_ITEMS = 0x5C, // 6 entries (0..5)
QUEST_RECORD_REWARD_COUNT = 4,
QUEST_RECORD_CHOICE_COUNT = 6,
// Trade window — local "player" side and remote "target" side.
// Player side is a flat int32 array (just itemIDs). Target side
// is a flat `{?, itemID}` array (8-byte stride). Both cap at 7
// slots (vanilla's 6 trade slots + 1 non-tradeable slot).
VAR_TRADE_PLAYER_SLOTS = 0x00B714F4,
VAR_TRADE_TARGET_SLOTS = 0x00B716D0,
TRADE_TARGET_STRIDE = 0x08,
OFF_TRADE_TARGET_ITEM_ID = 0x04,
TRADE_MAX_SLOTS = 7,
// Auction house — three independent arrays of entry-pointers
// covering the three views (list / owner / bidder). Each entry
// carries the itemID at `+0x08`.
VAR_AUCTION_LIST_ENTRIES = 0x00B72278,
VAR_AUCTION_LIST_COUNT = 0x00B7261C,
VAR_AUCTION_OWNER_ENTRIES = 0x00B72340,
VAR_AUCTION_OWNER_COUNT = 0x00B72624,
VAR_AUCTION_BIDDER_ENTRIES = 0x00B72470,
VAR_AUCTION_BIDDER_COUNT = 0x00B7262C,
OFF_AUCTION_ENTRY_ITEM_ID = 0x08,
// Auction sell slot — holds a single CGItem GUID for the item
// currently sitting in the "sell" frame. Engine resolves it via
// a typed object lookup; pass `OBJECT_TYPE_ITEM` and the GUID.
// `Script_StartAuction` posts whatever GUID is here, so writing an
// arbitrary bag item's GUID + calling it posts that item — no cursor,
// no ClickAuctionSellItemButton. Used by `AuctionHouse::PostItem`.
VAR_AUCTION_SELL_GUID_LO = 0x00B72608,
VAR_AUCTION_SELL_GUID_HI = 0x00B7260C,
// Auctioneer NPC GUID — set while an auction house window is open;
// `Script_StartAuction` writes it as the packet target and bails if
// it's zero (so this doubles as an "AH is open" probe).
VAR_AUCTION_AUCTIONEER_GUID_LO = 0x00B725F8,
VAR_AUCTION_AUCTIONEER_GUID_HI = 0x00B725FC,
// `Script_StartAuction` (`0x004CE770`) — `int __fastcall(void *L)`;
// reads (minBid, buyout, runTime) from L[1..3], validates the sell
// slot + auctioneer + runTime, and sends CMSG_AUCTION_SELL_ITEM
// (opcode 0x256 = { auctioneerGuid, sellItemGuid, bid, buyout,
// runTime }). Reused verbatim by `AuctionHouse::PostItem` per stack.
FUN_SCRIPT_START_AUCTION = 0x004CE770,
// Valid `runTime` values `Script_StartAuction` accepts, in minutes:
// {120, 480, 1440} = 2h / 8h / 24h (vanilla's three durations). The
// modern `duration` arg (1/2/3) indexes this table.
VAR_AUCTION_DURATION_TABLE = 0x00807028,
AUCTION_DURATION_TABLE_COUNT = 3,
// `__fastcall(ECX = typeCode, EDX = unused, [stack] = guidLo,
// [stack] = guidHi, [stack] = anyInt) → CGObject *`.
// Returns NULL when no object matches or the type doesn't match.
// The third stack arg (originally a `__FILE__/__LINE__` debug
// hint) is read by debug paths only — anything works at runtime.
FUN_GET_OBJECT_BY_GUID = 0x00468460,
OBJECT_TYPE_ITEM = 2,
// Inbox — array of mail-entry pointers behind a slot indirection.
// The address itself holds a heap pointer (`MOV ECX, [imm32]` in
// the engine), so reading the array requires one extra deref
// beyond plain `(uint8_t **)`. itemID inline on each entry at
// `+0x120`. (The engine's `Script_GetInboxItem` passes a per-
// entry completion callback at `0x004AF0A0` to GetRecord; for
// ID-only retrieval we skip the callback.)
//
// Entries also carry per-instance modifiers at `+0x12C`
// (enchantID), `+0x134` (suffix factor), `+0x138` (random
// property ID), etc. — `Script_GameTooltip_SetInboxItem` at
// `0x005354C0` copies them onto the tooltip object to render a
// fully-decorated tooltip. We don't expose them in
// `GetInboxItemLink` because 3.3.5's same function only emits
// basic itemID-only links (`FUN_0061E290(itemID)`); per-instance
// data only fully manifests when the player takes the item and
// the engine spawns a real CGItem.
VAR_INBOX_ENTRIES = 0x00B6EF54,
VAR_INBOX_COUNT = 0x00B6EFC0,
OFF_INBOX_ENTRY_ITEM_ID = 0x120,
// SendMail attached item — the engine stores the attached item's
// 64-bit GUID at these globals when the player drops an item onto
// the SendMail slot (`SetSendMailItem` / `ClickSendMailItemButton`).
// Cleared to zero by `ClearSendMail` and on `MAIL_CLOSED`. Vanilla
// allows exactly one attachment per outgoing mail (modern WoW lifted
// this to 12+; we ignore the modern `attachmentIndex` arg since only
// index 1 is meaningful).
//
// The attached item still exists as a live CGItem in the player's
// inventory until the mail is actually sent, so the GUID resolves
// via `FUN_GET_OBJECT_BY_GUID(OBJECT_TYPE_ITEM, ...)`. That lets
// `GetSendMailItemLink` return the full per-instance link (enchant
// / random suffix preserved) by feeding the resolved CGItem to
// `Item::Link::FromCGItem`.
VAR_SEND_MAIL_ITEM_GUID_LO = 0x00B6EF90,
VAR_SEND_MAIL_ITEM_GUID_HI = 0x00B6EF94,
// Craft window (engineering, alchemy, etc. before the "trade
// skill" overhaul). Same slot-indirection shape as inbox: the
// address holds a pointer to the heap-allocated entry-pointer
// array, NOT the array itself. Each entry's `+0x00` is a
// spellID (the recipe spell); the recipe's reagent list lives
// on the spell record at `+0xA8`.
VAR_CRAFT_ENTRIES = 0x00BDCF78,
VAR_CRAFT_COUNT = 0x00BDCFC0,
OFF_CRAFT_ENTRY_SPELL_ID = 0x00,
// Trade skill window — different storage from craft, same shape
// (slot-indirected entry-ptr array with a spellID inside). The
// recipe's created item lives on the spell record at `+0x19C`
// (the "produced item" field), and reagents at `+0xA8` (shared
// with craft).
VAR_TRADESKILL_ENTRIES = 0x00BDDFC0,
VAR_TRADESKILL_COUNT = 0x00BDE04C,
// SkillLine.dbc row ID of the currently-open trade skill window
// (the profession the player has open). Bounds-checked against
// `VAR_SKILL_LINE_COUNT` and used as `records[id]` by
// `Script_GetTradeSkillLine` (`0x004FDD40`). <= 0 / stale when no
// window is open. `FUN_004FC870` zeroes it on close (and fires
// event `0x13B`), so `> 0` reliably means "trade window open".
VAR_CURRENT_TRADESKILL_LINE = 0x00BDE040,
// Craft window (Enchanting, pet training) open-state flag — nonzero
// (3 for the enchanting-style craft) while open; `FUN_004F5FE0`
// zeroes it on close (fires event `0x169`). The Craft window has no
// skill-line-ID global — `TradeSkill::Link` derives the skill line
// from the first craft recipe — so this is the "craft open" gate.
VAR_CRAFT_WINDOW_STATE = 0x00BDCFB8,
// Spell.dbc "produced item" field for crafting recipes — the
// itemID this spell creates when cast. Reagent itemIDs and
// counts live at `OFF_SPELL_REAGENT_ID` / `OFF_SPELL_REAGENT_COUNT`
// above (shared with all spells that consume reagents, not just
// recipes).
OFF_SPELL_RECORD_CREATED_ITEM = 0x19C,
SPELL_RECIPE_MAX_REAGENTS = 8,
// Spell.dbc effect arrays — three effects per spell. Derived
// from `Script_CastShapeshiftForm` (`0x004B4810`): the form-toggle
// check reads `spellRec[+0x16C + i*4]` for the per-effect aura
// type, and `spellRec[+0x1A8 + i*4]` for that effect's misc
// value. Cross-checked against 3.3.5's `FUN_00726CE0`
// (`Script_CancelShapeshiftForm`'s inner), which does the same
// pair of reads against `0x24` (= `SPELL_AURA_MOD_SHAPESHIFT`)
// and a form-id compare.
//
// `EffectApplyAuraName[i]` is the SPELL_AURA_* code (0 = none /
// not an aura effect); `EffectMiscValue[i]` is effect-specific
// (form ID for shapeshift, channel index for periodic, etc.).
OFF_SPELL_RECORD_EFFECT_APPLY_AURA_NAME = 0x16C, // int32[3]
OFF_SPELL_RECORD_EFFECT_MISC_VALUE = 0x1A8, // int32[3]
SPELL_RECORD_EFFECT_COUNT = 3,
// SPELL_EFFECT_* id array (`Effect[3]`) — five arrays before
// EffectBasePoints (`+0x130`), so `0x130 - 5*0xC`. Used to tell craft
// recipes from profession abilities (Disenchant etc.) that also carry
// skill-up thresholds. Recipe-producing effects: CREATE_ITEM (items),
// ENCHANT_ITEM / _TEMPORARY (enchants), and LEARN_SPELL (Turtle's custom
// recipes, e.g. "Steel Plate Boots" = effect 36).
OFF_SPELL_RECORD_EFFECT = 0xF4, // int32[3]
SPELL_EFFECT_CREATE_ITEM = 24,
SPELL_EFFECT_LEARN_SPELL = 36,
SPELL_EFFECT_ENCHANT_ITEM = 53,
SPELL_EFFECT_ENCHANT_ITEM_TEMPORARY = 54,
// EffectBasePoints[3] — the base magnitude of each effect, stored as
// (value - 1) for the fixed-die spells that back item stats (the
// engine adds a 1..dieSides roll; dieSides == 1 makes it value = base
// + 1). Verified empirically: the "Increased Intellect 01/02/03"
// random-property spells (7468/7469/7470) hold base 0/1/2 for the
// +1/+2/+3 tiers. Read by Item::Stats when resolving random-suffix
// stat auras. Parallel [3] array to APPLY_AURA_NAME / MISC_VALUE.
OFF_SPELL_RECORD_EFFECT_BASE_POINTS = 0x130, // int32[3]
// EffectBaseDice[3] — added to EffectBasePoints for the effect's fixed
// magnitude (mangos `CalculateSimpleValue = BasePoints + BaseDice`).
// For every item-stat aura BaseDice == 1, so value = BasePoints + 1;
// reading it directly matches the engine exactly. Verified at field 67
// (Effect@61, DieSides@64, BaseDice@67, BasePoints@76) against 7468.
OFF_SPELL_RECORD_EFFECT_BASE_DICE = 0x10C, // int32[3]
// Per-effect EffectRadiusIndex[3] → SpellRadius.dbc. Verified by
// FUN_006e6350, which reads spellRec[+0x160] (effect 0) and
// spellRec[+0x164] (effect 1) as radius indices. 0 = effect has no
// radius. Read by GetSpellRadius.
OFF_SPELL_RECORD_EFFECT_RADIUS_INDEX = 0x160, // int32[3]
// SpellFamily classification, used by the SpellMod system (see
// VAR_SPELLMOD_*). Verified from FUN_006e6b30: SpellFamilyName at
// +0x280 (gates whether the player's class mods apply), 64-bit
// SpellFamilyFlags at +0x284 (selects which familyFlagBit rows to
// sum). AttributesEx2 (+0x24) bit 0x20000000 disables spell mods.
OFF_SPELL_RECORD_FAMILY_NAME = 0x280, // u32
OFF_SPELL_RECORD_FAMILY_FLAGS = 0x284, // u64
OFF_SPELL_RECORD_ATTRIBUTES = 0x18, // u32 (base Attributes)
SPELL_ATTR_PASSIVE = 0x40, // bit 6 — always-on aura
OFF_SPELL_RECORD_ATTRIBUTES_EX2 = 0x24, // u32
SPELL_ATTR_EX2_NO_SPELL_MODS = 0x20000000,
// Spell.dbc Mechanic field — the spell-level SpellMechanic ID (→
// SpellMechanic.dbc), 0 = none. Field 5 of the record
// (ID, School, Category, castUI, Dispel, Mechanic), which lands at
// +0x14 given Attributes (field 6) is verified at +0x18. Cross-
// confirmed by FUN_006e9ca0 (the mechanic-immunity check), which
// reads `spellRec[+0x14]` as the spell's mechanic when the per-
// effect EffectMiscValue is 0. Read by C_Spell.GetSpellMechanicByID.
OFF_SPELL_RECORD_MECHANIC = 0x14,
SPELL_AURA_MOD_STEALTH = 16,
SPELL_AURA_MOD_SHAPESHIFT = 36,
SPELL_AURA_MOUNTED = 78,
// Control-loss aura effect types (EffectApplyAuraName values), used by
// C_LossOfControl to classify a debuff. Values are authoritative from the
// Turtle server's indexed SPELL_AURA proc-handler table (SharedDefines).
SPELL_AURA_MOD_POSSESS = 2,
SPELL_AURA_MOD_CONFUSE = 5,
SPELL_AURA_MOD_CHARM = 6,
SPELL_AURA_MOD_FEAR = 7,
SPELL_AURA_MOD_STUN = 12,
SPELL_AURA_MOD_PACIFY = 25,
SPELL_AURA_MOD_ROOT = 26,
SPELL_AURA_MOD_SILENCE = 27,
SPELL_AURA_MOD_PACIFY_SILENCE = 60,
SPELL_AURA_MOD_DISARM = 67,
// SMSG_SPELL_COOLDOWN (0x134) handler, registered by the spell-opcode
// boot registrar FUN_006e7150 exactly like the failure/channel handlers
// Spell::Cast co-hooks — same `int __stdcall(uint32_t *opCode,
// CDataStore *packet)` shape. Body: GUID(u64) then (spellID, durationMs)
// u32 pairs. A player-GUID packet carrying >=2 spells that all share one
// duration is a school-interrupt lockout (Player::ProhibitSpellSchool is
// the only sender of that shape); see src/lossofcontrol/Info.cpp.
FUN_SPELL_COOLDOWN_HANDLER = 0x006E9460,
// Gossip menu data. Populated by the SMSG_GOSSIP_MESSAGE packet
// handler at 0x004E26E0 and reset by FUN_004E26A0 each time a new
// gossip window opens. Two parallel storage arrays:
// Options: 16 slots, stride 0x80C, sentinel = signed `index` == -1.
// Quests: 32 slots, stride 0x20C, sentinel = u32 `questID` == 0.
// Available vs. active is partitioned by the +0x008
// `status` field — values 3 or 4 mark an active-quest
// row, anything else is a deliverable.
VAR_GOSSIP_OPTIONS = 0x00BBBE90,
GOSSIP_OPTIONS_STRIDE = 0x80C,
GOSSIP_OPTIONS_MAX = 16,
OFF_GOSSIP_OPTION_TEXT = 0x000, // char[0x800] inline
OFF_GOSSIP_OPTION_INDEX = 0x800, // int32; -1 = unused slot
OFF_GOSSIP_OPTION_BOX_CODED = 0x804, // u8 (1 = needs password)
OFF_GOSSIP_OPTION_ICON = 0x808, // u8 icon type (0..10)
VAR_GOSSIP_QUESTS = 0x00BB74C0,
GOSSIP_QUESTS_STRIDE = 0x20C,
GOSSIP_QUESTS_MAX = 32,
OFF_GOSSIP_QUEST_ID = 0x000, // u32 questID; 0 = unused slot
OFF_GOSSIP_QUEST_LEVEL = 0x004, // i32 questLevel
OFF_GOSSIP_QUEST_STATUS = 0x008, // u32 status; 3|4 = active
OFF_GOSSIP_QUEST_TITLE = 0x00C, // char[0x200] inline
// Inline greeting buffer pushed by Script_GetGossipText. Populated
// by the engine after the NPC_TEXT.dbc query for the gossip giver
// resolves the textID embedded in SMSG_GOSSIP_MESSAGE.
VAR_GOSSIP_GREETING_TEXT = 0x00BBB678,
// Engine Lua C functions for the selector half of the gossip
// surface. The `FUN_GOSSIP_SELECT_*` helpers are the engine's
// internal selectors that the `Script_SelectGossip*` Lua wrappers
// call after parsing their args. We call them directly with the
// 0-based slot/index to skip the Lua-stack-stomp round-trip.
//
// FUN_GOSSIP_SELECT_OPTION — __fastcall(uint slot0Based,
// const char *password)
// Sends CMSG_GOSSIP_SELECT_OPTION with `OPTIONS[slot].index`.
// Handles the boxCoded/password-required gate internally —
// pass nullptr if no password.
// FUN_GOSSIP_SELECT_{AVAILABLE,ACTIVE}_QUEST — __fastcall(int idx)
// Walks `GOSSIP_QUESTS`, skipping rows of the wrong status,
// matches by 0-based position into the filtered list, sends
// CMSG with the matching questID.
FUN_GOSSIP_SELECT_OPTION = 0x004E2320,
FUN_GOSSIP_SELECT_AVAILABLE_QUEST = 0x004E24B0,
FUN_GOSSIP_SELECT_ACTIVE_QUEST = 0x004E2600,
FUN_SCRIPT_CLOSE_GOSSIP = 0x004E2B20,
// Current gossip NPC GUID (u64). Set by the SMSG_GOSSIP_MESSAGE
// handler, cleared by the gossip-close worker at 0x004E1FA0 (which
// then fires GOSSIP_CLOSED, event 0x12B). Non-zero = a gossip
// session is live — the gate that keeps `C_GossipInfo` from serving
// the previous NPC's stale arrays/text after close.
VAR_GOSSIP_NPC_GUID = 0x00BC3F58,
// --- Quest-greeting state (SMSG_QUESTGIVER_QUEST_LIST) -------------
// Vanilla's SECOND questgiver path: NPCs without a gossip menu send
// SMSG_QUESTGIVER_QUEST_LIST, whose handler (FUN_005dbb10) fills a
// storage entirely separate from the gossip arrays and fires
// QUEST_GREETING (event 300 = 0x12C) — the QuestFrameGreetingPanel
// ("Current Quests" / "Available Quests"). Vanilla Lua reads it via
// GetGreetingText / Get{Available,Active}Title / etc.; C_GossipInfo
// merges it in so modern-addon ports work on greeting NPCs too.
//
// Shared quest-session state, written by the panel-begin helper
// FUN_00500bd0(panelType, textID, guidLo, guidHi, ...):
// VAR_QUESTGIVER_GUID — u64, the current questgiver. Cleared by
// the session-close worker FUN_00501130 (fires QUEST_FINISHED,
// event 0x130). Non-zero = quest session live.
// VAR_QUEST_PANEL_TYPE — i32 panel: 0 greeting, 1 detail,
// 2 progress, 3 reward. begin(0) also zeroes both greeting
// arrays + counts + the text buffers.
VAR_QUESTGIVER_GUID = 0x00BE0810,
VAR_QUEST_PANEL_TYPE = 0x00BE0818,
// GUID the greeting arrays were filled for — written ONLY by the
// SMSG_QUESTGIVER_QUEST_LIST handler. The greeting arrays are valid
// iff this equals VAR_QUESTGIVER_GUID (and that is non-zero);
// otherwise they're leftovers from an older NPC (e.g. the current
// quest session came from a gossip-menu quest click, which begins
// at panel 1 without ever clearing the greeting arrays).
VAR_GREETING_NPC_GUID = 0x00C4D740,
// Greeting text (0x200 inline, $N/$C-expanded) — what vanilla's
// Script_GetGreetingText pushes.
VAR_QUEST_GREETING_TEXT = 0x00BDE068,
// The two greeting quest arrays: 32 entries, stride 0x4C =
// { u32 questID @ +0, i32 level @ +4, char title[0x40] @ +8,
// u32 extra @ +0x48 (available: status==0 flag; active: always
// 0 — the appender FUN_00500e90 never stores the status, see
// the scratch arrays below for isComplete) }.
// Appenders: FUN_00500e40 (available), FUN_00500e90 (active).
// Readers: Script_Get{Available,Active}{Title,Level} @ 0x00501AC0/
// 0x00501B30/0x00501BA0/0x00501C20.
VAR_GREETING_AVAILABLE_ENTRIES = 0x00BDFE60,
VAR_GREETING_ACTIVE_ENTRIES = 0x00BDE690,
GREETING_QUESTS_STRIDE = 0x4C,
GREETING_QUESTS_MAX = 32,
OFF_GREETING_QUEST_ID = 0x000,
OFF_GREETING_QUEST_LEVEL = 0x004,
OFF_GREETING_QUEST_TITLE = 0x008,
VAR_GREETING_AVAILABLE_COUNT = 0x00BE0834,
VAR_GREETING_ACTIVE_COUNT = 0x00BE0838,
// Scratch arrays the SMSG_QUESTGIVER_QUEST_LIST handler fills in
// packet order (32 × u32 each, zeroed per packet): questIDs and the
// per-quest dialog status. Status 3|4 = active (same sentinel as
// the gossip quest rows), 4 = complete/turn-in-ready. The canonical
// greeting arrays drop the status, so `isComplete` for an active
// greeting quest is recovered by questID lookup here.
VAR_GREETING_SCRATCH_IDS = 0x00C4D2B0,
VAR_GREETING_SCRATCH_STATUS = 0x00C4D340,
// Engine greeting-quest selectors — the workers vanilla's
// Script_Select{Available,Active}Quest call: `__fastcall(int
// idx0Based)`, index straight into the corresponding greeting
// array. They validate VAR_QUESTGIVER_GUID internally and send
// CMSG_QUESTGIVER_{QUERY_QUEST,COMPLETE_QUEST}.
FUN_GREETING_SELECT_AVAILABLE_QUEST = 0x005012A0,
FUN_GREETING_SELECT_ACTIVE_QUEST = 0x00501320,
// CDataStore primitive readers — `__thiscall void(this, void *out)`.
// Read at the current cursor (`+0x14`) and advance it by the value
// size. We call these directly from `Unit::MirrorTimer` to peek
// packet contents before the SMSG handler consumes them, then
// restore the cursor so the original handler reads the same bytes.
FUN_DATASTORE_READ_U32 = 0x00418E30,
FUN_DATASTORE_READ_U8 = 0x00418CB0,
OFF_DATASTORE_CURSOR = 0x14,
// Engine millisecond tick (returns `ulonglong` but truncating to
// `uint32_t` is fine for the time deltas we need — the high
// 32 bits only matter after 49 days of uptime). Same source the
// Lua `GetTime()` function reads, just in milliseconds rather
// than the seconds Lua sees. Returns either `GetTickCount()` or
// a higher-resolution timer depending on the engine's clock-
// selection flag at `0x00884C80`.
FUN_ENGINE_TICK_MS = 0x0042B750,
// Mirror timer (BREATH / FATIGUE-style) SMSG handler. Dispatches
// opcodes `0x1D9` (START), `0x1DA` (PAUSE), `0x1DB` (STOP) — but
// the vanilla engine doesn't cache any timer state, just reads
// the packet and immediately fires the corresponding
// MIRROR_TIMER_* Lua event. Our hook (`Unit::MirrorTimer`) peeks
// the packet via cursor save/restore on the CDataStore and
// builds a side cache that `GetMirrorTimerInfo` /
// `GetMirrorTimerProgress` can read back.
//
// __fastcall void(?, int opcode, ?, void *dataStore)
//
// The helper at `FUN_MIRROR_TIMER_TYPE_NAME` returns the
// engine's static type-name string for IDs 0..2 (`"EXHAUSTION"`,
// `"BREATH"`, `"FEIGNDEATH"`); `FUN_MIRROR_TIMER_LABEL` builds
// the localized display label by looking up `{TYPE}_LABEL` in
// the engine's localized strings, or substituting the spell
// name when the type is FEIGNDEATH and a spellID is non-zero.
FUN_SMSG_MIRROR_TIMER_HANDLER = 0x005E7990,
FUN_MIRROR_TIMER_TYPE_NAME = 0x005E7AE0,
FUN_MIRROR_TIMER_LABEL = 0x005E7B10,
SMSG_OPCODE_MIRROR_TIMER_START = 0x1D9,
SMSG_OPCODE_MIRROR_TIMER_PAUSE = 0x1DA,
SMSG_OPCODE_MIRROR_TIMER_STOP = 0x1DB,
MIRROR_TIMER_SLOT_COUNT = 3,
// `realmList` CVar reader — returns the configured realmlist
// address (e.g. "logon.turtle-wow.org") as a `const char *`, or
// NULL when unset. `__fastcall(int forceRefresh)`; pass 0 to read
// the cached value (callers in the engine pass non-zero only
// around CMSG_AUTH_SESSION reconnects). Lazily registers the CVar
// on first call.
//
// This is the realmlist *address*, not the display name (the
// friendly server name visible in the realm-select dialog lives
// in the `realmName` CVar at `FUN_005AB7D0`, read by
// `Script_GetServerName`). Credentials are scoped on this value
// because two different private servers may share the same
// friendly name but never the same realmlist address.
FUN_CVAR_REALM_LIST = 0x005AB680,
// Engine login entry — the C function `Script_DefaultServerLogin`
// (the glue Lua binding at `0x0046D160`) tail-calls into here with
// the account/password as raw C strings. We invoke it directly from
// C++ when dispatching a saved-credential login, bypassing the
// round-trip through Lua so the plaintext never crosses the
// Lua boundary on the way out.
//
// __fastcall void(ecx = const char *account, edx = char *password)
//
// The function:
// 1. Gates on three globals — VAR_GLUE_LOGIN_READY1,
// VAR_GLUE_LOGIN_READY2 (both must be nonzero) and
// VAR_GLUE_LOGIN_INPROGRESS (must be zero). All set up by the
// normal glue boot flow; a call made while the AccountLogin
// screen is showing is safe, an off-screen call silently no-ops.
// 2. Copies the account into a 0x40-byte buffer at `0x00B41DB0`
// and uppercases it in place.
// 3. Fires the "connecting" status event.
// 4. Hands the (uppercased account, password) pair to the SRP
// initiator at `FUN_005AB4B0`.
// 5. **Zeros the caller's password buffer in place** via an
// unrolled `REP STOSD` loop counting strlen bytes — so the
// decrypted-on-stack buffer we feed in gets scrubbed for free
// after the SRP step consumes it.
// 6. Calls into the AddOn-registry init (`FUN_0051C740`) with the
// uppercased account name. Same call documented in CLAUDE.md
// under "AddOn registry & hot-reload".
FUN_GLUE_LOGIN_ATTEMPT = 0x0046AFB0,
// Glue-state readiness flags read by `FUN_GLUE_LOGIN_ATTEMPT`'s
// prologue. Names reflect the gate-condition logic, not anything
// intrinsic to the engine — the engine just checks `R1 && R2 && !IP`.
VAR_GLUE_LOGIN_READY1 = 0x00B41DFC,
VAR_GLUE_LOGIN_READY2 = 0x00B41E04,
VAR_GLUE_LOGIN_INPROGRESS = 0x00B41DA0,
// The same `VAR_GLUE_LOGIN_INPROGRESS` global doubles as a glue
// state-code: `FUN_GLUE_ENTER_WORLD` sets it to `8` ("entering world")
// on a successful commit, which `Unit::Identity`'s enter-world co-hook
// gates on (the rename / char-locked bail paths return before it).
GLUE_STATE_ENTERING_WORLD = 8,
// `FUN_0046B500` — the enter-world worker behind `Script_EnterWorld` (the
// glue "Enter World" button: `Script_EnterWorld` is just `call this; ret`).
// Computes the selected character's struct into VAR_GLUE_SELECTED_CHAR and,
// on success, sets VAR_GLUE_LOGIN_INPROGRESS = 8. `Unit::Identity` co-hooks
// it to capture the selected character's GUID *before* the engine creates
// the in-world player object — so `UnitGUID("player")` / `PlayerGuid()`
// answer from addon-load time instead of returning nil/0 until the
// SMSG_UPDATE_OBJECT that populates the player object (≈PLAYER_LOGIN).
FUN_GLUE_ENTER_WORLD = 0x0046B500,
// Selected-character struct pointer (glue): char-array base +
// selectedIndex*0x120, written by FUN_GLUE_ENTER_WORLD. The character's
// 64-bit login GUID is at offset 0x00 (name at +0x08, race +0x100, class
// +0x101, level +0x108 — verified against `Script_GetCharacterInfo` at
// `0x004732A0`). Entries are filled from SMSG_CHAR_ENUM.
VAR_GLUE_SELECTED_CHAR = 0x00B41DF4,
OFF_GLUE_CHAR_GUID = 0x00,
// Cursor state — single global type-tag at VAR_CURSOR_TYPE
// dispatches reads through one of several payload slots depending
// on what's picked up. The engine's `CursorHasItem` /
// `CursorHasSpell` / `GetCursorMoney` and the various `Pickup*`
// functions all read/write through these. Discovered by tracing
// `Script_CursorHasItem` (`0x004895D0`) and the writers in
// `FUN_00494B60` (item), `FUN_00494CC0` (money), `FUN_00494D20`
// (spell), `FUN_00494E20` (pet action), `FUN_00494F80` (macro),
// `FUN_004950F0` (action/inv/etc.), `FUN_00495010` (merchant).
//
// Type values:
// 0 empty (nothing on cursor)
// 1 bag item — GUID at `VAR_CURSOR_ITEM_GUID_LO/_HI`,
// itemID resolved by feeding the GUID to
// `FUN_OBJECT_FROM_GUID` (filter 0x2).
// 2 money — copper at `VAR_CURSOR_MONEY_COPPER`
// 3 player spell — spellID at `VAR_CURSOR_SPELL_ID`
// 4 pet action — packed at `VAR_CURSOR_PETACTION_PACKED`
// 5 merchant item — itemID at `VAR_CURSOR_GENERIC_SLOT`,
// 0-based merchant slot at `VAR_CURSOR_GENERIC_SOURCE`.
// Written by `Script_PickupMerchantItem` (`0x004FB760`) →
// `FUN_004950F0(itemID, ?, slot0, 5)`.
// 6/7 other drag-source items — itemID at
// `VAR_CURSOR_GENERIC_SLOT`. Type 7 is action-bar pickup
// (`FUN_004E6130`); type 6 is another drag path (mail/etc.).
// 8 macro — 1-based index at `VAR_CURSOR_MACRO_INDEX`
// 9 inventory item (equipped slot) — itemID stored at
// `VAR_CURSOR_GENERIC_SLOT`. Bare itemID rather than a GUID
// because the item is out of the descriptor stream while
// on the cursor.
// 10 stable pet — 1-based index at `VAR_CURSOR_STABLEPET_INDEX`.
// Written by `Script_ClickStablePet` (`FUN_004CB420`) →
// `FUN_00495010(slot)`.
//
// `CursorHasItem` returns true for types 1 *and* 9 only.
VAR_CURSOR_TYPE = 0x00B4D900,
VAR_CURSOR_ITEM_GUID_LO = 0x00B4E248,
VAR_CURSOR_ITEM_GUID_HI = 0x00B4E24C,
VAR_CURSOR_MONEY_COPPER = 0x00B4E2F0,
VAR_CURSOR_SPELL_ID = 0x00B4E2F4,
VAR_CURSOR_PETACTION_PACKED = 0x00B4E2F8,
VAR_CURSOR_MACRO_INDEX = 0x00B4E2FC,
VAR_CURSOR_STABLEPET_INDEX = 0x00B4E300,
VAR_CURSOR_GENERIC_SLOT = 0x00B4B41C,
VAR_CURSOR_GENERIC_DISPLAY = 0x00B4D8EC,
VAR_CURSOR_GENERIC_SOURCE = 0x00B4B420,
// GUID → CGObject resolver. `__fastcall(type_filter, guid_lo,
// guid_hi) → CGObject *` at `0x00468460`. Type filter 0x2 = item,
// matching what `FUN_00494B60` and the trade-attached paths pass
// when re-resolving the cursor GUID to a `CGItem *`.
FUN_OBJECT_FROM_GUID = 0x00468460,
// Virtual XML-template registry (a Storm hash table) — the store that
// backs `inherits=` and `C_XMLUtil.GetTemplates`. The XML parser
// (`FUN_006ede10`) registers every `virtual="true"` frame into it via
// `FUN_006ee500`; the inherits resolver reads it via `FUN_006ee6f0`.
// Both operate on these globals, so it's the authoritative template list.
// See src/xml/Templates.cpp.
//
// VAR_XML_TEMPLATE_TABLE holds a POINTER to the bucket array (0 / the
// array unallocated) and VAR_XML_TEMPLATE_MASK the bucket-count mask;
// mask == 0xFFFFFFFF means no template has ever registered (walk = empty).
VAR_XML_TEMPLATE_TABLE = 0x00CEEA1C,
VAR_XML_TEMPLATE_MASK = 0x00CEEA24,
// Bucket struct (0xC bytes): { linkOffset@+0x0, ?@+0x4, chainHead@+0x8 }.
// A node's next pointer is at `*(node + linkOffset + 4)`; the tail
// sentinel has its low bit set (chain ends on `(ptr & 1) != 0`).
XML_TEMPLATE_BUCKET_STRIDE = 0xC,
OFF_XML_TEMPLATE_BUCKET_LINKOFF = 0x0,
OFF_XML_TEMPLATE_BUCKET_HEAD = 0x8,
// Registry node payload: template name string @+0x14, parsed definition
// XML node @+0x18 (hash @+0x0, virtual flag @+0x1C — unused here).
OFF_XML_TEMPLATE_NODE_NAME = 0x14,
OFF_XML_TEMPLATE_NODE_DEF = 0x18,
// Parsed XML element node: its tag-name string ("Frame" / "Button" /
// "CheckButton" / …) lives at +0x8 — this is the frame "type".
OFF_XML_NODE_TAG = 0x8,
// The definition node retains its full parsed DOM subtree — used by
// GetTemplateInfo to read `<Size>` / `inherits=`. First child @+0x4, next
// sibling @+0x1C. Attributes are read by name via the node method
// FUN_006f2cf0 (`__thiscall(node, name) -> value string`, null if absent).
OFF_XML_NODE_CHILD = 0x4,
OFF_XML_NODE_SIBLING = 0x1C,
FUN_XML_NODE_GET_ATTRIBUTE = 0x006F2CF0,
// By-name template lookup — the same one `inherits=` resolves through.
// `__fastcall(const char *name) -> definition node`, 0 if unregistered
// (case-insensitive, hashed). See FUN_006ee6f0 in Templates.cpp notes.
FUN_XML_TEMPLATE_LOOKUP = 0x006EE6F0,
};