Add C_Item.GetEnchantInfo(enchantID)

Resolves an item-enchantment ID (the enchantID from C_Item.GetWeaponEnchantInfo, and item permanent-enchant IDs) into its SpellItemEnchantment.dbc record: { enchantID, name, effects = {{type,amount,arg},...}, spellID } - name: localized display name ("Crusader", "Brilliant Mana Oil"). - effects: each active slot's ITEM_ENCHANTMENT_TYPE / amount / arg. - spellID: convenience for spell-type enchants (1/3/7) — the proc/ equip/use spellID, e.g. Crusader -> 20007 "Holy Strength", to chain into C_Spell.GetSpellDescription. Record layout verified by parsing the on-disk DBC against known records (Crusader 1900: type 1, arg 20007; Sharpened+3 id 13: type 2, amount 3; Reinforced Armor+8 id 15: type 4, amount 8): Type[3]@+0x04, Amount[3]@+0x10, EffectArg[3]@+0x28, Name[8]@+0x34. The engine's by-ID readers only touch name/flags/condition, so the effect columns couldn't be pinned from disassembly — the extracted dbc/ dump was the oracle. Verified in-game across all three example enchants. Placed in C_Item (not C_Spell): the id originates from C_Item.GetWeaponEnchantInfo and the concept is an item enchantment. Source-item is not derivable (no back-reference, no client reverse index).
Drop the redundant registration latch
2026-11-11 12:27:35 +00:00 · 2026-06-23 02:00:52 -05:00 · 2026-06-22 22:52:16 -05:00 · 2026-06-22 22:45:17 -05:00 · 2026-06-22 22:38:05 -05:00 · 2026-06-22 21:51:42 -05:00
20 changed files with 1385 additions and 179 deletions
@@ -3,6 +3,7 @@
 ## Notes: Library to emulate aspects of the modern WoW API on 1.12.1 / Lua 5.0.
 ## Version: DEV
 ## Author: Brues
+## X-Website: https://github.com/brues-code/ClassicAPI

 locales\locales.xml

@@ -14,6 +15,7 @@ Util\Constants.lua
 Util\String.lua
 Util\TableUtil.lua
 Util\MathUtil.lua
+Util\PixelUtil.lua
 Util\FrameUtil.lua
 Util\FormattingUtil.lua
 Util\TimeUtil.lua
@@ -0,0 +1,86 @@
+-- Backport of FrameXML/PixelUtil.lua to vanilla 1.12 / Lua 5.0.
+--
+-- PixelUtil snaps frame sizes/points to whole physical pixels so
+-- borders and textures stay crisp at fractional UI scales. The table
+-- ports verbatim — its only math deps (Round, Lerp,
+-- ClampedPercentageBetween) all live in MathUtil, which loads first.
+--
+-- The one piece vanilla lacks is the native `GetPhysicalScreenSize()`
+-- (added in 7.0). The ClassicAPI DLL provides it (see
+-- src/screen/Info.cpp) by reading the engine's `gxResolution` CVar, so
+-- it's a real global registered at engine boot — no Lua polyfill
+-- needed here.
+
+PixelUtil = {};
+
+function PixelUtil.GetPixelToUIUnitFactor()
+    local physicalWidth, physicalHeight = GetPhysicalScreenSize();
+    return 768.0 / physicalHeight;
+end
+
+function PixelUtil.GetNearestPixelSize(uiUnitSize, layoutScale, minPixels)
+    if uiUnitSize == 0 and (not minPixels or minPixels == 0) then
+        return 0;
+    end
+
+    local uiUnitFactor = PixelUtil.GetPixelToUIUnitFactor();
+    local numPixels = Round((uiUnitSize * layoutScale) / uiUnitFactor);
+    if minPixels then
+        if uiUnitSize < 0.0 then
+            if numPixels > -minPixels then
+                numPixels = -minPixels;
+            end
+        else
+            if numPixels < minPixels then
+                numPixels = minPixels;
+            end
+        end
+    end
+
+    return numPixels * uiUnitFactor / layoutScale;
+end
+
+function PixelUtil.ConvertPixelsToUI(desiredPixels, layoutScale)
+    return PixelUtil.GetNearestPixelSize(desiredPixels, layoutScale);
+end
+
+function PixelUtil.ConvertPixelsToUIForRegion(desiredPixels, region)
+    return PixelUtil.GetNearestPixelSize(desiredPixels, region:GetEffectiveScale());
+end
+
+function PixelUtil.SetWidth(region, width, minPixels)
+    region:SetWidth(PixelUtil.GetNearestPixelSize(width, region:GetEffectiveScale(), minPixels));
+end
+
+function PixelUtil.SetHeight(region, height, minPixels)
+    region:SetHeight(PixelUtil.GetNearestPixelSize(height, region:GetEffectiveScale(), minPixels));
+end
+
+function PixelUtil.SetSize(region, width, height, minWidthPixels, minHeightPixels)
+    PixelUtil.SetWidth(region, width, minWidthPixels);
+    PixelUtil.SetHeight(region, height, minHeightPixels);
+end
+
+function PixelUtil.SetPoint(region, point, relativeTo, relativePoint, offsetX, offsetY, minOffsetXPixels, minOffsetYPixels)
+    region:SetPoint(point, relativeTo, relativePoint,
+        PixelUtil.GetNearestPixelSize(offsetX, region:GetEffectiveScale(), minOffsetXPixels),
+        PixelUtil.GetNearestPixelSize(offsetY, region:GetEffectiveScale(), minOffsetYPixels)
+    );
+end
+
+function PixelUtil.SetStatusBarValue(statusBar, value)
+    local width = statusBar:GetWidth();
+    if width and width > 0.0 then
+        local min, max = statusBar:GetMinMaxValues();
+        local percent = ClampedPercentageBetween(value, min, max);
+        if percent == 0.0 or percent == 1.0 then
+            statusBar:SetValue(value);
+        else
+            local numPixels = PixelUtil.GetNearestPixelSize(statusBar:GetWidth() * percent, statusBar:GetEffectiveScale());
+            local roundedValue = Lerp(min, max, numPixels / width);
+            statusBar:SetValue(roundedValue);
+        end
+    else
+        statusBar:SetValue(value);
+    end
+end
@@ -32,8 +32,12 @@ function PlayerUtil.GetCurrentSpeed()
    return GetUnitSpeed("player") / 7 * 100
 end

+local playerGuid
 function GetPlayerGuid()
-	return UnitGUID("player");
+	if not playerGuid then
+		playerGuid = UnitGUID("player")
+	end
+	return playerGuid
 end

 function IsPlayerGuid(guid)
@@ -43,4 +47,4 @@ end
 function GetNameAndServerNameFromGUID(unitGUID)
 	local _, _, _, _, _, name = GetPlayerInfoByGUID(unitGUID);
 	return name, GetRealmName()
-end
+end
@@ -1,16 +1,3 @@
-- Backport of FrameXML/TimeUtil.lua (feasible subset) to vanilla 1.12 /
-- Lua 5.0.
--
-- Ports the deprecated-but-widely-used duration formatters (SecondsToTime,
-- SecondsToClock, SecondsToTimeAbbrev) plus the unit constants/helpers. The
-- SecondsFormatterMixin (the modern replacement) is omitted — it's a heavy
-- mixin class little addon code targets on classic.
--
-- 5.0 notes: `%` -> math.mod, `s:format()` -> string.format. The FrameXML
-- format-string globals these functions consume (DAYS_ABBR, D_HOURS,
-- HOURS_MINUTES_SECONDS, the *_ONELETTER_ABBR set, …) are defined in the
-- locale layer (locales/enUS.lua), which loads first.
-
 SECONDS_PER_MIN = 60;
 SECONDS_PER_HOUR = 60 * SECONDS_PER_MIN;
 SECONDS_PER_DAY = 24 * SECONDS_PER_HOUR;
@@ -52,67 +39,3 @@ function SecondsToClock(seconds, displayZeroHours)
        return string.format(MINUTES_SECONDS, units.minutes, units.seconds);
    end
 end
-
-- 1.12's native unit strings are bare labels ("Hr", "Min") with no `%d`,
-- unlike modern's "%d Hr"; insert the count correctly for either shape.
-local function FormatUnit(fmt, count)
-    if string.find(fmt, "%%d") then
-        return string.format(fmt, count);
-    end
-    return count .. " " .. fmt;
-end
-
-function SecondsToTime(seconds, noSeconds, notAbbreviated, maxCount, roundUp)
-    local time = "";
-    local count = 0;
-    local tempTime;
-    seconds = roundUp and math.ceil(seconds) or math.floor(seconds);
-    maxCount = maxCount or 2;
-
-    -- With a single term, use a higher 1.5x threshold; with 2+, 1.0x.
-    local threshold = (maxCount > 1) and 1.0 or 1.5;
-
-    if seconds >= SECONDS_PER_DAY * threshold then
-        count = count + 1;
-        tempTime = (count == maxCount and roundUp) and math.ceil(seconds / SECONDS_PER_DAY)
-            or math.floor(seconds / SECONDS_PER_DAY);
-        time = FormatUnit(notAbbreviated and D_DAYS or DAYS_ABBR, tempTime);
-        seconds = math.mod(seconds, SECONDS_PER_DAY);
-    end
-    if count < maxCount and seconds >= SECONDS_PER_HOUR * threshold then
-        count = count + 1;
-        if time ~= "" then time = time .. TIME_UNIT_DELIMITER; end
-        tempTime = (count == maxCount and roundUp) and math.ceil(seconds / SECONDS_PER_HOUR)
-            or math.floor(seconds / SECONDS_PER_HOUR);
-        time = time .. FormatUnit(notAbbreviated and D_HOURS or HOURS_ABBR, tempTime);
-        seconds = math.mod(seconds, SECONDS_PER_HOUR);
-    end
-    if count < maxCount and seconds >= SECONDS_PER_MIN * threshold then
-        count = count + 1;
-        if time ~= "" then time = time .. TIME_UNIT_DELIMITER; end
-        tempTime = (count == maxCount and roundUp) and math.ceil(seconds / SECONDS_PER_MIN)
-            or math.floor(seconds / SECONDS_PER_MIN);
-        time = time .. FormatUnit(notAbbreviated and D_MINUTES or MINUTES_ABBR, tempTime);
-        seconds = math.mod(seconds, SECONDS_PER_MIN);
-    end
-    if count < maxCount and seconds > 0 and not noSeconds then
-        if time ~= "" then time = time .. TIME_UNIT_DELIMITER; end
-        time = time .. FormatUnit(notAbbreviated and D_SECONDS or SECONDS_ABBR, seconds);
-    end
-    return time;
-end
-
-- Returns (formatString, value) for the single largest applicable unit.
-function SecondsToTimeAbbrev(seconds, thresholdOverride)
-    local threshold = thresholdOverride or 1.5;
-    if seconds >= SECONDS_PER_DAY * threshold then
-        return DAY_ONELETTER_ABBR, math.ceil(seconds / SECONDS_PER_DAY);
-    end
-    if seconds >= SECONDS_PER_HOUR * threshold then
-        return HOUR_ONELETTER_ABBR, math.ceil(seconds / SECONDS_PER_HOUR);
-    end
-    if seconds >= SECONDS_PER_MIN * threshold then
-        return MINUTE_ONELETTER_ABBR, math.ceil(seconds / SECONDS_PER_MIN);
-    end
-    return SECOND_ONELETTER_ABBR, seconds;
-end
@@ -1,13 +1,21 @@
-BINDING_NAME_AOELOOT = "AoE Loot"
+BINDING_NAME_AOELOOT = "AoE Loot";
 BINDING_NAME_FOCUSTARGET = "Focus Target";
 BINDING_NAME_TARGETFOCUS = "Target Focus";
+COPPER_AMOUNT_SYMBOL = "c";
 FOCUSTARGET = "Focus Target";
-ITEMS_VARIABLE_QUANTITY = "%d |4Item:Items;";
+GENERIC_FRACTION_STRING = "%d/%d";
+GOLD_AMOUNT_SYMBOL = "g";
+HOURS_MINUTES_SECONDS = "%.2d:%.2d:%.2d";
 ITEMS_EQUIPPED = "%d |4item:items; equipped";
 ITEMS_IN_INVENTORY = "%d |4item:items; in inventory";
-ITEM_SLOTS_IGNORED = "%d |4slot:slots; ignored";
-ITEM_MISSING = "%s missing";
 ITEMS_NOT_IN_INVENTORY = "%d |4item:items; missing";
+ITEMS_VARIABLE_QUANTITY = "%d |4Item:Items;";
+ITEM_MISSING = "%s missing";
+ITEM_SLOTS_IGNORED = "%d |4slot:slots; ignored";
+LARGE_NUMBER_SEPERATOR = ",";
+MINUTES_SECONDS = "%.2d:%.2d";
+PERCENTAGE_STRING = "%d%%";
+SILVER_AMOUNT_SYMBOL = "s";
 SLASH_CLEARFOCUS1 = "/clearfocus";
 SLASH_CLEARFOCUS2 = "/clearfocus";
 SLASH_EQUIP_SET1 = "/equipset";
@@ -15,25 +23,3 @@ SLASH_EQUIP_SET2 = "/equipset";
 SLASH_FOCUS1 = "/focus";
 SLASH_FOCUS2 = "/focus";
 TARGETFOCUS = "Target Focus";
-
-LARGE_NUMBER_SEPERATOR = ",";
-PERCENTAGE_STRING = "%d%%";
-GENERIC_FRACTION_STRING = "%d/%d";
-GOLD_AMOUNT_SYMBOL = "g";
-SILVER_AMOUNT_SYMBOL = "s";
-COPPER_AMOUNT_SYMBOL = "c";
-TIME_UNIT_DELIMITER = " ";
-HOURS_MINUTES_SECONDS = "%.2d:%.2d:%.2d";
-MINUTES_SECONDS = "%.2d:%.2d";
-DAYS_ABBR = "%d |4Day:Days;";
-HOURS_ABBR = "%d |4Hr:Hr;";
-MINUTES_ABBR = "%d |4Min:Min;";
-SECONDS_ABBR = "%d |4Sec:Sec;";
-D_DAYS = "%d |4Day:Days;";
-D_HOURS = "%d |4Hour:Hours;";
-D_MINUTES = "%d |4Minute:Minutes;";
-D_SECONDS = "%d |4Second:Seconds;";
-DAY_ONELETTER_ABBR = "%d d";
-HOUR_ONELETTER_ABBR = "%d h";
-MINUTE_ONELETTER_ABBR = "%d m";
-SECOND_ONELETTER_ABBR = "%d s";
@@ -38,7 +38,7 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [Hooks](docs/API.md#hooks) | `hooksecurefunc` |
 | [Input](docs/API.md#input) | `IsLeftAltKeyDown`, `IsLeftControlKeyDown`, `IsLeftShiftKeyDown`, `IsModifierKeyDown`, `IsMouseButtonDown`, `IsRightAltKeyDown`, `IsRightControlKeyDown`, `IsRightShiftKeyDown` |
 | [Instance](docs/API.md#instance) | `GetInstanceInfo` |
-| [Item](docs/API.md#item) | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetItemUniqueness`, `C_Item.GetItemUniquenessByID`, `C_Item.GetStackCount`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsItemOpenable`, `C_Item.IsLocked`, `C_Item.LockItem`, `C_Item.LockItemByGUID`, `C_Item.UnlockAllItems`, `C_Item.UnlockItem`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseAtCursor`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetAverageItemLevel`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
+| [Item](docs/API.md#item) | `C_Item.DoesItemExist`, `C_Item.DoesItemExistByID`, `C_Item.EquipItemByName`, `C_Item.GetCurrentItemLevel`, `C_Item.GetDetailedItemLevelInfo`, `C_Item.GetEnchantInfo`, `C_Item.GetItemCount`, `C_Item.GetItemFamily`, `C_Item.GetItemGUID`, `C_Item.GetItemIcon`, `C_Item.GetItemIconByID`, `C_Item.GetItemID`, `C_Item.GetItemInfoInstant`, `C_Item.GetItemInventoryType`, `C_Item.GetItemInventoryTypeByID`, `C_Item.GetItemLink`, `C_Item.GetItemLocation`, `C_Item.GetItemMaxStackSize`, `C_Item.GetItemMaxStackSizeByID`, `C_Item.GetItemName`, `C_Item.GetItemNameByID`, `C_Item.GetItemQuality`, `C_Item.GetItemQualityByID`, `C_Item.GetItemSellPrice`, `C_Item.GetItemSellPriceByID`, `C_Item.GetItemSetID`, `C_Item.GetItemSetIDByID`, `C_Item.GetItemSetInfo`, `C_Item.GetItemSpell`, `C_Item.GetItemUniqueness`, `C_Item.GetItemUniquenessByID`, `C_Item.GetStackCount`, `C_Item.GetWeaponEnchantInfo`, `C_Item.IsBound`, `C_Item.IsEquippableItem`, `C_Item.IsEquippedItem`, `C_Item.IsItemDataCached`, `C_Item.IsItemDataCachedByID`, `C_Item.IsItemOpenable`, `C_Item.IsLocked`, `C_Item.LockItem`, `C_Item.LockItemByGUID`, `C_Item.UnlockAllItems`, `C_Item.UnlockItem`, `C_Item.RequestLoadItemData`, `C_Item.RequestLoadItemDataByID`, `C_Item.UseAtCursor`, `C_Item.UseAtUnit`, `C_Item.UseItemByName`, `GetAuctionItemID`, `GetAuctionSellItemID`, `GetAverageItemLevel`, `GetCraftReagentItemID`, `GetInboxItemID`, `GetInventoryItemDurability`, `GetInventoryItemID`, `GetInventoryItemsForSlot`, `GetInventoryItemRepairCost`, `GetItemIcon`, `GetLootRollItemID`, `GetLootSlotItemID`, `GetMerchantItemID`, `GetQuestItemID`, `GetQuestLogItemID`, `GetTradePlayerItemID`, `GetTradeSkillItemID`, `GetTradeSkillReagentItemID`, `GetTradeTargetItemID`, `OffhandHasWeapon` |
 | [Loot](docs/API.md#loot) | `C_Loot.GetNearbyLootableUnits`, `C_Loot.GetLastScanResults`, `C_Loot.IsScanInProgress`, `C_Loot.LootUnit`, `C_Loot.LootUnitItem`, `C_Loot.ScanNearbyLoot` |
 | [Macros](docs/API.md#macros) | `GetLooseMacroIcons`, `GetLooseMacroItemIcons`, `GetMacroIcons`, `GetMacroItemIcons`, `GetMacroSpell` |
 | [Mail](docs/API.md#mail) | `GetInboxItemLink`, `GetSendMailItemLink` |
@@ -47,7 +47,8 @@ Full per-function reference: **[docs/API.md](docs/API.md)**.
 | [NamePlate](docs/API.md#nameplate) | `C_NamePlate.GetNamePlateForGUID`, `C_NamePlate.GetNamePlateForUnit`, `C_NamePlate.GetNamePlateGUIDs`, `C_NamePlate.GetNamePlates` |
 | [NameCache](docs/API.md#namecache) | `C_CreatureInfo.GetCreatureID`, `C_PlayerCache.GetPlayerInfoByName`, `C_PlayerCache.IsEnabled`, `C_PlayerCache.IsScanEnabled`, `C_PlayerCache.RememberPlayer`, `C_PlayerCache.SetEnabled`, `C_PlayerCache.SetScanEnabled`, `C_PlayerInfo.GUIDIsCreature`, `C_PlayerInfo.GUIDIsGameObject`, `C_PlayerInfo.GUIDIsPet`, `C_PlayerInfo.GUIDIsPlayer`, `GetPlayerInfoByGUID`, `UnitNameFromGUID` |
 | [Quest](docs/API.md#quest) | `C_QuestLog.GetQuestDetails`, `C_QuestLog.GetQuestIDForLogIndex`, `C_QuestLog.GetTitleForQuestID`, `C_QuestLog.IsOnQuest`, `C_QuestLog.IsQuestDataCachedByID`, `C_QuestLog.IsUnitOnQuest`, `C_QuestLog.RequestLoadQuestByID`, `GetQuestLogLeaderBoardID` |
-| [Spell](docs/API.md#spell) | `C_Spell.CancelSpellByID`, `C_Spell.CastAtCursor`, `C_Spell.DoesSpellExist`, `C_Spell.GetSchoolString`, `C_Spell.GetSpellCooldown`, `C_Spell.GetSpellDescription`, `C_Spell.GetSpellInfo`, `C_Spell.GetSpellLink`, `C_Spell.GetSpellMechanicByID`, `C_Spell.GetSpellName`, `C_Spell.GetSpellPowerCost`, `C_Spell.GetSpellRadius`, `C_Spell.GetSpellReagents`, `C_Spell.GetSpellSubtext`, `C_Spell.GetSpellTexture`, `C_Spell.IsAutoAttackSpell`, `C_Spell.IsCurrentSpell`, `C_Spell.IsRangedAutoAttackSpell`, `C_Spell.IsSelfBuff`, `C_Spell.IsSpellHarmful`, `C_Spell.IsSpellHelpful`, `C_Spell.IsSpellPassive`, `C_Spell.IsSpellUsable`, `C_Spell.SpellHasRange`, `CancelSpellByName`, `CastingInfo`, `CastSpellNoToggle`, `ChannelInfo`, `GetCraftSpellID`, `GetSpellInfo`, `GetSpellLink`, `GetSpellRadius`, `GetSpellSchool`, `IsHarmfulSpell`, `IsHelpfulSpell`, `IsPassiveSpell`, `IsPlayerSpell`, `IsSpellKnown`, `IsUsableSpell`, `SpellHasRange`, `UnitCastingInfo`, `UnitChannelInfo` |
+| [Screen](docs/API.md#screen) | `GetPhysicalScreenSize` |
+| [Spell](docs/API.md#spell) | `C_Spell.CancelSpellByID`, `C_Spell.CastAtCursor`, `C_Spell.CastAtUnit`, `C_Spell.DoesSpellExist`, `C_Spell.GetSchoolString`, `C_Spell.GetSpellCooldown`, `C_Spell.GetSpellDescription`, `C_Spell.GetSpellInfo`, `C_Spell.GetSpellLink`, `C_Spell.GetSpellMechanicByID`, `C_Spell.GetSpellName`, `C_Spell.GetSpellPowerCost`, `C_Spell.GetSpellRadius`, `C_Spell.GetSpellReagents`, `C_Spell.GetSpellSubtext`, `C_Spell.GetSpellTexture`, `C_Spell.IsAutoAttackSpell`, `C_Spell.IsCurrentSpell`, `C_Spell.IsRangedAutoAttackSpell`, `C_Spell.IsSelfBuff`, `C_Spell.IsSpellHarmful`, `C_Spell.IsSpellHelpful`, `C_Spell.IsSpellPassive`, `C_Spell.IsSpellUsable`, `C_Spell.SpellHasRange`, `CancelSpellByName`, `CastingInfo`, `CastSpellNoToggle`, `ChannelInfo`, `GetCraftSpellID`, `GetSpellInfo`, `GetSpellLink`, `GetSpellRadius`, `GetSpellSchool`, `IsHarmfulSpell`, `IsHelpfulSpell`, `IsPassiveSpell`, `IsPlayerSpell`, `IsSpellKnown`, `IsUsableSpell`, `SpellHasRange`, `UnitCastingInfo`, `UnitChannelInfo` |
 | [SpellBook](docs/API.md#spellbook) | `C_SpellBook.GetCurrentLevelSpells`, `C_SpellBook.GetSpellLevelLearned`, `C_SpellBook.GetSpellSkillLine`, `C_SpellBook.IsAutoAttackSpellBookItem`, `C_SpellBook.IsRangedAutoAttackSpellBookItem`, `FindSpellBookSlotByID` |
 | [State](docs/API.md#state) | `CancelShapeshiftForm`, `Dismount`, `GetMirrorTimerInfo`, `GetMirrorTimerProgress`, `GetShapeshiftFormID`, `IsAssistingRitual`, `IsFalling`, `IsInGroup`, `IsInRaid`, `IsLoggedIn`, `IsMounted`, `IsStealthed`, `IsSwimming` |
 | [Table](docs/API.md#table) | `table.wipe` |
@@ -88,6 +89,17 @@ functions, just behavior the stock 1.12 engine didn't have. See the
 | `CastSpellByName("<spellID>")` | Same — numeric strings resolve through the engine's name resolver |
 | `CastSpellNoToggle("<name>")` in a macro | Engine's macro parser now recognizes it as a primary-spell line, so the macro slot in an addon like pfUI highlights when its spell is auto-repeating or its self-aura is active |

+### Console commands
+
+Registered on the engine's developer console (the `~` console available
+when launching with `-console`), not as Lua functions. See the
+[Console section in the Lua reference](docs/API.md#console) for details.
+
+| Command | What it does |
+|---------|--------------|
+| `ExportInterfaceFiles code` | Extracts Blizzard's UI source (`.lua`/`.xml`/`.toc`/`.xsd`) from the MPQs to `BlizzardInterfaceCode\` |
+| `ExportInterfaceFiles art` | Extracts Blizzard's UI art (`.blp`/`.tga`) from the MPQs to `BlizzardInterfaceArt\` |
+
 ### Events

 | Event | Payload |
@@ -33,6 +33,9 @@ build instructions.
 - [Combat](#combat)
  - [`InCombatLockdown()`](#incombatlockdown)

+- [Console](#console)
+  - [`ExportInterfaceFiles art|code` (console command)](#exportinterfacefiles-artcode-console-command)
+
 - [Container](#container)
  - [`C_Container.GetContainerItemID(bagIndex, slotIndex)`](#c_containergetcontaineritemidbagindex-slotindex)
  - [`GetItemCooldown(itemInfo)` / `C_Container.GetItemCooldown(itemID)`](#getitemcooldowniteminfo--c_containergetitemcooldownitemid)
@@ -201,6 +204,7 @@ build instructions.
  - [`C_Item.UnlockAllItems()`](#c_itemunlockallitems)
  - [`C_Item.UnlockItem(itemLocation)`](#c_itemunlockitemitemlocation)
  - [`C_Item.UseAtCursor(itemInfo)`](#c_itemuseatcursoriteminfo)
+  - [`C_Item.UseAtUnit(itemInfo, unit)`](#c_itemuseatunititeminfo-unit)
  - [`C_Item.UseItemByName(itemInfo [, unit])`](#c_itemuseitembynameiteminfo--unit)
  - [`Get*ItemID` — companions to the engine's `Get*ItemLink` family](#getitemid--companions-to-the-engines-getitemlink-family)
  - [`GetAverageItemLevel()`](#getaverageitemlevel)
@@ -269,6 +273,9 @@ build instructions.
  - [`C_QuestLog.IsQuestDataCachedByID(questID)`](#c_questlogisquestdatacachedbyidquestid)
  - [`GetQuestLogLeaderBoardID(objectiveIndex [, questIndex])`](#getquestlogleaderboardidobjectiveindex--questindex)

+- [Screen](#screen)
+  - [`GetPhysicalScreenSize()`](#getphysicalscreensize)
+
 - [Spell](#spell)
  - [`C_Spell.DoesSpellExist(spellID)`](#c_spelldoesspellexistspellid)
  - [`C_Spell.GetSchoolString(schoolMask)`](#c_spellgetschoolstringschoolmask)
@@ -301,6 +308,7 @@ build instructions.
  - [`GetSpellSchool(spellID)`](#getspellschoolspellid)
  - [`CastSpellNoToggle(name | spellID)`](#castspellnotogglename--spellid)
  - [`C_Spell.CastAtCursor(spellID)`](#c_spellcastatcursorspellid)
+  - [`C_Spell.CastAtUnit(spellID, unit)`](#c_spellcastatunitspellid-unit)
  - [`C_Spell.CancelSpellByID(spellID)` / `CancelSpellByName(name)`](#c_spellcancelspellbyidspellid--cancelspellbynamename)
  - [`UnitCastingInfo(unit)` / `CastingInfo()`](#unitcastinginfounit--castinginfo)
  - [`UnitChannelInfo(unit)` / `ChannelInfo()`](#unitchannelinfounit--channelinfo)
@@ -831,6 +839,45 @@ if UnitAffectingCombat("player") then
 end
 ```

+## Console
+
+### `ExportInterfaceFiles art|code` (console command)
+
+A **developer-console command** (not a Lua function) — type it into the
+`~` console, which is available when the client is launched with
+`-console`. It extracts Blizzard's stock UI files out of the game's MPQ
+archives onto disk, mirroring the same-named command from later clients
+(4.3.4). Useful for reading the FrameXML / GlueXML source you're
+backporting addons against, or pulling out the default art.
+
+- `ExportInterfaceFiles code` — writes `.lua` / `.xml` / `.toc` /
+  `.xsd` files to `BlizzardInterfaceCode\…`
+- `ExportInterfaceFiles art` — writes `.blp` / `.tga` files to
+  `BlizzardInterfaceArt\…`
+
+Files are written relative to the client's working directory (next to
+`WoW.exe`), preserving their `Interface\…` subtree under the
+destination folder — e.g. `Interface\FrameXML\FrameXML.toc` becomes
+`BlizzardInterfaceCode\FrameXML\FrameXML.toc`. On completion the command
+prints a `wrote N file(s)` line back to the console.
+
+```
+> ExportInterfaceFiles code
+ExportInterfaceFiles: wrote 1234 code file(s) to BlizzardInterfaceCode\
+```
+
+Notes:
+
+- It enumerates the mounted MPQs' `(listfile)`, so it surfaces whatever
+  the archives actually ship — including Blizzard's own UI addons under
+  `Interface\AddOns\Blizzard_*` (AuctionUI, TalentUI, TradeSkillUI,
+  etc.), which are part of the stock UI source. Files present in
+  multiple archives (base + patches) are written once.
+- Your own loose, on-disk addons are *not* exported — they aren't in
+  any archive's listfile, so they're never enumerated.
+- It runs synchronously and briefly freezes the client while it walks
+  `Interface\` — expected for a one-shot extraction.
+
 ## Container

 ### `C_Container.GetContainerItemID(bagIndex, slotIndex)`
@@ -4759,6 +4806,32 @@ Cancels placement automatically when the cursor isn't on terrain —
 the item-use packet is never sent, so an off-screen click doesn't
 waste the grenade.

+### `C_Item.UseAtUnit(itemInfo, unit)`
+
+Unit-position analog of
+[`C_Item.UseAtCursor`](#c_itemuseatcursoriteminfo): uses `itemInfo` at
+`unit`'s feet rather than the cursor. ClassicAPI's `[@unit]` for
+ground-target on-use items. `itemInfo` accepts the same forms as
+`UseAtCursor` (itemID, bare `"item:N"`, full chat link, localized
+name); `unit` is any unit token (`"player"`, `"target"`,
+`"mouseover"`, `"party1"`, …).
+
+```lua
+C_Item.UseAtUnit(4068, "target")            -- Iron Grenade at the target's feet
+C_Item.UseAtUnit("Iron Grenade", "player")
+```
+
+Same chain as `UseAtCursor` (`Item::Location::FindByArgInBags` +
+`FUN_ITEM_USE`) but committing the placement at the unit's world
+position via
+[`Spell::AtCursor::CommitAtCoords`](#c_spellcastatunitspellid-unit)
+instead of the cursor raycast. Returns `true` when the placement
+landed at the unit; `false` for non-ground-target items (the item
+still fires with any implicit target), unparseable input,
+item-not-in-bags, or an unresolvable unit. The unit is resolved
+before the item fires, so an absent unit fails without consuming the
+item.
+
 ### `C_Item.UseItemByName(itemInfo [, unit])`

 Finds the first item in the player's bags matching `itemInfo` and
@@ -6581,6 +6654,40 @@ A separate function keeps the existing call wire-compatible.
 > first, skip zero slots, then the item array. 1-based `objectiveIndex`
 > counts only non-empty slots.

+## Screen
+
+### `GetPhysicalScreenSize()`
+
+Returns `(widthPixels, heightPixels)` — the display's physical
+resolution in pixels. Modern WoW added this as a native in 7.0
+(Legion); FrameXML's `PixelUtil` builds its entire pixel↔UI-unit
+conversion on it (`768.0 / physicalHeight`), which is what lets addons
+snap frames to whole pixels for crisp borders at fractional UI scales.
+
+```lua
+local w, h = GetPhysicalScreenSize()   -- e.g. 1920, 1080
+```
+
+Vanilla 1.12 has no such native — and no pre-parsed pixel-dimension
+global. `GetScreenWidth()`/`GetScreenHeight()` return UI-space units
+(derived from the UIParent aspect ratio at `[UIParent + 0x7c]`), not
+pixels. The engine only ever holds the current mode as the
+`gxResolution` CVar string (`"WIDTHxHEIGHT"`); both `SetScreenResolution`
+(`0x0048bfd0`) and the display-init path sscanf it on demand rather
+than caching dimensions anywhere. So we read the `gxResolution` CVar
+directly through the engine's by-name lookup (`FUN_FIND_CVAR`, value at
+`+0x20`) and parse it — the same source of truth the engine uses.
+
+Returns `1024, 768` (→ factor 1.0, making PixelUtil a 1:1 no-op) when
+the CVar is missing or unparseable. Caveat: in windowed mode
+`gxResolution` reflects the configured render resolution, which may
+differ from the OS window's client size — vanilla exposes no separate
+window-pixel query.
+
+The companion `PixelUtil` table (`PixelUtil.SetPoint`/`SetSize`/
+`SetStatusBarValue`/…) is provided Lua-side by the ClassicAPI addon and
+consumes this function.
+
 ## Spell

 > **All `C_Spell.*` functions in this section accept any spell
@@ -7325,6 +7432,70 @@ addons reading positions 4..8 by index still work.
 Equivalent to the extension of `GetWeaponEnchantInfo` introduced
 in 3.x.

+### `C_Item.GetEnchantInfo(enchantID)`
+
+Resolves an item-enchantment ID — the `enchantID` returned by
+[`C_Item.GetWeaponEnchantInfo`](#c_itemgetweaponenchantinfo) for a
+weapon's temporary enchant, and the same IDs item permanent enchants
+use — into a table:
+
+```lua
+local info = C_Item.GetEnchantInfo(enchantID)
+-- info.enchantID = <id>
+-- info.name      = "Crusader"        -- localized display name
+-- info.effects   = { {type=1, amount=0, arg=20007} }
+-- info.spellID   = 20007             -- spell-type enchants only
+```
+
+```lua
+-- A proc/equip enchant → chain its spellID into C_Spell:
+local info = C_Item.GetEnchantInfo(1900)          -- "Crusader"
+if info.spellID then
+    print(C_Spell.GetSpellDescription(info.spellID))  -- the proc's text
+end
+```
+
+`effects` is an array of the record's non-empty effect slots, each
+`{ type, amount, arg }` where `type` is the standard
+`ITEM_ENCHANTMENT_TYPE`:
+
+| type | meaning | carries |
+|------|---------|---------|
+| 1 | combat-proc spell | `arg` = spellID |
+| 2 | weapon damage | `amount` = +damage |
+| 3 | equip spell / aura | `arg` = spellID |
+| 4 | resistance / armor | `amount` = +value |
+| 5 | stat | `arg` = stat index, `amount` = value |
+| 6 | totem | — |
+| 7 | use spell | `arg` = spellID |
+
+For spell types (1/3/7) `arg` is a spellID feedable into
+[`C_Spell.GetSpellInfo`](#getspellinfospellid--getspellinfoslot-booktype) /
+`GetSpellDescription`; the first such id is also surfaced at top level
+as `spellID` for convenience (absent for non-spell enchants like
+sharpening stones).
+
+Returns `nil` for a non-numeric / non-positive id, an out-of-range
+id, or a record with no name.
+
+Reads `SpellItemEnchantment.dbc` (records `0x00C0D7D8`, count
+`0x00C0D7DC`) — the 24-column table every enchant ID indexes:
+`Type[3]@+0x04`, `Amount[3]@+0x10`, `EffectArg[3]@+0x28`,
+`Name[8]@+0x34` (locale-indexed). The layout was verified by parsing
+the on-disk DBC against known records (Crusader 1900 → type 1, arg
+20007; Sharpened +3 → type 2, amount 3). Fully resident from boot, so
+it answers for any enchant ID with no caching or round-trip.
+
+Lives in `C_Item` (not `C_Spell`) because the id originates from
+`C_Item.GetWeaponEnchantInfo` and the concept is an item enchantment —
+`SpellItemEnchantment` is just the DBC's internal name (enchants are
+*implemented* via spell effects).
+
+> **Not derivable: the source item.** The enchant record holds no
+> back-reference to the item that applied it, and vanilla has no
+> client-side reverse index (enchantID → item). Finding it would need
+> an external scraped DB (pfQuest/Questie-style).
+
 ### `IsHarmfulSpell(spell)` / `IsHelpfulSpell(spell)`

 Classify a spell as offensive (`IsHarmfulSpell`) or non-offensive
@@ -7520,6 +7691,36 @@ The companion item version is
 [`C_Item.UseAtCursor`](#c_itemuseatcursoriteminfo) — same chain via
 the item-use path for grenades / on-use ground-target items.

+### `C_Spell.CastAtUnit(spellID, unit)`
+
+Casts a ground-target spell at `unit`'s feet, bypassing the AoE
+reticle click. ClassicAPI's analog of modern's
+`/cast [@unit] Flamestrike` — `CastAtUnit(spellID, "player")` drops it
+at the player's position, `"target"` at the target's, and so on for
+any unit token (`"mouseover"`, `"party1"`, `"raid7"`, …). Returns
+`true` when the placement landed at the unit; `false` for
+non-ground-target spells (cast still fires normally), unknown
+spellIDs, or a unit with no resolvable position.
+
+```lua
+C_Spell.CastAtUnit(2120, "target")   -- Flamestrike at the target's feet
+C_Spell.CastAtUnit(10, "player")     -- Blizzard centered on yourself
+```
+
+Same two-stage shape as
+[`C_Spell.CastAtCursor`](#c_spellcastatcursorspellid), but instead of
+the cursor raycast, step 2 reads the unit's world position from its
+`GetPosition` virtual (the same one `CheckInteractDistance` /
+`UnitInRange` use) and commits placement there via
+`FUN_COMMIT_PLACEMENT_COORDS`. The unit is resolved *before* the cast
+is dispatched, so an absent/invalid unit fails cleanly without
+leaving the engine armed in placement mode. A genuinely unrecognized
+unit-token string raises the engine's standard "Unknown unit" error,
+matching `UnitHealth("garbage")`.
+
+The companion item version is
+[`C_Item.UseAtUnit`](#c_itemuseatunititeminfo-unit).
+
 ### `C_Spell.CancelSpellByID(spellID)` / `CancelSpellByName(name)`

 Cancel a buff on the player by spellID or by spell name. Modern WoW's
@@ -236,6 +236,25 @@ void PushLocalizedFormatInt(void *L, const char *globalName,
 }
 } // namespace Lua

+namespace Console {
+namespace {
+using RegisterCommand_t = int(__fastcall *)(const char *name, void *handler,
+                                            int category, const char *description);
+using Write_t = void(__fastcall *)(const char *line, int colorFlag);
+} // namespace
+
+void RegisterCommand(const char *name, CommandHandler handler, int category,
+                     const char *description) {
+    auto fn = reinterpret_cast<RegisterCommand_t>(Offsets::FUN_CONSOLE_COMMAND_REGISTER);
+    fn(name, reinterpret_cast<void *>(handler), category, description);
+}
+
+void Write(const char *line) {
+    auto fn = reinterpret_cast<Write_t>(Offsets::FUN_CONSOLE_WRITE);
+    fn(line, 0);
+}
+} // namespace Console
+
 namespace {
 ModuleAutoRegister *g_moduleHead = nullptr;
 GlueModuleAutoRegister *g_glueModuleHead = nullptr;
@@ -242,6 +242,50 @@ void PushLocalizedFormatInt(void *L, const char *globalName,
                            const char *fallback, int n);
 } // namespace Lua

+// Developer-console command system — the `~` console available when the
+// client is launched with `-console`. Vanilla maintains a
+// `TSExplicitList<CONSOLECOMMAND>`; these wrap the engine's registrar
+// and output paths. See the "Console commands & Interface file export"
+// section in CLAUDE.md for the underlying offsets and ABI.
+namespace Console {
+
+// Console-command handler ABI: `args` is the command-line text after
+// the command name (empty string when invoked bare). The engine
+// ignores the return value; return 1 by convention.
+using CommandHandler = int(__fastcall *)(void *unused, const char *args);
+
+// Help-grouping categories — the engine's `help` enumerates these nine
+// (in this order). Cosmetic: the value only affects which group `help`
+// lists the command under; the engine doesn't validate it. Values are
+// sequential table indices (graphics=1 confirmed via FUN_0066F6C0, the
+// rest follow the displayed order).
+enum Category {
+    CATEGORY_DEBUG = 0,
+    CATEGORY_GRAPHICS = 1,
+    CATEGORY_CONSOLE = 2,
+    CATEGORY_COMBAT = 3,
+    CATEGORY_GAME = 4,
+    CATEGORY_DEFAULT = 5,
+    CATEGORY_NET = 6,
+    CATEGORY_SOUND = 7,
+    CATEGORY_GM = 8,
+};
+
+// Registers a console command. `name` and `description` are stored BY
+// POINTER (the engine doesn't copy them), so pass string literals or
+// otherwise process-lifetime storage. Dedup-safe: re-registering the
+// same name is a harmless no-op, so it's fine to call from a hook that
+// fires more than once. Safe any time after engine boot — the command
+// table self-initializes on first use. `description` may be nullptr.
+void RegisterCommand(const char *name, CommandHandler handler, int category,
+                     const char *description);
+
+// Writes a line to the console output buffer. No-ops cleanly when the
+// console isn't active, so it's always safe to call.
+void Write(const char *line);
+
+} // namespace Console
+
 // Self-registration for API modules. Each module .cpp declares a file-scope
 // `static const Game::ModuleAutoRegister _r{&RegisterLuaFunctions};`, which
 // chains itself onto a global list at DLL-load time. `RunModuleRegistrations`
@@ -2428,6 +2428,29 @@ enum Offsets {
    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
+
    // 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
@@ -2820,8 +2843,12 @@ enum Offsets {
    // trailing zeros, hands the buffer to the caller. Caller frees
    // via `FUN_STORM_SMEM_FREE`.
    //
-    //   __cdecl int FileRead(
-    //       int          unused,         // always 0 from engine call sites
+    //   __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
@@ -2836,6 +2863,85 @@ enum Offsets {
    // 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
@@ -3379,13 +3485,19 @@ enum Offsets {
    // 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` and the
-    // both-mouse-buttons combo). `INPUT_FLAGS_MOVING_ANY` is the
-    // engine's own "is the user currently inputting translational
-    // movement" 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.
+    // 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,
@@ -0,0 +1,281 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `ExportInterfaceFiles art|code` — backport of the 4.3.4 developer-
+// console command of the same name. Registered as a real console
+// command (the `~` console available when the client is launched with
+// `-console`), exactly like retail. Dumps Blizzard's UI files out of
+// the mounted MPQ archives onto disk:
+//
+//   code → .lua / .xml / .toc / .xsd  →  BlizzardInterfaceCode\...
+//   art  → .blp / .tga                →  BlizzardInterfaceArt\...
+//
+// Files land relative to the client's working directory, mirroring the
+// retail command's `BlizzardInterface{Code,Art}\<relative-path>`
+// layout. On completion it writes a "wrote N files" line back to the
+// console.
+//
+// **How it works (vanilla 1.12 / Octo):**
+//
+// Like 4.3.4, we enumerate the mounted archives' `(listfile)` — the
+// flat, full-path file index — rather than walking directories. The
+// vanilla primitive is `FUN_MPQ_ENUM_FILES` (`0x00401470`, the same
+// MPQ walk the macro-icon loader uses): it loops the archive handles
+// and dispatches a callback per listfile entry under a path prefix
+// (here `"Interface\"`). We collect every matching full path (deduped
+// across archives), then read each via `FUN_FILE_READ` and write it to
+// disk with Win32.
+//
+// Don't confuse this with `FUN_0042AD10`, the disk-only
+// `FindFirstFileW` walker — pointing the export at that yields zero
+// MPQ files. See the `FUN_MPQ_ENUM_FILES` note in Offsets.h.
+//
+// We export the full `Interface\` tree, matching 4.3.4 (extension
+// filter only, no path exclusion). That INCLUDES `Interface\AddOns\` —
+// the listfile only indexes MPQ-baked files, so those AddOns entries
+// are Blizzard's own UI addons (Blizzard_AuctionUI, Blizzard_TalentUI,
+// …), which are part of the stock UI source. The player's loose,
+// on-disk addons live in no archive's listfile, so they're never
+// enumerated and never re-exported.
+
+#include "Game.h"
+#include "Offsets.h"
+
+#include <windows.h>
+
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <unordered_set>
+#include <vector>
+
+namespace Interface::Export {
+
+namespace {
+
+// Engine's file-content reader (see Offsets::FUN_FILE_READ). __stdcall
+// (callee cleans 28 bytes via RET 0x1C — NOT __cdecl; getting this
+// wrong corrupts the caller's stack). Allocates a Storm buffer; free
+// with SMemFree.
+using FileRead_t = int(__stdcall *)(int unused, const char *path, void **outBuf,
+                                    unsigned int *outSize, unsigned int extraBytes,
+                                    int flag1, int flag2);
+using SMemFree_t = void(__stdcall *)(void *ptr, const char *file, int line, int flags);
+
+// MPQ enumerator (see Offsets::FUN_MPQ_ENUM_FILES). The callback
+// receives each listfile entry's full path in ecx; returning 0 STOPS
+// enumeration, so we return 1 to keep going.
+using MpqEnumCb_t = int(__fastcall *)(const char *fullPath);
+using MpqEnumFiles_t = void(__fastcall *)(int archiveSelector, const char *pathPrefix,
+                                          MpqEnumCb_t callback, void *userParam);
+
+// The archive-set selector the engine's own macro-icon loader passes to
+// FUN_00401470 — covers the primary mounted archives plus the selected
+// extra. We mirror it.
+constexpr int kArchiveSelector = 6;
+
+// Case-insensitive ASCII equality.
+bool EqualsCI(const char *a, const char *b) {
+    for (;; ++a, ++b) {
+        char ca = *a, cb = *b;
+        if (ca >= 'A' && ca <= 'Z') ca = static_cast<char>(ca + ('a' - 'A'));
+        if (cb >= 'A' && cb <= 'Z') cb = static_cast<char>(cb + ('a' - 'A'));
+        if (ca != cb)
+            return false;
+        if (ca == '\0')
+            return true;
+    }
+}
+
+bool HasExtension(const char *name, const char *const *exts, int count) {
+    const char *dot = nullptr;
+    for (const char *p = name; *p; ++p) {
+        if (*p == '.')
+            dot = p;
+    }
+    if (dot == nullptr)
+        return false;
+    for (int i = 0; i < count; ++i) {
+        if (EqualsCI(dot + 1, exts[i]))
+            return true;
+    }
+    return false;
+}
+
+// Create every parent directory of `relPath` (a backslash-separated
+// path, e.g. "BlizzardInterfaceCode\FrameXML\Foo.lua"). Each component
+// is created relative to the working directory; existing dirs are a
+// no-op.
+void EnsureParentDirs(const std::string &relPath) {
+    std::string accum;
+    for (size_t i = 0; i < relPath.size(); ++i) {
+        const char c = relPath[i];
+        if (c == '\\' || c == '/') {
+            if (!accum.empty())
+                CreateDirectoryA(accum.c_str(), nullptr);
+            accum.push_back('\\');
+        } else {
+            accum.push_back(c);
+        }
+    }
+}
+
+bool WriteFileToDisk(const std::string &relPath, const void *data, unsigned int size) {
+    EnsureParentDirs(relPath);
+    HANDLE h = CreateFileA(relPath.c_str(), GENERIC_WRITE, 0, nullptr,
+                           CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, nullptr);
+    if (h == INVALID_HANDLE_VALUE)
+        return false;
+    bool ok = true;
+    if (size != 0) {
+        DWORD written = 0;
+        ok = WriteFile(h, data, size, &written, nullptr) != 0 && written == size;
+    }
+    CloseHandle(h);
+    return ok;
+}
+
+// Length of the "Interface\" prefix we strip from MPQ paths before
+// re-rooting under the destination folder.
+constexpr size_t kRootPrefixLen = 10; // strlen("Interface\\")
+
+const char *const kCodeExts[] = {"lua", "xml", "toc", "xsd"};
+const char *const kArtExts[] = {"blp", "tga"};
+
+enum Mode { MODE_CODE, MODE_ART };
+
+// Collector for the MPQ enumeration callback. File-static because
+// FUN_00401470 hands the callback only the path string; enumeration is
+// synchronous and single-threaded, so a file-static sink is safe.
+struct Collector {
+    const char *const *exts = nullptr;
+    int extCount = 0;
+    std::vector<std::string> files;
+    std::unordered_set<std::string> seen; // dedup across archives
+};
+Collector *g_collector = nullptr;
+
+// MPQ enumeration callback — one call per listfile entry under the
+// "Interface\" prefix. Keep going (return 1) regardless.
+int __fastcall CollectCb(const char *fullPath) {
+    Collector *c = g_collector;
+    if (c != nullptr && fullPath != nullptr &&
+        HasExtension(fullPath, c->exts, c->extCount)) {
+        if (c->seen.insert(fullPath).second)
+            c->files.emplace_back(fullPath);
+    }
+    return 1; // 0 would stop enumeration
+}
+
+// Enumerate every MPQ file under Interface\ whose extension matches
+// `mode`, read each, and write it under the destination root. Returns
+// the number of files successfully written.
+int ExportTree(Mode mode) {
+    auto MpqEnumFiles = reinterpret_cast<MpqEnumFiles_t>(Offsets::FUN_MPQ_ENUM_FILES);
+    auto FileRead = reinterpret_cast<FileRead_t>(Offsets::FUN_FILE_READ);
+    auto SMemFree = reinterpret_cast<SMemFree_t>(Offsets::FUN_STORM_SMEM_FREE);
+
+    const char *dstRoot =
+        (mode == MODE_ART) ? "BlizzardInterfaceArt" : "BlizzardInterfaceCode";
+
+    Collector collector;
+    collector.exts = (mode == MODE_ART) ? kArtExts : kCodeExts;
+    collector.extCount = (mode == MODE_ART) ? 2 : 4;
+
+    g_collector = &collector;
+    MpqEnumFiles(kArchiveSelector, "Interface\\", &CollectCb, nullptr);
+    g_collector = nullptr;
+
+    const std::vector<std::string> &files = collector.files;
+    int written = 0;
+    for (const std::string &src : files) {
+        void *buf = nullptr;
+        unsigned int size = 0;
+        if (FileRead(0, src.c_str(), &buf, &size, 0, 1, 0) == 0 || buf == nullptr)
+            continue;
+
+        // Re-root: "Interface\FrameXML\Foo.lua" -> "<dstRoot>\FrameXML\Foo.lua".
+        std::string dst = dstRoot;
+        dst.push_back('\\');
+        dst.append(src, kRootPrefixLen, std::string::npos);
+
+        if (WriteFileToDisk(dst, buf, size))
+            ++written;
+
+        SMemFree(buf, __FILE__, __LINE__, 0);
+    }
+    return written;
+}
+
+// Console-command handler ABI: edx = the argument text after the
+// command name ("" when bare). Mirrors 4.3.4's `art`/`code` dispatch.
+bool FirstTokenEquals(const char *s, const char *token) {
+    size_t i = 0;
+    for (; token[i] != '\0'; ++i) {
+        char a = s[i];
+        if (a >= 'A' && a <= 'Z') a = static_cast<char>(a + ('a' - 'A'));
+        if (a != token[i])
+            return false;
+    }
+    const char end = s[i];
+    return end == '\0' || end == ' ' || end == '\t';
+}
+
+int __fastcall Console_ExportInterfaceFiles(void * /*unused*/, const char *args) {
+    const char *p = (args != nullptr) ? args : "";
+    while (*p == ' ' || *p == '\t')
+        ++p;
+
+    Mode mode;
+    if (FirstTokenEquals(p, "art"))
+        mode = MODE_ART;
+    else if (FirstTokenEquals(p, "code"))
+        mode = MODE_CODE;
+    else {
+        Game::Console::Write("Usage: ExportInterfaceFiles art|code");
+        return 1;
+    }
+
+    const int written = ExportTree(mode);
+
+    char msg[160];
+    snprintf(msg, sizeof(msg), "ExportInterfaceFiles: wrote %d %s file(s) to %s\\",
+             written, (mode == MODE_ART) ? "art" : "code",
+             (mode == MODE_ART) ? "BlizzardInterfaceArt" : "BlizzardInterfaceCode");
+    Game::Console::Write(msg);
+    return 1;
+}
+
+// Register the console command. A console command is process-global
+// (not Lua-state-bound) and persists for the whole session, so the
+// single registration at glue boot — the earliest hook, firing at
+// launch before any console can be opened — covers both the login
+// console and in-world. The glue hook re-fires on each world→glue
+// return (logout), but the engine's registrar dedups by name (and we
+// pass the same string literal, so its pointer-equality fast path
+// catches the repeat), making a second call a no-op. The command name
+// and help string are stored by pointer, so they must be static —
+// string literals satisfy that for the DLL's lifetime.
+void EnsureRegistered() {
+    Game::Console::RegisterCommand(
+        "ExportInterfaceFiles", &Console_ExportInterfaceFiles,
+        Game::Console::CATEGORY_DEBUG,
+        "Extracts Blizzard's UI files from the MPQs to disk. "
+        "Usage: ExportInterfaceFiles art|code");
+}
+
+const Game::GlueModuleAutoRegister _autoreg{&EnsureRegistered};
+
+} // namespace
+
+} // namespace Interface::Export
@@ -0,0 +1,139 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `C_Item.GetEnchantInfo(enchantID)` -> table | nil
+//
+// Resolves an item-enchantment ID — the kind `C_Item.GetWeaponEnchantInfo`
+// returns for a weapon's temporary enchant (poisons, oils, sharpening
+// stones, shaman imbues, …), and the same IDs item permanent enchants
+// use — into its `SpellItemEnchantment.dbc` record and returns a table:
+//
+//   {
+//     enchantID = <id>,
+//     name      = "<localized display name>",   -- "Crusader", "+8 Spirit"
+//     effects   = {                              -- 1..3 active effect slots
+//       { type = <ITEM_ENCHANTMENT_TYPE>, amount = <int>, arg = <int> },
+//       ...
+//     },
+//     spellID   = <int>,   -- present only for spell-type enchants (proc/
+//                          -- equip/use): the EffectArg of the first such
+//                          -- effect, e.g. Crusader -> 20007 "Holy Strength".
+//   }
+//
+// `effects[i].type` is the standard ITEM_ENCHANTMENT_TYPE:
+//   1 = combat-proc spell   (arg = spellID)
+//   2 = weapon damage       (amount = +dmg)
+//   3 = equip spell / aura  (arg = spellID)
+//   4 = resistance / armor  (amount = +value)
+//   5 = stat                (arg = stat index, amount = value)
+//   6 = totem, 7 = use spell
+// For spell types (1/3/7) `arg` is a spellID you can feed straight into
+// `C_Spell.GetSpellInfo` / `GetSpellDescription`; `spellID` is surfaced
+// at top level as a convenience for that common case.
+//
+// Returns nil for a non-numeric / non-positive id, an out-of-range id,
+// or a record with no name. Lives in C_Item (not C_Spell) because the
+// id originates from `C_Item.GetWeaponEnchantInfo` and the concept is an
+// item enchantment — `SpellItemEnchantment` is just the DBC's internal
+// name (enchants are *implemented* via spell effects).
+//
+// Not derivable: the source item. The record holds no back-reference to
+// the item that applied the enchant, and vanilla has no client-side
+// reverse index (enchantID -> item).
+
+#include "Game.h"
+#include "Offsets.h"
+#include "dbc/Lookup.h"
+
+#include <cstdint>
+
+namespace Item::EnchantInfo {
+
+namespace {
+
+constexpr int kNumEffects = 3;
+constexpr int kNumNameLocales = 8; // Name[8]; field after is the locale mask
+
+// Spell-type enchants whose EffectArg is a spellID (proc / equip / use).
+bool IsSpellType(int type) { return type == 1 || type == 3 || type == 7; }
+
+int __fastcall Script_C_Item_GetEnchantInfo(void *L) {
+    if (!Game::Lua::IsNumber(L, 1))
+        return 0; // nil
+    const int enchantID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+    if (enchantID <= 0)
+        return 0;
+
+    const uint8_t *rec = DBC::Record(Offsets::VAR_SPELLITEMENCHANT_RECORDS,
+                                     Offsets::VAR_SPELLITEMENCHANT_COUNT,
+                                     static_cast<uint32_t>(enchantID));
+    if (rec == nullptr)
+        return 0; // OOR id or unpopulated slot -> nil
+
+    // Localized display name (8-slot locale array at +0x34). Clamp the
+    // locale index to the array bounds — index 8 would read the locale
+    // mask column that follows. enUS (0) fallback for empty slots.
+    auto names = reinterpret_cast<const char *const *>(rec + Offsets::OFF_SPELLITEMENCHANT_NAME);
+    int locale = *reinterpret_cast<const int *>(Offsets::VAR_LOCALE_INDEX);
+    if (locale < 0 || locale >= kNumNameLocales)
+        locale = 0;
+    const char *name = names[locale];
+    if (name == nullptr || name[0] == '\0')
+        name = names[0]; // enUS fallback
+    if (name == nullptr || name[0] == '\0')
+        return 0; // unnamed record -> nil
+
+    auto type = reinterpret_cast<const int32_t *>(rec + Offsets::OFF_SPELLITEMENCHANT_TYPE);
+    auto amount = reinterpret_cast<const int32_t *>(rec + Offsets::OFF_SPELLITEMENCHANT_AMOUNT);
+    auto arg = reinterpret_cast<const int32_t *>(rec + Offsets::OFF_SPELLITEMENCHANT_ARG);
+
+    Game::Lua::NewTable(L);
+    Game::Lua::SetFieldNumber(L, "enchantID", enchantID);
+    Game::Lua::SetFieldString(L, "name", name);
+
+    // effects = { {type,amount,arg}, ... } — only non-empty slots.
+    Game::Lua::PushString(L, "effects");
+    Game::Lua::NewTable(L);
+    int n = 0;
+    int spellID = 0;
+    for (int i = 0; i < kNumEffects; ++i) {
+        if (type[i] == 0)
+            continue;
+        if (spellID == 0 && IsSpellType(type[i]) && arg[i] != 0)
+            spellID = arg[i];
+        ++n;
+        Game::Lua::PushNumber(L, n); // 1-based array index
+        Game::Lua::NewTable(L);
+        Game::Lua::SetFieldNumber(L, "type", type[i]);
+        Game::Lua::SetFieldNumber(L, "amount", amount[i]);
+        Game::Lua::SetFieldNumber(L, "arg", arg[i]);
+        Game::Lua::SetTable(L, -3); // effects[n] = entry
+    }
+    Game::Lua::SetTable(L, -3); // result.effects = effects
+
+    if (spellID != 0)
+        Game::Lua::SetFieldNumber(L, "spellID", spellID);
+
+    return 1;
+}
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterTableFunction("C_Item", "GetEnchantInfo",
+                                     &Script_C_Item_GetEnchantInfo);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace Item::EnchantInfo
@@ -0,0 +1,90 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `C_Item.UseAtUnit(itemInfo, unit)` — use the named item at the given
+// unit's feet. For items whose on-use spell is ground-target (Iron
+// Grenade, demolition charges, etc.), bypasses the manual click on the
+// AoE reticle. `UseAtUnit(itemInfo, "target")` drops the reticle at
+// the target's position.
+//
+// Unit-position analog of `C_Item.UseAtCursor` — same bag-walk +
+// `FUN_ITEM_USE` dispatch, but the placement is committed at the
+// unit's world position (via `Spell::AtCursor::CommitAtCoords`)
+// instead of the cursor raycast.
+//
+// Returns `true` when the placement landed at the unit; `false` for
+// non-ground-target items (the item still fires, no implicit target),
+// unparseable input, item-not-in-bags, or an unresolvable unit.
+
+#include "Game.h"
+#include "Offsets.h"
+#include "item/Arg.h"
+#include "item/Location.h"
+#include "spell/AtCursor.h"
+#include "unit/Position.h"
+
+#include <cstdint>
+
+namespace Item::UseAtUnit {
+
+namespace {
+
+using UseItem_t = unsigned(__thiscall *)(const void *item, const uint64_t *targetGuid,
+                                          int flag);
+
+int __fastcall Script_C_Item_UseAtUnit(void *L) {
+    const auto arg = Item::Arg::Resolve(L, 1);
+    if (arg.itemID <= 0 && arg.name == nullptr) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    if (!Game::Lua::IsString(L, 2)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    const char *token = Game::Lua::ToString(L, 2);
+
+    // Resolve the unit position first — fail fast before firing the
+    // item if the unit is absent. (FindByArgInBags below stomps the
+    // Lua stack, so read the token argument before that runs.)
+    float pos[3];
+    if (!Unit::Position::ReadToken(token, pos)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+
+    Item::Location::ByGUIDResult found;
+    if (!Item::Location::FindByArgInBags(L, arg, &found)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+
+    const uint64_t zeroTarget = 0;
+    auto useItem = reinterpret_cast<UseItem_t>(Offsets::FUN_ITEM_USE);
+    useItem(found.item, &zeroTarget, 0);
+
+    const bool placed = Spell::AtCursor::CommitAtCoords(pos);
+    Game::Lua::PushBool(L, placed);
+    return 1;
+}
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterTableFunction("C_Item", "UseAtUnit",
+                                     &Script_C_Item_UseAtUnit);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace Item::UseAtUnit
@@ -111,10 +111,21 @@ void OnWorldTick() {

    const uint32_t flags = *reinterpret_cast<const uint32_t *>(
        ctrl + Offsets::OFF_UI_INPUT_FLAGS);
-    const bool moving        = (flags & Offsets::INPUT_FLAGS_MOVING_ANY) != 0;
    const bool freeLookHeld  = (flags & Offsets::INPUT_FLAG_FREE_LOOK) != 0;
    const bool mouselookHeld = (flags & Offsets::INPUT_FLAG_MOUSELOOK) != 0;

+    // MOVING — translational input. The WASD / autorun keys set the
+    // INPUT_FLAGS_MOVING_ANY bits directly. The "hold both mouse
+    // buttons to run forward" gesture does NOT: the engine drives that
+    // forward move at the movement layer (FUN_005103e0 from the button
+    // handler) and actually *clears* the autorun bit on the both-button
+    // press, so no MOVING_ANY bit is ever set. Detect it from the
+    // bit combo instead — both mouselook (RMB) and free-look (LMB)
+    // held means the engine is mouse-steering the character forward.
+    const bool mouseSteerMoving = mouselookHeld && freeLookHeld;
+    const bool moving =
+        (flags & Offsets::INPUT_FLAGS_MOVING_ANY) != 0 || mouseSteerMoving;
+
    // TURNING — latched bit-AND-rotation signal:
    //   STARTED fires when mouselook bit is held AND the body yaw
    //     changes (the first actual drag after pressing RMB).
@@ -0,0 +1,111 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `GetPhysicalScreenSize()` → (widthPixels, heightPixels) — the
+// display's physical resolution in pixels. Modern WoW added this as a
+// native in 7.0 (Legion); FrameXML's `PixelUtil` hangs its entire
+// pixel↔UI-unit conversion off it (`768.0 / physicalHeight`), which is
+// what lets addons snap frames to whole pixels.
+//
+// Vanilla 1.12 has no such native and no pre-parsed pixel-dimension
+// global — the engine only ever holds the current mode as the
+// `gxResolution` CVar string ("WIDTHxHEIGHT"). `Script_GetScreenWidth`
+// / `GetScreenHeight` return UI-space units (derived from the UIParent
+// aspect ratio at `[UIParent + 0x7c]`), not pixels, so they can't
+// serve. `SetScreenResolution` (`FUN_0048bfd0`) and the display-init
+// path both sscanf the `gxResolution` value on demand rather than
+// caching width/height anywhere — so the CVar string is the
+// authoritative current-resolution source, and we parse it the same
+// way the engine does.
+//
+// Returns 1024x768 (→ factor 1.0, i.e. 1 pixel == 1 UI unit, making
+// PixelUtil a no-op pass-through) when the CVar is missing or
+// unparseable. Caveat: in windowed mode `gxResolution` reflects the
+// configured render resolution, which may differ from the OS window's
+// client size — vanilla exposes no separate window-pixel query.
+
+#include "Game.h"
+#include "Offsets.h"
+
+#include <cstdint>
+
+namespace Screen::Info {
+
+namespace {
+
+using FindCVar_t = const uint8_t *(__fastcall *)(const char *name);
+
+// Parses "WIDTHxHEIGHT" (e.g. "1920x1080"). Tolerant of the separator
+// (any run of non-digits between the two numbers) so an uppercase 'X'
+// or stray spaces don't break it. Returns false unless both numbers
+// are present and positive.
+bool ParseResolution(const char *s, int *outW, int *outH) {
+    if (s == nullptr)
+        return false;
+
+    const char *p = s;
+    int w = 0;
+    bool gotW = false;
+    while (*p >= '0' && *p <= '9') {
+        w = w * 10 + (*p - '0');
+        ++p;
+        gotW = true;
+    }
+    if (!gotW)
+        return false;
+
+    while (*p != '\0' && (*p < '0' || *p > '9')) // skip the 'x' separator
+        ++p;
+
+    int h = 0;
+    bool gotH = false;
+    while (*p >= '0' && *p <= '9') {
+        h = h * 10 + (*p - '0');
+        ++p;
+        gotH = true;
+    }
+    if (!gotH || w <= 0 || h <= 0)
+        return false;
+
+    *outW = w;
+    *outH = h;
+    return true;
+}
+
+int __fastcall Script_GetPhysicalScreenSize(void *L) {
+    int width = 1024;
+    int height = 768; // fallback → 768/768 = factor 1.0 (no-op snapping)
+
+    auto findCVar = reinterpret_cast<FindCVar_t>(Offsets::FUN_FIND_CVAR);
+    const uint8_t *cvar = findCVar("gxResolution");
+    if (cvar != nullptr) {
+        const char *value = *reinterpret_cast<const char *const *>(
+            cvar + Offsets::OFF_CVAR_VALUE_STR);
+        ParseResolution(value, &width, &height);
+    }
+
+    Game::Lua::PushNumber(L, width);
+    Game::Lua::PushNumber(L, height);
+    return 2;
+}
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterGlobalFunction("GetPhysicalScreenSize",
+                                      &Script_GetPhysicalScreenSize);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+} // namespace
+
+} // namespace Screen::Info
@@ -70,9 +70,17 @@ void CancelPlacement() {
    fn();
 }

-} // namespace
+void Commit(const float coords[3]) {
+    auto commit = reinterpret_cast<CommitPlacementCoords_t>(
+        Offsets::FUN_COMMIT_PLACEMENT_COORDS);
+    commit(coords);
+}

-bool Resolve() {
+// Shared placement-readiness gate for both the cursor and explicit-
+// coords commit paths. Decision tree (preserved from the original
+// Resolve): no placement → false (no cancel); non-ground placement →
+// cancel + false; not in world → false; otherwise ready → true.
+bool PlacementReady() {
    const uint32_t state = *reinterpret_cast<const uint32_t *>(
        Offsets::VAR_SPELL_PLACEMENT_STATE);
    if (state == 0)
@@ -81,12 +89,25 @@ bool Resolve() {
    if ((state & Offsets::SPELL_PLACEMENT_GROUND_MASK) == 0) {
        // Spell wants a unit / item / corpse / etc. — not ground.
        // Cancel so the cursor recovers; caller learns via the false
-        // return that no cursor-placement happened.
+        // return that no placement happened.
        CancelPlacement();
        return false;
    }

-    if (!InWorld())
+    return InWorld();
+}
+
+} // namespace
+
+bool CommitAtCoords(const float coords[3]) {
+    if (!PlacementReady())
+        return false;
+    Commit(coords);
+    return true;
+}
+
+bool Resolve() {
+    if (!PlacementReady())
        return false;

    void *clickInfo = *reinterpret_cast<void *const *>(
@@ -114,9 +135,7 @@ bool Resolve() {
    const float *coords = reinterpret_cast<const float *>(
        static_cast<const uint8_t *>(clickInfo) + Offsets::OFF_CLICK_INFO_COORDS);

-    auto commit = reinterpret_cast<CommitPlacementCoords_t>(
-        Offsets::FUN_COMMIT_PLACEMENT_COORDS);
-    commit(coords);
+    Commit(coords);
    return true;
 }

@@ -126,16 +145,11 @@ using NameToSlot_t = int(__fastcall *)(const char *name, void *out);
 using CastDispatch_t = void(__fastcall *)(unsigned slot, int bookType,
                                           unsigned targetGuidLo, float targetGuidHi);

-int __fastcall Script_C_Spell_CastAtCursor(void *L) {
-    if (!Game::Lua::IsNumber(L, 1)) {
-        Game::Lua::PushBool(L, false);
-        return 1;
-    }
-    const int spellID = static_cast<int>(Game::Lua::ToNumber(L, 1));
-    if (spellID <= 0) {
-        Game::Lua::PushBool(L, false);
-        return 1;
-    }
+} // namespace
+
+bool DispatchSpellCast(int spellID) {
+    if (spellID <= 0)
+        return false;

    // Hand the spellID off as a numeric string — our `Spell::CastByID`
    // hook on `FUN_RESOLVE_SPELL_NAME_TO_SLOT` translates pure-numeric
@@ -148,17 +162,31 @@ int __fastcall Script_C_Spell_CastAtCursor(void *L) {
        Offsets::FUN_RESOLVE_SPELL_NAME_TO_SLOT);
    int bookType = 0;
    const int slot = nameToSlot(numBuf, &bookType);
-    if (slot < 0) {
-        // Spell not in the player's spellbook — can't cast it from
-        // here either way. Match `CastSpellByName`'s silent failure.
-        Game::Lua::PushBool(L, false);
-        return 1;
-    }
+    if (slot < 0)
+        return false; // not in the player's spellbook

    auto dispatch = reinterpret_cast<CastDispatch_t>(
        Offsets::FUN_SPELL_CAST_DISPATCH);
    dispatch(static_cast<unsigned>(slot), bookType,
             0, 0.0f); // no implicit target unit; engine handles placement
+    return true;
+}
+
+namespace {
+
+int __fastcall Script_C_Spell_CastAtCursor(void *L) {
+    if (!Game::Lua::IsNumber(L, 1)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    const int spellID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+
+    // Spell not in the player's spellbook → match `CastSpellByName`'s
+    // silent failure.
+    if (!DispatchSpellCast(spellID)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }

    const bool placed = Resolve();
    Game::Lua::PushBool(L, placed);
@@ -30,4 +30,22 @@ namespace Spell::AtCursor {
 // click-info struct pointer.
 bool Resolve();

+// Commits an in-flight ground-target placement at explicit world
+// coords (x, y, z) instead of the cursor raycast. Same placement
+// guards as `Resolve` (no placement active → false; non-ground
+// placement → cancel + false; not in world → false), but skips the
+// cursor entirely. Used by `C_Spell.CastAtUnit` / `C_Item.UseAtUnit`
+// to drop the reticle at a unit's feet. Returns true when the
+// placement was committed.
+bool CommitAtCoords(const float coords[3]);
+
+// Resolves a numeric `spellID` to a spellbook slot and dispatches the
+// cast through the engine — the shared front half of
+// `C_Spell.CastAtCursor` / `CastAtUnit`. For a ground-target spell
+// the engine enters placement mode (commit follows via `Resolve` /
+// `CommitAtCoords`); for a normal spell it fires immediately. Returns
+// true if the cast was dispatched (spell is in the player's
+// spellbook), false otherwise.
+bool DispatchSpellCast(int spellID);
+
 } // namespace Spell::AtCursor
@@ -0,0 +1,105 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+// `C_Spell.CastAtUnit(spellID, unit)` — cast a ground-target spell at
+// the given unit's feet, bypassing the manual click on the AoE
+// reticle. `CastAtUnit(spellID, "player")` drops it at the player's
+// position, `"target"` at the target's, etc.
+//
+// Same two-step shape as `C_Spell.CastAtCursor`, but the placement is
+// committed at the unit's world position instead of the cursor
+// raycast:
+//
+//   1. `Spell::AtCursor::DispatchSpellCast(spellID)` initiates the
+//      cast; the engine enters placement mode for a ground-target
+//      spell.
+//   2. Read the unit's world position (vtable `GetPosition`) and
+//      `Spell::AtCursor::CommitAtCoords()` commits the placement
+//      there.
+//
+// Returns `true` when the placement was committed at the unit; `false`
+// when the spell isn't ground-target (placement cancelled), the spell
+// isn't in the spellbook, or the unit has no resolvable position. The
+// cast itself still proceeds for non-ground spells, just with no
+// implicit target — matching `CastAtCursor`'s semantics.
+
+#include "Game.h"
+#include "spell/AtCursor.h"
+#include "spell/MacroPrimarySpell.h"
+#include "unit/Position.h"
+
+namespace Spell::AtUnit {
+
+namespace {
+
+int __fastcall Script_C_Spell_CastAtUnit(void *L) {
+    if (!Game::Lua::IsNumber(L, 1) || !Game::Lua::IsString(L, 2)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+    const int spellID = static_cast<int>(Game::Lua::ToNumber(L, 1));
+    const char *token = Game::Lua::ToString(L, 2);
+
+    // Resolve the unit's position before dispatching — fail fast so a
+    // bad/absent unit doesn't leave the engine sitting in placement
+    // mode. (A genuinely unrecognized token string raises the engine's
+    // standard "Unknown unit" error inside the resolver, same as
+    // `UnitHealth("garbage")`.)
+    float pos[3];
+    if (!Unit::Position::ReadToken(token, pos)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+
+    if (!Spell::AtCursor::DispatchSpellCast(spellID)) {
+        Game::Lua::PushBool(L, false);
+        return 1;
+    }
+
+    const bool placed = Spell::AtCursor::CommitAtCoords(pos);
+    Game::Lua::PushBool(L, placed);
+    return 1;
+}
+
+void RegisterLuaFunctions() {
+    Game::Lua::RegisterTableFunction("C_Spell", "CastAtUnit",
+                                     &Script_C_Spell_CastAtUnit);
+}
+
+const Game::ModuleAutoRegister _autoreg{&RegisterLuaFunctions};
+
+// Macro-parser pattern: tag macros calling
+// `C_Spell.CastAtUnit(<spellID>, ...)` with the spellID so action-bar
+// UIs highlight the slot. The first arg is the numeric spellID, so the
+// extractor just reads the leading numeric literal — same shape as
+// `CastAtCursor`'s.
+int ExtractCastAtUnitArg(const char *p, const char *end) {
+    while (p < end && (*p == ' ' || *p == '\t'))
+        ++p;
+    int value = 0;
+    const char *digitStart = p;
+    while (p < end && *p >= '0' && *p <= '9') {
+        if (value > 100000000) // sanity cap before overflow
+            return 0;
+        value = value * 10 + (*p - '0');
+        ++p;
+    }
+    return (p > digitStart && value > 0) ? value : 0;
+}
+
+const Spell::MacroPrimarySpell::PatternAutoRegister _patreg{
+    "C_Spell.CastAtUnit(", &ExtractCastAtUnitArg};
+
+} // namespace
+
+} // namespace Spell::AtUnit
@@ -0,0 +1,68 @@
+// This file is part of ClassicAPI.
+//
+// ClassicAPI is free software: you can redistribute it and/or modify it under the terms
+// of the GNU Lesser General Public License as published by the Free Software Foundation, either
+// version 3 of the License, or (at your option) any later version.
+//
+// ClassicAPI is distributed in the hope that it will be useful, but WITHOUT ANY
+// WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
+// PURPOSE. See the GNU Lesser General Public License for more details.
+//
+// You should have received a copy of the GNU Lesser General Public License along with
+// ClassicAPI. If not, see <https://www.gnu.org/licenses/>.
+
+#pragma once
+
+#include "Offsets.h"
+
+// Shared world-position read for any CGObject-derived unit. The
+// position comes from the object's `GetPosition` virtual (vtable
+// slot 5) — the same one `CheckInteractDistance` / `UnitInRange` use.
+// Header-only so callers (UnitInRange, CastAtUnit, UseAtUnit) don't
+// each re-derive the vtable-slot math.
+
+namespace Unit::Position {
+
+// Resolves a unit token ("player", "target", "party1", "mouseover",
+// …) to a `CGUnit *`. Returns nullptr for a recognized-but-absent
+// token (e.g. "party5" with no such member). NOTE: the engine's
+// resolver raises a Lua error for genuinely unrecognized token
+// strings — same contract as `UnitHealth("garbage")` — so only feed
+// it real unit tokens, or strings you're willing to let error.
+inline void *ResolveToken(const char *token) {
+    if (token == nullptr)
+        return nullptr;
+    using ResolveUnitToken_t = void *(__fastcall *)(const char *);
+    auto fn = reinterpret_cast<ResolveUnitToken_t>(Offsets::FUN_RESOLVE_UNIT_TOKEN);
+    return fn(token);
+}
+
+// Reads `obj`'s world position into `out[3]` (x, y, z). Calls
+// `obj->vtable[5](outBuf)`; the returned float* may equal `outBuf`
+// (object filled it) or point at a cached position field — either
+// way the values land in `out`. Returns false if `obj` is null or
+// the virtual yields no position (object has no known position yet).
+inline bool Read(void *obj, float out[3]) {
+    if (obj == nullptr)
+        return false;
+    auto **vtable = *reinterpret_cast<void ***>(obj);
+    using GetPosition_t = float *(__thiscall *)(void *self, float outBuf[3]);
+    auto fn = reinterpret_cast<GetPosition_t>(
+        vtable[Offsets::OFF_CGOBJECT_VTBL_GET_POSITION / 4]);
+    float *p = fn(obj, out);
+    if (p == nullptr)
+        return false;
+    if (p != out) {
+        out[0] = p[0];
+        out[1] = p[1];
+        out[2] = p[2];
+    }
+    return true;
+}
+
+// Convenience: resolve a token and read its position in one step.
+inline bool ReadToken(const char *token, float out[3]) {
+    return Read(ResolveToken(token), out);
+}
+
+} // namespace Unit::Position
@@ -15,42 +15,17 @@
 // uses, applied with a fixed 40-yard threshold.

 #include "Game.h"
-#include "Offsets.h"
+#include "unit/Position.h"

-#include <cstdint>
 #include <cstring>

 namespace Unit::Range {

 namespace {

-using ResolveUnitToken_t = void *(__fastcall *)(const char *token);
-using GetPosition_t = float *(__thiscall *)(void *self, float outBuf[3]);
-
 constexpr float kRangeYards = 40.0f;
 constexpr float kRangeYardsSq = kRangeYards * kRangeYards;

-void *ResolveUnit(const char *token) {
-    if (token == nullptr)
-        return nullptr;
-    auto fn = reinterpret_cast<ResolveUnitToken_t>(Offsets::FUN_RESOLVE_UNIT_TOKEN);
-    return fn(token);
-}
-
-// Calls `obj->vtable[5](outBuf)`. The returned float* may equal
-// outBuf (the object filled it directly) or point at a cached
-// position field on the object — either way, deref it for x/y/z.
-// Returns nullptr if the object's vtable virtual returns null (no
-// known position for this object yet).
-float *ReadPosition(void *obj, float outBuf[3]) {
-    if (obj == nullptr)
-        return nullptr;
-    auto **vtable = *reinterpret_cast<void ***>(obj);
-    auto fn = reinterpret_cast<GetPosition_t>(
-        vtable[Offsets::OFF_CGOBJECT_VTBL_GET_POSITION / 4]);
-    return fn(obj, outBuf);
-}
-
 int __fastcall Script_UnitInRange(void *L) {
    if (!Game::Lua::IsString(L, 1)) {
        Game::Lua::Error(L, "Usage: UnitInRange(\"unit\")");
@@ -69,19 +44,10 @@ int __fastcall Script_UnitInRange(void *L) {
        return 2;
    }

-    void *unit = ResolveUnit(token);
-    void *player = ResolveUnit("player");
-    if (unit == nullptr || player == nullptr) {
-        Game::Lua::PushBool(L, false);
-        Game::Lua::PushBool(L, false);
-        return 2;
-    }
-
-    float unitBuf[3] = {};
-    float playerBuf[3] = {};
-    const float *unitPos = ReadPosition(unit, unitBuf);
-    const float *playerPos = ReadPosition(player, playerBuf);
-    if (unitPos == nullptr || playerPos == nullptr) {
+    float unitPos[3] = {};
+    float playerPos[3] = {};
+    if (!Unit::Position::ReadToken(token, unitPos) ||
+        !Unit::Position::ReadToken("player", playerPos)) {
        Game::Lua::PushBool(L, false);
        Game::Lua::PushBool(L, false);
        return 2;
Author	SHA1	Message	Date
Brues	17f44f93f8	Add C_Item.GetEnchantInfo(enchantID) Resolves an item-enchantment ID (the enchantID from C_Item.GetWeaponEnchantInfo, and item permanent-enchant IDs) into its SpellItemEnchantment.dbc record: { enchantID, name, effects = {{type,amount,arg},...}, spellID } - name: localized display name ("Crusader", "Brilliant Mana Oil"). - effects: each active slot's ITEM_ENCHANTMENT_TYPE / amount / arg. - spellID: convenience for spell-type enchants (1/3/7) — the proc/ equip/use spellID, e.g. Crusader -> 20007 "Holy Strength", to chain into C_Spell.GetSpellDescription. Record layout verified by parsing the on-disk DBC against known records (Crusader 1900: type 1, arg 20007; Sharpened+3 id 13: type 2, amount 3; Reinforced Armor+8 id 15: type 4, amount 8): Type[3]@+0x04, Amount[3]@+0x10, EffectArg[3]@+0x28, Name[8]@+0x34. The engine's by-ID readers only touch name/flags/condition, so the effect columns couldn't be pinned from disassembly — the extracted dbc/ dump was the oracle. Verified in-game across all three example enchants. Placed in C_Item (not C_Spell): the id originates from C_Item.GetWeaponEnchantInfo and the concept is an item enchantment. Source-item is not derivable (no back-reference, no client reverse index).	2026-06-23 02:00:52 -05:00
Brues	73d90107b0	Drop the redundant registration latch The console registrar (FUN_0063F9E0) dedups by name, and we pass the same string literal so its pointer-equality fast path makes a repeat call a hard no-op. Verified in-game: after a logout→login cycle (which re-fires the glue hook), ExportInterfaceFiles stays listed once in `help debug` and still runs. The static latch was unnecessary.	2026-06-22 22:52:16 -05:00
Brues	ed389591ac	Register ExportInterfaceFiles once, at glue boot Console commands are process-global and persist for the session, so a single registration at glue boot (the earliest hook, fires at launch) covers both the login console and in-world — confirmed in-game. Drop the redundant in-game ModuleAutoRegister; it only ever hit the latch.	2026-06-22 22:45:17 -05:00
Brues	1867262cd9	Export Blizzard addons under Interface\AddOns The AddOns\ skip dropped Blizzard's own MPQ-baked UI addons (Blizzard_AuctionUI, Blizzard_TalentUI, …) — part of the stock UI source. Loose on-disk addons are never in an archive listfile, so nothing surfaces them (verified: both branches of FUN_00401470 walk MPQ listfiles / an in-memory registered-file list, not the loose disk dir); the skip was both wrong and unnecessary. Matches 4.3.4 (extension filter only, no path exclusion).	2026-06-22 22:38:05 -05:00
Brues	9b21f983b3	Add ExportInterfaceFiles console command Backport of the 4.3.4 developer-console command: dumps Blizzard's UI files out of the mounted MPQs to disk (`ExportInterfaceFiles code` writes .lua/.xml/.toc/.xsd to BlizzardInterfaceCode\; `art` writes .blp/.tga to BlizzardInterfaceArt\), preserving the Interface\ subtree and skipping the user's own AddOns\. - New src/interface/Export.cpp: enumerates each archive's (listfile) via the MPQ walker FUN_00401470, reads each entry through FUN_FILE_READ, and writes it out with Win32. - New generic Game::Console facility (RegisterCommand / Write / Category enum) wrapping the engine's console-command registrar and output paths, so future commands register in one line. - Offsets.h: FUN_MPQ_ENUM_FILES, FUN_CONSOLE_COMMAND_REGISTER, FUN_CONSOLE_WRITE; corrected FUN_FILE_READ to __stdcall and documented its archive-handle arg0. - Docs: README "Console commands" section + docs/API.md "Console" entry.	2026-06-22 21:51:42 -05:00
Brues	3b729f08cb	cleanup	2026-06-22 20:57:42 -05:00
Brues	cdb3faa982	caching player guid	2026-06-22 18:55:20 -05:00
Brues	bb79311556	add github repo to toc	2026-06-22 15:16:19 -05:00
Brues	e881e18720	Fire PLAYER_STARTED_MOVING for both-mouse-button run Holding both mouse buttons to run forward never fired PLAYER_STARTED_MOVING. Ghidra trace of the input button handler (FUN_00514840) shows that gesture drives the forward move directly at the movement layer (FUN_005103e0) and explicitly clears the autorun bit on the both-button press — so it sets none of the INPUT_FLAGS_MOVING_ANY bits the mover-detection reads. (The Offsets.h comment claiming the both-button combo sets autorun was wrong; corrected.) Detect it from the bit combo instead: both INPUT_FLAG_MOUSELOOK (RMB) and INPUT_FLAG_FREE_LOOK (LMB) held means the engine is mouse-steering the character forward. ORed into `moving`. Composes cleanly with the TURNING/LOOKING latches (unchanged).	2026-06-22 12:51:30 -05:00
Brues	ba4520493a	Stop clobbering native FrameXML time globals; sort enUS locale Stock 1.12.1 already defines DAYS_ABBR/HOURS_ABBR/MINUTES_ABBR/ SECONDS_ABBR (bare labels: "Day"/"Hr"/"Min"/"Sec") and the four *_ONELETTER_ABBR. Our enUS.lua loads after FrameXML, so redefining them with the modern "%d \|4Day:Days;" format silently overwrote the native values and broke any native/other-addon code reading the bare labels. Remove those redefinitions from enUS.lua (keep only the strings stock genuinely lacks), and drop SecondsToTime / SecondsToTimeAbbrev / FormatUnit from TimeUtil — they were the only consumers of the modern-format _ABBR strings. SecondsToClock stays (uses the stock-missing HOURS_MINUTES_SECONDS / MINUTES_SECONDS). Remaining enUS entries sorted, all still have live consumers.	2026-06-22 12:19:26 -05:00
Brues	dc80ade21b	Add native GetPhysicalScreenSize + PixelUtil backport `GetPhysicalScreenSize()` → (widthPixels, heightPixels). Modern WoW added this native in 7.0; FrameXML's PixelUtil builds its entire pixel↔UI-unit conversion on it (768/physicalHeight). 1.12 lacks it and has no pre-parsed pixel-dimension global — GetScreenWidth/Height are UI-space (UIParent aspect at [UIParent+0x7c]), and the engine only holds the current mode as the gxResolution CVar string, sscanf'd on demand by SetScreenResolution / display-init. So the native reads the gxResolution CVar directly (FUN_FIND_CVAR, value at +0x20) and parses "WIDTHxHEIGHT" — the same source pfUI's GetPerfectPixel uses. Verified in-game: 2560x1080. 7.0 was the only binary exposing the function, but retail .text is encrypted on disk so static decompilation yields garbage; derived the implementation from the 1.12 binary instead. Also backports FrameXML/PixelUtil.lua (SetPoint/SetSize/SetWidth/ SetHeight/SetStatusBarValue/Get*). Its math deps (Round/Lerp/ ClampedPercentageBetween) already live in MathUtil; it consumes the native GetPhysicalScreenSize (no Lua polyfill).	2026-06-22 00:04:17 -05:00
Brues	6addd6d5b1	Add CastAtUnit / UseAtUnit — ground-target placement at a unit's feet `C_Spell.CastAtUnit(spellID, unit)` and `C_Item.UseAtUnit(itemInfo, unit)` are the unit-position analogs of the existing `…AtCursor` pair: they commit the engine's in-flight ground-target placement at the resolved unit's world position instead of the cursor raycast. ClassicAPI's `/cast [@unit]` / `[@unit]` for AoE reticle spells and on-use items. Verified in-game against "player", "target", and "nameplate1". Implementation reuses the cursor path's placement primitives: - Extracted `Spell::AtCursor::DispatchSpellCast` + `CommitAtCoords` (explicit-coords commit, sharing the same placement-ready gate as the cursor `Resolve`). - New header-only `Unit::Position` (vtable slot-5 `GetPosition` read); migrated `UnitInRange` onto it to drop the duplicate copy. The unit is resolved before the cast/use is dispatched, so an absent unit fails cleanly without arming placement mode or consuming the item. Unknown token strings raise the engine's standard "Unknown unit" error, matching `UnitHealth("garbage")`.	2026-06-21 23:36:19 -05:00