Toggle search
Toggle menu
115
248
25
2.7K
SpiritVale Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Join the Playtest on Steam Now: SpiritVale

Module:GameSkills: Difference between revisions

From SpiritVale Wiki
More actions
← Older edit
No edit summary
No edit summary
 
(8 intermediate revisions by the same user not shown)
Line 3: Line 3:
-- Phase 6.5+ (Plug-in Slot Architecture)
-- Phase 6.5+ (Plug-in Slot Architecture)
--
--
-- Layout (Module 1–8):
-- Layout:
--  Row 1: Module 1 + Module 2   → Icon + Name, Skill Type strip
--  Row 1: Slot 1 + Slot 2 (Icon + SkillType)
--  Row 2: Module 3 + Module 4   → Description (Module 3), open slot (Module 4)
--  Row 2: Slot 3 + Slot 4 (Description + Placeholder)
--  Row 3: Module 5 + Module 6   → Source Types, Quick Stats
--  Row 3: Slot 5 + Slot 6 (SourceType + QuickStats)
--  Row 4: Module 7 + Module 8   → Special Mechanics, Level Selector
--  Row 4: Slot 7 + Slot 8 (SpecialMechanics + LevelSelector)
--
--
-- Requires Common.js:
-- Requires Common.js:
Line 23: Line 23:


local skillsCache
local skillsCache
local eventsCache


-- getSkills: lazy-load + cache skill dataset from GameData.
-- getSkills: lazy-load + cache skill dataset from GameData.
local function getSkills()
local function getSkills()
if not skillsCache then
        if not skillsCache then
skillsCache = GameData.loadSkills()
                skillsCache = GameData.loadSkills()
end
        end
return skillsCache
        return skillsCache
end
 
local function getEvents()
        if eventsCache == nil then
                if type(GameData.loadEvents) == "function" then
                        eventsCache = GameData.loadEvents()
                else
                        eventsCache = false
                end
        end
 
        return eventsCache
end
end


Line 93: Line 106:
-- listToText: join an array into a readable string.
-- listToText: join an array into a readable string.
local function listToText(list, sep)
local function listToText(list, sep)
if type(list) ~= "table" or #list == 0 then
        if type(list) ~= "table" or #list == 0 then
return nil
                return nil
end
        end
return table.concat(list, sep or ", ")
        return table.concat(list, sep or ", ")
end
end


-- isNoneLike: treat common "none" spellings as empty.
local function resolveDisplayName(v, kind)
local function isNoneLike(v)
        if v == nil then return nil end
if v == nil then return true end
local s = mw.text.trim(tostring(v))
if s == "" then return true end
s = mw.ustring.lower(s)
return (s == "none" or s == "no" or s == "n/a" or s == "na" or s == "null")
end


-- addRow: add a standard <tr><th>Label</th><td>Value</td></tr> row.
        local function firstString(keys, source)
local function addRow(tbl, label, value, rowClass, dataKey)
                for _, key in ipairs(keys) do
if value == nil or value == "" then
                        local candidate = source[key]
return
                        if type(candidate) == "string" and candidate ~= "" then
end
                                return candidate
                        end
                end
                return nil
        end


local row = tbl:tag("tr")
        if type(v) == "table" then
row:addClass("sv-row")
                local primaryKeys = { "External Name", "Display Name", "Name" }
if rowClass then row:addClass(rowClass) end
                local extendedKeys = { "Skill External Name", "Status External Name" }
if dataKey then row:attr("data-field", dataKey) end
                local internalKeys = { "Internal Name", "Internal ID", "ID", "InternalID", "Skill Internal Name", "InternalID" }
 
                return firstString(primaryKeys, v)
                        or firstString(extendedKeys, v)
                        or firstString(internalKeys, v)
        end
 
        if type(v) == "string" then
                if kind == "event" then
                        local events = getEvents()
                        if events and events.byId and events.byId[v] then
                                local mapped = resolveDisplayName(events.byId[v], "event")
                                if mapped then
                                        return mapped
                                end
                        end
                end
 
                return v
        end
 
        return tostring(v)
end


row:tag("th"):wikitext(label):done()
local function resolveEventName(v)
row:tag("td"):wikitext(value):done()
        local resolved = resolveDisplayName(v, "event")
        if type(resolved) == "string" then
                return resolved
        end
        return (resolved ~= nil) and tostring(resolved) or nil
end
end


-- formatUnitValue: format {Value, Unit} blocks (or scalar) for display.
local function resolveSkillNameFromEvent(ev)
local function formatUnitValue(v)
        if type(ev) ~= "table" then
if type(v) == "table" and v.Value ~= nil then
                return resolveDisplayName(ev, "skill") or "Unknown skill"
local unit = v.Unit
        end
local val  = v.Value
 
        local displayKeys = {
                "Skill External Name",
                "External Name",
                "Display Name",
                "Name",
                "Skill Name",
        }


if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
        for _, key in ipairs(displayKeys) do
return tostring(val) .. "%"
                local candidate = resolveDisplayName(ev[key], "skill")
elseif unit == "seconds" then
                if candidate then
return tostring(val) .. "s"
                        return candidate
elseif unit == "meters" then
                end
return tostring(val) .. "m"
        end
elseif unit == "tiles" then
return tostring(val) .. " tiles"
elseif unit and unit ~= "" then
return tostring(val) .. " " .. tostring(unit)
else
return tostring(val)
end
end


return (v ~= nil) and tostring(v) or nil
        local internalKeys = {
end
                "Skill Internal Name",
                "Skill ID",
                "Internal Name",
                "Internal ID",
                "ID",
        }


----------------------------------------------------------------------
        for _, key in ipairs(internalKeys) do
-- Dynamic spans (JS-driven)
                local candidate = ev[key]
----------------------------------------------------------------------
                if type(candidate) == "string" and candidate ~= "" then
                        return candidate
                end
        end


-- dynSpan: render a JS-updated span for a level series.
        return "Unknown skill"
local function dynSpan(series, level)
end
if type(series) ~= "table" or #series == 0 then
return nil
end


level = clamp(level or #series, 1, #series)
-- isNoneLike: treat common "none" spellings as empty.
local function isNoneLike(v)
if v == nil then return true end
local s = mw.text.trim(tostring(v))
if s == "" then return true end
s = mw.ustring.lower(s)
return (s == "none" or s == "no" or s == "n/a" or s == "na" or s == "null")
end


local span = mw.html.create("span")
-- addRow: add a standard <tr><th>Label</th><td>Value</td></tr> row.
span:addClass("sv-dyn")
local function addRow(tbl, label, value, rowClass, dataKey)
span:attr("data-series", mw.text.jsonEncode(series))
if value == nil or value == "" then
span:wikitext(mw.text.nowiki(series[level] or ""))
return
end
 
local row = tbl:tag("tr")
row:addClass("sv-row")
if rowClass then row:addClass(rowClass) end
if dataKey then row:attr("data-field", dataKey) end


return tostring(span)
row:tag("th"):wikitext(label):done()
row:tag("td"):wikitext(value):done()
end
end


-- isFlatList: true if all values in list are identical.
-- formatUnitValue: format {Value, Unit} blocks (or scalar) for display.
local function isFlatList(list)
local function formatUnitValue(v)
if type(list) ~= "table" or #list == 0 then
if type(v) == "table" and v.Value ~= nil then
return false
local unit = v.Unit
end
local val  = v.Value
local first = tostring(list[1])
 
for i = 2, #list do
if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
if tostring(list[i]) ~= first then
return tostring(val) .. "%"
return false
elseif unit == "seconds" then
return tostring(val) .. "s"
elseif unit == "meters" then
return tostring(val) .. "m"
elseif unit == "tiles" then
return tostring(val) .. " tiles"
elseif unit and unit ~= "" then
return tostring(val) .. " " .. tostring(unit)
else
return tostring(val)
end
end
end
end
return true
 
return (v ~= nil) and tostring(v) or nil
end
end


-- isNonZeroScalar: detect if a value is present and not effectively zero.
----------------------------------------------------------------------
local function isNonZeroScalar(v)
-- Dynamic spans (JS-driven)
if v == nil then return false end
----------------------------------------------------------------------
if type(v) == "number" then return v ~= 0 end
if type(v) == "string" then
local n = tonumber(v)
if n == nil then return v ~= "" end
return n ~= 0
end
if type(v) == "table" and v.Value ~= nil then
return isNonZeroScalar(v.Value)
end
return true
end


-- isZeroish: aggressively treat common “zero” text forms as zero.
-- dynSpan: render a JS-updated span for a level series.
local function isZeroish(v)
local function dynSpan(series, level)
if v == nil then return true end
if type(series) ~= "table" or #series == 0 then
if type(v) == "number" then return v == 0 end
return nil
if type(v) == "table" and v.Value ~= nil then
return isZeroish(v.Value)
end
end


local s = mw.text.trim(tostring(v))
level = clamp(level or #series, 1, #series)
if s == "" then return true end
if s == "0" or s == "0.0" or s == "0.00" then return true end
if s == "0s" or s == "0 s" then return true end
if s == "0m" or s == "0 m" then return true end
if s == "0%" or s == "0 %" then return true end


local n = tonumber((mw.ustring.gsub(s, "[^0-9%.%-]", "")))
local span = mw.html.create("span")
return (n ~= nil and n == 0)
span:addClass("sv-dyn")
span:attr("data-series", mw.text.jsonEncode(series))
span:wikitext(mw.text.nowiki(series[level] or ""))
 
return tostring(span)
end
end


-- valuePairRawText: render Base/Per Level blocks into readable text (fallback).
-- isFlatList: true if all values in list are identical.
local function valuePairRawText(block)
local function isFlatList(list)
if type(block) ~= "table" then
if type(list) ~= "table" or #list == 0 then
return nil
return false
end
local first = tostring(list[1])
for i = 2, #list do
if tostring(list[i]) ~= first then
return false
end
end
end
return true
end


local base = block.Base
-- isNonZeroScalar: detect if a value is present and not effectively zero.
local per  = block["Per Level"]
local function isNonZeroScalar(v)
 
if v == nil then return false end
if type(per) == "table" then
if type(v) == "number" then return v ~= 0 end
if #per == 0 then
if type(v) == "string" then
return formatUnitValue(base)
local n = tonumber(v)
end
if n == nil then return v ~= "" end
if isFlatList(per) then
return n ~= 0
return formatUnitValue(base) or tostring(per[1])
end
 
local vals = {}
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
end
return (#vals > 0) and table.concat(vals, " / ") or nil
end
end
 
if type(v) == "table" and v.Value ~= nil then
local baseText = formatUnitValue(base)
return isNonZeroScalar(v.Value)
local perText  = formatUnitValue(per)
 
if baseText and perText and isNonZeroScalar(per) then
return string.format("%s (Per Level: %s)", baseText, perText)
end
end
 
return true
return baseText or perText
end
end


-- valuePairDynamicValueOnly: render Base/Per Level blocks using dyn spans where possible.
-- isZeroish: aggressively treat common “zero” text forms as zero.
local function valuePairDynamicValueOnly(block, maxLevel, level)
local function isZeroish(v)
if v == nil then return true end
if type(v) == "number" then return v == 0 end
if type(v) == "table" and v.Value ~= nil then
return isZeroish(v.Value)
end
 
local s = mw.text.trim(tostring(v))
if s == "" then return true end
if s == "0" or s == "0.0" or s == "0.00" then return true end
if s == "0s" or s == "0 s" then return true end
if s == "0m" or s == "0 m" then return true end
if s == "0%" or s == "0 %" then return true end
 
local n = tonumber((mw.ustring.gsub(s, "[^0-9%.%-]", "")))
return (n ~= nil and n == 0)
end
 
-- valuePairRawText: render Base/Per Level blocks into readable text (fallback).
local function valuePairRawText(block)
if type(block) ~= "table" then
if type(block) ~= "table" then
return nil
return nil
Line 260: Line 325:
if type(per) == "table" then
if type(per) == "table" then
if #per == 0 then
if #per == 0 then
local baseText = formatUnitValue(base)
return formatUnitValue(base)
return baseText and mw.text.nowiki(baseText) or nil
end
end
if isFlatList(per) then
if isFlatList(per) then
local one  = formatUnitValue(per[1]) or tostring(per[1])
return formatUnitValue(base) or tostring(per[1])
local show = formatUnitValue(base) or one
end
return show and mw.text.nowiki(show) or nil
end


local series = {}
local vals = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
table.insert(vals, formatUnitValue(v) or tostring(v))
end
end
return dynSpan(series, level)
return (#vals > 0) and table.concat(vals, " / ") or nil
end
end


local txt = valuePairRawText(block)
local baseText = formatUnitValue(base)
return txt and mw.text.nowiki(txt) or nil
local perText  = formatUnitValue(per)
end


----------------------------------------------------------------------
if baseText and perText and isNonZeroScalar(per) then
-- Lookups
return string.format("%s (Per Level: %s)", baseText, perText)
----------------------------------------------------------------------
end


-- getSkillById: locate a skill by internal ID.
return baseText or perText
local function getSkillById(id)
id = trim(id)
if not id then return nil end
local dataset = getSkills()
return (dataset.byId or {})[id]
end
end


-- findSkillByName: locate a skill by external/display name.
-- valuePairDynamicValueOnly: render Base/Per Level blocks using dyn spans where possible.
local function findSkillByName(name)
local function valuePairDynamicValueOnly(block, maxLevel, level)
name = trim(name)
if type(block) ~= "table" then
if not name then return nil end
return nil
end


local dataset = getSkills()
local base = block.Base
local byName = dataset.byName or {}
local per  = block["Per Level"]


if byName[name] then
if type(per) == "table" then
return byName[name]
if #per == 0 then
end
local baseText = formatUnitValue(base)
 
return baseText and mw.text.nowiki(baseText) or nil
for _, rec in ipairs(dataset.records or {}) do
if type(rec) == "table" then
if rec["External Name"] == name or rec.Name == name or rec["Display Name"] == name then
return rec
end
end
end
end


return nil
if isFlatList(per) then
local one  = formatUnitValue(per[1]) or tostring(per[1])
local show = formatUnitValue(base) or one
return show and mw.text.nowiki(show) or nil
end
 
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
 
local txt = valuePairRawText(block)
return txt and mw.text.nowiki(txt) or nil
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Legacy damage helpers
-- Lookups
----------------------------------------------------------------------
----------------------------------------------------------------------


-- basisLabel: label ATK/MATK basis in legacy damage blocks.
-- getSkillById: locate a skill by internal ID.
local function basisLabel(entry, isHealing)
local function getSkillById(id)
if isHealing then
id = trim(id)
return "Healing"
if not id then return nil end
end
local dataset = getSkills()
return (dataset.byId or {})[id]
end


local atk  = entry and entry["ATK-Based"]
-- findSkillByName: locate a skill by external/display name.
local matk = entry and entry["MATK-Based"]
local function findSkillByName(name)
name = trim(name)
if not name then return nil end
 
local dataset = getSkills()
local byName = dataset.byName or {}
 
if byName[name] then
return byName[name]
end


if atk and matk then
for _, rec in ipairs(dataset.records or {}) do
return "Attack/Magic Attack"
if type(rec) == "table" then
elseif atk then
if rec["External Name"] == name or rec.Name == name or rec["Display Name"] == name then
return "Attack"
return rec
elseif matk then
end
return "Magic Attack"
end
end
end


return "Damage"
return nil
end
end


-- formatDamageEntry: legacy percent damage formatting (dynamic by level).
----------------------------------------------------------------------
local function formatDamageEntry(entry, maxLevel, level)
-- Legacy damage helpers
if type(entry) ~= "table" then
----------------------------------------------------------------------
 
-- basisLabel: label ATK/MATK basis in legacy damage blocks.
local function basisLabel(entry, isHealing)
if isHealing then
return "Healing"
end
 
local atk  = entry and entry["ATK-Based"]
local matk = entry and entry["MATK-Based"]
 
if atk and matk then
return "Attack/Magic Attack"
elseif atk then
return "Attack"
elseif matk then
return "Magic Attack"
end
 
return "Damage"
end
 
-- formatDamageEntry: legacy percent damage formatting (dynamic by level).
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
return nil
return nil
end
end
Line 476: Line 575:
----------------------------------------------------------------------
----------------------------------------------------------------------


-- Module row order (see layout notes above).
local HERO_SLOT_ASSIGNMENT = {
local MODULE_SLOT_ASSIGNMENT = {
[1] = "IconName",
        [1] = "IconName",
[2] = "Description",
        [2] = "SkillType", -- Damage/Element/Hits/Target/Cast/Combo strip
[3] = "LevelSelector",
        [3] = "Description",
[4] = "SkillType",
        [4] = nil, -- placeholder / intentionally open
[5] = "SourceType",
        [5] = "SourceType",
[6] = "QuickStats",
        [6] = "QuickStats",
[7] = "SpecialMechanics",
        [7] = "SpecialMechanics",
[8] = "Placeholder",
        [8] = "LevelSelector",
}
 
local MODULE_GRID_PAIRS = {
        { 3, 4 },
        { 5, 6 },
        { 7, 8 },
}
}


Line 498: Line 590:
----------------------------------------------------------------------
----------------------------------------------------------------------


-- heroBarBox: wrapper for hero-bar slot modules.
-- slotBox: standardized wrapper for all hero card slots.
local function heroBarBox(slot, extraClasses, innerHtml, isEmpty)
local function slotBox(slot, extraClasses, innerHtml, opts)
        local box = mw.html.create("div")
opts = opts or {}
        box:addClass("hero-bar-module")
        box:addClass("hero-bar-module-" .. tostring(slot))
        box:addClass("sv-module-slot")
        box:addClass("sv-module-slot-" .. tostring(slot))
        box:attr("data-hero-bar-module", tostring(slot))
        box:attr("data-module-slot", tostring(slot))


if slot == 2 then
local box = mw.html.create("div")
box:addClass("sv-herobar-compact")
box:addClass("sv-slot")
end
box:addClass("sv-slot--" .. tostring(slot))
box:attr("data-hero-slot", tostring(slot))


if extraClasses then
if opts.isFull then
if type(extraClasses) == "string" then
box:addClass("sv-slot--full")
box:addClass(extraClasses)
elseif type(extraClasses) == "table" then
for _, c in ipairs(extraClasses) do box:addClass(c) end
end
end
end
if isEmpty then
box:addClass("hero-bar-module-empty")
end
local body = box:tag("div"):addClass("hero-bar-module-body")
if innerHtml and innerHtml ~= "" then
body:wikitext(innerHtml)
end
return tostring(box)
end
-- moduleBox: wrapper for hero-module (2x2 grid) slot modules.
local function moduleBox(slot, extraClasses, innerHtml, isEmpty)
        local box = mw.html.create("div")
        box:addClass("hero-module")
        box:addClass("hero-module-" .. tostring(slot))
        box:addClass("sv-module-slot")
        box:addClass("sv-module-slot-" .. tostring(slot))
        box:attr("data-hero-module", tostring(slot))
        box:attr("data-module-slot", tostring(slot))


if extraClasses then
if extraClasses then
Line 550: Line 611:
end
end


if isEmpty then
if opts.isEmpty then
box:addClass("hero-module-empty")
box:addClass("sv-slot--empty")
end
end


local body = box:tag("div"):addClass("hero-module-body")
local body = box:tag("div"):addClass("sv-slot__body")
if innerHtml and innerHtml ~= "" then
if innerHtml and innerHtml ~= "" then
body:wikitext(innerHtml)
body:wikitext(innerHtml)
Line 914: Line 975:
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"


local wrap = mw.html.create("div")
local notesList = {}
wrap:addClass("sv-herobar-1-wrap")
if type(rec.Notes) == "table" then
 
for _, note in ipairs(rec.Notes) do
if icon and icon ~= "" then
local n = trim(note)
wrap:tag("div")
if n then
:addClass("sv-herobar-icon")
table.insert(notesList, mw.text.nowiki(n))
:wikitext(string.format("[[File:%s|80px|link=]]", icon))
end
end
elseif type(rec.Notes) == "string" then
local n = trim(rec.Notes)
if n then
notesList = { mw.text.nowiki(n) }
end
end
end


wrap:tag("div")
local req = rec.Requirements or {}
:addClass("spiritvale-infobox-title")
local reqSkillsRaw = (type(req["Required Skills"]) == "table") and req["Required Skills"] or {}
:wikitext(title)
local reqWeaponsRaw = (type(req["Required Weapons"]) == "table") and req["Required Weapons"] or {}
local reqStancesRaw = (type(req["Required Stances"]) == "table") and req["Required Stances"] or {}


return {
local reqSkills = {}
inner = tostring(wrap),
for _, rs in ipairs(reqSkillsRaw) do
classes = "module-herobar-1",
if type(rs) == "table" then
}
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
end
local lvlReq  = rs["Required Level"]
if lvlReq then
table.insert(reqSkills, string.format("%s (Lv.%s)", mw.text.nowiki(nameReq), mw.text.nowiki(tostring(lvlReq))))
else
table.insert(reqSkills, mw.text.nowiki(nameReq))
end
end
end
 
local reqWeapons = {}
for _, w in ipairs(reqWeaponsRaw) do
local wn = trim(w)
if wn then table.insert(reqWeapons, mw.text.nowiki(wn)) end
end
 
local reqStances = {}
for _, s in ipairs(reqStancesRaw) do
local sn = trim(s)
if sn then table.insert(reqStances, mw.text.nowiki(sn)) end
end
 
local hasNotes = (#notesList > 0)
local hasReq = (#reqSkills > 0) or (#reqWeapons > 0) or (#reqStances > 0)


-- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile).
-- Rules:
--  - If skill is non-damaging, hide Damage/Element/Hits.
--  - If Hits is empty, hide Hits.
--  - If Combo is empty, hide Combo.
-- Ordering:
--  - Desktop: Damage, Element, Hits, Target, Cast, Combo
--  - Mobile:  Damage, Element, Target, Cast, Hits, Combo (CSS reorder)
function PLUGINS.SkillType(rec, ctx)
local typeBlock = (type(rec.Type) == "table") and rec.Type or {}
local mech      = (type(rec.Mechanics) == "table") and rec.Mechanics or {}


local level    = ctx.level or 1
local wrap = mw.html.create("div")
local maxLevel = ctx.maxLevel or 1
wrap:addClass("sv-herobar-1-wrap")
wrap:addClass("sv-tip-scope")


local hideDamageBundle = (ctx.nonDamaging == true)
local iconBox = wrap:tag("div")
iconBox:addClass("sv-herobar-icon")


-- valName: extract a display string from typical {Name/ID/Value} objects.
if icon and icon ~= "" then
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped.
iconBox:wikitext(string.format("[[File:%s|80px|link=]]", icon))
local function valName(x)
if x == nil then return nil end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if x.Value ~= nil then return tostring(x.Value) end
end
if type(x) == "number" then
return tostring(x)
end
if type(x) == "string" and x ~= "" then
return x
end
return nil
end
end


-- hitsDisplay: find + render Hits from multiple possible structured locations.
local textBox = wrap:tag("div")
local function hitsDisplay()
textBox:addClass("sv-herobar-text")
local effects = (type(mech.Effects) == "table") and mech.Effects or {}
 
local titleRow = textBox:tag("div")
titleRow:addClass("sv-herobar-title-row")
 
local titleBox = titleRow:tag("div")
titleBox:addClass("spiritvale-infobox-title")
titleBox:wikitext(title)


local h =
if hasNotes then
typeBlock.Hits or typeBlock["Hits"] or typeBlock["Hit Count"] or typeBlock["Hits Count"] or
local notesBtn = mw.html.create("span")
mech.Hits or mech["Hits"] or mech["Hit Count"] or mech["Hits Count"] or
notesBtn:addClass("sv-tip-btn sv-tip-btn--notes")
effects.Hits or effects["Hits"] or effects["Hit Count"] or effects["Hits Count"] or
notesBtn:attr("role", "button")
rec.Hits or rec["Hits"]
notesBtn:attr("tabindex", "0")
notesBtn:attr("data-sv-tip", "notes")
notesBtn:attr("aria-label", "Notes")
notesBtn:attr("aria-expanded", "false")
notesBtn:tag("span"):addClass("sv-ico sv-ico--info"):attr("aria-hidden", "true"):wikitext("i")
titleRow:node(notesBtn)
end


if h == nil or isNoneLike(h) then
if hasReq then
return nil
local pillRow = wrap:tag("div")
end
pillRow:addClass("sv-pill-row")
pillRow:addClass("sv-pill-row--req")
local pill = pillRow:tag("span")
pill:addClass("sv-pill sv-pill--req sv-tip-btn")
pill:attr("role", "button")
pill:attr("tabindex", "0")
pill:attr("data-sv-tip", "req")
pill:attr("aria-label", "Requirements")
pill:attr("aria-expanded", "false")
pill:wikitext("Requirements")
end


-- ValuePair-style table (Base/Per Level) => dynamic series
if hasNotes then
if type(h) == "table" then
local notesContent = wrap:tag("div")
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
notesContent:addClass("sv-tip-content")
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
notesContent:attr("data-sv-tip-content", "notes")
end
notesContent:tag("div"):addClass("sv-tip-title"):wikitext("Notes")
notesContent:tag("div"):wikitext(table.concat(notesList, "<br />"))
end


-- Unit block {Value, Unit}
if hasReq then
if h.Value ~= nil then
local reqContent = wrap:tag("div")
local t = formatUnitValue(h)
reqContent:addClass("sv-tip-content")
return t and mw.text.nowiki(t) or nil
reqContent:attr("data-sv-tip-content", "req")
end


-- Fallback name extraction
if #reqSkills > 0 then
local function valName(x)
local section = reqContent:tag("div")
if x == nil then return nil end
section:addClass("sv-tip-section")
if type(x) == "table" then
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Skills")
if x.Name and x.Name ~= "" then return tostring(x.Name) end
section:tag("div"):wikitext(table.concat(reqSkills, "<br />"))
if x.ID and x.ID ~= "" then return tostring(x.ID) end
end
if x.Value ~= nil then return tostring(x.Value) end
end
if type(x) == "number" then return tostring(x) end
if type(x) == "string" and x ~= "" then return x end
return nil
end


local vn = valName(h)
if #reqWeapons > 0 then
if vn and not isNoneLike(vn) then
local section = reqContent:tag("div")
return mw.text.nowiki(vn)
section:addClass("sv-tip-section")
end
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Weapons")
section:tag("div"):wikitext(table.concat(reqWeapons, ", "))
end
end


-- Scalar number/string
if #reqStances > 0 then
if type(h) == "number" then
local section = reqContent:tag("div")
return mw.text.nowiki(fmtNum(h))
section:addClass("sv-tip-section")
end
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Stances")
if type(h) == "string" then
section:tag("div"):wikitext(table.concat(reqStances, ", "))
local t = trim(h)
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil
end
end
return nil
end
end


-- comboDisplay: render Combo as a compact text block (Type (+ details)).
return {
local function comboDisplay()
inner = tostring(wrap),
local c = (type(mech.Combo) == "table") and mech.Combo or nil
classes = "module-icon-name",
if not c then return nil end
}
end


local typ = trim(c.Type)
-- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile).
if not typ or isNoneLike(typ) then
-- Rules:
return nil
--  - If skill is non-damaging, hide Damage/Element/Hits.
end
--  - If Hits is empty, hide Hits.
 
--  - If Combo is empty, hide Combo.
local details = {}
-- Ordering:
--  - Desktop: Damage, Element, Hits, Target, Cast, Combo
--  - Mobile:  Damage, Element, Target, Cast, Hits, Combo (CSS reorder)
function PLUGINS.SkillType(rec, ctx)
local typeBlock = (type(rec.Type) == "table") and rec.Type or {}
local mech      = (type(rec.Mechanics) == "table") and rec.Mechanics or {}


local pct = formatUnitValue(c.Percent)
local level    = ctx.level or 1
if pct and not isZeroish(pct) then
local maxLevel = ctx.maxLevel or 1
table.insert(details, mw.text.nowiki(pct))
end


local dur = formatUnitValue(c.Duration)
local hideDamageBundle = (ctx.nonDamaging == true)
if dur and not isZeroish(dur) then
table.insert(details, mw.text.nowiki(dur))
end


if #details > 0 then
-- valName: extract a display string from typical {Name/ID/Value} objects.
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped.
local function valName(x)
if x == nil then return nil end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if x.Value ~= nil then return tostring(x.Value) end
end
end
return mw.text.nowiki(typ)
if type(x) == "number" then
return tostring(x)
end
if type(x) == "string" and x ~= "" then
return x
end
return nil
end
end


local grid = mw.html.create("div")
-- hitsDisplay: find + render Hits from multiple possible structured locations.
grid:addClass("sv-type-grid")
local function hitsDisplay()
grid:addClass("sv-compact-root")
local effects = (type(mech.Effects) == "table") and mech.Effects or {}


local added = false
local h =
typeBlock.Hits or typeBlock["Hits"] or typeBlock["Hit Count"] or typeBlock["Hits Count"] or
mech.Hits or mech["Hits"] or mech["Hit Count"] or mech["Hits Count"] or
effects.Hits or effects["Hits"] or effects["Hit Count"] or effects["Hits Count"] or
rec.Hits or rec["Hits"]


-- addChunk: add one labeled value cell (key drives CSS ordering).
if h == nil or isNoneLike(h) then
local function addChunk(key, label, valueHtml)
return nil
if valueHtml == nil or valueHtml == "" then return end
end
added = true


local chunk = grid:tag("div")
-- ValuePair-style table (Base/Per Level) => dynamic series
:addClass("sv-type-chunk")
if type(h) == "table" then
:addClass("sv-type-" .. tostring(key))
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
:attr("data-type-key", tostring(key))
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
end


chunk:tag("div")
-- Unit block {Value, Unit}
:addClass("sv-type-label")
if h.Value ~= nil then
:wikitext(mw.text.nowiki(label))
local t = formatUnitValue(h)
return t and mw.text.nowiki(t) or nil
end


chunk:tag("div")
-- Fallback name extraction
:addClass("sv-type-value")
local function valName(x)
:wikitext(valueHtml)
if x == nil then return nil end
end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if x.Value ~= nil then return tostring(x.Value) end
end
if type(x) == "number" then return tostring(x) end
if type(x) == "string" and x ~= "" then return x end
return nil
end


-- Damage + Element + Hits bundle (hidden when non-damaging)
local vn = valName(h)
if not hideDamageBundle then
if vn and not isNoneLike(vn) then
local dmg  = valName(typeBlock.Damage or typeBlock["Damage Type"])
return mw.text.nowiki(vn)
local ele  = valName(typeBlock.Element or typeBlock["Element Type"])
end
local hits = hitsDisplay()
end


if dmg and not isNoneLike(dmg) then
-- Scalar number/string
addChunk("damage", "Damage", mw.text.nowiki(dmg))
if type(h) == "number" then
return mw.text.nowiki(fmtNum(h))
end
end
if ele and not isNoneLike(ele) then
if type(h) == "string" then
addChunk("element", "Element", mw.text.nowiki(ele))
local t = trim(h)
end
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil
if hits then
addChunk("hits", "Hits", hits)
end
end
return nil
end
end


-- Target + Cast
-- comboDisplay: render Combo as a compact text block (Type (+ details)).
local tgt = valName(typeBlock.Target or typeBlock["Target Type"])
local function comboDisplay()
local cst = valName(typeBlock.Cast  or typeBlock["Cast Type"])
local c = (type(mech.Combo) == "table") and mech.Combo or nil
if not c then return nil end


if tgt and not isNoneLike(tgt) then
local typ = trim(c.Type)
addChunk("target", "Target", mw.text.nowiki(tgt))
if not typ or isNoneLike(typ) then
end
return nil
if cst and not isNoneLike(cst) then
end
addChunk("cast", "Cast", mw.text.nowiki(cst))
end


-- Combo
local details = {}
local combo = comboDisplay()
if combo then
addChunk("combo", "Combo", combo)
end


return {
local pct = formatUnitValue(c.Percent)
inner = added and tostring(grid) or "",
if pct and not isZeroish(pct) then
classes = "module-skill-type",
table.insert(details, mw.text.nowiki(pct))
}
end
end


function PLUGINS.Description(rec, ctx)
local dur = formatUnitValue(c.Duration)
        local desc = trim(rec.Description)
if dur and not isZeroish(dur) then
        if not desc then
table.insert(details, mw.text.nowiki(dur))
                return nil
end
        end


        local wrapper = mw.html.create("div")
if #details > 0 then
        wrapper:addClass("sv-module-description")
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
        wrapper:wikitext(string.format("''%s''", desc))
end
return mw.text.nowiki(typ)
end


        return {
local grid = mw.html.create("div")
                inner = tostring(wrapper),
grid:addClass("sv-type-grid")
                classes = "module-description",
grid:addClass("sv-compact-root")
        }
end


-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling.
local added = false
function PLUGINS.SourceType(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


local basisWord = nil
-- addChunk: add one labeled value cell (key drives CSS ordering).
local sourceKind = nil
local function addChunk(key, label, valueHtml)
local sourceVal  = nil
if valueHtml == nil or valueHtml == "" then return end
local scaling    = nil
added = true


-- sourceValueForLevel: dynamic formatting for structured Source blocks.
local chunk = grid:tag("div")
local function sourceValueForLevel(src)
:addClass("sv-type-chunk")
if type(src) ~= "table" then
:addClass("sv-type-" .. tostring(key))
return nil
:attr("data-type-key", tostring(key))
end


local per = src["Per Level"]
chunk:tag("div")
if type(per) == "table" and #per > 0 then
:addClass("sv-type-label")
if isFlatList(per) then
:wikitext(mw.text.nowiki(label))
local one  = formatUnitValue(per[1]) or tostring(per[1])
local show = formatUnitValue(src.Base) or one
return show and mw.text.nowiki(show) or nil
end


local series = {}
chunk:tag("div")
for _, v in ipairs(per) do
:addClass("sv-type-value")
table.insert(series, formatUnitValue(v) or tostring(v))
:wikitext(valueHtml)
end
end
return dynSpan(series, level)
end


return valuePairDynamicValueOnly(src, maxLevel, level)
-- Damage + Element + Hits bundle (hidden when non-damaging)
if not hideDamageBundle then
local dmg  = valName(typeBlock.Damage or typeBlock["Damage Type"])
local ele  = valName(typeBlock.Element or typeBlock["Element Type"])
local hits = hitsDisplay()
 
if dmg and not isNoneLike(dmg) then
addChunk("damage", "Damage", mw.text.nowiki(dmg))
end
if ele and not isNoneLike(ele) then
addChunk("element", "Element", mw.text.nowiki(ele))
end
if hits then
addChunk("hits", "Hits", hits)
end
end
end


if type(rec.Source) == "table" then
-- Target + Cast
local src = rec.Source
local tgt = valName(typeBlock.Target or typeBlock["Target Type"])
local atkFlag  = (src["ATK-Based"] == true)
local cst = valName(typeBlock.Cast  or typeBlock["Cast Type"])
local matkFlag = (src["MATK-Based"] == true)
basisWord = basisWordFromFlags(atkFlag, matkFlag)


sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
if tgt and not isNoneLike(tgt) then
sourceVal  = sourceValueForLevel(src)
addChunk("target", "Target", mw.text.nowiki(tgt))
scaling    = src.Scaling
end
if cst and not isNoneLike(cst) then
addChunk("cast", "Cast", mw.text.nowiki(cst))
end
end


-- Fallback to legacy Damage lists if Source absent
-- Combo
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
local combo = comboDisplay()
local dmg = rec.Damage
if combo then
scaling = scaling or dmg.Scaling
addChunk("combo", "Combo", combo)
end
 
        return {
                inner = added and tostring(grid) or "",
                classes = "module-skill-type",
        }
end
 
-- PLUGIN: Description (Hero Slot 3) - primary description text.
function PLUGINS.Description(rec)
        local desc = trim(rec.Description)
        if not desc then
                return nil
        end


local main = dmg["Main Damage"]
        local body = mw.html.create("div")
local refl = dmg["Reflect Damage"]
        body:addClass("sv-description")
local flat = dmg["Flat Damage"]
        body:wikitext(string.format("''%s''", desc))


if type(main) == "table" and #main > 0 then
        return {
local pick = nil
                inner = tostring(body),
for _, d in ipairs(main) do
                classes = "module-description",
if type(d) == "table" and d.Type ~= "Healing" then
        }
pick = d
end
break
end
end
pick = pick or main[1]


if type(pick) == "table" then
-- PLUGIN: Placeholder (Hero Slot 4) - reserved/blank.
local atkFlag  = (pick["ATK-Based"] == true)
function PLUGINS.Placeholder()
local matkFlag = (pick["MATK-Based"] == true)
        return nil
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
end


sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
sourceVal  = legacyPercentAtLevel(pick, level)
end
elseif type(refl) == "table" and #refl > 0 and type(refl[1]) == "table" then
local pick = refl[1]
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


sourceKind = "Reflect"
-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling.
sourceVal  = legacyPercentAtLevel(pick, level)
function PLUGINS.SourceType(rec, ctx)
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
local level = ctx.level or 1
local pick = flat[1]
local maxLevel = ctx.maxLevel or 1
local atkFlag  = (pick["ATK-Based"] == true)
 
local matkFlag = (pick["MATK-Based"] == true)
local basisWord = nil
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
local sourceKind = nil
local sourceVal  = nil
local scaling    = nil


sourceKind = "Flat"
-- sourceValueForLevel: dynamic formatting for structured Source blocks.
sourceVal  = legacyPercentAtLevel(pick, level)
local function sourceValueForLevel(src)
if type(src) ~= "table" then
return nil
end
end
end


local scalingLines = formatScalingCompactLines(scaling)
local per = src["Per Level"]
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
if type(per) == "table" and #per > 0 then
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)
if isFlatList(per) then
local one  = formatUnitValue(per[1]) or tostring(per[1])
local show = formatUnitValue(src.Base) or one
return show and mw.text.nowiki(show) or nil
end


if (not hasSource) and (not hasScaling) then
local series = {}
return nil
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
 
return valuePairDynamicValueOnly(src, maxLevel, level)
end
end


local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
if type(rec.Source) == "table" then
local src = rec.Source
local atkFlag  = (src["ATK-Based"] == true)
local matkFlag = (src["MATK-Based"] == true)
basisWord = basisWordFromFlags(atkFlag, matkFlag)


local extra = { "skill-source-module" }
sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
sourceVal  = sourceValueForLevel(src)
 
scaling    = src.Scaling
if hasSource and (not hasScaling) then
table.insert(extra, "sv-only-source")
elseif hasScaling and (not hasSource) then
table.insert(extra, "sv-only-scaling")
end
end


local wrap = mw.html.create("div")
-- Fallback to legacy Damage lists if Source absent
wrap:addClass("sv-source-grid")
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
wrap:addClass("sv-compact-root")
local dmg = rec.Damage
scaling = scaling or dmg.Scaling


if hasMod then
local main = dmg["Main Damage"]
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
local refl = dmg["Reflect Damage"]
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
local flat = dmg["Flat Damage"]
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
end


if hasSource then
if type(main) == "table" and #main > 0 then
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
local pick = nil
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
for _, d in ipairs(main) do
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
if type(d) == "table" and d.Type ~= "Healing" then
end
pick = d
break
end
end
pick = pick or main[1]


if hasScaling then
if type(pick) == "table" then
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
local atkFlag  = (pick["ATK-Based"] == true)
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


local list = scalingCol:tag("div"):addClass("sv-scaling-list")
sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
for _, line in ipairs(scalingLines) do
sourceVal  = legacyPercentAtLevel(pick, level)
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
end
elseif type(refl) == "table" and #refl > 0 and type(refl[1]) == "table" then
local pick = refl[1]
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
 
sourceKind = "Reflect"
sourceVal  = legacyPercentAtLevel(pick, level)
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
local pick = flat[1]
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
 
sourceKind = "Flat"
sourceVal  = legacyPercentAtLevel(pick, level)
end
end
end
end


return {
local scalingLines = formatScalingCompactLines(scaling)
inner = tostring(wrap),
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
classes = extra,
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)
}
end


-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
if (not hasSource) and (not hasScaling) then
-- NOTE: Hits does NOT live here (it lives in SkillType).
return nil
function PLUGINS.QuickStats(rec, ctx)
end
local level = ctx.level or 1
 
local maxLevel = ctx.maxLevel or 1
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
local promo = ctx.promo


local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
local extra = { "skill-source-module", "module-source-type" }
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}


local function dash() return "—" end
if hasSource and (not hasScaling) then
table.insert(extra, "sv-only-source")
elseif hasScaling and (not hasSource) then
table.insert(extra, "sv-only-scaling")
end


-- Range (0 => —)
local wrap = mw.html.create("div")
local rangeVal = nil
wrap:addClass("sv-source-grid")
if mech.Range ~= nil and not isNoneLike(mech.Range) then
wrap:addClass("sv-compact-root")
local n = toNum(mech.Range)
 
if n ~= nil then
if hasMod then
if n ~= 0 then
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
rangeVal = mw.text.nowiki(formatUnitValue(mech.Range) or tostring(mech.Range))
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
end
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
else
local t = mw.text.trim(tostring(mech.Range))
if t ~= "" and not isNoneLike(t) then
rangeVal = mw.text.nowiki(t)
end
end
end
end


-- Area
if hasSource then
local areaVal = formatAreaSize(mech.Area, maxLevel, level)
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
end


-- Timings
if hasScaling then
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"],  maxLevel), level)
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")
local durVal  = displayFromSeries(seriesFromValuePair(bt["Duration"],  maxLevel), level)


-- Promote status duration if needed
local list = scalingCol:tag("div"):addClass("sv-scaling-list")
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
for _, line in ipairs(scalingLines) do
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
end
 
-- Cost: MP + HP
local function labeledSeries(block, label)
local s = seriesFromValuePair(block, maxLevel)
if not s then return nil end
local any = false
for i, v in ipairs(s) do
if v ~= "—" then
s[i] = tostring(v) .. " " .. label
any = true
else
s[i] = "—"
end
end
end
return any and s or nil
end
end


local mpS = labeledSeries(rc["Mana Cost"], "MP")
return {
local hpS = labeledSeries(rc["Health Cost"], "HP")
inner = tostring(wrap),
classes = extra,
}
end


local costSeries = {}
-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
for lv = 1, maxLevel do
-- NOTE: Hits does NOT live here (it lives in SkillType).
local mp = mpS and mpS[lv] or "—"
function PLUGINS.QuickStats(rec, ctx)
local hp = hpS and hpS[lv] or "—"
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
local promo = ctx.promo


if mp ~= "—" and hp ~= "—" then
local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
costSeries[lv] = mp .. " + " .. hp
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
elseif mp ~= "—" then
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}
costSeries[lv] = mp
elseif hp ~= "—" then
costSeries[lv] = hp
else
costSeries[lv] = "—"
end
end


local costVal = displayFromSeries(costSeries, level)
local function dash() return "—" end


local grid = mw.html.create("div")
-- Range (0 => —)
grid:addClass("sv-m4-grid")
local rangeVal = nil
grid:addClass("sv-compact-root")
if mech.Range ~= nil and not isNoneLike(mech.Range) then
 
local n = toNum(mech.Range)
local function addCell(label, val)
if n ~= nil then
local cell = grid:tag("div"):addClass("sv-m4-cell")
if n ~= 0 then
cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label))
rangeVal = mw.text.nowiki(formatUnitValue(mech.Range) or tostring(mech.Range))
cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash())
end
else
local t = mw.text.trim(tostring(mech.Range))
if t ~= "" and not isNoneLike(t) then
rangeVal = mw.text.nowiki(t)
end
end
end
end


addCell("Range",    rangeVal)
-- Area
addCell("Area",      areaVal)
local areaVal = formatAreaSize(mech.Area, maxLevel, level)
addCell("Cost",      costVal)
addCell("Cast Time", castVal)
addCell("Cooldown", cdVal)
addCell("Duration", durVal)


return {
-- Timings
inner = tostring(grid),
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
classes = "module-quick-stats",
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"],  maxLevel), level)
}
local durVal  = displayFromSeries(seriesFromValuePair(bt["Duration"],  maxLevel), level)
end


-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
-- Promote status duration if needed
-- Shows:
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
--  - Flags (deduped)
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
--  - Special mechanics (mech.Effects)
end
-- NOTE: Combo lives in SkillType (Hero Bar Slot 2).
function PLUGINS.SpecialMechanics(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


local mech    = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
-- Cost: MP + HP
local effects = (type(mech.Effects) == "table") and mech.Effects or nil
local function labeledSeries(block, label)
local mods    = (type(rec.Modifiers) == "table") and rec.Modifiers or nil
local s = seriesFromValuePair(block, maxLevel)
 
if not s then return nil end
------------------------------------------------------------------
local any = false
-- Hits guard (we want Hits ONLY in SkillType)
for i, v in ipairs(s) do
------------------------------------------------------------------
if v ~= "—" then
local function isHitsKey(name)
s[i] = tostring(v) .. " " .. label
if not name then return false end
any = true
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
else
return (
s[i] = "—"
k == "hit" or
end
k == "hits" or
end
k == "hit count" or
return any and s or nil
k == "hits count" or
k == "hitcount" or
k == "hitscount"
)
end
end


------------------------------------------------------------------
local mpS = labeledSeries(rc["Mana Cost"], "MP")
-- Flags (flat, de-duped)
local hpS = labeledSeries(rc["Health Cost"], "HP")
------------------------------------------------------------------
local flagSet = {}


local denyFlags = {
local costSeries = {}
["self centered"] = true,
for lv = 1, maxLevel do
["self-centred"] = true,
local mp = mpS and mpS[lv] or "—"
["bond"] = true,
local hp = hpS and hpS[lv] or "—"
["combo"] = true,
 
        ["hybrid"] = true,
if mp ~= "—" and hp ~= "—" then
costSeries[lv] = mp .. " + " .. hp
elseif mp ~= "—" then
costSeries[lv] = mp
elseif hp ~= "—" then
costSeries[lv] = hp
else
costSeries[lv] = "—"
end
end


-- hits variants
local costVal = displayFromSeries(costSeries, level)
["hit"] = true,
["hits"] = true,
["hit count"] = true,
["hits count"] = true,
["hitcount"] = true,
["hitscount"] = true,
}


local function allowFlag(name)
local grid = mw.html.create("div")
if not name then return false end
grid:addClass("sv-m4-grid")
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
grid:addClass("sv-compact-root")
if k == "" then return false end
if denyFlags[k] then return false end
return true
end


local function addFlags(sub)
local function addCell(label, val)
if type(sub) ~= "table" then return end
local cell = grid:tag("div"):addClass("sv-m4-cell")
for k, v in pairs(sub) do
cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label))
if v and allowFlag(k) then
cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash())
flagSet[tostring(k)] = true
end
end
end
end


if mods then
addCell("Range",    rangeVal)
addFlags(mods["Movement Modifiers"])
addCell("Area",      areaVal)
addFlags(mods["Combat Modifiers"])
addCell("Cost",      costVal)
addFlags(mods["Special Modifiers"])
addCell("Cast Time", castVal)
for k, v in pairs(mods) do
addCell("Cooldown", cdVal)
if type(v) == "boolean" and v and allowFlag(k) then
addCell("Duration",  durVal)
flagSet[tostring(k)] = true
 
end
return {
end
inner = tostring(grid),
end
classes = "module-quick-stats",
}
end
 
-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
-- Shows:
--  - Flags (deduped)
--  - Special mechanics (mech.Effects)
-- NOTE: Combo lives in SkillType (Hero Bar Slot 2).
function PLUGINS.SpecialMechanics(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


local flags = {}
local mech    = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
for k, _ in pairs(flagSet) do table.insert(flags, k) end
local effects = (type(mech.Effects) == "table") and mech.Effects or nil
table.sort(flags)
local mods    = (type(rec.Modifiers) == "table") and rec.Modifiers or nil


------------------------------------------------------------------
------------------------------------------------------------------
-- Special mechanics (name => value)
-- Hits guard (we want Hits ONLY in SkillType)
------------------------------------------------------------------
------------------------------------------------------------------
local mechItems = {}
local function isHitsKey(name)
if not name then return false end
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
return (
k == "hit" or
k == "hits" or
k == "hit count" or
k == "hits count" or
k == "hitcount" or
k == "hitscount"
)
end


if effects then
------------------------------------------------------------------
local keys = {}
-- Flags (flat, de-duped)
for k, _ in pairs(effects) do table.insert(keys, k) end
------------------------------------------------------------------
table.sort(keys)
local flagSet = {}


for _, name in ipairs(keys) do
local denyFlags = {
-- Skip Hits completely (it belongs in SkillType)
["self centered"] = true,
if not isHitsKey(name) then
["self-centred"] = true,
local block = effects[name]
["bond"] = true,
if type(block) == "table" then
["combo"] = true,
-- Also skip if the block's Type is "Hits" (some data may encode it that way)
        ["hybrid"] = true,
if not isHitsKey(block.Type) then
local disp = displayFromSeries(seriesFromValuePair(block, maxLevel), level)
local t = trim(block.Type)


local value = disp
-- hits variants
["hit"] = true,
["hits"] = true,
["hit count"] = true,
["hits count"] = true,
["hitcount"] = true,
["hitscount"] = true,
}


-- If Type exists and is distinct, prefix it.
local function allowFlag(name)
if t and not isNoneLike(t) and mw.ustring.lower(t) ~= mw.ustring.lower(tostring(name)) then
if not name then return false end
if value then
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
value = mw.text.nowiki(t) .. ": " .. value
if k == "" then return false end
else
if denyFlags[k] then return false end
value = mw.text.nowiki(t)
return true
end
end
end


if value then
local function addFlags(sub)
table.insert(mechItems, { label = tostring(name), value = value })
if type(sub) ~= "table" then return end
end
for k, v in pairs(sub) do
end
if v and allowFlag(k) then
end
flagSet[tostring(k)] = true
end
end
end
end
end
end


local hasFlags = (#flags > 0)
if mods then
local hasMech  = (#mechItems > 0)
addFlags(mods["Movement Modifiers"])
addFlags(mods["Combat Modifiers"])
addFlags(mods["Special Modifiers"])
for k, v in pairs(mods) do
if type(v) == "boolean" and v and allowFlag(k) then
flagSet[tostring(k)] = true
end
end
end


if (not hasFlags) and (not hasMech) then
local flags = {}
local root = mw.html.create("div")
for k, _ in pairs(flagSet) do table.insert(flags, k) end
root:addClass("sv-sm-root")
table.sort(flags)
root:addClass("sv-compact-root")
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")


return {
------------------------------------------------------------------
inner = tostring(root),
-- Special mechanics (name => value)
classes = "module-special-mechanics",
------------------------------------------------------------------
}
local mechItems = {}
end


local count = 0
if effects then
if hasFlags then count = count + 1 end
local keys = {}
if hasMech  then count = count + 1 end
for k, _ in pairs(effects) do table.insert(keys, k) end
table.sort(keys)


local root = mw.html.create("div")
for _, name in ipairs(keys) do
root:addClass("sv-sm-root")
-- Skip Hits completely (it belongs in SkillType)
root:addClass("sv-compact-root")
if not isHitsKey(name) then
 
local block = effects[name]
local layout = root:tag("div"):addClass("sv-sm-layout")
if type(block) == "table" then
layout:addClass("sv-sm-count-" .. tostring(count))
-- Also skip if the block's Type is "Hits" (some data may encode it that way)
if not isHitsKey(block.Type) then
local disp = displayFromSeries(seriesFromValuePair(block, maxLevel), level)
local t = trim(block.Type)
 
local value = disp
 
-- If Type exists and is distinct, prefix it.
if t and not isNoneLike(t) and mw.ustring.lower(t) ~= mw.ustring.lower(tostring(name)) then
if value then
value = mw.text.nowiki(t) .. ": " .. value
else
value = mw.text.nowiki(t)
end
end


-- Column 1: Flags
if value then
if hasFlags then
table.insert(mechItems, { label = tostring(name), value = value })
local fcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-flags")
end
for _, f in ipairs(flags) do
end
fcol:tag("div"):addClass("sv-sm-flag"):wikitext(mw.text.nowiki(f))
end
end
end
end
end
end


-- Column 2: Special Mechanics (stacked)
local hasFlags = (#flags > 0)
if hasMech then
local hasMech  = (#mechItems > 0)
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech")
 
for _, it in ipairs(mechItems) do
if (not hasFlags) and (not hasMech) then
local one = mcol:tag("div"):addClass("sv-sm-mech")
local root = mw.html.create("div")
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label))
root:addClass("sv-sm-root")
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—")
root:addClass("sv-compact-root")
end
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")
 
return {
inner = tostring(root),
classes = "module-special-mechanics",
}
end
end


return {
local count = 0
inner = tostring(root),
if hasFlags then count = count + 1 end
classes = "module-special-mechanics",
if hasMech  then count = count + 1 end
}
end


-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
local root = mw.html.create("div")
function PLUGINS.LevelSelector(rec, ctx)
root:addClass("sv-sm-root")
local level = ctx.level or 1
root:addClass("sv-compact-root")
local maxLevel = ctx.maxLevel or 1


local inner = mw.html.create("div")
local layout = root:tag("div"):addClass("sv-sm-layout")
inner:addClass("sv-level-ui")
layout:addClass("sv-sm-count-" .. tostring(count))


inner:tag("div")
-- Column 1: Flags
:addClass("sv-level-label")
if hasFlags then
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
local fcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-flags")
for _, f in ipairs(flags) do
fcol:tag("div"):addClass("sv-sm-flag"):wikitext(mw.text.nowiki(f))
end
end


local slider = inner:tag("div"):addClass("sv-level-slider")
-- Column 2: Special Mechanics (stacked)
if hasMech then
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech")
for _, it in ipairs(mechItems) do
local one = mcol:tag("div"):addClass("sv-sm-mech")
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label))
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—")
end
end
 
return {
inner = tostring(root),
classes = "module-special-mechanics",
}
end
 
-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
function PLUGINS.LevelSelector(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
 
local inner = mw.html.create("div")
inner:addClass("sv-level-ui")
 
inner:tag("div")
:addClass("sv-level-label")
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
 
local slider = inner:tag("div"):addClass("sv-level-slider")


if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
Line 1,605: Line 1,791:
-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors.
-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors.
local function safeCallPlugin(name, rec, ctx)
local function safeCallPlugin(name, rec, ctx)
local fn = PLUGINS[name]
        local fn = PLUGINS[name]
if type(fn) ~= "function" then
        if type(fn) ~= "function" then
return nil
                return nil
end
        end
local ok, out = pcall(fn, rec, ctx)
        local ok, out = pcall(fn, rec, ctx)
if not ok then
        if not ok then
return nil
                return nil
end
        end
return normalizeResult(out)
        return normalizeResult(out)
end
end


-- renderHeroBarSlot: render a hero-bar slot by plugin assignment.
-- isEmptySlotContent: true when a slot has no meaningful content.
local function renderHeroBarSlot(slotIndex, rec, ctx)
-- NOTE: JS placeholders (sv-dyn spans, slider markup) are considered content.
        local pluginName = MODULE_SLOT_ASSIGNMENT[slotIndex]
local function isEmptySlotContent(inner)
         if not pluginName then
         if inner == nil then return true end
                return heroBarBox(slotIndex, nil, "", true)
        end


         local res = safeCallPlugin(pluginName, rec, ctx)
         local raw = tostring(inner)
        if not res or not res.inner or res.inner == "" then
                return heroBarBox(slotIndex, nil, "", true)
        end


         return heroBarBox(slotIndex, res.classes, res.inner, false)
         -- Guard rails for JS-injected regions.
end
        for _, pat in ipairs({ "sv%-dyn", "data%-series", "sv%-level%-range", "sv%-level%-slider", "sv%-level%-ui" }) do
 
                if mw.ustring.find(raw, pat) then
-- isEmptyModuleContent: true when a module slot has no meaningful content.
                        return false
local function isEmptyModuleContent(inner)
                end
        if inner == nil then return true end
 
        local asString = tostring(inner)
 
        if mw.ustring.find(asString, "sv%-dyn") or mw.ustring.find(asString, "data%-series") then
                return false
         end
         end


         local trimmed = mw.text.trim(asString)
         local trimmed = mw.text.trim(raw)
         if trimmed == "" or trimmed == "—" then
         if trimmed == "" or trimmed == "—" then
                 return true
                 return true
Line 1,650: Line 1,825:
end
end


-- mergeClasses: merge string/table classes with an optional extra class.
-- renderHeroSlot: render a standardized hero slot by plugin assignment.
local function mergeClasses(base, extra)
local function renderHeroSlot(slotIndex, rec, ctx)
        local list = {}
         local pluginName = HERO_SLOT_ASSIGNMENT[slotIndex]
 
        local function add(item)
                if type(item) == "string" then
                        for cls in mw.ustring.gmatch(item, "[^%s]+") do
                                table.insert(list, cls)
                        end
                elseif type(item) == "table" then
                        for _, c in ipairs(item) do
                                add(c)
                        end
                end
        end
 
        add(base)
        add(extra)
 
        if #list == 0 then
                return nil
        elseif #list == 1 then
                return list[1]
        end
 
        return list
end
 
-- renderModuleSlot: render a hero-module slot by plugin assignment.
local function renderModuleSlot(slotIndex, rec, ctx)
         local pluginName = MODULE_SLOT_ASSIGNMENT[slotIndex]
         if not pluginName then
         if not pluginName then
                 return nil
                 return nil
Line 1,686: Line 1,833:


         local res = safeCallPlugin(pluginName, rec, ctx)
         local res = safeCallPlugin(pluginName, rec, ctx)
         if not res or isEmptyModuleContent(res.inner) then
         if not res or isEmptySlotContent(res.inner) then
                 return nil
                 return nil
         end
         end
Line 1,700: Line 1,847:
----------------------------------------------------------------------
----------------------------------------------------------------------


-- buildHeroBarUI: build the top hero bar (2 slots).
-- buildHeroSlotsUI: build the standardized 4-row slot grid (2 columns).
local function buildHeroBarUI(rec, ctx)
local function buildHeroSlotsUI(rec, ctx)
local bar = mw.html.create("div")
bar:addClass("hero-bar-grid")
bar:wikitext(renderHeroBarSlot(1, rec, ctx))
bar:wikitext(renderHeroBarSlot(2, rec, ctx))
return tostring(bar)
end
 
-- buildModuleGridUI: build the lower module rows (Modules 3–8, 3 rows).
local function buildModuleGridUI(rec, ctx)
         local grid = mw.html.create("div")
         local grid = mw.html.create("div")
        grid:addClass("hero-modules-grid")
         grid:addClass("sv-slot-grid")
         grid:addClass("sv-modules-grid")


         local slots = {}
         local slots = {}
         for _, pair in ipairs(MODULE_GRID_PAIRS) do
         for slot = 1, 8 do
                 for _, slot in ipairs(pair) do
                 slots[slot] = renderHeroSlot(slot, rec, ctx)
                        slots[slot] = renderModuleSlot(slot, rec, ctx)
                end
         end
         end


         local hasModules = false
         local hasSlots = false
         for _, pair in ipairs(MODULE_GRID_PAIRS) do
         for _, pair in ipairs({ { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }) do
                 local left  = slots[pair[1]]
                 local left  = slots[pair[1]]
                 local right = slots[pair[2]]
                 local right = slots[pair[2]]


                 if left or right then
                 if left or right then
                        hasSlots = true
                         if left and right then
                         if left and right then
                                 grid:wikitext(moduleBox(pair[1], left.classes, left.inner, false))
                                 grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isEmpty = false }))
                                 grid:wikitext(moduleBox(pair[2], right.classes, right.inner, false))
                                 grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isEmpty = false }))
                         elseif left then
                         elseif left then
                                 grid:wikitext(moduleBox(pair[1], mergeClasses(left.classes, "hero-module-full"), left.inner, false))
                                 grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isFull = true }))
                         elseif right then
                         elseif right then
                                 grid:wikitext(moduleBox(pair[2], mergeClasses(right.classes, "hero-module-full"), right.inner, false))
                                 grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isFull = true }))
                         end
                         end
                        hasModules = true
                 end
                 end
         end
         end


         if not hasModules then
         if not hasSlots then
                 return ""
                 return ""
         end
         end
Line 1,748: Line 1,883:
end
end


-- addModuleGridRow: add the lower module grid into the infobox table.
-- addHeroSlotsRow: add the standardized slot grid into the infobox table.
local function addModuleGridRow(tbl, modulesUI)
local function addHeroSlotsRow(tbl, slotsUI)
         if not modulesUI or modulesUI == "" then
         if not slotsUI or slotsUI == "" then
                 return
                 return
         end
         end


         local row = tbl:tag("tr")
         local row = tbl:tag("tr")
         row:addClass("hero-modules-row")
         row:addClass("sv-slot-row")


         local cell = row:tag("td")
         local cell = row:tag("td")
         cell:attr("colspan", 2)
         cell:attr("colspan", 2)
         cell:addClass("hero-modules-cell")
         cell:addClass("sv-slot-cell")
         cell:wikitext(modulesUI)
         cell:wikitext(slotsUI)
end
end


Line 1,812: Line 1,947:
end
end


        -- Module 1–2 (Icon + Skill Type)
-- Standardized slot grid
        local heroRow = root:tag("tr")
addHeroSlotsRow(root, buildHeroSlotsUI(rec, ctx))
        heroRow:addClass("spiritvale-infobox-main")
        heroRow:addClass("sv-hero-title-row")
        heroRow:addClass("hero-title-bar")
 
local heroCell = heroRow:tag("th")
        heroCell:attr("colspan", 2)
        heroCell:addClass("sv-hero-title-cell")
        heroCell:wikitext(buildHeroBarUI(rec, ctx))
 
        -- Module grid (rows 2–4)
        addModuleGridRow(root, buildModuleGridUI(rec, ctx))


-- Users (hide on direct skill page)
-- Users (hide on direct skill page)
if showUsers then
        if showUsers then
local users = rec.Users or {}
                local users = rec.Users or {}
addRow(root, "Classes",  listToText(users.Classes),  "sv-row-users", "Users.Classes")
                addRow(root, "Classes",  listToText(users.Classes),  "sv-row-users", "Users.Classes")
addRow(root, "Summons",  listToText(users.Summons),  "sv-row-users", "Users.Summons")
                addRow(root, "Summons",  listToText(users.Summons),  "sv-row-users", "Users.Summons")
addRow(root, "Monsters", listToText(users.Monsters), "sv-row-users", "Users.Monsters")
                addRow(root, "Monsters", listToText(users.Monsters), "sv-row-users", "Users.Monsters")
addRow(root, "Events",   listToText(users.Events),   "sv-row-users", "Users.Events")
                do
end
                        local eventsList = {}
                        if type(users.Events) == "table" then
                                for _, ev in ipairs(users.Events) do
                                        local name = resolveEventName(ev) or ev
                                        if name ~= nil then
                                                table.insert(eventsList, mw.text.nowiki(tostring(name)))
                                        end
                                end
                        end
                        addRow(root, "Events", listToText(eventsList), "sv-row-users", "Users.Events")
                end
        end


-- Requirements
        -- Mechanics (keep small extras only)
local req = rec.Requirements or {}
        local mech = rec.Mechanics or {}
local hasReq =
        if next(mech) ~= nil then
(type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0) or
                if mech["Autocast Multiplier"] ~= nil then
(type(req["Required Weapons"]) == "table" and #req["Required Weapons"] > 0) or
                        addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier")
(type(req["Required Stances"]) == "table" and #req["Required Stances"] > 0)
                end
 
        end
if hasReq then
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
local skillParts = {}
for _, rs in ipairs(req["Required Skills"]) do
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
local lvlReq  = rs["Required Level"]
if lvlReq then
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
else
table.insert(skillParts, nameReq)
end
end
addRow(root, "Required Skills", table.concat(skillParts, ", "), "sv-row-req", "Requirements.Required Skills")
end
 
addRow(root, "Required Weapons", listToText(req["Required Weapons"]), "sv-row-req", "Requirements.Required Weapons")
addRow(root, "Required Stances", listToText(req["Required Stances"]), "sv-row-req", "Requirements.Required Stances")
end
 
-- Mechanics (keep small extras only)
local mech = rec.Mechanics or {}
if next(mech) ~= nil then
if mech["Autocast Multiplier"] ~= nil then
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier")
end
end


-- Legacy damage breakdown (only when Source absent)
-- Legacy damage breakdown (only when Source absent)
Line 1,944: Line 2,053:


local amt = valuePairRawText(r)
local amt = valuePairRawText(r)
amt = amt and mw.text.nowiki(amt) or nil
amt = amt and mw.text.nowiki(amt) or nil
 
 
local seg = mw.text.nowiki(label)
local seg = mw.text.nowiki(label)
if amt then
if amt then
seg = seg .. " – " .. amt
seg = seg .. " – " .. amt
end
end
table.insert(parts, seg)
table.insert(parts, seg)
end
end
end
end
 
 
return (#parts > 0) and table.concat(parts, "<br />") or nil
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
end
 
 
local suppressIdx = (type(ctx.promo) == "table") and ctx.promo.suppressDurationIndex or nil
local suppressIdx = (type(ctx.promo) == "table") and ctx.promo.suppressDurationIndex or nil
local statusApps = formatStatusApplications(rec["Status Applications"], suppressIdx)
local statusApps = formatStatusApplications(rec["Status Applications"], suppressIdx)
local statusRem  = formatStatusRemoval(rec["Status Removal"])
local statusRem  = formatStatusRemoval(rec["Status Removal"])
if statusApps or statusRem then
if statusApps or statusRem then
addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications")
addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications")
addRow(root, "Removes", statusRem,  "sv-row-status", "Status Removal")
addRow(root, "Removes", statusRem,  "sv-row-status", "Status Removal")
end
end
 
 
-- Events
        -- Events
local function formatEvents(list)
        local function formatEvents(list)
if type(list) ~= "table" or #list == 0 then return nil end
                if type(list) ~= "table" or #list == 0 then return nil end
local parts = {}
                local parts = {}
for _, ev in ipairs(list) do
                for _, ev in ipairs(list) do
if type(ev) == "table" then
                        if type(ev) == "table" then
local action = ev.Action or "On event"
                                local action = resolveDisplayName(ev.Action, "event") or ev.Action or "On event"
local name  = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
                                local name  = resolveSkillNameFromEvent(ev)
table.insert(parts, string.format("%s → %s", action, name))
                                table.insert(parts, string.format("%s → %s", mw.text.nowiki(action), mw.text.nowiki(name)))
end
                        end
end
                end
return (#parts > 0) and table.concat(parts, "<br />") or nil
                return (#parts > 0) and table.concat(parts, "<br />") or nil
end
        end


local eventsText = formatEvents(rec.Events)
local eventsText = formatEvents(rec.Events)
Line 1,984: Line 2,093:
end
end


-- Notes
return tostring(root)
if type(rec.Notes) == "table" and #rec.Notes > 0 then
addRow(root, "Notes", table.concat(rec.Notes, "<br />"), "sv-row-meta", "Notes")
end
 
return tostring(root)
end
end


Retrieved from "https://spiritvale.info/wiki/Module:GameSkills"