-- WeakestAuras -- WeakAuras2 display translation and import compatibility report. if WeakestAuras.disabled then return end local WA = WeakestAuras local REGION_MAP = { icon = "icon", aurabar = "progressbar", texture = "texture", progresstexture = "progresstexture", text = "text", empty = "empty", group = "group", dynamicgroup = "dynamicgroup", model = "model", stopmotion = "fallback", } local GROUP_TYPES = { group = true, dynamicgroup = true } -- A bar texture travels as a LibSharedMedia *name*, and the sender's media -- registry is not ours: an unknown name resolves to a missing file and the bar -- draws nothing at all, which reads as a broken import rather than a missing -- skin. Every name therefore lands on a bundled texture. -- -- Names we ship (`WA.Widgets.BarTextures()`) pass through untouched. The aliases -- below are the common wago names matched to the closest thing we have -- flat -- fills to Flat, gradient/gloss fills to the bundled grain that looks like them. -- Anything unlisted falls back to the region default and is reported, so the -- user knows a skin was substituted rather than wondering why a bar looks plain. local BAR_TEXTURE_ALIASES = { ["Solid"] = "Flat", ["ElvUI Blank"] = "Flat", ["Details Flat"] = "Flat", ["Details Hyanda"] = "Flat", ["Details D'ictum"] = "Flat", ["Blizzard Raid Bar"] = "Blizzard", ["Blizzard Raid Bar 2"] = "Blizzard", ["Melli Dark"] = "MelliDark", ["Melli Dark Rough"] = "MelliDark", ["Minimalist"] = "Minimalist", ["X-Perl"] = "Gloss", ["X-Perl 3"] = "Gloss", ["Glaze v2"] = "Glaze2", ["Perl v2"] = "Perl2", ["Smooth v2"] = "Smoothv2", ["LiteStepLite"] = "LiteStep", ["Bantobar"] = "BantoBar", ["Skewed"] = "Smooth", } local BAR_TEXTURE_DEFAULT = "Blizzard" local PROTOTYPE_KEYS = { "width", "height", "alpha", "anchorFrameType", "anchorFrameFrame", "anchorFrameParent", "selfPoint", "anchorPoint", "xOffset", "yOffset", "frameStrata", "customText", "customTextUpdate", "customTextUpdateThrottle", } local TEXT_KEYS = { "font", "outline", "justify", "justifyV", "spacing", "shadowColor", "shadowXOffset", "shadowYOffset", } -- Wago's own bookkeeping: an id, a version stamp, the update-channel flags. It -- travels on every display and none of it is display data, so reporting it per -- key per display costs a 52-child pack 192 lines of the summary and buries -- everything in it that is a real loss. Not carried, and noted once for the -- whole import instead of dropped per display. local WAGO_BOOKKEEPING_KEYS = { "information", "semver", "skipWagoUpdate", "ignoreWagoUpdate", "preferToUpdate", "wagoID", "tocversion", } local ANIMATION_CODE_KEYS = { "translateFunc", "alphaFunc", "scaleFunc", "rotateFunc", "colorFunc", } local ACTION_CODE_KEYS = { "custom", "customOnLoad", "customOnUnload", "message_custom", } local TRIGGER_CODE_KEYS = { { key = "custom", label = "custom" }, { key = "customDuration", label = "duration" }, { key = "customName", label = "name" }, { key = "customIcon", label = "icon" }, { key = "customTexture", label = "texture" }, { key = "customStacks", label = "stacks" }, { key = "customVariables", label = "variables" }, { key = "customOverlay1", label = "overlay1" }, { key = "customOverlay2", label = "overlay2" }, { key = "customOverlay3", label = "overlay3" }, } local DISPLAY_CODE_KEYS = { { key = "customText", label = "custom text" }, { key = "customSort", label = "custom sort" }, { key = "customGrow", label = "custom grow" }, { key = "customAnchorPerUnit", label = "custom anchor" }, } -- Group fields carried beyond the region defaults. controlledChildren is -- deliberately not among them and never copied: the child list is rebuilt from -- the payload's own tree, whose ids are all reassigned on install. local GROUP_KEYS = { "customSort", "hybridPosition", "hybridSortMode", "sortHybridTable", } local GROW_TYPES = { UP = true, DOWN = true, LEFT = true, RIGHT = true, HORIZONTAL = true, VERTICAL = true, GRID = true, CIRCLE = true, COUNTERCIRCLE = true, CUSTOM = true, } -- Group fields with no local counterpart at all, each changing how the group -- behaves rather than how one aura is decorated, so each is reported. -- -- `growOn` is deliberately not among them. It is upstream's list of the state -- fields whose change re-runs a custom grow; ours re-runs the grow on every -- layout pass, so dropping it changes how often the author's function runs and -- never what it produces. The function itself is carried. local GROUP_DROP_KEYS = { "sortOn", "anchorOn" } -- A group's border here is one fixed edge; upstream picks an edge file, a -- backdrop and three insets. Reported only when the border is actually on -- -- every export carries the block whether or not it is drawn. local GROUP_BORDER_ART_KEYS = { "borderEdge", "borderOffset", "borderInset", "borderSize", "borderBackdrop", "backdropColor", "background", "backgroundInset", } local ACTION_SPECS = { init = { { key = "custom", enabled = "do_custom", body = true }, { key = "customOnLoad", enabled = "do_custom_load", body = true }, { key = "customOnUnload", enabled = "do_custom_unload", body = true }, }, start = { { key = "custom", enabled = "do_custom", body = true }, { key = "message_custom", enabled = "do_message", body = false }, }, finish = { { key = "custom", enabled = "do_custom", body = true }, { key = "message_custom", enabled = "do_message", body = false }, }, } local ACTION_DROP_KEYS = { "message_channel", } -- The glow targets Actions.lua can resolve. Upstream reaches its unit frames -- through LibGetFrame; ours resolve the same two off the region's stored unit. local GLOW_FRAME_TYPES = { PARENTFRAME = true, FRAMESELECTOR = true, UNITFRAME = true, NAMEPLATE = true, } local AURA_TRIGGER_KEYS = { "unit", "specificUnit", "debuffType", "useName", "auranames", "matchesShowOn", "ownOnly", "useStacks", "stacksOperator", "stacks", "useRem", "remOperator", "rem", "useTotal", "totalOperator", "total", "use_debuffClass", "debuffClass", } -- Upstream's name-pattern operators, and the closest thing this addon's aura -- trigger has. Ours is a plain substring test (TriggerAura's `string.find` with -- plain = true) inverted by "nomatch", so only `find('%s')` translates exactly; -- the other two are approximations and say so. local AURA_NAME_PATTERN_OPERATORS = { ["find('%s')"] = { op = "match" }, ["=="] = { op = "match", note = "exact name match becomes a substring match" }, ["match('%s')"] = { op = "match", note = "Lua pattern match becomes a substring match" }, } local CUSTOM_TRIGGER_KEYS = { "custom_type", "check", "events", "custom", "custom_hide", "duration", "customDuration", "customName", "customIcon", "customVariables", } local CUSTOM_UNSUPPORTED_KEYS = { "customTexture", "customStacks", "customOverlay1", "customOverlay2", "customOverlay3", } local AURA_CLONE_KEYS = { "combineMode", "combinePerUnit", "showClones", "perUnitMode", "useMatch_count", "match_count", "match_countOperator", "useMatchPerUnit_count", "matchPerUnit_count", "matchPerUnit_countOperator", } local CUSTOM_TYPES = { status = true, event = true, stateupdate = true } -- Generic-trigger condition variables upstream spells differently, theirs -> -- ours, per prototype -- so the `name` a dozen prototypes share on both sides is -- only redirected where it really differs. The trigger fields these belong to -- are mapped by GENERIC_ARG_NAMES, which is the same divergence seen from the -- editor's side rather than a second one. local GENERIC_VARIABLE_NAMES = { -- Upstream's aura trigger calls "did the aura match" `buffed`, and offers it -- only when the trigger shows a state either way -- which is the one case -- where our own `active` says anything, so the two are the same flag. aura = { buffed = "active" }, -- Upstream's cast trigger stores the spell name as `spell`; ours is the -- `name` every other prototype uses. cast = { spell = "name" }, health = { deficit = "healthDeficit" }, power = { deficit = "powerDeficit" }, -- A combo aura's conditions were written against upstream's Power trigger, -- so they name its `power` variable rather than ours. combopoints = { power = "comboPoints", percentpower = "percentComboPoints", deficit = "comboPointDeficit" }, charstats = { attackpower = "attackPower", spellpower = "spellPower" }, experience = { currentXP = "xp", totalXP = "xpMax", percentXP = "xpPercent" }, rangecheck = { range = "distance" }, unitcharacteristics = { name = "unitName" }, } local SUBTEXT_KEYS = { "text_text", "text_color", "text_fontSize", "text_font", "text_fontType", "text_visible", "text_justify", "text_justifyV", "text_spacing", "text_shadowColor", "text_shadowXOffset", "text_shadowYOffset", "anchor_point", "anchorXOffset", "anchorYOffset", "rotateText", } local SUBTEXT_DROP_KEYS = { "text_automaticWidth", "text_fixedWidth", "text_wordWrap", } local SUBBORDER_KEYS = { "border_visible", "border_color", "border_size", "border_offset", "anchor_mode", "anchor_area", } -- Edge art that is a plain solid line, which is exactly what SubBorder draws -- with WHITE8X8 sized by border_size. Anything outside this set is real art we -- have no counterpart for, and still reports. local SOLID_BORDER_EDGES = { ["Square Full White"] = true, ["1 Pixel"] = true, ["None"] = true, } local SUBGLOW_KEYS = { "glow", "useGlowColor", "glowColor", "glowType", "glowLines", "glowFrequency", "glowLength", "glowThickness", "glowScale", "glowBorder", "glowXOffset", "glowYOffset", "anchor_mode", "anchor_area", } local SUBTICK_KEYS = { "tick_visible", "tick_color", "tick_placement_mode", "automatic_length", "tick_thickness", "tick_length", "use_texture", "tick_texture", "tick_blend_mode", "tick_desaturate", "tick_rotation", "tick_xOffset", "tick_yOffset", "tick_mirror", "tick_placements", } local SUBREGION_TYPES = { subtext = true, subborder = true, subglow = true, subtick = true, subbackground = true, subforeground = true, } local DROPPED_FORMATS = { Unit = true, GUID = true, GCDTime = true } local function hasSource(value) return type(value) == "string" and string.find(value, "%S") ~= nil end local function reportDrop(report, reason, detail) table.insert(report.dropped, { reason = reason, detail = detail }) end -- --------------------------------------------------------------------------- -- Media paths -- -- An export carries absolute paths into the *sender's* WeakAuras install -- (`Interface\Addons\WeakAuras\PowerAurasMedia\Auras\Aura22`), and this client -- has never had that addon, so the file is not there and the region paints the -- engine's missing-texture block. The same art and sounds are bundled here, so -- the path is rewritten onto our copy. -- -- Three properties of the incoming string are load-bearing, all of them observed -- in the wago corpus: -- -- * **Case varies.** Upstream writes both `Addons` and `AddOns`, so every -- comparison happens on a lowercased copy. -- * **The extension is optional.** `...\Square_FullWhite` and -- `...\Ring_10px.tga` are both real exported values for the same kind of -- field, so a lookup that misses tries again without the extension. -- * **Either separator can appear.** Normalised to `\` before matching. -- -- The destination is looked up in the catalogues the pickers are built from -- rather than computed from the source name. Rewriting onto a file we do not -- ship would replace a dead path the report can name with one that looks live -- and still draws nothing. -- --------------------------------------------------------------------------- local MEDIA_ROOTS = { { prefix = "interface\\addons\\weakauras\\media\\textures\\", kind = "texture" }, { prefix = "interface\\addons\\weakauras\\poweraurasmedia\\auras\\", kind = "texture" }, { prefix = "interface\\addons\\weakauras\\media\\sounds\\", kind = "sound" }, { prefix = "interface\\addons\\weakauras\\poweraurasmedia\\sounds\\", kind = "sound" }, { prefix = "interface\\addons\\weakauras\\media\\fonts\\", kind = "font" }, } -- The bundled statusbars dropped upstream's Statusbar_ prefix to match the bare -- names this addon's bar picker stores, so they are the one set whose incoming -- name does not find itself in WA.textureTypes. local BAR_TEXTURE_RENAMES = { Statusbar_Clean = "Clean", Statusbar_Stripes = "Stripes", Statusbar_Stripes_Thick = "ThickStripes", Statusbar_Stripes_Thin = "ThinStripes", } local mediaIndex -- Files a texture path may omit the extension of, so both spellings resolve. local function addMedia(index, path) local _, _, file = string.find(path, "([^\\]+)$") if not file then return end local lower = string.lower(file) index[lower] = path local _, _, stem = string.find(lower, "^(.+)%.[^.]*$") if stem and index[stem] == nil then index[stem] = path end end local function buildMediaIndex() local index = { texture = {}, sound = {}, font = {} } for category, list in pairs(WA.textureTypes or {}) do for i = 1, #list do addMedia(index.texture, WA.Widgets.TexturePath(category, list[i])) end end for name, bar in pairs(BAR_TEXTURE_RENAMES) do addMedia(index.texture, WA.Widgets.BarTexturePath(bar)) -- BarTexturePath returns an extensionless path, so addMedia's own stem -- pass never fires and the upstream spelling has to be keyed by hand. index.texture[string.lower(name)] = WA.Widgets.BarTexturePath(bar) end for path in pairs(WA.bundled_sound_types or {}) do addMedia(index.sound, path) end local fonts = WA.textCore and WA.textCore.FONTS or {} for i = 1, #fonts do addMedia(index.font, fonts[i].path) end return index end -- The bundled path for a WeakAuras2 media path, or nil for anything else -- -- a path into a third-party addon, or into a WeakAuras folder whose file this -- addon does not carry. Both stay as they are and are reported. local function rewriteMedia(value) if type(value) ~= "string" or value == "" then return nil end local normalized = string.gsub(value, "/", "\\") local lower = string.lower(normalized) for i = 1, #MEDIA_ROOTS do local root = MEDIA_ROOTS[i] if string.sub(lower, 1, string.len(root.prefix)) == root.prefix then mediaIndex = mediaIndex or buildMediaIndex() local file = string.sub(lower, string.len(root.prefix) + 1) local index = mediaIndex[root.kind] local hit = index[file] if not hit then local _, _, stem = string.find(file, "^(.+)%.[^.]*$") hit = stem and index[stem] end return hit end end return nil end -- Fields whose value is a media path, wherever they sit. Walked recursively over -- the finished display rather than rewritten at each translation site, so an -- action, a condition's change value, a sub-region and a user-config default are -- all covered by one pass and none can be forgotten when a new one is added. -- -- `sound` also names a *condition property*, but that is a `property` key rather -- than a `sound` one, and the paths it points at live in the change's `value` -- table -- which this walk reaches anyway. -- -- The kind here is documentation: `rewriteMedia` takes the kind from the path's -- own MEDIA_ROOTS prefix, so this table only decides *whether* a key is walked. -- That is what lets `media` -- an author option's chosen path, whose kind is -- whatever its sibling `mediaType` says -- sit in a table keyed by one kind. local MEDIA_KEYS = { displayIcon = "texture", groupIcon = "texture", texture = "texture", foregroundTexture = "texture", backgroundTexture = "texture", sparkTexture = "texture", tick_texture = "texture", sound = "sound", sound_path = "sound", media = "sound", text_font = "font", font = "font", } local function remapMedia(node, report, label, seen) if type(node) ~= "table" then return end seen = seen or {} if seen[node] then return end seen[node] = true for key, value in pairs(node) do if type(value) == "table" then remapMedia(value, report, label, seen) elseif MEDIA_KEYS[key] then local rewritten = rewriteMedia(value) if rewritten and rewritten ~= value then node[key] = rewritten reportDrop(report, "WeakAuras media path rewritten", label .. " " .. key .. ": " .. value .. " -> " .. rewritten) end end end end local function take(dst, src, keys) if type(src) ~= "table" then return end for i = 1, #keys do local key = keys[i] if src[key] ~= nil then dst[key] = WA.DeepCopy(src[key]) end end end local function copyBlock(dst, src, key) if src[key] ~= nil then dst[key] = WA.DeepCopy(src[key]) end end -- The unit tokens a trigger may name here. `tokens` is the list the target -- trigger actually offers, and passing the wrong one imports a display that -- watches nothing: the single tokens plus the `specific` escape hatch by -- default; the multi-unit families for a trigger that fans one out into a clone -- per member (a generic prototype declaring `statesParameter = "unit"`, or the -- aura system); and the aura system's own list, which adds upstream's `multi` on -- top -- any-target GUID-keyed tracking, which TriggerAura alone has a producer -- for. A token off the end of the right list refuses the whole display, since -- importing it as some other unit is the failure that looks right and behaves -- wrong. local function isSupportedUnit(unit, tokens) if unit == nil then return true end tokens = tokens or WA.unit_tokens for i = 1, #(tokens or {}) do if tokens[i] == unit then return true end end return false end local function validateTriggerCode(source, detail, report, tableExpression) if not hasSource(source) then return true end local valid = true if type(WA.LoadFunction) == "function" then local candidate = source if tableExpression then candidate = "function() return \n" .. source .. "\n end" end valid = WA.LoadFunction(candidate, nil) ~= nil end if not valid then reportDrop(report, "custom code", detail) return false end return true end local function validateConditionCode(source, detail, report, body) if not hasSource(source) then return false end local valid = true if type(WA.LoadFunction) == "function" then valid = WA.LoadFunction(source, nil, body) ~= nil end if not valid then reportDrop(report, "custom code", detail) return false end return true end local function conditionLabel(data, index) return tostring(data.id or "?") .. " condition " .. index end -- The second return of translateConditionCheck for a check that was never -- filled in, as opposed to one that was and could not be translated. Its own -- table so it can never collide with a detail string a caller prints. local UNFILLED_CHECK = {} local function conditionTemplate(templates, trigger, variable) if trigger == -1 then return WA.globalConditions and WA.globalConditions[variable] end if type(trigger) ~= "number" or trigger < 1 then return nil end return templates[trigger] and templates[trigger][variable] end local function translateConditionCheck(source, templates, report, label, types) if type(source) ~= "table" then return nil, "missing check" end local trigger = source.trigger if trigger == -2 then if source.variable ~= "AND" and source.variable ~= "OR" then return nil, "unknown combinator " .. tostring(source.variable) end if type(source.checks) ~= "table" then return nil, "combinator has no checks" end local checks, filled = {}, 0 for i = 1, #source.checks do local child, detail = translateConditionCheck(source.checks[i], templates, report, label .. " check " .. i, types) if child then table.insert(checks, child) filled = filled + 1 elseif detail ~= UNFILLED_CHECK then filled = filled + 1 reportDrop(report, "condition check", label .. " check " .. i .. ": " .. tostring(detail)) end end if #checks == 0 then return nil, (filled == 0 and UNFILLED_CHECK) or "all combinator checks are invalid" end return { trigger = -2, variable = source.variable, checks = checks } end -- A row the author added in the options UI and never filled in. Upstream -- evaluates a check only once it names both halves (its walk falls to -- `elseif (trigger and variable)` after the -2 and -1 cases), so this is not a -- condition that failed to translate and must not be reported as one. if trigger == nil or source.variable == nil then return nil, UNFILLED_CHECK end local variable = source.variable local renames = types and types[trigger] and GENERIC_VARIABLE_NAMES[types[trigger]] if renames and renames[variable] then variable = renames[variable] end local template = conditionTemplate(templates, trigger, variable) if not template then return nil, "unknown variable " .. tostring(source.variable) .. " for trigger " .. tostring(trigger) end -- A custom check's `value` is Lua that will run and its `op` the event list -- that runs it, so unlike every other check it has to clear the same syntax -- bar a condition's custom-code *change* does. Source that will not compile -- drops the check rather than importing a condition that can only be false. if trigger == -1 and variable == "customcheck" then -- No code at all is a row the author added and never filled in, which -- upstream generates no test for -- the same reading the trigger/variable -- guard above gives an empty check. if not hasSource(source.value) then return nil, UNFILLED_CHECK end if not validateConditionCode(source.value, label .. " custom check", report) then return nil, "custom check code" end end local check = { trigger = WA.DeepCopy(trigger), variable = WA.DeepCopy(variable) } if source.op ~= nil then check.op = WA.DeepCopy(source.op) end if source.value ~= nil then check.value = WA.DeepCopy(source.value) end return check end local function conditionCodeValue(value) if type(value) == "table" and type(value.custom) == "string" then return value.custom end if type(value) == "string" then return value end return nil end local function translateConditionChanges(source, properties, report, label) if type(source) ~= "table" then return nil, "missing changes" end local changes = {} for i = 1, #source do local change = source[i] if type(change) ~= "table" then return nil, "invalid change" end -- A property-less change is a row the author added and never filled in. -- Upstream's code generator emits nothing for it, so skipping it is what -- upstream does -- and refusing the whole condition over it would take -- out the filled rows beside it. if change.property ~= nil and properties[change.property] == nil then return nil, "unknown property " .. tostring(change.property) end if change.property ~= nil then local property = change.property local value = WA.DeepCopy(change.value) -- An absent value is not an unfilled row: upstream serializes the *off* -- setting of a bool as no value at all, so a "turn the glow off" change -- arrives looking identical to one the author never filled in. Its code -- generator coerces nil per property type (formatValueForAssignment), and -- dropping the change instead leaves the property latched on once any -- condition has set it -- which is how a pack's glow never goes out. -- -- Only the types upstream gives a nil a meaning are coerced. The rest -- -- list, icon, sound, chat, glowexternal -- generate `nil` there too, so -- for those the row really is unset and still drops. if change.value == nil then local ptype = properties[property].type if ptype == "bool" then value = false elseif ptype == "number" then value = 0 elseif ptype == "color" then value = { 1, 1, 1, 1 } elseif ptype == "string" or ptype == "texture" then value = "" end if value == nil then reportDrop(report, "condition change", label .. " " .. tostring(property) .. ": no value set") else table.insert(changes, { property = WA.DeepCopy(property), value = value }) end elseif property == "customcode" then local code = conditionCodeValue(value) if code and validateConditionCode(code, label .. " " .. property, report, true) then table.insert(changes, { property = WA.DeepCopy(property), value = value }) elseif not code then reportDrop(report, "custom code", label .. " " .. property) end else table.insert(changes, { property = WA.DeepCopy(property), value = value }) end end end return changes end local function translateConditions(source, data, report) if type(source) ~= "table" then reportDrop(report, "condition", conditionLabel(data, 1) .. ": invalid conditions") return {} end data.triggers = data.triggers or {} local templates = WA.GetConditionTemplates(data) local properties = WA.GetProperties(data) local types = {} for i = 1, #data.triggers do local entry = data.triggers[i] types[i] = entry and entry.trigger and entry.trigger.type end local conditions = {} for i = 1, #source do local label = conditionLabel(data, i) local item = source[i] local check, checkDetail = translateConditionCheck(item and item.check, templates, report, label, types) local changes, changeDetail if check then changes, changeDetail = translateConditionChanges(item and item.changes, properties, report, label) end if check and changes then table.insert(conditions, { check = check, changes = changes }) elseif checkDetail == UNFILLED_CHECK then -- Nothing was asked for, so nothing was lost. else reportDrop(report, "condition", label .. ": " .. tostring(checkDetail or changeDetail)) end end return conditions end local function loadLabel(data, field) return tostring(data.id or "?") .. ": " .. field end local function loadValuePresent(value) if value == nil or value == false then return false end if type(value) == "string" then return value ~= "" end if type(value) == "table" then for _, child in pairs(value) do if loadValuePresent(child) then return true end end return false end return true end local function selectedLoadValues(block) local values = {} if type(block) ~= "table" or type(block.multi) ~= "table" then return values end for key, selected in pairs(block.multi) do if selected then table.insert(values, key) end end return values end -- Every one of these constraints takes a set here, so upstream's shape lands -- whole and the local values need no collapsing. `use_` false is -- upstream's "several values" rather than off -- the same overload the generic -- trigger args cross, undone by the same reading. local function translateLoadMultiselect(source, destination, field, report, data) local use = source["use_" .. field] local block = source[field] if use == nil or not loadValuePresent(block) then return end if use == true then local single = type(block) == "table" and block.single or nil if single == nil then local selected = selectedLoadValues(block) single = #selected == 1 and selected[1] or nil end if single ~= nil then destination["use_" .. field] = "single" destination[field] = WA.DeepCopy(single) return end else local selected = selectedLoadValues(block) if #selected > 0 then destination["use_" .. field] = "multi" destination[field .. "_multi"] = {} for i = 1, #selected do destination[field .. "_multi"][selected[i]] = true end return end end reportDrop(report, "load constraint", loadLabel(data, field) .. " has an unsupported multi-select") end -- Upstream's "Class and Specialization" names a retail/MoP-Classic spec id; -- vanilla has no specs, so the class half is honoured and the narrowing within -- the class is the reported loss. Cata Classic hands out talent-tree ids -- instead of spec ids and only the druid triple (748/750/752) has been seen in -- the wild and verified; a wrong class here would hide the display for the -- class that owns it, which is worse than the report, so nothing else from that -- range is guessed at. Classes this client has never had (DEATHKNIGHT and -- later) keep their token: it can never match, which is exactly what a -- DK-only display loading on a vanilla realm should do. local SPEC_ID_CLASS = { [62] = "MAGE", [63] = "MAGE", [64] = "MAGE", [65] = "PALADIN", [66] = "PALADIN", [70] = "PALADIN", [71] = "WARRIOR", [72] = "WARRIOR", [73] = "WARRIOR", [102] = "DRUID", [103] = "DRUID", [104] = "DRUID", [105] = "DRUID", [250] = "DEATHKNIGHT", [251] = "DEATHKNIGHT", [252] = "DEATHKNIGHT", [253] = "HUNTER", [254] = "HUNTER", [255] = "HUNTER", [256] = "PRIEST", [257] = "PRIEST", [258] = "PRIEST", [259] = "ROGUE", [260] = "ROGUE", [261] = "ROGUE", [262] = "SHAMAN", [263] = "SHAMAN", [264] = "SHAMAN", [265] = "WARLOCK", [266] = "WARLOCK", [267] = "WARLOCK", [268] = "MONK", [269] = "MONK", [270] = "MONK", [577] = "DEMONHUNTER", [581] = "DEMONHUNTER", [1467] = "EVOKER", [1468] = "EVOKER", [1473] = "EVOKER", [748] = "DRUID", [750] = "DRUID", [752] = "DRUID", } local function translateLoadClassAndSpec(source, destination, report, data) local use = source.use_class_and_spec local block = source.class_and_spec if use == nil or not loadValuePresent(block) then return end local ids if use == true then local single = type(block) == "table" and block.single or nil if single == nil then local selected = selectedLoadValues(block) single = #selected == 1 and selected[1] or nil end ids = { single } else ids = selectedLoadValues(block) end local classes, n = {}, 0 for i = 1, #ids do local cls = SPEC_ID_CLASS[tonumber(ids[i]) or -1] if cls and not classes[cls] then classes[cls] = true n = n + 1 end end if n == 0 then reportDrop(report, "load constraint", loadLabel(data, "class_and_spec") .. " has no mappable class") return end -- A source carrying both constraints already narrowed by class; layering the -- widened copy over it would say nothing new. if not destination.use_class then destination.use_class = "multi" destination.class_multi = classes end reportDrop(report, "load constraint", loadLabel(data, "class_and_spec") .. " kept as class only") end -- Upstream's Instance Size Type. This client cannot read an instance's size, so -- the values land on Load.lua's approximated `instancesize` buckets; the -- retail-and-later buckets this client can never be in are dropped from a set -- silently -- they can never match here, so unticking them loses nothing -- -- and refuse a single, where the author's one chosen value is the whole -- constraint. local INSTANCE_SIZE_BUCKETS = { none = true, party = true, ten = true, twenty = true, twentyfive = true, fortyman = true, pvp = true, } local function translateLoadInstanceSize(source, destination, report, data) local use = source.use_size local block = source.size if use == nil or not loadValuePresent(block) then return end if use == true then local single = type(block) == "table" and block.single or nil if single == nil then local selected = selectedLoadValues(block) single = #selected == 1 and selected[1] or nil end if single ~= nil and INSTANCE_SIZE_BUCKETS[single] then destination.use_instancesize = "single" destination.instancesize = WA.DeepCopy(single) return end else local selected = selectedLoadValues(block) local set, n = {}, 0 for i = 1, #selected do if INSTANCE_SIZE_BUCKETS[selected[i]] then set[selected[i]] = true n = n + 1 end end if n > 0 then destination.use_instancesize = "multi" destination.instancesize_multi = set return end end reportDrop(report, "load constraint", loadLabel(data, "size") .. " has an unsupported value") end local function translateLoad(source, data, report) if type(source) ~= "table" then return {} end local destination = {} if source.never or source.use_never then destination.never = true end for _, field in ipairs({ "class", "race", "faction", "ingroup" }) do translateLoadMultiselect(source, destination, field, report, data) end translateLoadClassAndSpec(source, destination, report, data) translateLoadInstanceSize(source, destination, report, data) local tristates = { combat = { trueValue = "incombat", falseValue = "outofcombat" }, alive = { trueValue = "alive", falseValue = "dead" }, mounted = { trueValue = "mounted", falseValue = "notmounted" }, vehicle = { trueValue = "ontaxi", falseValue = "nottaxi" }, } for field, values in pairs(tristates) do if source["use_" .. field] and source[field] ~= nil then destination["use_" .. field] = true destination[field] = source[field] and values.trueValue or values.falseValue end end local simple = { "level", "zone", "player", "realm", "guild" } -- Load.lua's stance constraint takes the multi-select tier, and what a source -- carrying one holds is the single bar position an older WeakAuras stored. -- Coerced, since the position is matched against a number. if source.use_stance and tonumber(source.stance) then destination.use_stance = "single" destination.stance = tonumber(source.stance) end for i = 1, #simple do local field = simple[i] if source["use_" .. field] and source[field] ~= nil then destination["use_" .. field] = true destination[field] = WA.DeepCopy(source[field]) if source[field .. "_operator"] ~= nil then destination[field .. "_operator"] = WA.DeepCopy(source[field .. "_operator"]) end end end if source.use_groupSize and source.groupSize ~= nil then destination.use_size = true destination.size = WA.DeepCopy(source.groupSize) destination.size_operator = WA.DeepCopy(source.groupSize_operator or source.groupSizeOperator or ">=") end for _, field in ipairs({ "spellknown", "not_spellknown", "itemequiped", "not_itemequiped" }) do if source["use_" .. field] and loadValuePresent(source[field]) then destination["use_" .. field] = true destination[field] = WA.DeepCopy(source[field]) end end local consumed = { never = true, use_never = true, class = true, race = true, faction = true, ingroup = true, combat = true, alive = true, mounted = true, vehicle = true, level = true, zone = true, stance = true, player = true, realm = true, guild = true, groupSize = true, groupSize_operator = true, groupSizeOperator = true, spellknown = true, not_spellknown = true, itemequiped = true, not_itemequiped = true, class_and_spec = true, use_class_and_spec = true, size = true, use_size = true, } consumed.use_zoneIds = true -- `spec` is a fossil, not a loss: the load option was Shadowlands-retail-only -- (hidden and inert on every Classic flavor, whose clients have no -- GetSpecialization) and upstream deleted it outright in late 2022. Every -- pack observed carrying it is a Classic export whose own client ignores it -- -- the warrior packs gate Mortal Strike, Bloodthirst and Shield Slam all on -- "spec 1" -- so enforcing it would hide displays their authors see. consumed.spec = true consumed.use_spec = true for _, field in ipairs(simple) do consumed[field .. "_operator"] = true end for _, field in ipairs({ "combat", "alive", "mounted", "vehicle", "class", "race", "faction", "ingroup", "level", "zone", "stance", "player", "realm", "guild", "groupSize", "spellknown", "not_spellknown", "itemequiped", "not_itemequiped" }) do consumed["use_" .. field] = true end consumed.use_groupSize = true for key, value in pairs(source) do if not consumed[key] and type(key) == "string" and string.sub(key, 1, 4) == "use_" and value and loadValuePresent(source[string.sub(key, 5)]) then reportDrop(report, "load constraint", loadLabel(data, string.sub(key, 5))) end end if source.use_zoneIds and loadValuePresent(source.zoneIds) then reportDrop(report, "load constraint", loadLabel(data, "zoneIds")) end return destination end local function reportStateCompatibility(trigger, triggernum, report) if trigger.custom_type ~= "stateupdate" then return end local code = tostring(trigger.custom or "") .. "\n" .. tostring(trigger.customVariables or "") if string.find(code, "additionalProgress", 1, true) then reportDrop(report, "unsupported custom state", "trigger " .. triggernum .. ": additionalProgress") end if string.find(code, "tooltip", 1, true) then reportDrop(report, "unsupported custom state", "trigger " .. triggernum .. ": state.tooltip") end if string.find(code, "modRate", 1, true) or string.find(code, "useModRate", 1, true) then reportDrop(report, "unsupported custom state", "trigger " .. triggernum .. ": modRate") end end -- Upstream keeps names and spell ids in two lists; ours keeps one, whose entries -- are read as an id when they parse as a number (TriggerAura's buildEntries). So -- the spell ids append to the name list rather than needing a second field. local function translateAuraSpellIds(trigger, source) local ids = source.auraspellids if type(ids) ~= "table" or #ids == 0 then return end trigger.auranames = trigger.auranames or {} for i = 1, #ids do local id = tonumber(ids[i]) if id then table.insert(trigger.auranames, tostring(id)) end end if #trigger.auranames > 0 then trigger.useName = true end end -- namePattern_name/_operator upstream, namePattern/namePatternOperator here. -- Carrying useNamePattern without the pattern is the worst of the three -- outcomes: the runtime skips an empty pattern, so the aura silently stops -- filtering by name at all. local function translateAuraNamePattern(trigger, source, triggernum, report) if not source.useNamePattern then return end local pattern = source.namePattern_name if type(pattern) ~= "string" or pattern == "" then reportDrop(report, "aura name pattern", "trigger " .. triggernum .. ": no pattern text") return end local mapped = AURA_NAME_PATTERN_OPERATORS[source.namePattern_operator or "find('%s')"] if not mapped then reportDrop(report, "aura name pattern", "trigger " .. triggernum .. ": unsupported operator " .. tostring(source.namePattern_operator)) return end trigger.useNamePattern = true trigger.namePattern = WA.DeepCopy(pattern) trigger.namePatternOperator = mapped.op if mapped.note then reportDrop(report, "aura name pattern", "trigger " .. triggernum .. ": " .. mapped.note) end end -- Upstream's group-wide match count -- `useGroup_count` plus an operator and a -- count, meaning "how many of the group matched". It is `match_count` wearing a -- different spelling, so the engine gap AURA_CLONE_KEYS refuses over is the same -- one; but it arrives on the trigger rather than in the clone block, and -- refusing over it would take out the whole raid-buff family. -- -- The trigger imports and shows one clone per matching member. Naming the loss -- matters because the common value inverts what the display means: `== 0` is -- "nobody in the group has this buff", and what imports is "show per member who -- does". local function translateAuraGroupCount(source, triggernum, report) if not source.useGroup_count then return end reportDrop(report, "aura group match count", "trigger " .. triggernum .. ": " .. tostring(source.group_countOperator or "==") .. " " .. tostring(source.group_count)) end local function translateAuraTrigger(source, triggernum, report) if not isSupportedUnit(source.unit, WA.unit_tokens_aura) then report.refused = "trigger " .. triggernum .. " uses unsupported unit " .. tostring(source.unit) return nil end for i = 1, #AURA_CLONE_KEYS do local key = AURA_CLONE_KEYS[i] if source[key] ~= nil and (key == "combineMode" or source[key]) then report.refused = "trigger " .. triggernum .. " uses clone-dependent aura setting " .. key return nil end end local trigger = {} take(trigger, source, AURA_TRIGGER_KEYS) trigger.type = "aura" translateAuraGroupCount(source, triggernum, report) translateAuraSpellIds(trigger, source) translateAuraNamePattern(trigger, source, triggernum, report) -- A trigger with the name filters off and nothing to match on never shows -- (TriggerAura's buildTriggerInfo skips it), which looks like an aura that -- imported fine and is simply broken. Naming it is the whole difference. if not trigger.useName and not trigger.useNamePattern then reportDrop(report, "aura trigger matches nothing", "trigger " .. triggernum .. ": no name or spell id survived translation") end return trigger end local function translateCustomTrigger(source, entry, triggernum, report) if source.custom_type ~= nil and not CUSTOM_TYPES[source.custom_type] then report.refused = "trigger " .. triggernum .. " uses unsupported custom type " .. tostring(source.custom_type) return nil end local trigger = {} take(trigger, source, CUSTOM_TRIGGER_KEYS) trigger.type = "custom" -- The event list travels as written -- including retail names like -- UNIT_POWER_UPDATE and GROUP_ROSTER_UPDATE, which GenericTrigger's -- EVENT_COMPAT registers and fires natively. Rewriting them here would make -- an imported trigger's events box mean something different from a -- hand-written one's, and would leave the author's own `event ==` tests -- comparing against names the rewrite took away. for i = 1, #CUSTOM_UNSUPPORTED_KEYS do local key = CUSTOM_UNSUPPORTED_KEYS[i] if source[key] ~= nil then reportDrop(report, "unsupported custom field", "trigger " .. triggernum .. ": " .. key) end end local codeFields = { { key = "custom", detail = "custom", tableExpression = false }, { key = "customDuration", detail = "duration", tableExpression = false }, { key = "customName", detail = "name", tableExpression = false }, { key = "customIcon", detail = "icon", tableExpression = false }, { key = "customVariables", detail = "variables", tableExpression = true }, } for i = 1, #codeFields do local field = codeFields[i] if trigger[field.key] ~= nil and not validateTriggerCode(trigger[field.key], "trigger " .. triggernum .. " " .. field.detail, report, field.tableExpression) then trigger[field.key] = nil end end local untrigger = entry and entry.untrigger if type(untrigger) == "table" and untrigger.custom ~= nil then if validateTriggerCode(untrigger.custom, "trigger " .. triggernum .. " uncustom", report, false) then untrigger = { custom = WA.DeepCopy(untrigger.custom) } else untrigger = {} end else untrigger = {} end reportStateCompatibility(source, triggernum, report) return trigger, untrigger end -- The local prototype behind an upstream `trigger.event` key, answered from the -- prototypes' own `wa2Event` declarations rather than from a list written out -- here: a prototype that declares one becomes importable with no edit, and one -- that declares none (`combatevents`, whose name collides with upstream's Combat -- Log without sharing its source) stays refused. -- Walked per lookup rather than cached: the trigger types register after this -- file's chunk runs, and a cache built on the first import would not see a type -- registered after it -- which is the property this derivation exists for. local function genericPrototypeFor(event) if type(event) ~= "string" then return nil end for key, spec in pairs(WA.triggerTypes or {}) do if spec.wa2Event == event then return key end end return nil end -- Upstream arg names the local prototype spells differently, ours -> theirs. -- Every one of these is a stored condition variable here, so aligning the name -- would have to walk each saved condition and each text placeholder that names -- it; the mapping costs a line and loses nothing, since GENERIC_VARIABLE_NAMES -- renames an imported condition's variable through the same knowledge. local GENERIC_ARG_NAMES = { health = { healthDeficit = "deficit" }, power = { powerDeficit = "deficit" }, -- Upstream's `hastepercent` is deliberately absent: theirs is a rating -- conversion, ours the cast-speed multiplier, and equating them would carry -- a wrong number across rather than none. charstats = { attackPower = "attackpower", spellPower = "spellpower" }, experience = { xp = "currentXP", xpPercent = "percentXP" }, rangecheck = { distance = "range" }, unitcharacteristics = { unitName = "namerealm" }, -- A combo trigger arrives as a Power trigger (see COMBO_POINT_POWER_TYPE), -- so its threshold is upstream's `power` and its operator `power_operator`. combopoints = { comboPoints = "power" }, conditions = { groupType = "ingroup" }, combatlog = { spellIdList = "spellId", spellNameList = "spellName" }, } -- Where a mapped arg's *values* diverge as well as its name, ours -> theirs. -- Only one does: upstream's group_types calls a party "group", and the local -- name is the one `WA.ConditionGroupType` reports and a saved condition on the -- stored variable already compares against. local GENERIC_ARG_VALUES = { conditions = { groupType = { solo = "solo", party = "group", raid = "raid" } }, } -- WeakAuras2 has no combo-point trigger. On every client it builds against, -- combo points *are* a power type -- `Enum.PowerType.ComboPoints` is 4 -- so a -- combo aura exports as a Power trigger with `powertype = 4`, which is what the -- whole ComboFill / ring-accent family on wago is made of. -- -- Index 4 on this client is `Happiness`, vanilla pet happiness (ClassicAPI's -- Enum.PowerType is 1.12's, not modern's), and combo points are not a power type -- here at all -- `GetComboPoints` is the only source. Translating the number -- literally yields a trigger testing `UnitPowerType(unit) == 4`, which can never -- be true for a player, so every such display imports silently invisible. -- -- Upstream's own non-retail branch special-cases the same number to -- `GetComboPoints(unit, unit .. '-target')`, which is exactly what -- PROTOTYPES["combopoints"] does, so the trigger is re-pointed at that -- prototype. It stays a redirect rather than a second `wa2Event = "Power"` -- declaration because genericPrototypeFor returns the first match out of a -- `pairs` walk -- two prototypes claiming one event would resolve at random. local COMBO_POINT_POWER_TYPE = 4 -- Power types this client has a bar for. Upstream offers every expansion's, -- and one we have no equivalent of decides what the trigger matches, so it is -- refused rather than imported as some other resource. local SUPPORTED_POWER_TYPES = { [0] = true, [1] = true, [2] = true, [3] = true } -- A select arrives either bare or in upstream's { single = } / { multi = } -- wrapper; powertype has to be read before the walker unwraps it. local function selectNumber(value) if type(value) == "table" then if value.single ~= nil then return tonumber(value.single) end for key, selected in pairs(value.multi or {}) do if selected then return tonumber(key) end end return nil end return tonumber(value) end -- Upstream trigger settings with no local counterpart. `refuse` names one that -- decides or inverts what the trigger matches, where importing without it would -- claim the aura does something it does not; `drop` names one that only widens -- the match, which is reported the way a dropped load constraint is. A function -- decides from the value, for a setting whose default is harmless. local GENERIC_UNSUPPORTED = { cast = { spell = "refuse", spellNames = "refuse", spellId = "refuse", castType = "drop", interruptible = "drop", sourceUnit = "drop", destUnit = "drop" }, castsucceeded = { spellNames = "refuse", spellId = "refuse" }, -- ClassicAPI's _ENERGIZE payload has no over-energize value to test. combatlog = { overEnergize = "drop" }, -- Upstream splits an instance by raid size and by difficulty, neither of -- which this client reports; its instance *type* list is the same split, so -- landing it would widen "25 man" into every raid. All three widen, so all -- three are reported rather than silently ignored. conditions = { instance_type = "drop", instance_size = "drop", instance_difficulty = "drop" }, crowdcontrol = { spellName = "drop" }, itemequipped = { itemSlot = "drop" }, itemset = { equipped = "drop" }, location = { zoneIds = "drop", instanceId = "drop", instanceSize = "drop", instanceDifficulty = "drop" }, power = { showCost = "drop", powertype = function(value) local index = selectNumber(value) if index == nil or SUPPORTED_POWER_TYPES[index] then return nil end -- 4 never reaches here: it is redirected to combopoints first. return "refuse" end }, -- The combo route inherits upstream's Power settings, and the resource-shaped -- ones have no counterpart on a count out of five. `requirePowerType` stays a -- drop here where the Power prototype now carries it: GetComboPoints is not a -- power read, so there is no displayed-type test to hang it on. combopoints = { requirePowerType = "drop", showCost = "drop", percentpower = "drop", deficit = "drop" }, reputation = { factionID = "refuse", watched = "refuse" }, talentknown = { talent = "refuse", spec = "refuse" }, totem = { totemName = "refuse", totemNamePattern = "refuse", clones = "refuse" }, unitcharacteristics = { class = "drop", hostility = "drop", character = "drop", unitisunit = "drop", npcId = "drop", dead = "drop" }, -- showOn is spelled and valued as upstream spells it, so it lands with no -- entry here at all. weaponenchant = { enchant = "refuse", stacks = "drop" }, } local GENERIC_CODE_DROPS = { "customDuration", "customName", "customIcon" } -- Upstream's number filters travel as strings, and its comparison filters as -- one-entry arrays once the user has ever opened the second bound. local GENERIC_OPERATORS = { ["=="] = "==", ["~="] = "~=", ["<"] = "<", ["<="] = "<=", [">"] = ">", [">="] = ">=", ["find('%s')"] = "find", } -- Whether upstream's trigger actually applies a setting. `use_` false is a -- multiselect's "several values" mode rather than "off", so a value still present -- under it counts as applied. local function upstreamSetting(source, key) local use = source["use_" .. key] if use == false then return type(source[key]) == "table" and loadValuePresent(source[key]) end if use ~= nil then return true end return loadValuePresent(source[key]) end -- The keys a prototype's editor writes, from the defaults its own args build. -- `use_`, `_operator`, `_multi` and the `2` pair qualify -- a base key rather than being keys in their own right, and are taken with it. local function genericBaseKeys(defaults) local bases = {} for key in pairs(defaults) do local companion = string.sub(key, 1, 4) == "use_" or string.find(key, "_operator$") ~= nil or string.find(key, "_multi$") ~= nil if not companion then local _, _, stem = string.find(key, "^(.+)2$") companion = stem ~= nil and defaults[stem] ~= nil end if not companion then table.insert(bases, key) end end return bases end -- Upstream's multiselect shape onto a local one. The mode is carried by -- `use_`, which upstream overloads: true is "one value" and *false* is -- "several", the state a plain boolean gate would read as off. Ours spells the -- three states out, so this is where the overload is undone. -- `wantNumber` follows the local default's type -- a set's keys are strings once -- they have been through a serialiser, whatever the domain is. -- `incoming` maps upstream's values onto ours where the two vocabularies differ; -- a value missing from it has no local counterpart and is skipped rather than -- stored, since a filter carrying a value this client never reports would match -- nothing while looking configured. The caller reports what was skipped. local function landMultiSelect(trigger, base, value, use, wantNumber, incoming, skipped) local function coerce(v) if incoming then local mapped = incoming[v] if mapped == nil then table.insert(skipped, tostring(v)) end return mapped end if not wantNumber then return v end return tonumber(v) or v end if use == false then local set = {} for key, selected in pairs((type(value) == "table" and value.multi) or {}) do if selected then local mapped = coerce(key) if mapped ~= nil then set[mapped] = true end end end trigger["use_" .. base] = "multi" trigger[base .. "_multi"] = set elseif use then local single = type(value) == "table" and value.single or value local mapped = single ~= nil and coerce(single) or nil if mapped == nil then -- Nothing left to match on; an empty single filter would be a filter -- that can never pass, where off is what the author would recognise. trigger["use_" .. base] = false else trigger["use_" .. base] = "single" trigger[base] = mapped end else trigger["use_" .. base] = false end end -- Upstream's multiEntry table onto a local list, entries as trimmed strings. A -- save from before the field took several entries keeps one bare value there. -- `csv` is the NPC ID filter's shape instead: one comma-separated string whose -- "-" entries exclude (ParseStringCheck), kept here as one "-ID" entry each. local function landList(value, csv) if value == nil then return nil end local raw = {} if type(value) == "table" then for i = 1, #value do raw[i] = value[i] end elseif csv and type(value) == "string" then for part in string.gmatch(value, "[^,]+") do table.insert(raw, part) end else raw[1] = value end local out = {} for i = 1, #raw do local _, _, negate, rest = string.find(tostring(raw[i]), "^%s*(%-?)%s*(.-)%s*$") if rest ~= "" then table.insert(out, negate .. rest) end end return out end -- One value out of upstream's multiselect shape, or nil when it names several: -- a select here holds one value and cannot express the set. local function singleSelectValue(value, use) if use ~= false and value.single ~= nil then return value.single end local found for key, selected in pairs(value.multi or {}) do if selected then if found ~= nil then return nil end found = key end end if found == nil then return value.single end return found end -- Upstream keys Item Type Equipped's one multiselect on -- `classID * 256 + subclassID`, where the class is its own select here and the -- subclasses a set inside it. Two fields cannot hold a selection spanning two -- item classes (a shield beside a list of weapons), so that one is refused -- rather than imported as whichever class the walk happened to see first. local ITEM_TYPE_CLASS_STRIDE = 256 local function translateItemTypeEquipped(trigger, source, label, report) -- Upstream's slot filter is a plain select, so its `use_` key is a real -- on/off gate; ours is always-on with an "Any Slot" entry, which is what an -- ungated upstream trigger means. if not upstreamSetting(source, "itemSlot") then trigger.itemSlot = 0 end if not upstreamSetting(source, "itemTypeName") then return true end local value = source.itemTypeName local ids = {} if type(value) == "table" then if source.use_itemTypeName == false then for key, selected in pairs(value.multi or {}) do if selected then table.insert(ids, tonumber(key)) end end elseif value.single ~= nil then table.insert(ids, tonumber(value.single)) end elseif value ~= nil then table.insert(ids, tonumber(value)) end local classID, subclasses = nil, {} for i = 1, #ids do local combined = ids[i] if combined then local class = math.floor(combined / ITEM_TYPE_CLASS_STRIDE) if classID ~= nil and classID ~= class then report.refused = label .. " selects item types from more than one item class" return false end classID = class subclasses[math.fmod(combined, ITEM_TYPE_CLASS_STRIDE)] = true end end if classID == nil then return true end trigger.itemClassID = classID trigger.use_itemSubclassID = "multi" trigger.itemSubclassID_multi = subclasses return true end local function translateGenericTrigger(source, triggernum, report) local protoKey = genericPrototypeFor(source.event) if not protoKey then report.refused = "trigger " .. triggernum .. " event " .. tostring(source.event) .. " is not supported" return nil end local label = "trigger " .. triggernum .. " " .. tostring(source.event) -- Power type 4 is combo points upstream and pet happiness here, so the -- trigger is re-pointed before anything reads the prototype it named. if protoKey == "power" and upstreamSetting(source, "powertype") and selectNumber(source.powertype) == COMBO_POINT_POWER_TYPE then -- GetComboPoints answers for the player's points on the player's target -- and nothing else, so a combo trigger watching another unit cannot be -- honoured -- and importing it as the player's would claim the aura -- watches something it does not. if source.unit ~= nil and source.unit ~= "player" then report.refused = label .. " reads combo points on " .. tostring(source.unit) .. ", which this client can only answer for the player" return nil end protoKey = "combopoints" reportDrop(report, "combo points imported as their own trigger", label .. ": power type 4 is combo points upstream and pet happiness here") end local spec = WA.triggerTypes[protoKey] or {} local defaults = spec.defaults or {} -- An inverted match is never a widening: a prototype without its own inverse -- would show exactly when the author meant it to hide. if defaults.inverse == nil and source.use_inverse then report.refused = label .. " is inverted, which this trigger cannot express" return nil end -- Upstream offers these on every trigger; here they are compiled only for a -- custom one, so on a prototype they would be code nothing ever runs. for i = 1, #GENERIC_CODE_DROPS do if hasSource(source[GENERIC_CODE_DROPS[i]]) then reportDrop(report, "unsupported trigger code", label .. ": " .. GENERIC_CODE_DROPS[i]) end end local unsupported = GENERIC_UNSUPPORTED[protoKey] or {} for key, verdict in pairs(unsupported) do if upstreamSetting(source, key) then if type(verdict) == "function" then verdict = verdict(source[key]) end if verdict == "refuse" then report.refused = label .. " uses " .. key .. ", which has no counterpart here" return nil elseif verdict == "drop" then reportDrop(report, "unsupported trigger filter", label .. ": " .. key) end end end local names = GENERIC_ARG_NAMES[protoKey] or {} local trigger = { type = protoKey } local listArgs = {} for i = 1, #(spec.args or {}) do if spec.args[i].type == "list" then listArgs[spec.args[i].name] = spec.args[i] end end local bases = genericBaseKeys(defaults) for i = 1, #bases do local base = bases[i] local srcKey = names[base] or base local wantNumber = type(defaults[base]) == "number" -- A list lands from the arg declarations below: read as a scalar here, -- its entries past the second would be lost. if listArgs[base] then -- landed below -- A multiselect owns its own gate key, so it lands whole and skips the -- gate/operator/second-bound handling the scalar filters share. elseif defaults[base .. "_multi"] ~= nil then local ours = (GENERIC_ARG_VALUES[protoKey] or {})[base] local incoming, skipped if ours then incoming, skipped = {}, {} for localValue, upstreamValue in pairs(ours) do incoming[upstreamValue] = localValue end end landMultiSelect(trigger, base, source[srcKey], source["use_" .. srcKey], wantNumber, incoming, skipped) for i = 1, #(skipped or {}) do reportDrop(report, "unsupported trigger filter", label .. ": " .. base .. " value " .. skipped[i]) end else local value, second = source[srcKey], nil local operator, operator2 = source[srcKey .. "_operator"], nil if type(value) == "table" and (value.single ~= nil or value.multi ~= nil) then value = singleSelectValue(value, source["use_" .. srcKey]) if value == nil then reportDrop(report, "unsupported trigger filter", label .. ": " .. base .. " selects a set this trigger cannot express") end elseif type(value) == "table" then value, second = value[1], value[2] end if type(operator) == "table" then operator, operator2 = operator[1], operator[2] end if wantNumber then value, second = tonumber(value), tonumber(second) end if defaults["use_" .. base] ~= nil then local use = source["use_" .. srcKey] if use ~= nil then trigger["use_" .. base] = use and true or false end if value ~= nil then trigger[base] = WA.DeepCopy(value) end if operator ~= nil then local mapped = GENERIC_OPERATORS[operator] if mapped then trigger[base .. "_operator"] = mapped else trigger["use_" .. base] = false reportDrop(report, "unsupported trigger filter", label .. ": " .. base .. " " .. tostring(operator)) end end if second ~= nil then if defaults[base .. "2"] ~= nil then trigger["use_" .. base .. "2"] = true trigger[base .. "2"] = WA.DeepCopy(second) if GENERIC_OPERATORS[operator2] then trigger[base .. "2_operator"] = GENERIC_OPERATORS[operator2] end else reportDrop(report, "unsupported trigger filter", label .. ": second " .. base .. " bound") end end elseif type(defaults[base]) == "boolean" then -- A plain flag: upstream keeps it under `use_` and leaves the -- name itself for whatever the flag qualifies, where a toggle here is -- the bare key and nothing else. -- -- Written even when the source carries neither spelling. An absent -- upstream toggle is off, and a prototype's `migrate` hook reads a -- missing key as "saved before this toggle existed" -- Power's does, -- to keep an old trigger's implicit narrowing -- so leaving it nil -- would hand an import a migration meant for local data. local flag = source["use_" .. srcKey] if flag == nil then flag = value end trigger[base] = flag and true or false elseif value ~= nil then trigger[base] = WA.DeepCopy(value) end end end -- A tristate is upstream's use_ on its own -- nil, true or false -- -- with no base key in the defaults for the walk above to find, so it is -- taken from the arg declarations and lands verbatim. for i = 1, #(spec.args or {}) do local arg = spec.args[i] if arg.type == "tristate" then local use = source["use_" .. (names[arg.name] or arg.name)] if use == true or use == false then trigger["use_" .. arg.name] = use end end end for name, arg in pairs(listArgs) do local srcKey = names[name] or name local use = source["use_" .. srcKey] if use ~= nil then trigger["use_" .. name] = use and true or false end local entries = landList(source[srcKey], arg.listNegate) if entries then trigger[name] = entries end end if protoKey == "itemtypeequipped" and not translateItemTypeEquipped(trigger, source, label, report) then return nil end local fansOut = spec.statesParameter == "unit" if defaults.unit ~= nil and not isSupportedUnit(trigger.unit, fansOut and WA.unit_tokens_multi) then report.refused = label .. " uses unsupported unit " .. tostring(trigger.unit) return nil end -- The prototype's own verdict on a setting it cannot express, in its words. if spec.importCheck then local reason = spec.importCheck(trigger) if reason then report.refused = label .. " " .. reason return nil end end return trigger end local function translateTriggerEntry(entry, triggernum, report) if type(entry) ~= "table" or type(entry.trigger) ~= "table" then report.refused = "trigger " .. triggernum .. " has no trigger data" return nil end local source = entry.trigger local trigger, untrigger if source.type == "aura2" then trigger = translateAuraTrigger(source, triggernum, report) elseif source.type == "custom" then trigger, untrigger = translateCustomTrigger(source, entry, triggernum, report) elseif source.type == "aura" then report.refused = "trigger " .. triggernum .. " is a legacy aura trigger (type aura)" return nil else trigger = translateGenericTrigger(source, triggernum, report) end if not trigger then return nil end if not untrigger then untrigger = {} if type(entry.untrigger) == "table" and entry.untrigger.custom ~= nil then if validateTriggerCode(entry.untrigger.custom, "trigger " .. triggernum .. " uncustom", report, false) then untrigger.custom = WA.DeepCopy(entry.untrigger.custom) end end end return { trigger = trigger, untrigger = untrigger } end local function translateTriggers(source, report) if source.triggers == nil then return nil end if type(source.triggers) ~= "table" then report.refused = "display has invalid trigger data" return nil end local sourceTriggers = source.triggers local triggers = {} for i = 1, #sourceTriggers do local entry = translateTriggerEntry(sourceTriggers[i], i, report) if not entry then return nil end triggers[i] = entry end if sourceTriggers.disjunctive == "all" or sourceTriggers.disjunctive == "any" or sourceTriggers.disjunctive == "custom" then triggers.disjunctive = sourceTriggers.disjunctive elseif sourceTriggers.disjunctive ~= nil then reportDrop(report, "unsupported trigger combination", tostring(sourceTriggers.disjunctive)) end if sourceTriggers.activeTriggerMode ~= nil then triggers.activeTriggerMode = WA.DeepCopy(sourceTriggers.activeTriggerMode) end if sourceTriggers.customTriggerLogic ~= nil then if validateTriggerCode(sourceTriggers.customTriggerLogic, "trigger logic", report, false) then triggers.customTriggerLogic = WA.DeepCopy(sourceTriggers.customTriggerLogic) else triggers.customTriggerLogic = nil end end return triggers end local function subDetail(kind, index, detail) return kind .. " " .. index .. ": " .. detail end local function knownTextSymbol(data, symbol) local bare = symbol local _, _, scoped = string.find(symbol, "^%d+%.(.+)$") if scoped then bare = scoped end if WA.dynamic_texts and WA.dynamic_texts[bare] then return true end if string.find(bare, "^c%d*$") then return true end if type(WA.TextSymbols) == "function" then local names = WA.TextSymbols(data) for i = 1, #(names or {}) do if names[i] == bare then return true end end end return false end local function scanTextPlaceholders(text, callback) if type(text) ~= "string" then return end local seen = {} local function visit(symbol) if symbol ~= "" and not seen[symbol] then seen[symbol] = true callback(symbol) end end local pos = 1 while true do local start, finish, symbol = string.find(text, "%%([%w_%.]+)", pos) if not start then break end if start == 1 or string.sub(text, start - 1, start - 1) ~= "%" then visit(symbol) end pos = finish + 1 end pos = 1 while true do local start, finish, symbol = string.find(text, "%%{([^}]*)}", pos) if not start then break end visit(symbol) pos = finish + 1 end end local function reportTextPlaceholders(text, data, index, report) scanTextPlaceholders(text, function(symbol) local _, _, bare = string.find(symbol, "^%d+%.(.+)$") bare = bare or symbol if bare == "i" then reportDrop(report, "known-blank text placeholder", subDetail("subtext", index, "%i")) elseif not knownTextSymbol(data, symbol) then reportDrop(report, "unsupported text placeholder", subDetail("subtext", index, "%" .. symbol)) end end) end local function translateTextFormats(source, destination, data, index, report) scanTextPlaceholders(source.text_text, function(symbol) local prefix = "text_text_format_" .. symbol .. "_" local prefixLength = string.len(prefix) local hasSettings = false for key in pairs(source) do if type(key) == "string" and string.sub(key, 1, prefixLength) == prefix then hasSettings = true end end if hasSettings then local format = source[prefix .. "format"] if not format or DROPPED_FORMATS[format] or not (WA.format_types and WA.format_types[format]) then reportDrop(report, "unsupported text format", subDetail("subtext", index, "%" .. symbol .. " (" .. tostring(format) .. ")")) else for key, value in pairs(source) do if type(key) == "string" and string.sub(key, 1, prefixLength) == prefix then destination[key] = WA.DeepCopy(value) end end end end end) end local function translateFont(font) local default = WA.textCore and WA.textCore.DEFAULTS and WA.textCore.DEFAULTS.font default = default or "Fonts\\FRIZQT__.TTF" if type(font) ~= "string" then return nil, default end if font == "Friz Quadrata TT" then return default, default end -- A font travels as a LibSharedMedia name, but an author who typed a path -- into the box exports the path, and upstream's own faces are bundled here -- under a different folder. font = rewriteMedia(font) or font local aliases = WA.textCore and WA.textCore.FONT_ALIASES if aliases and aliases[font] then font = aliases[font] end local fonts = WA.textCore and WA.textCore.FONTS or {} for i = 1, #fonts do if fonts[i].path == font then return font, default end if fonts[i].name == font then return fonts[i].path, default end end return nil, default end local function subAnchorSupported(data, key) local values = WA.regionPrototype.GetSubRegionAnchors(data, "point") for i = 1, #values do if values[i] == key then return true end end return false end -- Upstream keeps the anchored part and the point in a single value -- ("OUTER_TOPLEFT", "ICON_LEFT", "SPARK"); ours splits them across anchor_target -- and anchor_point, the latter being one of the nine SetPoint accepts. Whether a -- part exists is asked of the destination region type, since a bar's ICON_* has -- no icon to sit on once the display is an icon. local function translateSubtextAnchor(destination, source, data, index, report) local anchor = destination.anchor_point if anchor == nil then anchor = source.text_anchorPoint end if type(anchor) ~= "string" or anchor == "AUTO" then if anchor ~= nil then reportDrop(report, "anchor substitution", subDetail("subtext", index, tostring(anchor) .. " -> CENTER")) end anchor = "CENTER" end local point = WA.regionPrototype.ResolveAnchorPoint(anchor, "CENTER") local target = anchor if not subAnchorSupported(data, target) then target = subAnchorSupported(data, point) and point or "region" if anchor ~= point then reportDrop(report, "anchor substitution", subDetail("subtext", index, anchor .. " -> " .. target)) end end destination.anchor_target = target destination.anchor_point = point -- Upstream's own default is AUTO, resolved at paint time from the anchor; -- ours stores a real point, so an AUTO (or absent) self point is resolved here. if WA.regionPrototype.IsAnchorPoint(source.text_selfPoint) then destination.self_point = source.text_selfPoint else destination.self_point = WA.regionPrototype.AutoSelfPoint(anchor, point, data.regionType) end end local function translateSubtext(source, index, data, report) local destination = {} take(destination, source, SUBTEXT_KEYS) destination.type = "subtext" if destination.anchorXOffset == nil and source.text_anchorXOffset ~= nil then destination.anchorXOffset = WA.DeepCopy(source.text_anchorXOffset) end if destination.anchorYOffset == nil and source.text_anchorYOffset ~= nil then destination.anchorYOffset = WA.DeepCopy(source.text_anchorYOffset) end translateSubtextAnchor(destination, source, data, index, report) if source.text_font ~= nil then local font, default = translateFont(source.text_font) if font then destination.text_font = font else destination.text_font = default reportDrop(report, "unsupported font", subDetail("subtext", index, tostring(source.text_font))) end end -- The three width fields are one setting, and the other two are inert while -- the width is automatic -- which is upstream's default. Only a subtext that -- asked for a fixed width has lost anything to report. if source.text_automaticWidth == "Fixed" then for i = 1, #SUBTEXT_DROP_KEYS do local key = SUBTEXT_DROP_KEYS[i] if source[key] ~= nil then reportDrop(report, "unsupported subtext field", subDetail("subtext", index, key)) end end end translateTextFormats(source, destination, data, index, report) reportTextPlaceholders(source.text_text, data, index, report) return destination end local function translateSubborder(source, index, report) local destination = {} take(destination, source, SUBBORDER_KEYS) destination.type = "subborder" if destination.anchor_area == nil and source.border_anchor ~= nil then destination.anchor_area = WA.DeepCopy(source.border_anchor) end if source.border_edge ~= nil and not SOLID_BORDER_EDGES[source.border_edge] then reportDrop(report, "unsupported border art", subDetail("subborder", index, "border_edge")) end return destination end local function translateSubglow(source, index, report) local destination = {} take(destination, source, SUBGLOW_KEYS) destination.type = "subglow" -- glowDuration is the Proc glow's pulse period and 1 is upstream's default. -- It only ever meant anything to Proc, whose substitution to Pixel is -- reported just below on its own terms. if source.glowDuration ~= nil and source.glowDuration ~= 1 then reportDrop(report, "unsupported glow field", subDetail("subglow", index, "glowDuration")) end if destination.glowType == "Proc" then destination.glowType = "Pixel" reportDrop(report, "glow type substitution", subDetail("subglow", index, "Proc -> Pixel")) elseif destination.glowType ~= nil and (not WA.glow_types or not WA.glow_types[destination.glowType]) then local original = destination.glowType destination.glowType = "Pixel" reportDrop(report, "glow type substitution", subDetail("subglow", index, tostring(original) .. " -> Pixel")) end return destination end local function translateSubtick(source, index, report) local destination = {} take(destination, source, SUBTICK_KEYS) destination.type = "subtick" if destination.tick_placements == nil and source.tick_placement ~= nil then destination.tick_placements = { WA.DeepCopy(source.tick_placement) } end if source.progressSources ~= nil then if type(source.progressSources) ~= "table" then reportDrop(report, "unsupported progress source", subDetail("subtick", index, "progressSources")) else local first = source.progressSources[1] if type(first) == "table" then if first[1] ~= nil then destination.tick_progressSource = WA.DeepCopy(first[1]) end if first[2] ~= nil and first[2] ~= "" then reportDrop(report, "per-property progress source", subDetail("subtick", index, tostring(first[2]))) end elseif first ~= nil then reportDrop(report, "unsupported progress source", subDetail("subtick", index, "progressSources")) end if #source.progressSources > 1 then reportDrop(report, "multiple progress sources", subDetail("subtick", index, "progressSources")) end end end return destination end local function translateSubRegion(source, index, parentType, data, report) if type(source) ~= "table" then reportDrop(report, "unsupported sub-region", subDetail("sub-region", index, "invalid data")) return nil end local kind = source.type -- The bar's own fill under its pre-sub-region name; upstream's Modernize -- does the same rename. if kind == "aurabar_bar" then kind = "subforeground" end if not SUBREGION_TYPES[kind] then reportDrop(report, "unsupported sub-region", subDetail("sub-region", index, tostring(kind))) return nil end local spec = WA.subRegionTypes and WA.subRegionTypes[kind] if spec and spec.supports and not spec.supports(parentType) then reportDrop(report, "unsupported sub-region", subDetail("sub-region", index, kind .. " on " .. parentType)) return nil end if kind == "subtext" then return translateSubtext(source, index, data, report) end if kind == "subborder" then return translateSubborder(source, index, report) end if kind == "subglow" then return translateSubglow(source, index, report) end -- The placeholders standing for the region's own art carry no fields at -- all, upstream included. Their position is the whole content: dropping one -- would pull every later effect down a slot, which is exactly the draw order -- the aura's author arranged -- and the slot every `sub..*` condition -- change on a later effect addresses. if kind == "subbackground" or kind == "subforeground" then return { type = kind } end return translateSubtick(source, index, report) end local function translateSubRegions(source, data, report) if source.subRegions == nil then return nil end if type(source.subRegions) ~= "table" then reportDrop(report, "unsupported sub-regions", "invalid data") return {} end local destination = {} for i = 1, #source.subRegions do local sub = translateSubRegion(source.subRegions[i], i, data.regionType, data, report) if sub then table.insert(destination, sub) end end return destination end local function keysFor(localType) local keys, seen = {}, {} -- Seeded taken, so the loop below cannot pick it up out of a group's -- defaults: it names children by id, and every id in an import is reassigned. seen.controlledChildren = true local function add(key) if not seen[key] then seen[key] = true table.insert(keys, key) end end local spec = WA.regionTypes[localType] for key in pairs(spec and spec.defaults or {}) do add(key) end if spec and spec.isGroup then for i = 1, #GROUP_KEYS do add(GROUP_KEYS[i]) end return keys end for i = 1, #PROTOTYPE_KEYS do add(PROTOTYPE_KEYS[i]) end if localType == "text" then for i = 1, #TEXT_KEYS do add(TEXT_KEYS[i]) end end return keys end -- Calls an author's Lua makes on the `WeakAuras` table that this addon does not -- answer. AuraEnv's shim covers the names it can honour faithfully; a call that -- misses it reads nil and errors where it stands, so it is named at import -- rather than discovered as a stack trace in the client. -- -- Calls only -- `WeakAuras.Name(` -- because these authors also use that table -- as a scratch namespace (`WeakAuras.ComboFill1 = ...`), and those work: the -- shim is a real writable table. Reporting the stash keys would bury the two or -- three names that actually break under a list of twenty that do not. local function collectForeignApi(report, source) if type(source) ~= "string" or not report then return end for name in string.gmatch(source, "WeakAuras[%.:]([%w_]+)%s*%(") do if not (WA.ForeignApiNames and WA.ForeignApiNames[name]) then report.foreignApi = report.foreignApi or {} report.foreignApiOrder = report.foreignApiOrder or {} if not report.foreignApi[name] then report.foreignApi[name] = true table.insert(report.foreignApiOrder, name) end end end end -- The other half of the same question: upstream's `WA_` helpers are bare names -- in the environment an author's Lua runs in, not fields on the WeakAuras table, -- so the walk above cannot see them. AuraEnv answers the ones it can answer -- faithfully; the rest read nil and error at the call, and are named here. -- -- A name the same chunk defines is the author's own helper, not upstream's, and -- is skipped -- these packs do write `WA_MyThing = function()`. local function collectForeignEnv(report, source) if type(source) ~= "string" or not report then return end for name in string.gmatch(source, "(WA_[%w_]+)%s*%(") do if not (WA.AuraEnvNames and WA.AuraEnvNames[name]) and not string.find(source, "function%s+" .. name .. "%s*%(") and not string.find(source, name .. "%s*=%s*function") then report.foreignEnv = report.foreignEnv or {} report.foreignEnvOrder = report.foreignEnvOrder or {} if not report.foreignEnv[name] then report.foreignEnv[name] = true table.insert(report.foreignEnvOrder, name) end end end end -- `UnitClass`'s third return. -- -- Retail's is (localized, token, classID) and every "is there a warlock in the -- group" check reads position 3. Vanilla's -- which is what this client has, -- since ClassicAPI does not hook it -- stops at two, so the comparison is -- `nil == 9` on every unit and the check is silently false forever. That is the -- worst shape a gap can take: no error, no report, and a display that simply -- never lights. -- -- ClassicAPI does answer the question, under another name: `UnitClassBase(unit)` -- returns (token, classID), so position 2 there is position 3 here. The rewrite -- is exact for `select(3, UnitClass(x))`, which is how the corpus spells it -- every time but one; the multiple-assignment form takes a different number of -- names on each side, so it is reported rather than guessed at -- naming a -- thing it cannot do beats guessing and being quietly wrong. local function rewriteUnitClass(source) local rewritten, count = string.gsub(source, "select%s*%(%s*3%s*,%s*UnitClass%s*%(", "select(2, UnitClassBase(") -- Three or more names taking a UnitClass call: the third is the classID that -- is not there. Two is fine -- the localized name and the token both exist. local assigned = string.find(rewritten, "[%w_]+%s*,%s*[%w_]+%s*,%s*[%w_]+%s*=%s*UnitClass%s*%(") ~= nil return rewritten, count > 0, assigned end -- Whether a rewrite left the chunk as compilable as it found it. The source may -- be a function expression or a bare body, so both wrappings are tried and the -- comparison is on the pair -- a chunk that did not compile before is allowed -- not to compile after, which is the case where the author's own Lua is broken. local function sameCompileResult(before, after) if type(WA.LoadFunction) ~= "function" then return true end local function compiles(source, body) return WA.LoadFunction(source, nil, body) ~= nil end return compiles(before, false) == compiles(after, false) and compiles(before, true) == compiles(after, true) end -- Every key whose value is user Lua, wherever it sits. Walked recursively over -- the finished display for the same reason remapMedia is: a trigger, an -- untrigger, an action, a condition change, an animation and a custom-grow are -- all covered by one pass, and a key added later cannot be forgotten at some -- individual translation site. local CODE_KEYS = { custom = true, untrigger = true, customText = true, customSort = true, customAnchorPerUnit = true, customGrow = true, customTriggerLogic = true, customDuration = true, customName = true, customIcon = true, customTexture = true, customStacks = true, customVariables = true, customOverlay1 = true, customOverlay2 = true, customOverlay3 = true, translateFunc = true, alphaFunc = true, scaleFunc = true, rotateFunc = true, colorFunc = true, } local function remapUnitClass(node, report, seen) if type(node) ~= "table" then return end seen = seen or {} if seen[node] then return end seen[node] = true for key, value in pairs(node) do if type(value) == "table" then remapUnitClass(value, report, seen) elseif CODE_KEYS[key] and type(value) == "string" then local rewritten, classFixed, classAssigned = rewriteUnitClass(value) -- The one outcome worse than leaving a call to error is corrupting the -- chunk around it. Anything that stops compiling is discarded whole. if rewritten ~= value and not sameCompileResult(value, rewritten) then rewritten, classFixed = value, false reportDrop(report, "custom code", tostring(node.id or "code") .. ": code rewrite discarded") end if classFixed then report.unitClassFixed = true end if classAssigned then report.unitClassAssigned = true end if rewritten ~= value then node[key] = rewritten end end end end local function addCode(report, name, source, active) if not hasSource(source) then return end collectForeignApi(report, source) collectForeignEnv(report, source) table.insert(report.code, { name = name, source = source, active = active and true or false }) end function WA.CollectImportCode(data, report, prefix) if type(data) ~= "table" then return end report = report or { code = {} } report.code = report.code or {} prefix = prefix or (tostring(data.id or "?") .. " - ") for i = 1, #DISPLAY_CODE_KEYS do local item = DISPLAY_CODE_KEYS[i] local active if item.key == "customSort" then active = data.sort == "custom" elseif item.key == "customGrow" then active = data.grow == "CUSTOM" elseif item.key == "customAnchorPerUnit" then active = data.useAnchorPerUnit and true or false else active = true end addCode(report, prefix .. item.label, data[item.key], active) end local triggers = data.triggers for n = 1, #(triggers or {}) do local entry = triggers[n] for _, slot in ipairs({ "trigger", "untrigger" }) do local block = entry and entry[slot] for i = 1, #TRIGGER_CODE_KEYS do local item = TRIGGER_CODE_KEYS[i] local label, liveKey = item.label, item.key -- The untrigger block holds one field the compiler reads, under the -- name the predicate knows it by; anything else stored there is -- carried and never run. if slot == "untrigger" then label = "un" .. label liveKey = item.key == "custom" and "untrigger" or nil end addCode(report, prefix .. "trigger " .. n .. " " .. label, block and block[item.key], liveKey and WA.TriggerCodeIsLive(entry and entry.trigger, liveKey)) end end end addCode(report, prefix .. "trigger logic", triggers and triggers.customTriggerLogic, triggers and triggers.disjunctive == "custom") local conditions = data.conditions -- A Custom Check is code that runs, so the check half of a condition is -- disclosed alongside its changes. Recursive because a combinator's children -- can each carry one. local function addCheckCode(check, where) if type(check) ~= "table" then return end if check.trigger == -2 then local subs = check.checks or {} for i = 1, #subs do addCheckCode(subs[i], where .. " check " .. i) end return end if check.trigger == -1 and check.variable == "customcheck" then addCode(report, where .. " custom check", check.value, true) end end for n = 1, #(conditions or {}) do addCheckCode(conditions[n] and conditions[n].check, prefix .. "condition " .. n) local changes = conditions[n] and conditions[n].changes or {} for i = 1, #changes do local change = changes[i] local property = change and change.property local source if property == "customcode" or property == "chat" or property == "sound" or property == "glowexternal" then source = conditionCodeValue(change.value) end if source then addCode(report, prefix .. "condition " .. n .. " " .. tostring(change.property), source, true) end end end local animation = data.animation for _, phase in ipairs({ "start", "main", "finish" }) do local block = animation and animation[phase] for i = 1, #ANIMATION_CODE_KEYS do local key = ANIMATION_CODE_KEYS[i] local slot = string.sub(key, 1, string.len(key) - 4) addCode(report, prefix .. "animation " .. phase .. " " .. key, block and block[key], WA.AnimationCodeIsLive(block, slot)) end end local actions = data.actions for _, phase in ipairs({ "init", "start", "finish" }) do local block = actions and actions[phase] for i = 1, #ACTION_CODE_KEYS do local key = ACTION_CODE_KEYS[i] local enabled = "do_custom" if key == "customOnLoad" then enabled = "do_custom_load" elseif key == "customOnUnload" then enabled = "do_custom_unload" elseif key == "message_custom" then enabled = "do_message" end addCode(report, prefix .. "action " .. phase .. " " .. key, block and block[key], block and block[enabled]) end end end local function animationPresetTypes(phase) if phase == "start" then return WA.anim_start_preset_types end if phase == "finish" then return WA.anim_finish_preset_types end return WA.anim_main_preset_types end local function animationCapabilities(localType) return { scale = localType ~= "group" and localType ~= "dynamicgroup", color = localType ~= "group" and localType ~= "dynamicgroup", rotate = localType == "texture" or localType == "progresstexture", } end local function validateAnimation(data, sourceType, report) local animation = data.animation if type(animation) ~= "table" then return end local caps = animationCapabilities(sourceType) for _, phase in ipairs({ "start", "main", "finish" }) do local block = animation[phase] if type(block) == "table" then if block.type == "preset" and not animationPresetTypes(phase)[block.preset] then reportDrop(report, "unsupported animation preset", phase .. ": " .. tostring(block.preset)) block.type, block.preset = "none", nil end if block.use_scale and not caps.scale then reportDrop(report, "unsupported animation", phase .. ": use_scale") block.use_scale = false end if block.use_rotate and not caps.rotate then reportDrop(report, "unsupported animation", phase .. ": use_rotate") block.use_rotate = false end if block.use_color and not caps.color then reportDrop(report, "unsupported animation", phase .. ": use_color") block.use_color = false end for i = 1, #ANIMATION_CODE_KEYS do local key = ANIMATION_CODE_KEYS[i] local source = block[key] if hasSource(source) and type(WA.LoadFunction) == "function" and not WA.LoadFunction(source, nil) then block[key] = nil reportDrop(report, "custom code", "animation " .. phase .. " " .. key) end end end end end local function validateActionCode(data, report) local actions = data.actions if type(actions) ~= "table" then return end for _, phase in ipairs({ "init", "start", "finish" }) do local block = actions[phase] local specs = ACTION_SPECS[phase] if type(block) == "table" then for i = 1, #(specs or {}) do local spec = specs[i] local source = block[spec.key] if hasSource(source) and type(WA.LoadFunction) == "function" and not WA.LoadFunction(source, nil, spec.body) then block[spec.key] = nil reportDrop(report, "custom code", "action " .. phase .. " " .. spec.key) end end end end end -- Upstream writes an aura reference as "WeakAuras:"; ours is the same shape -- under our own name. The id inside is the *exporter's*, and every id in an -- import is reassigned -- remapChildIdKeys (ImportExport.lua) rewrites it once -- the whole pack is installed and the old-to-new map is complete. local WA2_ANCHOR_PREFIX = "WeakAuras:" local function translateAnchorReference(value) if type(value) ~= "string" or value == "" then return nil end local _, _, id = string.find(value, "^WeakAuras:(.+)$") if id then return WA.ANCHOR_AURA_PREFIX .. id end return value end -- Upstream's Proc glow carries two keys nothing else reads. Dropping the art -- (below) without them would leave an aura whose saved glow still claims a start -- animation the replacement art has no concept of. local GLOW_PROC_KEYS = { "glow_startAnim", "glow_duration" } -- One glow descriptor, wherever it came from: an action block's keys sit on the -- block, a condition change's on its `value`, and the shape is upstream's own -- either way. A frame we cannot resolve is dropped outright, because a glow -- aimed at nothing is a control the user will keep adjusting to no effect; an -- art we do not draw falls back rather than dropping, since a glow of the wrong -- shape still tells them what it was meant to tell them. local function sanitizeGlow(block, report, label) if type(block) ~= "table" then return end if block.glow_type and not (WA.glow_types and WA.glow_types[block.glow_type]) then reportDrop(report, "unsupported glow art", label .. ": " .. tostring(block.glow_type)) block.glow_type = nil end if block.glow_frame_type and not GLOW_FRAME_TYPES[block.glow_frame_type] then reportDrop(report, "unsupported glow frame", label .. ": " .. tostring(block.glow_frame_type)) block.glow_frame_type, block.glow_frame = nil, nil end -- A frame selector names a global frame or another display, and upstream -- writes both into the one field. The aura reference carries the exporter's -- id, which remapChildIdKeys rewrites once the pack is installed. if block.glow_frame_type == "FRAMESELECTOR" then block.glow_frame = translateAnchorReference(block.glow_frame) if not block.glow_frame then reportDrop(report, "unsupported glow frame", label .. ": no frame named") block.glow_frame_type = nil end end for i = 1, #GLOW_PROC_KEYS do local key = GLOW_PROC_KEYS[i] if block[key] ~= nil then reportDrop(report, "unsupported glow art", label .. ": " .. key) block[key] = nil end end end local function sanitizeActions(data, report) local actions = data.actions if type(actions) ~= "table" then return end for _, phase in ipairs({ "init", "start", "finish" }) do local block = actions[phase] if type(block) == "table" then for i = 1, #ACTION_DROP_KEYS do local key = ACTION_DROP_KEYS[i] if block[key] ~= nil then reportDrop(report, "unsupported action", phase .. ": " .. key) block[key] = nil end end if block.message_type == "INSTANCE_CHAT" then reportDrop(report, "unsupported action", phase .. ": INSTANCE_CHAT") block.message_type, block.do_message = nil, nil end sanitizeGlow(block, report, phase) -- A glow whose frame is gone would light this aura's own region -- instead of the one the author picked, which is worse than silence. if block.do_glow and not block.glow_frame_type then reportDrop(report, "unsupported action", phase .. ": glow") block.do_glow = nil end end end end -- The condition half of the same descriptor. `translateConditionChanges` copies -- a change's value wholesale -- correct for every other property, but a glow -- carries frame and art names that have to survive the same check the action -- block's do. local function sanitizeConditionGlows(data, report) local conditions = data.conditions for n = 1, #(conditions or {}) do local changes = conditions[n] and conditions[n].changes or {} for i = 1, #changes do local change = changes[i] if change and change.property == "glowexternal" and type(change.value) == "table" then sanitizeGlow(change.value, report, conditionLabel(data, n) .. " glow") end end end end local function reportMediaOptions(options, report, seen) if type(options) ~= "table" then return end seen = seen or {} if seen[options] then return end seen[options] = true if options.type == "media" then reportDrop(report, "media option", options.name or options.key or "unnamed") end for _, value in pairs(options) do if type(value) == "table" then reportMediaOptions(value, report, seen) end end end local function noteWagoBookkeeping(source, report) for i = 1, #WAGO_BOOKKEEPING_KEYS do local key = WAGO_BOOKKEEPING_KEYS[i] if source[key] ~= nil then report.wagoKeys = report.wagoKeys or {} report.wagoKeyOrder = report.wagoKeyOrder or {} if not report.wagoKeys[key] then report.wagoKeys[key] = true table.insert(report.wagoKeyOrder, key) end end end end -- Texture-valued fields whose value can be a fileID or an atlas name, neither of -- which resolves on this client. The value is kept -- it is still what the author -- chose, and the options tab shows it -- and every paint falls back to a -- placeholder rather than the engine's missing-texture block. Reported so the -- substitution is not a silent one. local TEXTURE_FIELDS = { { key = "groupIcon", label = "group icon" }, -- `displayIcon` is the icon only under Manual. Everywhere else the display -- asks its trigger first (WA.ResolveDisplayIcon) and reaches this value only -- when no trigger names one, so calling it "the icon" overstates a loss the -- user may never see. Upstream's default is Automatic, so nil is Automatic. { key = "displayIcon", label = "manual icon", autoLabel = "fallback icon", autoWhen = function(source) return source.iconSource ~= 0 end }, { key = "sparkTexture", label = "spark texture" }, { key = "texture", label = "texture", only = "texture" }, { key = "foregroundTexture", label = "foreground texture" }, { key = "backgroundTexture", label = "background texture" }, } -- A path into some *other* addon's folder, after the WeakAuras rewrite has had -- its turn. Nothing offline can tell whether the sender's addon is installed -- here, so the value is left alone -- but silence would be wrong too, since this -- is the second most common reason an imported display draws nothing. local function foreignAddonPath(value) if type(value) ~= "string" then return false end local lower = string.lower(string.gsub(value, "/", "\\")) if not string.find(lower, "^interface\\addons\\") then return false end return string.find(lower, "^interface\\addons\\weakestauras\\") == nil end local function reportUndrawableTextures(source, data, report) for i = 1, #TEXTURE_FIELDS do local field = TEXTURE_FIELDS[i] local value = source[field.key] if value ~= nil and value ~= "" and (not field.only or source.regionType == field.only) then local label = field.label if field.autoWhen and field.autoWhen(source) then label = field.autoLabel end if not WA.DrawableTexture(value) then reportDrop(report, "texture this client cannot load", tostring(source.id or "?") .. " " .. label .. ": " .. tostring(value)) elseif foreignAddonPath(data[field.key]) then reportDrop(report, "texture from an addon that may not be installed", tostring(source.id or "?") .. " " .. label .. ": " .. tostring(data[field.key])) end end end end -- Lands an incoming bar texture on one this addon actually ships. textureSource -- is forced to LSM because it is ours, not upstream's: a bar arriving with a -- stale Picker source would look at an empty textureInput and draw nothing. local function translateBarTexture(data, source, report) data.textureSource = "LSM" data.textureInput = nil local name = source.texture if name == nil then return end local shipped = WA.Widgets.BarTextures() for i = 1, #shipped do if shipped[i] == name then return end end local alias = BAR_TEXTURE_ALIASES[name] data.texture = alias or BAR_TEXTURE_DEFAULT reportDrop(report, "bar texture substituted", tostring(source.id or "?") .. ": " .. tostring(name) .. " -> " .. data.texture) end -- The model region renders only the legacy camera (SetPosition + SetFacing); -- an aura built with upstream's transform camera (api = SetTransform) has the -- transform's yaw folded into `rotation` here, once -- rz's rest value is 90, -- so the delta from it is the yaw the author meant. The st_* keys travel -- through untouched for the trip back to a retail client, which ignores -- `rotation` under api anyway. local function translateModel(data, source, report) local label = tostring(source.id or "?") -- Pinned to at least empty, or MergeDefaults seeds the fresh-aura default -- model onto the import and an unloadable model silently becomes Ragnaros. if data.model_path == nil then data.model_path = "" end if source.api then data.rotation = (tonumber(source.model_st_rz) or 90) - 90 if data.rotation < 0 then data.rotation = data.rotation + 360 end reportDrop(report, "model camera transform approximated", label) end if source.modelIsUnit then local unit = source.model_fileId if type(unit) ~= "string" or unit == "" or string.find(tostring(unit), "^soft") then reportDrop(report, "unit this client does not have", label .. ": " .. tostring(unit)) end elseif not source.modelDisplayInfo then -- A display id renders through SetDisplayInfo as is; no local table -- can tell which retail ids this client's CreatureDisplayInfo holds. local resolvable = WA.ResolveModelFile(source.model_fileId) or (type(source.model_path) == "string" and source.model_path ~= "") if not resolvable then reportDrop(report, "model this client cannot load", label .. ": " .. tostring(source.model_fileId)) end end end -- --------------------------------------------------------------------------- -- Anchoring -- -- Upstream's anchor frame types and ours are the same vocabulary bar one, so an -- anchor is carried rather than flattened onto the screen. -- -- Flattening is not the cosmetic loss it looks like. A display anchored to -- another frame usually carries xOffset and yOffset of 0 and takes its whole -- position from the anchor, so forcing SCREEN does not merely shift it -- it -- collapses every display in the set onto one point. The corpus's ComboFill1-5 -- are exactly that: five textures at (0,0), each anchored to a different combo -- point behind it, which imported as five textures stacked in one place. -- -- PRD is retail's Personal Resource Display, which this client has no equivalent -- of; CUSTOM resolves its frame by running the author's Lua, which would have to -- travel through the code-disclosure path before it could be honoured. Both fall -- back to the screen and say so. -- --------------------------------------------------------------------------- local ANCHOR_FRAME_TYPES = { SCREEN = true, UIPARENT = true, SELECTFRAME = true, MOUSE = true, NAMEPLATE = true, UNITFRAME = true, } local function translateAnchor(data, source, report) local frameType = source.anchorFrameType local label = tostring(source.id or "?") if frameType == nil or not ANCHOR_FRAME_TYPES[frameType] then if frameType ~= nil and frameType ~= "SCREEN" then reportDrop(report, "anchored to a frame this client has no equivalent of", label .. ": " .. tostring(frameType) .. " -> screen") end data.anchorFrameType = "SCREEN" data.anchorFrameFrame, data.anchorFrameParent = nil, nil return end data.anchorFrameType = frameType if frameType ~= "SELECTFRAME" then data.anchorFrameFrame = nil return end local reference = translateAnchorReference(source.anchorFrameFrame) if not reference then reportDrop(report, "anchored to a frame that was not named", label .. ": imported anchored to screen") data.anchorFrameType = "SCREEN" data.anchorFrameFrame, data.anchorFrameParent = nil, nil return end data.anchorFrameFrame = reference -- A reference to another aura is resolved by id and travels with the pack. A -- global frame name is the sender's UI, not ours, and nothing offline can say -- whether it exists here -- kept, since the alternative is silently moving -- the display, and reported so the miss is not a mystery. if string.sub(source.anchorFrameFrame, 1, string.len(WA2_ANCHOR_PREFIX)) ~= WA2_ANCHOR_PREFIX then reportDrop(report, "anchored to a frame from the sender's UI", label .. ": " .. tostring(source.anchorFrameFrame)) end end local function translateGroup(data, source, report) local label = tostring(source.id or "?") -- A group's stored selfPoint means something upstream that it cannot mean -- here, and honouring it displaces the whole pack. -- -- Upstream's group frame is 2x2 and never resized (Group.lua's create), so -- which of its corners is pinned moves it by a pixel -- the static group even -- overwrites selfPoint on every modify, to BOTTOMLEFT or CENTER, which is why -- an export can carry a point nothing ever reads back. A dynamic group's -- selfPoint is a third thing again: the corner its children grow from, which -- is `align` here. Our group frame is sized to its children's bounding box, so -- pinning it by a corner instead of its centre shifts every child by half that -- box -- hundreds of pixels for a real pack. -- -- A grid is the one case where nothing is lost: upstream's options write -- selfPoint from gridType (its gridSelfPoints table) whenever either is -- touched, so the corner it names is one gridType already carries. -- -- Under a custom grow it is worse than a shift: the author's own function -- writes coordinates in whatever corner selfPoint names, and CENTER is what -- picking CUSTOM sets it to upstream, so anything else means the aura was -- hand-edited afterwards and its Lua will not mean here what it meant there. -- The drop below is the only warning that gives. if data.selfPoint ~= nil and data.selfPoint ~= "CENTER" and data.grow ~= "GRID" then reportDrop(report, "group anchor point", label .. ": " .. tostring(data.selfPoint) .. " -> CENTER") end data.selfPoint = "CENTER" -- A group's alpha cascades onto its children upstream; here the container -- frame has no alpha of its own, so a translucent pack would import opaque. if source.alpha ~= nil and source.alpha ~= 1 then reportDrop(report, "group alpha", label .. ": " .. tostring(source.alpha)) end -- Every grow upstream names is ours under the same name, geometry fields -- included, so `take` carries them; the guard is for a value from a future -- version rather than for a known gap. if data.grow ~= nil and not GROW_TYPES[data.grow] then reportDrop(report, "unsupported grow direction", label .. ": " .. tostring(data.grow)) data.grow = nil end for i = 1, #GROUP_DROP_KEYS do local key = GROUP_DROP_KEYS[i] if source[key] then reportDrop(report, "unsupported group field", label .. ": " .. key) end end if source.border then for i = 1, #GROUP_BORDER_ART_KEYS do if source[GROUP_BORDER_ART_KEYS[i]] ~= nil then reportDrop(report, "group border art", label) break end end end end local function translateDisplay(source, report) local sourceType = source.regionType local localType = REGION_MAP[sourceType] if not localType then report.refused = "unsupported region type " .. tostring(sourceType) return nil end local data = {} if source.id ~= nil then data.id = WA.DeepCopy(source.id) end if source.uid ~= nil then data.uid = WA.DeepCopy(source.uid) end -- Author metadata, outside keysFor's per-type whitelist because every type -- carries it: the Info tab shows and edits both. if type(source.desc) == "string" then data.desc = source.desc end if type(source.url) == "string" then data.url = source.url end take(data, source, keysFor(localType)) data.regionType = sourceType == "aurabar" and "progressbar" or sourceType if sourceType == "stopmotion" then reportDrop(report, "unsupported region type", sourceType) elseif sourceType == "model" then translateModel(data, source, report) end translateAnchor(data, source, report) if GROUP_TYPES[sourceType] then translateGroup(data, source, report) else if sourceType == "aurabar" then translateBarTexture(data, source, report) end local progress = source.progressSource if type(progress) == "table" then data.progressSource = WA.DeepCopy(progress[1]) if progress[1] == 0 then if progress[3] ~= nil then data.progressSourceManualValue = WA.DeepCopy(progress[3]) end if progress[4] ~= nil then data.progressSourceManualTotal = WA.DeepCopy(progress[4]) end end if progress[2] ~= nil and progress[2] ~= "" then reportDrop(report, "per-property progress source", tostring(progress[2])) end end local triggers = translateTriggers(source, report) if report.refused then return nil end if triggers then data.triggers = triggers end end local subRegions = translateSubRegions(source, data, report) if subRegions then data.subRegions = subRegions end if source.conditions ~= nil then data.conditions = translateConditions(source.conditions, data, report) end if source.load ~= nil then data.load = translateLoad(source.load, data, report) end copyBlock(data, source, "animation") copyBlock(data, source, "actions") copyBlock(data, source, "authorOptions") copyBlock(data, source, "config") if source.authorMode ~= nil then data.authorMode = WA.DeepCopy(source.authorMode) end validateAnimation(data, localType, report) sanitizeActions(data, report) sanitizeConditionGlows(data, report) validateActionCode(data, report) reportMediaOptions(data.authorOptions, report) WA.ValidateUserConfig(data) remapMedia(data, report, tostring(source.id or "?")) remapUnitClass(data, report) reportUndrawableTextures(source, data, report) noteWagoBookkeeping(source, report) local codeSource = WA.DeepCopy(source) codeSource.animation = data.animation codeSource.actions = data.actions codeSource.customText = data.customText codeSource.conditions = data.conditions codeSource.customSort = data.customSort codeSource.customAnchorPerUnit = data.customAnchorPerUnit -- The disclosure has to show what will run, not what the author sent, or the -- listed source and the saved source disagree wherever a call was rewritten. -- `codeSource` is a copy of the upstream payload, so it needs the same pass; -- rewriting is idempotent, and the fields it shares by reference with `data` -- have already been done. remapUnitClass(codeSource, report) WA.CollectImportCode(codeSource, report, tostring(source.id or "?") .. " - ") -- Current-schema by construction -- fresh tables, current field names, -- upstream's own draw order -- so the importer's migrations must not touch -- it. The source's internalVersion counts upstream Modernize passes, not -- our schema, and is never carried. data.internalVersion = WA.SCHEMA_VERSION return data end -- A dynamic group arranges its children itself and cannot own a nested group -- -- the one placement WA.CanPlaceAura refuses outright. Silently flattening the -- pack would put a sub-group's children where their author never arranged them, -- so the whole import stops instead. local function placementRefusal(parentSource, childSource) if parentSource.regionType ~= "dynamicgroup" then return nil end if not GROUP_TYPES[childSource.regionType] then return nil end return "\"" .. tostring(childSource.id) .. "\" is a group inside a dynamic group, which cannot be placed here" end -- The displays under the root, parents before their own children and siblings in -- the author's order. The installer walks the same list and depends on that -- ordering to have a parent's assigned id in hand by the time it reaches a child. -- -- payload.c is a flat list in both transmission versions and means two different -- things. v1421 strips parent and controlledChildren and sends the root's direct -- children; v2000 keeps both and sends every descendant, so there the tree exists -- only in those fields. The version decides which, never the presence of a parent -- field -- a v2000 pack read as v1421 loses every sub-group's nesting, and the -- reverse finds no tree at all. local function buildTree(payload, report) local rootSource = payload.d local children = payload.c if children == nil then return {} end if type(children) ~= "table" then report.refused = "payload has invalid child displays" return nil end local count = #children if count > 0 and not GROUP_TYPES[rootSource.regionType] then report.refused = "child displays require a group root" return nil end -- Every id below is a table key, and a nil one raises rather than refusing. if count > 0 and type(rootSource.id) ~= "string" then report.refused = "the group display has no id" return nil end for i = 1, count do if type(children[i]) ~= "table" or type(children[i].id) ~= "string" then report.refused = "child display " .. i .. " has no id" return nil end end local nodes = {} if payload.v ~= 2000 then for i = 1, count do local refusal = placementRefusal(rootSource, children[i]) if refusal then report.refused = refusal return nil end table.insert(nodes, { source = children[i], parent = rootSource.id }) end return nodes end local byId = { [rootSource.id] = rootSource } for i = 1, count do local child = children[i] if byId[child.id] then report.refused = "two displays share the id \"" .. child.id .. "\"" return nil end byId[child.id] = child end -- Following controlledChildren rather than each child's parent is what keeps -- siblings in the author's order; `seen` is also the cycle guard, since a -- payload can name a group as its own ancestor. local seen = {} local function walk(parentSource) local list = parentSource.controlledChildren if type(list) ~= "table" then return end for i = 1, #list do if report.refused then return end local child = byId[list[i]] if child and child ~= rootSource and not seen[child] then seen[child] = true local refusal = placementRefusal(parentSource, child) if refusal then report.refused = refusal return end table.insert(nodes, { source = child, parent = parentSource.id }) walk(child) end end end walk(rootSource) if report.refused then return nil end for i = 1, count do if not seen[children[i]] then reportDrop(report, "aura not imported", tostring(children[i].id) .. ": no group in this import claims it") end end return nodes end -- A group whose children all refused installs as an empty box: it holds -- nothing, draws nothing, and the user has to hunt it down and delete it. It -- leaves with them, and so does any group left empty by its leaving. A group its -- author shipped empty stays -- that one is deliberate, so only a group that -- *lost* children is pruned. local function pruneEmptyGroups(children, nodes, report) local authored = {} for i = 1, #nodes do authored[nodes[i].parent] = true end local pruning = true while pruning do pruning = false local hasChild = {} for i = 1, #children do hasChild[children[i].parent] = true end for i = #children, 1, -1 do local child = children[i] if GROUP_TYPES[child.regionType] and authored[child.id] and not hasChild[child.id] then table.remove(children, i) reportDrop(report, "aura not imported", tostring(child.id) .. ": an empty group, none of its auras could be imported") pruning = true end end end end function WA.WA2Translate(payload) local report = { created = {}, dropped = {}, code = {}, refused = nil } if type(payload) ~= "table" then report.refused = "payload is not a table" return nil, report end if type(payload.d) ~= "table" then report.refused = "payload has no display" return nil, report end -- The root is translated before the tree is walked, so that a root refusing on -- its own terms says so rather than being reported as a malformed group. local ok, root = pcall(translateDisplay, payload.d, report) if not ok then report.refused = "translation failed: " .. tostring(root) return nil, report end if not root then return nil, report end local nodes = buildTree(payload, report) if not nodes then return nil, report end -- A child that refuses is dropped by name rather than refusing the pack: the -- rest of it behaves exactly as its author arranged, and a named absence is -- a visible failure where refusing thirty auras over one leaves the user -- nothing they can act on. Only the root refusing refuses the import, and a -- child's own report is merged only once it survives, so a dropped display -- never contributes code to the disclosure list. local children, dropped = {}, {} local nodeCount = #nodes for i = 1, nodeCount do local node = nodes[i] local label = tostring(node.source.id or "?") if dropped[node.parent] then dropped[label] = true reportDrop(report, "aura not imported", label .. ": its group was not imported") else local childReport = { created = {}, dropped = {}, code = {}, refused = nil } local childOk, child = pcall(translateDisplay, node.source, childReport) if childOk and child then child.parent = node.parent table.insert(children, child) for n = 1, #childReport.dropped do table.insert(report.dropped, childReport.dropped[n]) end for n = 1, #childReport.code do table.insert(report.code, childReport.code[n]) end for n = 1, #(childReport.foreignApiOrder or {}) do local name = childReport.foreignApiOrder[n] report.foreignApi = report.foreignApi or {} report.foreignApiOrder = report.foreignApiOrder or {} if not report.foreignApi[name] then report.foreignApi[name] = true table.insert(report.foreignApiOrder, name) end end for n = 1, #(childReport.wagoKeyOrder or {}) do local name = childReport.wagoKeyOrder[n] report.wagoKeys = report.wagoKeys or {} report.wagoKeyOrder = report.wagoKeyOrder or {} if not report.wagoKeys[name] then report.wagoKeys[name] = true table.insert(report.wagoKeyOrder, name) end end for n = 1, #(childReport.foreignEnvOrder or {}) do local name = childReport.foreignEnvOrder[n] report.foreignEnv = report.foreignEnv or {} report.foreignEnvOrder = report.foreignEnvOrder or {} if not report.foreignEnv[name] then report.foreignEnv[name] = true table.insert(report.foreignEnvOrder, name) end end if childReport.unitClassFixed then report.unitClassFixed = true end if childReport.unitClassAssigned then report.unitClassAssigned = true end else dropped[label] = true reportDrop(report, "aura not imported", label .. ": " .. tostring(childOk and childReport.refused or child)) end end end pruneEmptyGroups(children, nodes, report) if nodeCount > 0 and #children == 0 then report.refused = "none of this group's " .. nodeCount .. " auras could be imported" return nil, report end return { root = root, children = children }, report end -- How many *distinct* details one reason spells out before it just counts. A -- pack of eighty children reports the same drop eighty times, and a summary -- nobody can read to the end is a review step in name only -- so identical -- details collapse to one entry carrying its repeat count, and the budget below -- buys that many separate problems rather than that many copies of the first. local DETAIL_LIMIT = 6 function WA.ImportSummary(pending, report) local root = pending and pending.root or {} local childCount = #(pending and pending.children or {}) local header = "Importing \"" .. tostring(root.id or "Imported") .. "\" (" .. tostring(root.regionType or "unknown") .. ")" if childCount == 1 then header = header .. " and 1 aura inside it" elseif childCount > 1 then header = header .. " and " .. childCount .. " auras inside it" end local lines = { header } -- Above the rest of the summary, not down with the version block: this is -- the one warning that says settings are being dropped right now. if report and report.schemaAhead then table.insert(lines, "") table.insert(lines, "Made with a newer WeakestAuras (data version " .. tostring(report.schemaAhead) .. "; this one reads " .. tostring(WA.SCHEMA_VERSION) .. "). It will import, but anything that version added may come in at defaults.") end if #(report and report.code or {}) > 0 then table.insert(lines, "") table.insert(lines, "Runs this author's Lua:") for i = 1, #report.code do local item = report.code[i] local state = item.active and "active" or "inactive" table.insert(lines, " " .. tostring(item.name) .. " (" .. state .. ")") local source = string.gsub(item.source or "", "\n", "\n ") table.insert(lines, " " .. source) end end if #(report and report.foreignApiOrder or {}) > 0 then table.insert(lines, "") table.insert(lines, "That Lua calls WeakAuras functions this addon does not have. Each errors " .. "where it stands; the rest of the aura is unaffected.") for i = 1, #report.foreignApiOrder do table.insert(lines, " WeakAuras." .. tostring(report.foreignApiOrder[i])) end end if #(report and report.foreignEnvOrder or {}) > 0 then table.insert(lines, "") table.insert(lines, "It also calls WeakAuras helpers that live in the environment rather than " .. "on that table, and these are not provided. Each errors where it stands.") for i = 1, #report.foreignEnvOrder do table.insert(lines, " " .. tostring(report.foreignEnvOrder[i]) .. "()") end end if report and report.unitClassFixed then table.insert(lines, "") table.insert(lines, "Rewrote UnitClass's class-id read. This client's UnitClass returns only " .. "the localized name and the class token, so select(3, UnitClass(unit)) is nil on " .. "every unit and the check it feeds is silently false; each was rewritten to " .. "select(2, UnitClassBase(unit)), which answers the same id.") end if report and report.unitClassAssigned then table.insert(lines, "") table.insert(lines, "That Lua also reads UnitClass's third return by assignment, which this " .. "client does not have and which takes a different number of names to rewrite. " .. "UnitClassBase(unit) returns the token and the class id.") end if #(report and report.dropped or {}) > 0 then local groups, byReason = {}, {} for i = 1, #report.dropped do local item = report.dropped[i] local group = byReason[item.reason] if not group then group = { reason = item.reason, count = 0, details = {}, repeats = {}, seen = {} } byReason[item.reason] = group table.insert(groups, group) end group.count = group.count + 1 local detail = tostring(item.detail) local at = group.seen[detail] if at then group.repeats[at] = group.repeats[at] + 1 else table.insert(group.details, detail) at = #group.details group.seen[detail] = at group.repeats[at] = 1 end end table.insert(lines, "") table.insert(lines, "Not imported:") for i = 1, #groups do local group = groups[i] local distinct = #group.details local shown = distinct if shown > DETAIL_LIMIT then shown = DETAIL_LIMIT end local parts = {} for n = 1, shown do parts[n] = group.details[n] if group.repeats[n] > 1 then parts[n] = parts[n] .. " (x" .. group.repeats[n] .. ")" end end local line = " " .. tostring(group.reason) .. " (" .. group.count .. ") " .. table.concat(parts, ", ") if distinct > shown then line = line .. ", and " .. (distinct - shown) .. " more" end table.insert(lines, line) end end if #(report and report.wagoKeyOrder or {}) > 0 then table.insert(lines, "") table.insert(lines, "Wago bookkeeping (" .. table.concat(report.wagoKeyOrder, ", ") .. ") is not carried.") end if report and report.sourceVersion then table.insert(lines, "") table.insert(lines, "Exported from " .. (report.sourceAddon or "WeakestAuras") .. " " .. tostring(report.sourceVersion)) local mods = report.sourceMods if type(mods) == "table" then local parts = {} if mods.classicapi then table.insert(parts, "ClassicAPI " .. tostring(mods.classicapi)) end if mods.nampower then table.insert(parts, "Nampower " .. tostring(mods.nampower)) end if #parts > 0 then table.insert(lines, " built with " .. table.concat(parts, ", ")) end end if report.sourceAddon == "WeakestAuras" and WA.VersionNewer(report.sourceVersion, WA.version) then table.insert(lines, " That WeakestAuras is newer than this one -- settings it added may not survive.") end end return table.concat(lines, "\n") end