Files
DmorphOcto/DmorphOcto.lua
T
Claude bff37f399f DMorph 2.0.0: weapon glows and real skin, face and hair (DmorphHelper)
VanillaHelpers can't change a weapon's enchant glow or your own skin,
face and hair, so DMorph now ships a small optional DLL for that.

- helper/DmorphHelper.dll (C, MinGW, MinHook): adds DmorphHelper_Get/
  SetItemEnchants and DmorphHelper_Get/SetLook. It uses VanillaHelpers'
  own game addresses and only switches on when it finds VanillaHelpers'
  hooks at two of them; otherwise it does nothing.
- tools/install_helper.ps1 puts it in the game folder and dlls.txt
  (after VanillaHelpers.dll, with a backup); -Remove takes it out.
- tools/build_options.ps1 (run by update_from_game.ps1) reads every
  enchant glow and every skin colour, face, hair style, hair colour and
  facial hair from the game's own tables into Data/Glows.lua and
  Data/CharOptions.lua, checking the columns and the files first.
- New Glows tab: pick main hand, off hand or ranged, search, click a
  glow; No glow / My own glow. Also .glow (.enchant).
- Races: with the helper, the first five rows change your model's real
  skin, face and hair one at a time, with your gear showing. A row whose
  value doesn't go with another moves that one to the closest value and
  says so. Each race keeps its own picked look; NPC looks stay as a row.
- Picked glows and looks are put back within a second after the server
  resends the real ones, survive /reload, and are saved in outfits.
- Tests: a fake DmorphHelper and the fake game's tables (344 checks).

Not tried in game yet: the helper has only been built and checked here.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_017nTJ1LNa66vwpT5UiEtvM8
2026-10-11 08:52:15 +00:00

2351 lines
67 KiB
Lua

-- DMorph for OctoWoW: morph state, wardrobe, catalogue search and the chat
-- commands. The window lives in UI.lua and calls the same DmorphOcto.*
-- functions as the commands.
--
-- DMorph itself is a DLL built for WotLK 3.3.5a (build 12340) with that
-- client's addresses hardcoded, so it can't run on OctoWoW's 1.12.1 client.
-- This addon drives the morph API of VanillaHelpers.dll (v1.1.0+) instead:
-- OctoLauncher ships it as the "vanillaHelpers" mod and it is built for the
-- 1.12.1 client.
--
-- The client runs Lua 5.0: no #, no %, no string.match, no select(), and
-- table.getn() counts element by element, so long lists keep their own count.
local VERSION = "2.0.0"
local PREFIX = "|cff33ff99DMorph|r: "
local MISSING_API = "VanillaHelpers v1.1.0 or newer is not loaded, so morphing is unavailable. "
.. "Enable the 'vanillaHelpers' mod in OctoLauncher (or add VanillaHelpers.dll to dlls.txt) "
.. "and restart the game."
-- Player model display IDs, indexed by race ID. VanillaHelpers recognises
-- exactly these and rewrites race and gender as well, so your own skin, face
-- and hair carry over. Race 10 is the High Elf on Turtle-based clients.
local RACES = {
{ name = "Human", male = 49, female = 50 },
{ name = "Orc", male = 51, female = 52 },
{ name = "Dwarf", male = 53, female = 54 },
{ name = "Night Elf", male = 55, female = 56 },
{ name = "Undead", male = 57, female = 58 },
{ name = "Tauren", male = 59, female = 60 },
{ name = "Gnome", male = 1563, female = 1564 },
{ name = "Troll", male = 1478, female = 1479 },
{ name = "Goblin", male = 6894, female = 6895 },
{ name = "High Elf", male = 15476, female = 15475 },
}
local RACE_ALIASES = {
human = 1, orc = 2, dwarf = 3, nightelf = 4, ne = 4, undead = 5, scourge = 5,
forsaken = 5, tauren = 6, gnome = 7, troll = 8, goblin = 9, highelf = 10,
bloodelf = 10,
}
-- UnitRace() file tokens, only used when the native model isn't in RACES.
local RACE_TOKENS = {
HUMAN = 1, ORC = 2, DWARF = 3, NIGHTELF = 4, SCOURGE = 5, TAUREN = 6,
GNOME = 7, TROLL = 8, GOBLIN = 9, HIGHELF = 10, BLOODELF = 10,
}
-- Inventory slots that show on the character model, numbered like DMorph
-- and GetInventorySlotInfo(). Neck, rings and trinkets have no model.
local SLOT_ORDER = { 1, 3, 4, 5, 6, 7, 8, 9, 10, 15, 16, 17, 18, 19 }
local SLOT_NAMES = {
[1] = "Head", [3] = "Shoulder", [4] = "Shirt", [5] = "Chest", [6] = "Waist",
[7] = "Legs", [8] = "Feet", [9] = "Wrist", [10] = "Hands", [15] = "Back",
[16] = "Main hand", [17] = "Off hand", [18] = "Ranged", [19] = "Tabard",
}
-- The slots whose enchant glow DmorphHelper can change.
local GLOW_SLOT = { [16] = true, [17] = true, [18] = true }
local SLOT_ALIASES = {
head = 1, shoulder = 3, shoulders = 3, shirt = 4, chest = 5, waist = 6,
belt = 6, legs = 7, feet = 8, boots = 8, wrist = 9, wrists = 9, hands = 10,
gloves = 10, back = 15, cloak = 15, mainhand = 16, offhand = 17,
ranged = 18, tabard = 19,
}
DmorphOcto = {
VERSION = VERSION,
MISSING_API = MISSING_API,
RACES = RACES,
SLOT_ORDER = SLOT_ORDER,
SLOT_NAMES = SLOT_NAMES,
GLOW_SLOTS = { 16, 17, 18 },
}
local M = DmorphOcto
-- An outfit is { display, race, gender (0 male, 1 female), items[slot] }.
local db -- DmorphOctoDB, per character: the outfit currently applied
local account -- DmorphOctoAccount, shared: saved outfits and the minimap button
local nativeRace, nativeGender
local sessionReady = false
local warnedMissingAPI = false
local pendingApply
local listeners = {}
local creatures
local items = {}
local sets
local looks = {}
local InitDB -- defined under State; the catalogue needs it first
local function Print(msg)
DEFAULT_CHAT_FRAME:AddMessage(PREFIX .. msg)
end
local function Report(ok, message)
Print(message)
end
local function HasMorphAPI()
return type(SetUnitDisplayID) == "function"
and type(SetUnitVisibleItemID) == "function"
and type(UnitDisplayInfo) == "function"
end
M.HasMorphAPI = HasMorphAPI
-- VanillaHelpers reports bad input with lua_error, so every call is guarded.
-- A nil value clears that override.
local function Morph(fn, a1, a2, a3)
return pcall(fn, a1, a2, a3)
end
local function ParseID(text)
local n = tonumber(text or "")
if n and n >= 0 and n <= 2147483647 and n == math.floor(n) then
return n
end
end
M.ParseID = ParseID
local function Trim(text)
local _, _, trimmed = strfind(text or "", "^%s*(.-)%s*$")
return trimmed
end
local function RaceModel(race, gender)
if gender == 1 then
return RACES[race].female
end
return RACES[race].male
end
function M.DescribeBody(race, gender)
if gender == 1 then
return RACES[race].name .. " female"
end
return RACES[race].name .. " male"
end
local function RaceList()
local list = ""
for race = 1, table.getn(RACES) do
list = list .. ", " .. race .. " " .. RACES[race].name
end
return strsub(list, 3)
end
local function SlotList()
local list = ""
for i = 1, table.getn(SLOT_ORDER) do
local slot = SLOT_ORDER[i]
list = list .. ", " .. slot .. " " .. strlower(SLOT_NAMES[slot])
end
return strsub(list, 3)
end
-- Catalogue -----------------------------------------------------------------
-- Data/*.lua hold the catalogue as text so the game loads it quickly; each
-- list is parsed the first time it's needed. An entry is
-- { id, name, lowercase name, quality, kind }.
local function NewCatalog()
return { ids = {}, names = {}, lower = {}, quality = {}, kind = {}, byID = {}, count = 0 }
end
local function AddEntry(catalog, id, name, quality, kind)
local n = catalog.count + 1
catalog.count = n
catalog.ids[n], catalog.names[n], catalog.lower[n] = id, name, strlower(name)
catalog.quality[n], catalog.kind[n] = quality, kind
if not catalog.byID[id] then
catalog.byID[id] = n
end
end
local function Before(a, b)
return a[3] < b[3] or (a[3] == b[3] and a[1] < b[1])
end
-- Merges two name-sorted lists. The data files are sorted the way Lua
-- compares strings, so this is one pass.
local function Merge(a, n, b, m)
local out, k, i, j = {}, 0, 1, 1
while i <= n or j <= m do
local x, y = a[i], b[j]
if not y or (x and not Before(y, x)) then
i = i + 1
else
x, j = y, j + 1
end
k = k + 1
out[k] = x
end
return out, k
end
local function Fill(catalog, list, count)
for i = 1, count do
local e = list[i]
AddEntry(catalog, e[1], e[2], e[4], e[5])
end
return catalog
end
-- Creature models by kind: a creature's name, or named after the model file;
-- 2 and 3 are the same for the models OctoWoW added to the stock 1.12.1 client.
M.KIND_CREATURE, M.KIND_MODEL, M.KIND_NEW, M.KIND_NEW_MODEL = 0, 1, 2, 3
M.MODEL_FILTERS = {
{ text = "All models" },
{ text = "Creatures", kinds = { [0] = true, [2] = true } },
{ text = "Bosses", tag = "boss" },
{ text = "Rare creatures", tag = "rare" },
{ text = "Mounts", tag = "mount" },
{ text = "Other models", kinds = { [1] = true, [3] = true } },
{ text = "New in OctoWoW", kinds = { [2] = true, [3] = true } },
}
-- Items and sets are kind 0 (stock 1.12.1) or 2 (added by Turtle WoW / OctoWoW).
M.ITEM_FILTERS = {
{ text = "All items" },
{ text = "1.12 items", kinds = { [0] = true } },
{ text = "New in OctoWoW", kinds = { [2] = true } },
}
M.SET_FILTERS = {
{ text = "All sets" },
{ text = "1.12 sets", kinds = { [0] = true } },
{ text = "New in OctoWoW", kinds = { [2] = true } },
}
-- Item and set quality, as GetItemInfo() numbers it.
M.QUALITY_FILTERS = {
{ text = "Any quality" },
{ text = "Poor", quality = 0 },
{ text = "Common", quality = 1 },
{ text = "Uncommon", quality = 2 },
{ text = "Rare", quality = 3 },
{ text = "Epic", quality = 4 },
{ text = "Legendary", quality = 5 },
}
-- Display and item IDs that can't show in this client: Data/HiddenModels.lua
-- and Data/HiddenItems.lua, written by tools/build_models.ps1 and
-- tools/build_items.ps1 from the game's own files.
local hiddenModels, hiddenItems
local function ReadIDs(text)
local set = {}
for id in string.gfind(text or "", "%d+") do
set[tonumber(id)] = true
end
return set
end
local function HiddenModels()
if not hiddenModels then
hiddenModels = ReadIDs(DmorphOcto_HiddenModels)
DmorphOcto_HiddenModels = nil
end
return hiddenModels
end
local function HiddenItems()
if not hiddenItems then
hiddenItems = ReadIDs(DmorphOcto_HiddenItems)
DmorphOcto_HiddenItems = nil
end
return hiddenItems
end
-- Creatures.lua (named creatures) and Models.lua (every other display ID the
-- client has) together list every model, less the ones that can't show.
function M.GetCreatureCatalog()
if creatures then
return creatures
end
local hidden = HiddenModels()
local named, other, n, m = {}, {}, 0, 0
for id, name in string.gfind(DmorphOcto_CreatureData or "", "(%d+)\t([^\r\n]+)") do
id = tonumber(id)
if not hidden[id] then
n = n + 1
named[n] = { id, name, strlower(name), 0, M.KIND_CREATURE }
end
end
for id, kind, name in string.gfind(DmorphOcto_ModelData or "", "(%d+)\t(%d)\t([^\r\n]+)") do
id = tonumber(id)
if not hidden[id] then
m = m + 1
other[m] = { id, name, strlower(name), 0, tonumber(kind) }
end
end
DmorphOcto_CreatureData, DmorphOcto_ModelData = nil, nil -- the parsed tables replace the text
creatures = Fill(NewCatalog(), Merge(named, n, other, m))
-- Tags for the filters: bosses and rares by display and name, mounts by
-- display. Data/ModelTags.lua (OctoWoW's client and Turtle WoW's ranks) and
-- Data/ClassicTags.lua (the 1.12.1 database); a boss stays a boss.
local byName, mounts = {}, {}
for _, text in ipairs({ DmorphOcto_TagData or "", DmorphOcto_ClassicTagData or "" }) do
for id, tag, name in string.gfind(text, "(%d+)\t(%a+)\t([^\r\n]*)") do
if tag == "mount" then
mounts[tonumber(id)] = true
else
local key = id .. "\t" .. strlower(name)
if byName[key] ~= "boss" then
byName[key] = tag
end
end
end
end
DmorphOcto_TagData, DmorphOcto_ClassicTagData = nil, nil
creatures.tags = {}
for i = 1, creatures.count do
local tag = byName[creatures.ids[i] .. "\t" .. creatures.lower[i]]
if mounts[creatures.ids[i]] then
tag = (tag and (tag .. " ") or "") .. "mount"
end
creatures.tags[i] = tag
end
return creatures
end
-- Inventory slots by the INVTYPE_ name GetItemInfo() returns.
local EQUIP_SLOTS = {
INVTYPE_HEAD = { 1 }, INVTYPE_SHOULDER = { 3 }, INVTYPE_BODY = { 4 }, INVTYPE_CHEST = { 5 },
INVTYPE_ROBE = { 5 }, INVTYPE_WAIST = { 6 }, INVTYPE_LEGS = { 7 }, INVTYPE_FEET = { 8 },
INVTYPE_WRIST = { 9 }, INVTYPE_HAND = { 10 }, INVTYPE_CLOAK = { 15 }, INVTYPE_TABARD = { 19 },
INVTYPE_WEAPON = { 16, 17 }, INVTYPE_2HWEAPON = { 16 }, INVTYPE_WEAPONMAINHAND = { 16 },
INVTYPE_SHIELD = { 17 }, INVTYPE_WEAPONOFFHAND = { 17 }, INVTYPE_HOLDABLE = { 17 },
INVTYPE_RANGED = { 18 }, INVTYPE_THROWN = { 18 }, INVTYPE_RANGEDRIGHT = { 18 },
}
local function ParseItems(text, kind, list, n, skip)
local hidden = HiddenItems()
for id, quality, name in string.gfind(text or "", "(%d+)\t(%d)\t([^\r\n]+)") do
id = tonumber(id)
if not ((skip and skip[id]) or hidden[id]) then
n = n + 1
list[n] = { id, name, strlower(name), tonumber(quality), kind }
end
end
return list, n
end
-- Items the game told us about in this or an earlier session (see Item
-- lookup), saved as DmorphOctoAccount.itemInfo[id] = "slots<TAB>quality<TAB>name".
local function LearnedItems(slot, skip)
local list, n, hidden = {}, 0, HiddenItems()
for id, info in pairs(account.itemInfo) do
if info and not skip[id] and not hidden[id] then
local _, _, slots, quality, name = strfind(info, "^([%d,]+)\t(%-?%d+)\t(.+)$")
if slots and strfind("," .. slots .. ",", "," .. slot .. ",", 1, true) then
n = n + 1
list[n] = { id, name, strlower(name), tonumber(quality), M.KIND_NEW }
end
end
end
table.sort(list, Before)
return list, n
end
-- Every item that fits the slot: Items.lua (the 1.12.1 database), then
-- ItemsExtra.lua (Turtle WoW and OctoWoW) and the items looked up in game.
function M.GetItemCatalog(slot)
if not items[slot] then
InitDB()
local base, n = ParseItems(DmorphOcto_ItemData and DmorphOcto_ItemData[slot], 0, {}, 0)
local seen = {}
for i = 1, n do
seen[base[i][1]] = true
end
local extra, m = ParseItems(DmorphOcto_ItemExtra and DmorphOcto_ItemExtra[slot], M.KIND_NEW, {}, 0, seen)
for i = 1, m do
seen[extra[i][1]] = true
end
local learned, k = LearnedItems(slot, seen)
local both, count = Merge(base, n, extra, m)
items[slot] = Fill(NewCatalog(), Merge(both, count, learned, k))
end
return items[slot]
end
-- The slots an item can be morphed into, or nil if it isn't known.
local itemSlots
function M.GetItemSlots(itemID)
if not itemSlots then
itemSlots = {}
for i = 1, table.getn(SLOT_ORDER) do
local slot = SLOT_ORDER[i]
for id in pairs(M.GetItemCatalog(slot).byID) do
local list = itemSlots[id]
if not list then
list = {}
itemSlots[id] = list
end
table.insert(list, slot)
end
end
end
return itemSlots[itemID]
end
-- Item lists are rebuilt the next time they're needed (after a lookup).
local function ForgetItemLists()
items, itemSlots = {}, nil
if sets then
sets.qualityKnown = nil
end
end
-- An item's quality from the item lists, or nil.
local function ItemQuality(itemID)
local slots = M.GetItemSlots(itemID)
if slots then
local catalog = M.GetItemCatalog(slots[1])
return catalog.quality[catalog.byID[itemID]]
end
end
-- Every item set in the client, with the pieces that show on a character. A
-- set's quality is that of its best known piece.
function M.GetSetCatalog()
if not sets then
sets = NewCatalog()
sets.pieces = {}
for id, kind, name, list in string.gfind(DmorphOcto_SetData or "", "(%d+)\t(%d)\t([^\t\r\n]+)\t([%d,]+)") do
AddEntry(sets, tonumber(id), name, nil, tonumber(kind))
local pieces = {}
for piece in string.gfind(list, "%d+") do
table.insert(pieces, tonumber(piece))
end
sets.pieces[sets.count] = pieces
end
DmorphOcto_SetData = nil
end
if not sets.qualityKnown then
sets.qualityKnown = true
for i = 1, sets.count do
local best
for k = 1, table.getn(sets.pieces[i]) do
local quality = ItemQuality(sets.pieces[i][k])
if quality and (not best or quality > best) then
best = quality
end
end
sets.quality[i] = best
end
end
return sets
end
-- The game's dressed NPCs of a race and gender (Data/Looks.lua), the fewest
-- clothes first. Each look is { displayID, skin, face, hair style, hair
-- colour, facial hair, pieces of clothing, outfit number }.
function M.GetLooks(race, gender)
local key = race .. ":" .. gender
if not looks[key] then
local list, n, hidden = {}, 0, HiddenModels()
local text = DmorphOcto_LookData and DmorphOcto_LookData[key] or ""
for a, b, c, d, e, f, g, h in string.gfind(text, "(%d+),(%d+),(%d+),(%d+),(%d+),(%d+),(%d+),(%d+)") do
if not hidden[tonumber(a)] then
n = n + 1
list[n] = { tonumber(a), tonumber(b), tonumber(c), tonumber(d), tonumber(e), tonumber(f), tonumber(g), tonumber(h) }
end
end
looks[key] = list
end
return looks[key]
end
-- The character creator's rows and the look field each one reads. NPC looks
-- are fixed combinations, so a row's < > goes to the next value some NPC of
-- that race has, in the look that keeps the most of the other rows.
M.LOOK_FEATURES = { "Skin colour", "Face", "Hair style", "Hair colour", "Facial hair", "Outfit" }
local LOOK_FIELDS = { 2, 3, 4, 5, 6, 8 }
-- What keeping each row is worth when another one changes. Each outweighs
-- all the ones below it: skin colour, hair style, hair colour, face, facial
-- hair, outfit.
local FEATURE_WEIGHTS = { 32, 4, 16, 8, 2, 1 }
-- The values row f (1-6) has among a race and gender's looks, sorted.
function M.GetLookValues(race, gender, f)
local list = M.GetLooks(race, gender)
local field = LOOK_FIELDS[f]
local seen, values = {}, {}
for k = 1, table.getn(list) do
local v = list[k][field]
if not seen[v] then
seen[v] = true
table.insert(values, v)
end
end
table.sort(values)
return values
end
-- Row f's value in a look.
function M.LookValue(look, f)
return look[LOOK_FIELDS[f]]
end
-- The position of the look that has `value` in row f and keeps the most of
-- look `from`'s other rows (then the most similar clothes), or nil.
function M.FindLook(race, gender, f, value, from)
local list = M.GetLooks(race, gender)
local field, want = LOOK_FIELDS[f], list[from]
local best, bestScore
for k = 1, table.getn(list) do
local look = list[k]
if look[field] == value then
local keep, pieces = 0, 0
if want then
for g = 1, 6 do
if g ~= f and look[LOOK_FIELDS[g]] == want[LOOK_FIELDS[g]] then
keep = keep + FEATURE_WEIGHTS[g]
end
end
pieces = math.abs(look[7] - want[7])
end
local score = keep * 1000 - pieces * 20 - look[7]
if not best or score > bestScore then
best, bestScore = k, score
end
end
end
return best
end
-- Every value of row f and, for each, the look FindLook picks from look `from`.
function M.GetLookChoices(race, gender, f, from)
local values, at = M.GetLookValues(race, gender, f), {}
for i = 1, table.getn(values) do
at[values[i]] = M.FindLook(race, gender, f, values[i], from)
end
return values, at
end
-- Row f of look `from` one value along (step 1 or -1, wrapping around). Returns
-- the new look's position, its place among the row's values, how many values
-- there are, and the other rows that had to change with it ({} if none); or
-- nil when every NPC of the race has the same value.
function M.StepLook(race, gender, f, from, step)
local list = M.GetLooks(race, gender)
local values = M.GetLookValues(race, gender, f)
local n, cur = table.getn(values), list[from]
if n < 2 or not cur then
return nil
end
local pos = 1
for i = 1, n do
if values[i] == cur[LOOK_FIELDS[f]] then
pos = i
end
end
pos = math.mod(pos - 1 + step + n, n) + 1
local k = M.FindLook(race, gender, f, values[pos], from)
local changed = {}
for g = 1, 6 do
if g ~= f and list[k][LOOK_FIELDS[g]] ~= cur[LOOK_FIELDS[g]] then
table.insert(changed, g)
end
end
return k, pos, n, changed
end
-- Item lookup -------------------------------------------------------------------
-- ItemsExtra.lua lists items whose slot isn't known offline: OctoWoW items
-- from Atlas-CFM's loot tables and the item sets. In the background, a few a
-- second, the addon reads them from the client's cache or (with ClassicAPI)
-- asks the server, and saves the answers account-wide. Found ones join the
-- item lists and the sets.
local LOOKUP_STEP, LOOKUP_TIMEOUT, LOOKUP_PARALLEL = 0.25, 20, 4
local lookup = { pos = 1, count = 0, ids = {}, waiting = {}, waitCount = 0, left = 0, version = 0 }
local function CanAskServer()
return type(C_Item) == "table" and type(C_Item.RequestLoadItemDataByID) == "function"
end
-- "slots<TAB>quality<TAB>name" for an item the client knows, false if it
-- doesn't show on a character, nil if the client doesn't know it yet.
local function ReadItemInfo(itemID)
local ok, name, _, quality, _, _, _, _, equipLoc = pcall(GetItemInfo, itemID)
if not (ok and name) then
return nil
end
local slots = EQUIP_SLOTS[equipLoc or ""]
if not slots then
return false
end
return table.concat(slots, ",") .. "\t" .. (quality or 1) .. "\t" .. string.gsub(name, "\t", " ")
end
local function Record(itemID, info)
if account.itemInfo[itemID] == nil and info ~= nil then
account.itemInfo[itemID] = info
lookup.left = lookup.left - 1
if info then
lookup.changed = true
end
end
end
-- How many items are still to be looked up, and how many there were.
function M.GetLookupStatus()
return lookup.left, lookup.count
end
-- Bumped whenever looked-up items join the lists, so the window can redraw.
function M.GetItemsVersion()
return lookup.version
end
local function StartLookup()
if lookup.started then
return
end
lookup.started = true
for id in string.gfind(DmorphOcto_ItemPending or "", "(%d+)\t") do
id = tonumber(id)
lookup.count = lookup.count + 1
lookup.ids[lookup.count] = id
if account.itemInfo[id] == nil then
lookup.left = lookup.left + 1
end
end
DmorphOcto_ItemPending = nil
end
local function LookupTick(elapsed)
for id, wait in pairs(lookup.waiting) do
if wait <= elapsed then
-- No answer: try again next session.
lookup.waiting[id] = nil
lookup.waitCount = lookup.waitCount - 1
else
lookup.waiting[id] = wait - elapsed
end
end
local askServer = CanAskServer()
local checked = 0
while lookup.pos <= lookup.count and checked < 40 and lookup.waitCount < LOOKUP_PARALLEL do
local id = lookup.ids[lookup.pos]
lookup.pos = lookup.pos + 1
if account.itemInfo[id] == nil and not lookup.waiting[id] then
checked = checked + 1
local info = ReadItemInfo(id)
if info ~= nil then
Record(id, info)
elseif askServer then
lookup.waiting[id] = LOOKUP_TIMEOUT
lookup.waitCount = lookup.waitCount + 1
pcall(C_Item.RequestLoadItemDataByID, id)
break -- one question per step
end
end
end
if lookup.changed then
lookup.changed = nil
lookup.version = lookup.version + 1
ForgetItemLists()
end
return lookup.pos > lookup.count and lookup.waitCount == 0
end
-- ClassicAPI's ITEM_DATA_LOAD_RESULT(itemID, success).
local function LookupAnswer(itemID, success)
if not lookup.waiting[itemID] then
return
end
lookup.waiting[itemID] = nil
lookup.waitCount = lookup.waitCount - 1
if success then
Record(itemID, ReadItemInfo(itemID))
else
Record(itemID, false) -- the server has no such item
end
end
-- Whether entry i passes a filter from the *_FILTERS lists ({ kinds = ..., tag
-- = ... }) and a quality from QUALITY_FILTERS. Both are optional.
local function Keep(catalog, i, filter, quality)
if filter then
if filter.kinds and not filter.kinds[catalog.kind[i]] then
return false
end
if filter.tag then
local tags = catalog.tags and catalog.tags[i]
if not (tags and strfind(tags, filter.tag, 1, true)) then
return false
end
end
end
return not quality or catalog.quality[i] == quality
end
-- Positions of the catalogue entries matching the text, plus how many there
-- are: an exact ID first, then names starting with the text, then names
-- containing it. byID lists them by ID instead.
function M.FilterCatalog(catalog, text, filter, quality, byID)
local query = strlower(Trim(text))
local result, n = {}, 0
local number = ParseID(query)
local later, m = {}, 0
for i = 1, catalog.count do
if Keep(catalog, i, filter, quality) then
local at = query == "" or strfind(catalog.lower[i], query, 1, true)
if query == "" or catalog.ids[i] == number or at == 1 then
n = n + 1
result[n] = i
elseif at then
m = m + 1
later[m] = i
end
end
end
for i = 1, m do
result[n + i] = later[i]
end
n = n + m
if byID then
local ids = catalog.ids
table.sort(result, function(a, b)
return ids[a] < ids[b] or (ids[a] == ids[b] and a < b)
end)
end
return result, n
end
-- The catalogue's name for a display ID and what kind of entry it is, or nil.
function M.GetDisplayName(displayID)
local catalog = M.GetCreatureCatalog()
local index = catalog.byID[displayID]
if index then
return catalog.names[index], catalog.kind[index]
end
end
function M.DescribeDisplay(displayID)
local name = M.GetDisplayName(displayID)
if name then
return name .. " (" .. displayID .. ")"
end
return "display " .. displayID
end
-- The item's name from the client's cache, or else from the catalogue: the
-- slot's own list first, then the others (a shirt can be morphed onto the chest).
function M.DescribeItem(itemID, slot)
local ok, name = pcall(GetItemInfo, itemID)
if not (ok and name) then
name = nil
local lists = { slot }
for i = 1, table.getn(SLOT_ORDER) do
table.insert(lists, SLOT_ORDER[i])
end
for i = 1, table.getn(lists) do
local catalog = SLOT_NAMES[lists[i]] and M.GetItemCatalog(lists[i])
local index = catalog and catalog.byID[itemID]
if index then
name = catalog.names[index]
break
end
end
end
if name then
return "[" .. name .. "] (" .. itemID .. ")"
end
return "item " .. itemID
end
function M.DescribeOutfit(outfit)
local look = "your own model"
if outfit.display then
look = M.DescribeDisplay(outfit.display)
elseif outfit.race then
look = M.DescribeBody(outfit.race, outfit.gender)
end
local count = 0
for _ in pairs(outfit.items) do
count = count + 1
end
local extra = ""
if outfit.look then
extra = extra .. ", own face"
end
if outfit.glows and next(outfit.glows) then
extra = extra .. ", glows"
end
if outfit.mount then
extra = extra .. ", mount"
end
if count == 1 then
return look .. ", 1 item" .. extra
end
return look .. ", " .. count .. " items" .. extra
end
-- State ---------------------------------------------------------------------
-- Five look values (skin colour, face, hair style, hair colour, facial hair),
-- copied, or nil if look isn't one.
local function ValidLook(look)
if type(look) ~= "table" then
return nil
end
for i = 1, 5 do
local v = look[i]
if type(v) ~= "number" or v < 0 or v > 255 or v ~= math.floor(v) then
return nil
end
end
return { look[1], look[2], look[3], look[4], look[5] }
end
-- Drops anything that isn't a usable ID, e.g. from a hand-edited file.
local function SanitizeOutfit(outfit)
outfit.display = ParseID(outfit.display)
if outfit.display == 0 then
outfit.display = nil
end
outfit.mount = ParseID(outfit.mount)
if outfit.mount == 0 then
outfit.mount = nil
end
if not (type(outfit.race) == "number" and RACES[outfit.race]) then
outfit.race = nil
end
if outfit.gender ~= 1 then
outfit.gender = 0
end
if type(outfit.items) ~= "table" then
outfit.items = {}
end
for slot, itemID in pairs(outfit.items) do
itemID = ParseID(itemID)
if not SLOT_NAMES[slot] or itemID == 0 then
itemID = nil
end
outfit.items[slot] = itemID
end
-- Weapon glows (DmorphHelper): slot -> enchant ID, 0 for none.
if type(outfit.glows) ~= "table" then
outfit.glows = {}
end
for slot, enchantID in pairs(outfit.glows) do
enchantID = ParseID(enchantID)
if not GLOW_SLOT[slot] or (enchantID and enchantID > 1000000) then
enchantID = nil
end
outfit.glows[slot] = enchantID
end
-- An outfit's own look: { race, gender, the five values }.
local look = outfit.look
if type(look) == "table" and RACES[look.race] and (look.gender == 0 or look.gender == 1) and ValidLook(look) then
outfit.look = ValidLook(look)
outfit.look.race, outfit.look.gender = look.race, look.gender
else
outfit.look = nil
end
return outfit
end
-- The current look as an outfit: db, plus the look picked for your body.
local function CopyOutfit(outfit)
local copy = { display = outfit.display, race = outfit.race, gender = outfit.gender, mount = outfit.mount,
items = {}, glows = {} }
for slot, itemID in pairs(outfit.items) do
copy.items[slot] = itemID
end
for slot, enchantID in pairs(outfit.glows) do
copy.glows[slot] = enchantID
end
local race, gender = M.GetBodyRace()
local look = race and ValidLook(outfit.looks[race .. ":" .. gender])
if look then
look.race, look.gender = race, gender
copy.look = look
end
return copy
end
function InitDB()
if db then
return
end
if type(DmorphOctoDB) ~= "table" then
DmorphOctoDB = {}
end
db = SanitizeOutfit(DmorphOctoDB)
-- Mount skins per mount (own display -> skin) and the mounts ridden.
if type(db.mountSkins) ~= "table" then
db.mountSkins = {}
end
for real, skin in pairs(db.mountSkins) do
if type(real) ~= "number" or not ParseID(skin) or ParseID(skin) == 0 then
db.mountSkins[real] = nil
end
end
local ridden = {}
if type(db.ridden) == "table" then
for i = 1, table.getn(db.ridden) do
local id = ParseID(db.ridden[i])
if id and id > 0 then
table.insert(ridden, id)
end
end
end
db.ridden = ridden
-- DmorphHelper: the look picked per body ("race:gender" -> five values),
-- and per weapon slot and for the look, the real values last seen and
-- what was last written.
local picked = {}
if type(db.looks) == "table" then
for key, look in pairs(db.looks) do
local _, _, race = strfind(type(key) == "string" and key or "", "^(%d+):[01]$")
if race and RACES[tonumber(race)] then
picked[key] = ValidLook(look)
end
end
end
db.looks = picked
db.lookReal, db.lookWritten = ValidLook(db.lookReal), ValidLook(db.lookWritten)
for _, key in ipairs({ "glowReal", "glowWritten" }) do
local kept = {}
if type(db[key]) == "table" then
for slot, pair in pairs(db[key]) do
if GLOW_SLOT[slot] and type(pair) == "table" and type(pair[1]) == "number" and type(pair[2]) == "number" then
kept[slot] = { pair[1], pair[2] }
end
end
end
db[key] = kept
end
if type(DmorphOctoAccount) ~= "table" then
DmorphOctoAccount = {}
end
account = DmorphOctoAccount
if type(account.outfits) ~= "table" then
account.outfits = {}
end
-- Items looked up in game: id -> "slots<TAB>quality<TAB>name", or false.
if type(account.itemInfo) ~= "table" then
account.itemInfo = {}
end
for id, info in pairs(account.itemInfo) do
if type(id) ~= "number" or (info ~= false and type(info) ~= "string") then
account.itemInfo[id] = nil
end
end
for name, outfit in pairs(account.outfits) do
if type(name) == "string" and type(outfit) == "table" then
SanitizeOutfit(outfit)
else
account.outfits[name] = nil
end
end
-- Favourites: { id = displayID, mount = true or nil }, oldest first, each once.
local favourites, seen = {}, {}
if type(account.favourites) == "table" then
for i = 1, table.getn(account.favourites) do
local fav = account.favourites[i]
local id = type(fav) == "table" and ParseID(fav.id)
if id and id > 0 then
local mount = fav.mount and true or nil
local key = (mount and "mount" or "model") .. id
if not seen[key] then
seen[key] = true
table.insert(favourites, { id = id, mount = mount })
end
end
end
end
account.favourites = favourites
-- Sharing with other DMorph users (Share.lua): on unless switched off.
account.shareOff = account.shareOff == true or nil
account.othersOff = account.othersOff == true or nil
end
function M.GetState()
InitDB()
return db
end
function M.GetAccount()
InitDB()
return account
end
function M.GetNative()
return nativeRace, nativeGender
end
-- Called after every change, so the window can redraw.
function M.RegisterListener(fn)
table.insert(listeners, fn)
end
local function Notify()
for i = 1, table.getn(listeners) do
listeners[i]()
end
end
local function CaptureNative()
nativeRace, nativeGender = nil, nil
local ok, _, native = pcall(UnitDisplayInfo, "player")
if ok and native then
for race = 1, table.getn(RACES) do
if RACES[race].male == native then
nativeRace, nativeGender = race, 0
elseif RACES[race].female == native then
nativeRace, nativeGender = race, 1
end
end
end
if not nativeRace then
local _, token = UnitRace("player")
nativeRace = RACE_TOKENS[strupper(token or "")]
local sex = UnitSex("player")
if sex == 3 then
nativeGender = 1
elseif sex == 2 then
nativeGender = 0
end
end
end
-- Runs once per UI session, before the first morph is applied.
local function EnsureSession()
if sessionReady then
return
end
-- VanillaHelpers' overrides can outlive a /reload, and a race morph also
-- replaces the native model ID, so drop ours before reading the real one.
if db.display or db.race then
Morph(SetUnitDisplayID, "player", nil)
end
-- The mount skin is put back on by the mount watcher once you ride.
if type(SetUnitMountDisplayID) == "function" and (db.mount or next(db.mountSkins)) then
Morph(SetUnitMountDisplayID, "player", nil)
end
CaptureNative()
sessionReady = true
end
-- Every action that morphs starts here.
local function Begin()
InitDB()
if not HasMorphAPI() then
return false
end
EnsureSession()
return true
end
-- .morph and the race/gender morph share UNIT_FIELD_DISPLAYID: last one wins.
local function BodyDisplayID()
if db.display then
return db.display
end
if db.race then
return RaceModel(db.race, db.gender)
end
end
-- After a body change the game is still building the model, and a look or
-- glow written into it then could mix with the old one; so DmorphHelper's
-- watcher holds off this long, then runs (see Glows and your own look).
local helperHold, helperWait = 0, 0
local function ApplyBody()
helperHold, helperWait = 0.5, 0.5
return Morph(SetUnitDisplayID, "player", BodyDisplayID())
end
local function ApplyItem(slot)
return Morph(SetUnitVisibleItemID, "player", slot, db.items[slot])
end
-- Mount morphs need VanillaHelpers' SetUnitMountDisplayID (v1.1.0 has it).
local function HasMountAPI()
return type(SetUnitMountDisplayID) == "function"
end
M.HasMountAPI = HasMountAPI
-- Mount skins -----------------------------------------------------------------
-- A skin is a display ID your mount shows instead of its own: db.mount for all
-- your mounts, db.mountSkins[real display] for one of them. VanillaHelpers'
-- mount override holds the model whatever the server says, so it would keep
-- you on a mount after you dismount. So the skin is only put on while you
-- ride: when the mount field turns non-zero you mounted, and the buff that
-- came with it is the mount's; when that buff goes, you dismounted and the
-- override comes off, which lets the game's own mount and dismount through.
local watch = {}
local function BuffTextures()
local set, any = {}, false
for i = 1, 32 do
local ok, texture = pcall(UnitBuff, "player", i)
if not (ok and texture) then
break
end
set[texture], any = true, true
end
return set, any
end
local function SkinFor(real)
return db.mountSkins[real] or db.mount
end
local function StopSkin()
if watch.active then
watch.active, watch.skin = nil, nil
Morph(SetUnitMountDisplayID, "player", nil)
end
end
local function RememberRidden(real)
for i = 1, table.getn(db.ridden) do
if db.ridden[i] == real then
return
end
end
table.insert(db.ridden, real)
if table.getn(db.ridden) > 20 then
table.remove(db.ridden, 1)
end
end
-- Runs every tenth of a second.
local function WatchMount()
if not (sessionReady and HasMountAPI()) then
return
end
if watch.active then
local buffs = BuffTextures()
for texture in pairs(watch.candidates) do
if not buffs[texture] then
-- The mount's buff is gone: you dismounted.
StopSkin()
watch.last, watch.real = buffs, nil
Notify()
return
end
end
-- Each change tells the listeners (the window, and Share.lua so other
-- DMorph users see the skin come and go).
local skin = SkinFor(watch.real)
if not skin then
StopSkin()
Notify()
elseif skin ~= watch.skin then
watch.skin = skin
Morph(SetUnitMountDisplayID, "player", skin)
Notify()
end
return
end
local ok, _, _, field = pcall(UnitDisplayInfo, "player")
if not ok then
return
end
if field and field > 0 then
if watch.real ~= field then
watch.real = field
RememberRidden(field)
Notify()
end
local skin = SkinFor(field)
if skin and skin ~= field then
local buffs, any = BuffTextures()
local candidates, found = {}, false
for texture in pairs(buffs) do
if not (watch.last and watch.last[texture]) then
candidates[texture], found = true, true
end
end
if not found then
candidates = buffs -- mounted before we could look: any buff going counts
end
if any then
watch.candidates, watch.skin, watch.active = candidates, skin, true
Morph(SetUnitMountDisplayID, "player", skin)
Notify()
end
end
else
if watch.real then
watch.real = nil
Notify()
end
if db.mount or next(db.mountSkins) then
watch.last = BuffTextures()
end
end
end
-- Whether you ride, the display ID of your own mount, and the skin it shows.
function M.GetMountState()
InitDB()
if watch.real then
return true, watch.real, watch.skin
end
return false
end
-- The mounts you've ridden on this character (their own display IDs).
function M.GetRiddenMounts()
InitDB()
return db.ridden
end
function M.GetMountSkin(real)
InitDB()
if real then
return db.mountSkins[real]
end
return db.mount
end
-- What other DMorph users should see: your body's display ID (nil when you
-- aren't morphed), your item morphs (slot -> item ID), and the mount skin
-- showing now (nil on foot or without a skin).
function M.GetSharedLook()
InitDB()
local mount
if watch.active then
mount = watch.skin
end
return BodyDisplayID(), db.items, mount
end
-- Glows and your own look (DmorphHelper.dll) ----------------------------------
-- DmorphHelper.dll (helper/ in this folder) does two things VanillaHelpers
-- can't, on your screen only like every morph: it rewrites a weapon slot's
-- enchant IDs, which the game draws the enchant's glow from, and your skin
-- colour, face, hair style, hair colour and facial hair (the values character
-- creation sets). The server sends the real values again now and then (a new
-- enchant, a loading screen), so a watcher puts the chosen ones back once a
-- second. Whatever it reads that it didn't write is the real value, kept so
-- "your own" can put it back.
local MISSING_HELPER = "DmorphHelper.dll isn't loaded, so weapon glows and real skin, face and hair changes "
.. "are unavailable. Close the game, run tools\\install_helper.ps1 from the DmorphOcto folder, and start it again."
M.MISSING_HELPER = MISSING_HELPER
-- Rows 1-5 of the Races tab, in DmorphHelper_GetLook's order.
local OWN_LOOK_NPC = { "npcSkin", "npcFace", "npcHairStyle", "npcHairColour" }
local function HasHelper()
return type(DmorphHelper_GetItemEnchants) == "function" and type(DmorphHelper_SetItemEnchants) == "function"
and type(DmorphHelper_GetLook) == "function" and type(DmorphHelper_SetLook) == "function"
end
M.HasHelper = HasHelper
-- Every glow the client can draw (Data/Glows.lua): per glow its visual ID, an
-- enchant ID that shows it, its name (the shortest enchant name), all the
-- enchant names and its effect models.
local glows
function M.GetGlows()
local text = DmorphOcto_GlowData or ""
if not glows or glows.text ~= text then
glows = { text = text, count = 0, visual = {}, enchant = {}, name = {}, names = {}, models = {}, search = {} }
for visual, enchant, names, models in string.gfind(text, "(%d+)\t(%d+)\t([^\t\n]*)\t([^\t\n]*)") do
local n = glows.count + 1
glows.count = n
glows.visual[n], glows.enchant[n] = tonumber(visual), tonumber(enchant)
local _, _, first = strfind(names, "^([^;]+)")
glows.name[n] = first or ("Glow " .. visual)
glows.names[n], glows.models[n] = names, models
glows.search[n] = strlower(names .. " " .. models .. " " .. visual .. " " .. enchant)
end
end
return glows
end
-- The glows whose names, effect models or IDs have every word of text.
function M.FilterGlows(text)
local all, words = M.GetGlows(), {}
for word in string.gfind(strlower(text or ""), "%S+") do
table.insert(words, word)
end
local result, count = {}, 0
for i = 1, all.count do
local keep = true
for k = 1, table.getn(words) do
if not strfind(all.search[i], words[k], 1, true) then
keep = false
break
end
end
if keep then
count = count + 1
result[count] = i
end
end
return result, count
end
function M.DescribeGlow(enchantID)
if enchantID == 0 then
return "no glow"
end
local all = M.GetGlows()
for i = 1, all.count do
if all.enchant[i] == enchantID then
return all.name[i]
end
end
return "enchant " .. enchantID
end
-- The glow picked for a weapon slot (an enchant ID, 0 for none, nil for your
-- own) and the slot's real permanent enchant, if seen.
function M.GetGlow(slot)
InitDB()
local real = db.glowReal[slot]
return db.glows[slot], real and real[1]
end
-- The skin colours, faces and hair a race and gender can wear
-- (Data/CharOptions.lua), or nil.
function M.GetLookOptions(race, gender)
local all = DmorphOcto_CharOptions
local o = type(all) == "table" and race and all[race .. ":" .. gender]
if type(o) == "table" and type(o.skin) == "table" and table.getn(o.skin) > 0 then
return o
end
end
-- The values row f (1-5) can have with the rest of look, sorted: a face needs
-- its skin colour, a hair colour its hair style.
local function LookChoices(o, look, f)
local list
if f == 1 then
list = o.skin
elseif f == 2 then
list = o.face and o.face[look[1]]
elseif f == 3 then
list = o.hairStyle
elseif f == 4 then
list = o.hairColour and o.hairColour[look[3]] or o.anyHairColour
else
list = o.facialHair
end
return type(list) == "table" and list or {}
end
local function Nearest(list, value)
local best
for i = 1, table.getn(list) do
local v = list[i]
if v == value then
return v
end
if not best or math.abs(v - value) < math.abs(best - value) then
best = v
end
end
return best or value
end
-- Makes look one the race can wear, row by row; returns the rows changed.
local function ClampLook(o, look)
local changed = {}
for f = 1, 5 do
local v = Nearest(LookChoices(o, look, f), look[f])
if v ~= look[f] then
look[f] = v
table.insert(changed, f)
end
end
return changed
end
-- Row f of a look: its choices, the value's place among them (0 if it isn't
-- one), and whether only NPCs have that value.
function M.LookRow(o, look, f)
local values = LookChoices(o, look, f)
local pos = 0
for i = 1, table.getn(values) do
if values[i] == look[f] then
pos = i
end
end
local npc = OWN_LOOK_NPC[f] and type(o[OWN_LOOK_NPC[f]]) == "table" and o[OWN_LOOK_NPC[f]][look[f]] and true
return values, pos, npc or false
end
local function SameValues(a, b)
if not (a and b) then
return false
end
for i = 1, 5 do
if a[i] ~= b[i] then
return false
end
end
return true
end
local function CopyLook(look)
return { look[1], look[2], look[3], look[4], look[5] }
end
local function ReadLook()
local ok, a, b, c, d, e = pcall(DmorphHelper_GetLook, "player")
if ok and type(a) == "number" then
return { a, b, c, d, e }
end
end
-- Your real look: what the game has, unless that's what we wrote.
local function RealLook()
local current = HasHelper() and ReadLook()
if current and not SameValues(current, db.lookWritten) then
return current
end
return db.lookReal or current
end
-- The body your look shows on (race, gender), its options, the look it has
-- (5 values, or nil when unknown) and whether that's one you picked.
function M.GetLookState()
InitDB()
local race, gender = M.GetBodyRace()
local o = M.GetLookOptions(race, gender)
local picked = race and db.looks[race .. ":" .. gender]
if picked then
return race, gender, o, picked, true
end
return race, gender, o, RealLook(), false
end
-- Puts the picked glows and look on, and puts the real ones back where
-- nothing is picked any more.
local function WatchHelper()
if not (sessionReady and HasHelper()) or helperHold > 0 then
return
end
local current = ReadLook()
if current then
if not SameValues(current, db.lookWritten) then
db.lookReal = current
end
local race, gender = M.GetBodyRace()
local want = race and db.looks[race .. ":" .. gender]
local restore = not want and db.lookWritten
if restore then
want = db.lookReal
end
if want and not SameValues(current, want) then
if pcall(DmorphHelper_SetLook, "player", want[1], want[2], want[3], want[4], want[5]) then
db.lookWritten = CopyLook(want)
end
end
if restore then
db.lookWritten = nil
end
end
for slot in pairs(GLOW_SLOT) do
local ok, p, t = pcall(DmorphHelper_GetItemEnchants, "player", slot)
if ok and type(p) == "number" then
local written = db.glowWritten[slot]
if not (written and written[1] == p and written[2] == t) then
db.glowReal[slot] = { p, t }
end
local want
if db.glows[slot] then
want = { db.glows[slot], 0 }
elseif written then
want = db.glowReal[slot]
end
if want and (want[1] ~= p or want[2] ~= t) then
if pcall(DmorphHelper_SetItemEnchants, "player", slot, want[1], want[2]) then
db.glowWritten[slot] = { want[1], want[2] }
end
end
if not db.glows[slot] then
db.glowWritten[slot] = nil
end
end
end
end
-- Glow and look actions need both DLLs.
local function HelperBegin()
if not Begin() then
return false, MISSING_API
end
if not HasHelper() then
return false, MISSING_HELPER
end
return true
end
-- enchantID: an enchant whose glow the slot shows, 0 for no glow, nil for
-- your own.
function M.SetGlow(slot, enchantID)
local ok, err = HelperBegin()
if not ok then
return false, err
end
if not GLOW_SLOT[slot] then
return false, "Glows show on weapons: main hand (16), off hand (17) or ranged (18)."
end
if enchantID ~= nil then
enchantID = ParseID(enchantID)
if not enchantID or enchantID > 1000000 then
return false, "Enchant IDs are whole numbers."
end
end
db.glows[slot] = enchantID
WatchHelper()
Notify()
if not enchantID then
return true, SLOT_NAMES[slot] .. ": your own glow."
end
return true, SLOT_NAMES[slot] .. ": " .. M.DescribeGlow(enchantID) .. "."
end
M.LOOK_ROWS = { "Skin colour", "Face", "Hair style", "Hair colour", "Facial hair" }
local function RowName(f, gender)
if f == 5 and gender == 1 then
return "Features"
end
return M.LOOK_ROWS[f]
end
M.LookRowName = RowName
local function NoOptions(race, gender)
if not race then
return "Couldn't detect your race, pick one first."
end
return "There's no skin, face and hair list for " .. M.DescribeBody(race, gender)
.. " yet. Close the game and run tools\\update_from_game.ps1, then try again."
end
-- "the face and hair colour"
local function JoinRows(rows, gender)
local names = {}
for i = 1, table.getn(rows) do
table.insert(names, strlower(RowName(rows[i], gender)))
end
local n = table.getn(names)
if n == 1 then
return names[1]
end
return table.concat(names, ", ", 1, n - 1) .. " and " .. names[n]
end
local function PickLook(race, gender, look)
db.looks[race .. ":" .. gender] = CopyLook(look)
WatchHelper()
Notify()
end
-- Your model (race morph or your own) with these five values, made valid for
-- it. Returns ok, message.
function M.SetOwnLook(values)
local ok, err = HelperBegin()
if not ok then
return false, err
end
local race, gender, o = M.GetLookState()
if not o then
return false, NoOptions(race, gender)
end
local look = CopyLook(values)
local changed = ClampLook(o, look)
PickLook(race, gender, look)
if table.getn(changed) > 0 then
return true, M.DescribeBody(race, gender) .. " has no such " .. JoinRows(changed, gender)
.. ", so the closest one is on."
end
return true, "Look set."
end
-- Row f (1-5) of your model's look one value along (step 1 or -1, wrapping).
-- A row whose new value doesn't go with another row (a face is per skin
-- colour, a hair colour per hair style) moves that one to its closest value.
function M.StepOwnLook(f, step)
local ok, err = HelperBegin()
if not ok then
return false, err
end
local race, gender, o, current = M.GetLookState()
if not o then
return false, NoOptions(race, gender)
end
if not current then
return false, "Couldn't read your look from the game."
end
local look = CopyLook(current)
ClampLook(o, look)
local values = LookChoices(o, look, f)
local n = table.getn(values)
if n < 2 then
return false, M.DescribeBody(race, gender) .. " has just one " .. strlower(RowName(f, gender)) .. "."
end
local pos = 1
for i = 1, n do
if values[i] == look[f] then
pos = i
end
end
pos = math.mod(pos - 1 + step + n, n) + 1
look[f] = values[pos]
local changed = ClampLook(o, look)
PickLook(race, gender, look)
local message = RowName(f, gender) .. " " .. pos .. " of " .. n
local _, _, npc = M.LookRow(o, look, f)
if npc then
message = message .. " (an NPC-only one)"
end
message = message .. "."
if table.getn(changed) > 0 then
message = message .. " The " .. JoinRows(changed, gender) .. " changed too: this one doesn't come with the old one."
end
return true, message
end
-- A random look for your model, from everything its race can wear.
function M.RandomOwnLook()
local ok, err = HelperBegin()
if not ok then
return false, err
end
local race, gender, o, current = M.GetLookState()
if not o then
return false, NoOptions(race, gender)
end
local look = CopyLook(current or { 0, 0, 0, 0, 0 })
for try = 1, 5 do
for f = 1, 5 do
local values = LookChoices(o, look, f)
if table.getn(values) > 0 then
look[f] = values[math.random(table.getn(values))]
end
end
if not SameValues(look, current) then
break
end
end
PickLook(race, gender, look)
return true, "A random " .. M.DescribeBody(race, gender) .. " look."
end
-- Back to your real skin, face and hair on the model you show.
function M.ResetOwnLook()
local ok, err = HelperBegin()
if not ok then
return false, err
end
local race, gender = M.GetBodyRace()
if race then
db.looks[race .. ":" .. gender] = nil
end
WatchHelper()
Notify()
return true, "Your own face, skin and hair."
end
local function ApplySaved()
if not Begin() then
return
end
if BodyDisplayID() then
ApplyBody()
end
for slot in pairs(db.items) do
ApplyItem(slot)
end
WatchHelper()
Notify()
end
-- Turns the outcome of the VanillaHelpers calls into (ok, message).
local function Result(ok, err, message)
Notify()
if ok then
return true, message
end
return false, "|cffff5555" .. tostring(err) .. "|r"
end
-- Actions: each returns ok, message -----------------------------------------
function M.ResetModel()
if not Begin() then
return false, MISSING_API
end
db.display, db.race, db.gender = nil, nil, 0
db.looks = {}
local ok, err = ApplyBody()
WatchHelper()
return Result(ok, err, "Model reset.")
end
function M.ResetAll()
if not Begin() then
return false, MISSING_API
end
db.display, db.race, db.gender = nil, nil, 0
db.looks, db.glows = {}, {}
local ok, err = ApplyBody()
WatchHelper()
db.mount, db.mountSkins = nil, {}
StopSkin()
for i = 1, table.getn(SLOT_ORDER) do
local slot = SLOT_ORDER[i]
db.items[slot] = nil
local slotOK, slotErr = ApplyItem(slot)
if ok and not slotOK then
ok, err = slotOK, slotErr
end
end
return Result(ok, err, "Model and items reset.")
end
function M.SetDisplay(displayID)
if not Begin() then
return false, MISSING_API
end
displayID = ParseID(displayID)
if not displayID then
return false, "Display IDs are whole numbers."
end
if displayID == 0 then
return M.ResetModel()
end
db.display, db.race, db.gender = displayID, nil, 0
local ok, err = ApplyBody()
return Result(ok, err, "Morphed into " .. M.DescribeDisplay(displayID) .. ".")
end
-- The race and gender your model shows now, morphed or your own.
function M.GetBodyRace()
InitDB()
if db.race then
return db.race, db.gender
end
return nativeRace, nativeGender or 0
end
-- gender is 0 or 1; anything else keeps the current gender.
function M.SetRace(race, gender)
if not Begin() then
return false, MISSING_API
end
if not RACES[race] then
return false, "Unknown race. Races: " .. RaceList()
end
if gender ~= 0 and gender ~= 1 then
local _
_, gender = M.GetBodyRace()
end
if race == nativeRace and gender == nativeGender then
db.display, db.race, db.gender = nil, nil, 0
else
db.display, db.race, db.gender = nil, race, gender
end
local ok, err = ApplyBody()
return Result(ok, err, "Race: " .. M.DescribeBody(race, gender) .. ".")
end
function M.ToggleGender()
if not Begin() then
return false, MISSING_API
end
local race, gender = M.GetBodyRace()
if not race then
return false, "Couldn't detect your race, pick one first."
end
return M.SetRace(race, 1 - gender)
end
-- itemID 0 resets the slot.
function M.SetItem(slot, itemID)
if not Begin() then
return false, MISSING_API
end
if not SLOT_NAMES[slot] then
return false, "Neck, rings and trinkets don't show on your model. Slots: " .. SlotList()
end
itemID = ParseID(itemID)
if not itemID then
return false, "Item IDs are whole numbers."
end
if itemID == 0 then
itemID = nil
end
db.items[slot] = itemID
local ok, err = ApplyItem(slot)
if itemID then
return Result(ok, err, SLOT_NAMES[slot] .. ": " .. M.DescribeItem(itemID, slot) .. ".")
end
return Result(ok, err, SLOT_NAMES[slot] .. " reset.")
end
-- Gives your mount a skin: any creature model, shown whenever you ride. real
-- (a display ID from GetRiddenMounts) sets it for that mount only, else for
-- all your mounts. displayID 0 takes the skin off.
function M.SetMountSkin(displayID, real)
if not Begin() then
return false, MISSING_API
end
if not HasMountAPI() then
return false, "This VanillaHelpers can't morph mounts: update it to v1.1.0 or newer."
end
displayID = ParseID(displayID)
if not displayID then
return false, "Display IDs are whole numbers."
end
if displayID == 0 then
displayID = nil
end
local target = "all your mounts"
if real then
db.mountSkins[real] = displayID
target = M.DescribeDisplay(real)
else
db.mount = displayID
end
WatchMount()
Notify()
if not displayID then
return true, "Skin for " .. target .. " removed."
end
local when = " It shows when you mount."
if watch.active then
when = ""
end
return true, "Skin for " .. target .. ": " .. M.DescribeDisplay(displayID) .. "." .. when
end
-- The skin for all your mounts (.mount, favourites).
function M.SetMount(displayID)
return M.SetMountSkin(displayID)
end
-- Puts on every piece of set `index` (its position in GetSetCatalog) whose
-- slot is known. Slots the set has no piece for keep what they show.
function M.WearSet(index)
if not Begin() then
return false, MISSING_API
end
local catalog = M.GetSetCatalog()
local pieces = catalog.pieces[index]
if not pieces then
return false, "Pick a set in the list first."
end
local used, worn, unknown = {}, 0, 0
local ok, err = true, nil
for i = 1, table.getn(pieces) do
local slots = M.GetItemSlots(pieces[i])
local slot
if slots then
-- A second one-hand weapon goes in the off hand.
for k = 1, table.getn(slots) do
if not used[slots[k]] then
slot = slots[k]
break
end
end
else
unknown = unknown + 1
end
if slot then
used[slot] = true
worn = worn + 1
db.items[slot] = pieces[i]
local slotOK, slotErr = ApplyItem(slot)
if ok and not slotOK then
ok, err = slotOK, slotErr
end
end
end
local later = ""
if unknown > 0 then
later = " " .. unknown .. " more still being looked up: try again in a minute."
end
if worn == 0 then
Notify()
return false, "None of " .. catalog.names[index] .. "'s pieces are known yet." .. later
end
local count = worn .. " pieces"
if worn == 1 then
count = "1 piece"
end
return Result(ok, err, "Wearing " .. catalog.names[index] .. " (" .. count .. ")." .. later)
end
-- Favourites ----------------------------------------------------------------
-- Models and mounts kept at hand, shared by all your characters: a list of
-- { id = displayID, mount = true or nil }, oldest first.
function M.GetFavourites()
InitDB()
return account.favourites
end
local function FindFavourite(displayID, mount)
local list = account.favourites
for i = 1, table.getn(list) do
if list[i].id == displayID and list[i].mount == mount then
return i
end
end
end
function M.IsFavourite(displayID, mount)
InitDB()
return FindFavourite(displayID, mount and true or nil) ~= nil
end
-- Adds the model (or, with mount set, the mount) to the favourites, or takes
-- it off if it's there already.
function M.ToggleFavourite(displayID, mount)
InitDB()
displayID = ParseID(displayID)
if not displayID or displayID == 0 then
return false, "Pick a model first."
end
mount = mount and true or nil
local what = "favourite models"
if mount then
what = "favourite mounts"
end
local index = FindFavourite(displayID, mount)
if index then
table.remove(account.favourites, index)
return true, "Removed " .. M.DescribeDisplay(displayID) .. " from your " .. what .. "."
end
table.insert(account.favourites, { id = displayID, mount = mount })
return true, "Added " .. M.DescribeDisplay(displayID) .. " to your " .. what .. "."
end
-- Wardrobe ------------------------------------------------------------------
function M.GetOutfitNames()
InitDB()
local names = {}
for name in pairs(account.outfits) do
table.insert(names, name)
end
table.sort(names, function(a, b)
return strlower(a) < strlower(b)
end)
return names
end
function M.GetOutfit(name)
InitDB()
return account.outfits[name]
end
-- The saved name matching text, ignoring case.
function M.FindOutfit(text)
InitDB()
text = strlower(Trim(text))
for name in pairs(account.outfits) do
if strlower(name) == text then
return name
end
end
end
function M.SaveOutfit(name)
InitDB()
name = Trim(name)
if name == "" then
return false, "Type a name for the outfit first."
end
local replaced = account.outfits[name] ~= nil
account.outfits[name] = CopyOutfit(db)
Notify()
if replaced then
return true, "Updated outfit \"" .. name .. "\"."
end
return true, "Saved outfit \"" .. name .. "\"."
end
-- Puts on the whole outfit: slots it doesn't morph go back to your own gear.
function M.LoadOutfit(name)
if not Begin() then
return false, MISSING_API
end
local outfit = account.outfits[name]
if not outfit then
return false, "There is no outfit called \"" .. tostring(name) .. "\"."
end
db.display, db.race, db.gender = outfit.display, outfit.race, outfit.gender
if db.race == nativeRace and db.gender == nativeGender then
db.race, db.gender = nil, 0
end
local ok, err = ApplyBody()
for i = 1, table.getn(SLOT_ORDER) do
local slot = SLOT_ORDER[i]
db.items[slot] = outfit.items[slot]
local slotOK, slotErr = ApplyItem(slot)
if ok and not slotOK then
ok, err = slotOK, slotErr
end
end
db.mount = outfit.mount
-- The outfit's glows, and its look for its body (else your own).
db.glows = {}
for slot, enchantID in pairs(outfit.glows) do
db.glows[slot] = enchantID
end
local race, gender = M.GetBodyRace()
if race then
db.looks[race .. ":" .. gender] = nil
end
local look = outfit.look
if look and look.race == race and look.gender == gender then
db.looks[race .. ":" .. gender] = ValidLook(look)
end
WatchHelper()
return Result(ok, err, "Loaded outfit \"" .. name .. "\".")
end
function M.DeleteOutfit(name)
InitDB()
if not account.outfits[name] then
return false, "There is no outfit called \"" .. tostring(name) .. "\"."
end
account.outfits[name] = nil
Notify()
return true, "Deleted outfit \"" .. name .. "\"."
end
-- Chat commands -------------------------------------------------------------
local function ShowHelp()
Print("v" .. VERSION .. " - /dmorph opens the morph window. Chat commands:")
Print(".morph <displayID> - morph into any model (.morph 0 resets)")
Print(".race <1-10> - " .. RaceList())
Print(".gender - swap the gender of your race or race morph")
Print(".item <slot> <itemID or item link> - morph a visible item (itemID 0 resets the slot). Slots: " .. SlotList())
Print(".demorph - reset your model (DMorph's F5); .demorph all - reset model and items (F10)")
Print(".outfit [name] - list or put on saved outfits; .outfit save <name>; .outfit delete <name>")
Print(".mount <displayID> - morph your mount (.mount 0 resets)")
Print(".glow <mainhand/offhand/ranged> <enchantID> - a weapon's enchant glow (0 none, own your own); needs DmorphHelper.dll")
Print(".share on/off - whether other DMorph users see your morph; .share others on/off - whether you see theirs")
Print(".dmorph status - show what is morphed. Keys: Key Bindings > DMorph.")
if not HasMorphAPI() then
Print(MISSING_API)
end
end
local function ShowStatus()
if not HasMorphAPI() then
Print(MISSING_API)
elseif type(VANILLAHELPERS_VERSION) == "number" then
local v = VANILLAHELPERS_VERSION
Print(format("VanillaHelpers v%d.%d.%d is loaded.", math.floor(v / 10000),
math.floor(math.mod(v, 10000) / 100), math.mod(v, 100)))
end
if HasHelper() then
local ok, version = pcall(DmorphHelper_Version)
Print("DmorphHelper v" .. tostring(ok and version or "?") .. " is loaded: weapon glows and real skin, face and hair work.")
else
Print("DmorphHelper.dll is not loaded: weapon glows and real skin, face and hair changes need it (tools\\install_helper.ps1).")
end
if nativeRace then
Print("Your character: " .. M.DescribeBody(nativeRace, nativeGender) .. ".")
end
if db.display then
Print("Model: " .. M.DescribeDisplay(db.display) .. ".")
elseif db.race then
Print("Model: " .. M.DescribeBody(db.race, db.gender) .. ".")
else
Print("Model: not morphed.")
end
local list = ""
for i = 1, table.getn(SLOT_ORDER) do
local slot = SLOT_ORDER[i]
if db.items[slot] then
list = list .. ", " .. SLOT_NAMES[slot] .. " " .. M.DescribeItem(db.items[slot], slot)
end
end
if list == "" then
Print("Items: not morphed.")
else
Print("Items: " .. strsub(list, 3) .. ".")
end
for i = 1, table.getn(M.GLOW_SLOTS) do
local slot = M.GLOW_SLOTS[i]
if db.glows[slot] then
Print("Glow, " .. strlower(SLOT_NAMES[slot]) .. ": " .. M.DescribeGlow(db.glows[slot]) .. ".")
end
end
local bodies = {}
for key in pairs(db.looks) do
local _, _, race, gender = strfind(key, "^(%d+):(%d)$")
table.insert(bodies, M.DescribeBody(tonumber(race), tonumber(gender)))
end
if table.getn(bodies) > 0 then
table.sort(bodies)
Print("Own face, skin and hair picked for: " .. table.concat(bodies, ", ") .. ".")
end
if db.mount then
Print("Mount skin: " .. M.DescribeDisplay(db.mount) .. ".")
end
for real, skin in pairs(db.mountSkins) do
Print("Skin for " .. M.DescribeDisplay(real) .. ": " .. M.DescribeDisplay(skin) .. ".")
end
end
local commands = {}
-- Other files (Share.lua) add their own chat commands here.
M.commands = commands
function commands.morph(args)
local displayID = ParseID(args[1] or "0")
if not displayID then
return Print("Usage: .morph <displayID> (.morph 0 resets)")
end
Report(M.SetDisplay(displayID))
end
function commands.race(args)
local word = strlower(args[1] or "")
local race = RACE_ALIASES[word] or ParseID(word)
if race == 11 then
return Print("Draenei don't exist in the 1.12 client. Races: " .. RaceList())
end
if not race or not RACES[race] then
return Print("Usage: .race <1-10> (" .. RaceList() .. ")")
end
Report(M.SetRace(race))
end
function commands.gender()
Report(M.ToggleGender())
end
function commands.item(args, line)
local word = strlower(args[1] or "")
local slot = SLOT_ALIASES[word] or ParseID(word)
if not slot or slot < 1 or slot > 19 then
return Print("Usage: .item <slot> <itemID> (slots: " .. SlotList() .. ")")
end
-- Accept a shift-clicked item link as well as a plain ID.
local _, _, linkID = strfind(line, "item:(%d+)")
local itemID = ParseID(linkID or args[2] or "0")
if not itemID then
return Print("Usage: .item <slot> <itemID> (itemID 0 resets the slot)")
end
Report(M.SetItem(slot, itemID))
end
function commands.mount(args)
local displayID = ParseID(args[1] or "0")
if not displayID then
return Print("Usage: .mount <displayID> (.mount 0 resets)")
end
Report(M.SetMount(displayID))
end
-- .glow mainhand 1900, .glow offhand 0 (no glow), .glow ranged own.
function commands.glow(args)
local word = strlower(args[1] or "")
local slot = SLOT_ALIASES[word] or ({ mh = 16, oh = 17 })[word] or ParseID(word)
local value = strlower(args[2] or "")
local enchantID = ParseID(value)
if not (slot and GLOW_SLOT[slot]) or not (enchantID or value == "own") then
return Print("Usage: .glow <mainhand/offhand/ranged> <enchantID> (0 for no glow, own for your own)")
end
Report(M.SetGlow(slot, enchantID))
end
commands.enchant = commands.glow
function commands.scale()
Print(".scale isn't available on OctoWoW: VanillaHelpers has no API for model scale.")
end
function commands.demorph(args)
if strlower(args[1] or "") == "all" then
return Report(M.ResetAll())
end
Report(M.ResetModel())
end
function commands.outfit(args, line)
local _, _, rest = strfind(line, "^%S+%s*(.-)%s*$")
local action = strlower(args[1] or "")
local _, _, name = strfind(rest, "^%S+%s*(.-)$")
if rest == "" then
local names = M.GetOutfitNames()
if table.getn(names) == 0 then
return Print("No outfits saved yet. Save your current look with .outfit save <name>.")
end
return Print("Outfits: " .. table.concat(names, ", ") .. ".")
elseif action == "save" then
return Report(M.SaveOutfit(name))
elseif action == "delete" then
return Report(M.DeleteOutfit(M.FindOutfit(name) or name))
end
Report(M.LoadOutfit(M.FindOutfit(rest) or rest))
end
function commands.dmorph(args)
local action = strlower(args[1] or "")
if action == "status" then
return ShowStatus()
elseif action == "" and M.ToggleUI then
return M.ToggleUI()
end
ShowHelp()
end
-- Runs a command line such as "morph 4527". Returns false when the first word
-- isn't one of ours, so the caller can pass the text on untouched.
local function RunCommand(line)
local args = {}
for word in string.gfind(line, "%S+") do
table.insert(args, word)
end
local name = strlower(table.remove(args, 1) or "")
local handler = commands[name]
if not handler then
return false
end
InitDB()
if HasMorphAPI() then
EnsureSession()
end
handler(args, line)
return true
end
-- DMorph's interface: commands typed into chat with a leading dot. Anything
-- that isn't one of our commands still goes to the server as before.
local orig_SendChatMessage = SendChatMessage
function SendChatMessage(msg, chatType, language, channel)
if type(msg) == "string" then
local _, _, line = strfind(msg, "^%s*%.(.*)$")
if line and RunCommand(line) then
return
end
end
return orig_SendChatMessage(msg, chatType, language, channel)
end
SLASH_DMORPHOCTO1 = "/dmorph"
SlashCmdList["DMORPHOCTO"] = function(msg)
local _, _, line = strfind(msg or "", "^%s*%.?(.*)$")
if not RunCommand(line) then
RunCommand("dmorph " .. line)
end
end
-- Key bindings (Bindings.xml); the reset keys stand in for DMorph's F5/F10.
BINDING_HEADER_DMORPHOCTO = "DMorph"
BINDING_NAME_DMORPHOCTO_TOGGLE = "Open or close the DMorph window"
BINDING_NAME_DMORPHOCTO_RESET = "Reset model (DMorph F5)"
BINDING_NAME_DMORPHOCTO_RESETALL = "Reset model and items (DMorph F10)"
function DmorphOcto_ToggleUI()
RunCommand("dmorph")
end
function DmorphOcto_Reset()
RunCommand("demorph")
end
function DmorphOcto_ResetAll()
RunCommand("demorph all")
end
-- Events --------------------------------------------------------------------
local frame = CreateFrame("Frame")
frame:Hide()
frame:RegisterEvent("VARIABLES_LOADED")
frame:RegisterEvent("PLAYER_ENTERING_WORLD")
frame:SetScript("OnEvent", function()
InitDB()
if event ~= "PLAYER_ENTERING_WORLD" then
return
end
if not HasMorphAPI() then
if not warnedMissingAPI then
warnedMissingAPI = true
Print(MISSING_API)
end
return
end
-- Fires after every loading screen; give the client a moment to build the
-- player model before re-applying the saved morph.
pendingApply = 0.5
frame:Show()
end)
frame:SetScript("OnUpdate", function()
pendingApply = pendingApply - arg1
if pendingApply <= 0 then
frame:Hide()
ApplySaved()
end
end)
-- Item lookup runs in the background from shortly after login until every
-- pending item has an answer.
local lookupFrame = CreateFrame("Frame")
lookupFrame:Hide()
lookupFrame:SetScript("OnUpdate", function()
this.elapsed = this.elapsed + arg1
if this.elapsed >= LOOKUP_STEP then
if LookupTick(this.elapsed) then
this:Hide()
end
this.elapsed = 0
end
end)
lookupFrame:SetScript("OnEvent", function()
LookupAnswer(arg1, arg2)
end)
local loginFrame = CreateFrame("Frame")
loginFrame:RegisterEvent("PLAYER_ENTERING_WORLD")
loginFrame:SetScript("OnEvent", function()
this:UnregisterEvent("PLAYER_ENTERING_WORLD")
InitDB()
StartLookup()
if CanAskServer() then
pcall(lookupFrame.RegisterEvent, lookupFrame, "ITEM_DATA_LOAD_RESULT")
end
lookupFrame.elapsed = -15 -- let the login settle first
lookupFrame:Show()
end)
-- The mount watcher: puts the mount skin on while you ride (see Mount skins).
local mountFrame = CreateFrame("Frame")
mountFrame:SetScript("OnUpdate", function()
this.wait = (this.wait or 0) - arg1
if this.wait <= 0 then
this.wait = 0.1
WatchMount()
end
end)
-- The DmorphHelper watcher: keeps the picked glows and look on (see Glows and
-- your own look).
local helperFrame = CreateFrame("Frame")
helperFrame:SetScript("OnUpdate", function()
helperHold = helperHold - arg1
helperWait = helperWait - arg1
if helperWait <= 0 then
helperWait = 1
WatchHelper()
end
end)