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
 
(14 intermediate revisions by the same user not shown)
Line 4: Line 4:
--
--
-- Layout:
-- Layout:
--  1) hero-title-bar        (TOP BAR, 2 slots: herobar 1..2)
--  Row 1: Slot 1 + Slot 2 (Icon + SkillType)
--  2) hero-description-bar  (description strip)
--  Row 2: Slot 3 + Slot 4 (Description + Placeholder)
--  3) hero-modules row      (4 slots: hero-module-1..4)
--   Row 3: Slot 5 + Slot 6 (SourceType + QuickStats)
--  Row 4: Slot 7 + Slot 8 (SpecialMechanics + LevelSelector)
--
--
-- Requires Common.js:
-- Requires Common.js:
Line 22: 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 92: 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
 
local function resolveDisplayName(v, kind)
        if v == nil then return nil end
 
        local function firstString(keys, source)
                for _, key in ipairs(keys) do
                        local candidate = source[key]
                        if type(candidate) == "string" and candidate ~= "" then
                                return candidate
                        end
                end
                return nil
        end
 
        if type(v) == "table" then
                local primaryKeys = { "External Name", "Display Name", "Name" }
                local extendedKeys = { "Skill External Name", "Status External Name" }
                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
 
local function resolveEventName(v)
        local resolved = resolveDisplayName(v, "event")
        if type(resolved) == "string" then
                return resolved
        end
        return (resolved ~= nil) and tostring(resolved) or nil
end
 
local function resolveSkillNameFromEvent(ev)
        if type(ev) ~= "table" then
                return resolveDisplayName(ev, "skill") or "Unknown skill"
        end
 
        local displayKeys = {
                "Skill External Name",
                "External Name",
                "Display Name",
                "Name",
                "Skill Name",
        }
 
        for _, key in ipairs(displayKeys) do
                local candidate = resolveDisplayName(ev[key], "skill")
                if candidate then
                        return candidate
                end
        end
 
        local internalKeys = {
                "Skill Internal Name",
                "Skill ID",
                "Internal Name",
                "Internal ID",
                "ID",
        }
 
        for _, key in ipairs(internalKeys) do
                local candidate = ev[key]
                if type(candidate) == "string" and candidate ~= "" then
                        return candidate
                end
        end
 
        return "Unknown skill"
end
end


Line 475: Line 575:
----------------------------------------------------------------------
----------------------------------------------------------------------


local HERO_BAR_SLOT_ASSIGNMENT = {
local HERO_SLOT_ASSIGNMENT = {
[1] = "IconName",
[1] = "IconName",
[2] = "SkillType", -- Damage/Element/Hits/Target/Cast/Combo strip
[2] = "Description",
}
[3] = "LevelSelector",
 
[4] = "SkillType",
local HERO_MODULE_SLOT_ASSIGNMENT = {
[5] = "SourceType",
[1] = "SourceType",
[6] = "QuickStats",
[2] = "QuickStats",
[7] = "SpecialMechanics",
[3] = "SpecialMechanics",
[8] = "Placeholder",
[4] = "LevelSelector",
}
}


Line 491: 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)
opts = opts or {}
 
local box = mw.html.create("div")
local box = mw.html.create("div")
box:addClass("hero-bar-module")
box:addClass("sv-slot")
box:addClass("hero-bar-module-" .. tostring(slot))
box:addClass("sv-slot--" .. tostring(slot))
box:attr("data-hero-bar-module", tostring(slot))
box:attr("data-hero-slot", tostring(slot))


if slot == 2 then
if opts.isFull then
box:addClass("sv-herobar-compact")
box:addClass("sv-slot--full")
end
end


Line 510: Line 611:
end
end


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


local body = box:tag("div"):addClass("hero-bar-module-body")
local body = box:tag("div"):addClass("sv-slot__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:attr("data-hero-module", tostring(slot))
 
if extraClasses then
if type(extraClasses) == "string" then
box:addClass(extraClasses)
elseif type(extraClasses) == "table" then
for _, c in ipairs(extraClasses) do box:addClass(c) end
end
end
 
if isEmpty then
box:addClass("hero-module-empty")
end
 
local body = box:tag("div"):addClass("hero-module-body")
if innerHtml and innerHtml ~= "" then
if innerHtml and innerHtml ~= "" then
body:wikitext(innerHtml)
body:wikitext(innerHtml)
Line 729: Line 803:


-- formatAreaSize: human readable area sizing for QuickStats.
-- formatAreaSize: human readable area sizing for QuickStats.
local function formatAreaSize(area)
-- Shows: "<Area Size> (<number>)" e.g. "Medium (4)"
local function formatAreaSize(area, maxLevel, level)
if type(area) ~= "table" then
if type(area) ~= "table" then
return nil
return nil
end
end


local raw = area["Area Size"]
-- Helper: pull a number from scalar/unit/valuepair-ish things.
if raw == nil then
local function extractNumber(v)
return nil
if v == nil then return nil end
end
 
local name, num


if type(raw) == "table" then
-- Unit block {Value, Unit}
name = raw.Name or raw.ID or raw.Value
if type(v) == "table" and v.Value ~= nil then
num  = raw.Value
local n = toNum(v.Value)
if raw.Name or raw.ID then
return n
name = raw.Name or raw.ID
end
end
elseif type(raw) == "string" then
name = raw
elseif type(raw) == "number" then
num = raw
end


if num == nil then
-- ValuePair {Base, Per Level} -> prefer Base at current level if series exists
num = toNum(area["Area Value"]) or toNum(area["Area Size Value"]) or toNum(area["Area Number"]) or toNum(area["Area Radius"])
if type(v) == "table" and (v.Base ~= nil or v["Per Level"] ~= nil) then
end
local s = seriesFromValuePair(v, maxLevel or 1)
 
if type(s) == "table" and #s > 0 then
if name ~= nil then
local idx = clamp(level or 1, 1, #s)
local s = mw.text.trim(tostring(name))
local txt = s[idx]
if s == "" or isNoneLike(s) then
if txt and txt ~= "—" then
-- try parse numeric from string (e.g. "4 tiles" -> 4)
local num = tonumber((mw.ustring.gsub(tostring(txt), "[^0-9%.%-]", "")))
return num
end
end
return nil
return nil
end
end
if mw.ustring.find(s, "%(") then
 
return mw.text.nowiki(s)
-- Plain scalar
if type(v) == "number" then return v end
if type(v) == "string" then
local num = tonumber((mw.ustring.gsub(mw.text.trim(v), "[^0-9%.%-]", "")))
return num
end
end
if num ~= nil and num ~= 0 then
 
return mw.text.nowiki(string.format("%s (%s)", s, fmtNum(num)))
return nil
end
 
-- 1) Read Area Size label/name
local rawSize = area["Area Size"]
if rawSize == nil then
return nil
end
 
local sizeName = nil
if type(rawSize) == "table" then
sizeName = rawSize.Name or rawSize.ID or rawSize.Value
elseif type(rawSize) == "string" then
sizeName = rawSize
elseif type(rawSize) == "number" then
-- uncommon; treat as numeric-only label
sizeName = tostring(rawSize)
end
 
sizeName = sizeName and mw.text.trim(tostring(sizeName)) or nil
if not sizeName or sizeName == "" or isNoneLike(sizeName) then
return nil
end
 
-- 2) Find the numeric “exact number” to append
-- Prefer the explicit Area Distance block, then fall back to other known numeric keys.
local num = nil
 
local dist = area["Area Distance"]
if type(dist) == "table" then
-- Prefer Effective Distance if present and non-zero, else Base
num = extractNumber(dist["Effective Distance"]) or extractNumber(dist.Effective) or extractNumber(dist["Effective"])
if not num or num == 0 then
num = extractNumber(dist.Base) or extractNumber(dist["Base"])
end
end
return mw.text.nowiki(s)
end
end


if num ~= nil and num ~= 0 then
if not num or num == 0 then
return mw.text.nowiki(string.format("(%s)", fmtNum(num)))
num =
extractNumber(area["Area Value"]) or
extractNumber(area["Area Size Value"]) or
extractNumber(area["Area Number"]) or
extractNumber(area["Area Radius"])
end
 
-- 3) Render
-- If size already contains parentheses, assume it already includes the numeric.
if mw.ustring.find(sizeName, "%(") then
return mw.text.nowiki(sizeName)
end
 
if num and num ~= 0 then
return mw.text.nowiki(string.format("%s (%s)", sizeName, fmtNum(num)))
end
end


return nil
return mw.text.nowiki(sizeName)
end
end


Line 854: 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


-- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile).
local reqStances = {}
-- Rules:
for _, s in ipairs(reqStancesRaw) do
--  - If skill is non-damaging, hide Damage/Element/Hits.
local sn = trim(s)
--  - If Hits is empty, hide Hits.
if sn then table.insert(reqStances, mw.text.nowiki(sn)) end
--  - If Combo is empty, hide Combo.
end
-- 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 hasNotes = (#notesList > 0)
local maxLevel = ctx.maxLevel or 1
local hasReq = (#reqSkills > 0) or (#reqWeapons > 0) or (#reqStances > 0)


local hideDamageBundle = (ctx.nonDamaging == true)


-- valName: extract a display string from typical {Name/ID/Value} objects.
local wrap = mw.html.create("div")
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped.
wrap:addClass("sv-herobar-1-wrap")
local function valName(x)
wrap:addClass("sv-tip-scope")
if x == nil then return nil end
 
if type(x) == "table" then
local iconBox = wrap:tag("div")
if x.Name and x.Name ~= "" then return tostring(x.Name) end
iconBox:addClass("sv-herobar-icon")
if x.ID and x.ID ~= "" then return tostring(x.ID) end
 
if x.Value ~= nil then return tostring(x.Value) end
if icon and icon ~= "" then
end
iconBox:wikitext(string.format("[[File:%s|80px|link=]]", icon))
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 h =
local titleRow = textBox:tag("div")
typeBlock.Hits or typeBlock["Hits"] or typeBlock["Hit Count"] or typeBlock["Hits Count"] or
titleRow:addClass("sv-herobar-title-row")
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"]


if h == nil or isNoneLike(h) then
local titleBox = titleRow:tag("div")
return nil
titleBox:addClass("spiritvale-infobox-title")
end
titleBox:wikitext(title)


-- ValuePair-style table (Base/Per Level) => dynamic series
if hasNotes then
if type(h) == "table" then
local notesBtn = mw.html.create("span")
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
notesBtn:addClass("sv-tip-btn sv-tip-btn--notes")
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
notesBtn:attr("role", "button")
end
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 hasReq then
local pillRow = wrap:tag("div")
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


-- Unit block {Value, Unit}
if hasNotes then
if h.Value ~= nil then
local notesContent = wrap:tag("div")
local t = formatUnitValue(h)
notesContent:addClass("sv-tip-content")
return t and mw.text.nowiki(t) or nil
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


-- Fallback name extraction
if hasReq then
local function valName(x)
local reqContent = wrap:tag("div")
if x == nil then return nil end
reqContent:addClass("sv-tip-content")
if type(x) == "table" then
reqContent:attr("data-sv-tip-content", "req")
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


local vn = valName(h)
if #reqSkills > 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 Skills")
section:tag("div"):wikitext(table.concat(reqSkills, "<br />"))
end
end


-- Scalar number/string
if #reqWeapons > 0 then
if type(h) == "number" then
local section = reqContent:tag("div")
return mw.text.nowiki(fmtNum(h))
section:addClass("sv-tip-section")
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Weapons")
section:tag("div"):wikitext(table.concat(reqWeapons, ", "))
end
end
if type(h) == "string" then
 
local t = trim(h)
if #reqStances > 0 then
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil
local section = reqContent:tag("div")
section:addClass("sv-tip-section")
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Stances")
section:tag("div"):wikitext(table.concat(reqStances, ", "))
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.
-- 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 details = {}
local level    = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


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


local dur = formatUnitValue(c.Duration)
-- valName: extract a display string from typical {Name/ID/Value} objects.
if dur and not isZeroish(dur) then
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped.
table.insert(details, mw.text.nowiki(dur))
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
 
if type(x) == "number" then
if #details > 0 then
return tostring(x)
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
end
if type(x) == "string" and x ~= "" then
return x
end
end
return mw.text.nowiki(typ)
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
-- Damage + Element + Hits bundle (hidden when non-damaging)
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if not hideDamageBundle then
if x.Value ~= nil then return tostring(x.Value) end
local dmg  = valName(typeBlock.Damage or typeBlock["Damage Type"])
end
local ele  = valName(typeBlock.Element or typeBlock["Element Type"])
if type(x) == "number" then return tostring(x) end
local hits = hitsDisplay()
if type(x) == "string" and x ~= "" then return x end
return nil
end


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


-- Target + Cast
return nil
local tgt = valName(typeBlock.Target or typeBlock["Target Type"])
local cst = valName(typeBlock.Cast  or typeBlock["Cast Type"])
 
if tgt and not isNoneLike(tgt) then
addChunk("target", "Target", mw.text.nowiki(tgt))
end
if cst and not isNoneLike(cst) then
addChunk("cast", "Cast", mw.text.nowiki(cst))
end
end


-- Combo
-- comboDisplay: render Combo as a compact text block (Type (+ details)).
local combo = comboDisplay()
local function comboDisplay()
if combo then
local c = (type(mech.Combo) == "table") and mech.Combo or nil
addChunk("combo", "Combo", combo)
if not c then return nil end
end


return {
local typ = trim(c.Type)
inner = added and tostring(grid) or "",
if not typ or isNoneLike(typ) then
classes = "module-skill-type",
return nil
}
end
end


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


local basisWord = nil
local pct = formatUnitValue(c.Percent)
local sourceKind = nil
if pct and not isZeroish(pct) then
local sourceVal  = nil
table.insert(details, mw.text.nowiki(pct))
local scaling    = nil
end


-- sourceValueForLevel: dynamic formatting for structured Source blocks.
local dur = formatUnitValue(c.Duration)
local function sourceValueForLevel(src)
if dur and not isZeroish(dur) then
if type(src) ~= "table" then
table.insert(details, mw.text.nowiki(dur))
return nil
end
end


local per = src["Per Level"]
if #details > 0 then
if type(per) == "table" and #per > 0 then
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
if isFlatList(per) then
end
local one  = formatUnitValue(per[1]) or tostring(per[1])
return mw.text.nowiki(typ)
local show = formatUnitValue(src.Base) or one
end
return show and mw.text.nowiki(show) or nil
end


local series = {}
local grid = mw.html.create("div")
for _, v in ipairs(per) do
grid:addClass("sv-type-grid")
table.insert(series, formatUnitValue(v) or tostring(v))
grid:addClass("sv-compact-root")
end
return dynSpan(series, level)
end


return valuePairDynamicValueOnly(src, maxLevel, level)
local added = false
end


if type(rec.Source) == "table" then
-- addChunk: add one labeled value cell (key drives CSS ordering).
local src = rec.Source
local function addChunk(key, label, valueHtml)
local atkFlag  = (src["ATK-Based"] == true)
if valueHtml == nil or valueHtml == "" then return end
local matkFlag = (src["MATK-Based"] == true)
added = true
basisWord = basisWordFromFlags(atkFlag, matkFlag)


sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
local chunk = grid:tag("div")
sourceVal  = sourceValueForLevel(src)
:addClass("sv-type-chunk")
scaling    = src.Scaling
:addClass("sv-type-" .. tostring(key))
:attr("data-type-key", tostring(key))
 
chunk:tag("div")
:addClass("sv-type-label")
:wikitext(mw.text.nowiki(label))
 
chunk:tag("div")
:addClass("sv-type-value")
:wikitext(valueHtml)
end
end


-- Fallback to legacy Damage lists if Source absent
-- Damage + Element + Hits bundle (hidden when non-damaging)
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
if not hideDamageBundle then
local dmg = rec.Damage
local dmg  = valName(typeBlock.Damage or typeBlock["Damage Type"])
scaling = scaling or dmg.Scaling
local ele  = valName(typeBlock.Element or typeBlock["Element Type"])
local hits = hitsDisplay()


local main = dmg["Main Damage"]
if dmg and not isNoneLike(dmg) then
local refl = dmg["Reflect Damage"]
addChunk("damage", "Damage", mw.text.nowiki(dmg))
local flat = dmg["Flat Damage"]
end
 
if ele and not isNoneLike(ele) then
if type(main) == "table" and #main > 0 then
addChunk("element", "Element", mw.text.nowiki(ele))
local pick = nil
end
for _, d in ipairs(main) do
if hits then
if type(d) == "table" and d.Type ~= "Healing" then
addChunk("hits", "Hits", hits)
pick = d
end
break
end
end
end
pick = pick or main[1]


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


sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
if tgt and not isNoneLike(tgt) then
sourceVal  = legacyPercentAtLevel(pick, level)
addChunk("target", "Target", mw.text.nowiki(tgt))
end
end
elseif type(refl) == "table" and #refl > 0 and type(refl[1]) == "table" then
if cst and not isNoneLike(cst) then
local pick = refl[1]
addChunk("cast", "Cast", mw.text.nowiki(cst))
local atkFlag  = (pick["ATK-Based"] == true)
end
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


sourceKind = "Reflect"
-- Combo
sourceVal  = legacyPercentAtLevel(pick, level)
local combo = comboDisplay()
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
if combo then
local pick = flat[1]
addChunk("combo", "Combo", combo)
local atkFlag  = (pick["ATK-Based"] == true)
end
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


sourceKind = "Flat"
        return {
sourceVal  = legacyPercentAtLevel(pick, level)
                inner = added and tostring(grid) or "",
end
                classes = "module-skill-type",
end
        }
end


local scalingLines = formatScalingCompactLines(scaling)
-- PLUGIN: Description (Hero Slot 3) - primary description text.
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
function PLUGINS.Description(rec)
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)
        local desc = trim(rec.Description)
        if not desc then
                return nil
        end


if (not hasSource) and (not hasScaling) then
        local body = mw.html.create("div")
return nil
        body:addClass("sv-description")
end
        body:wikitext(string.format("''%s''", desc))


local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
        return {
                inner = tostring(body),
                classes = "module-description",
        }
end


local extra = { "skill-source-module" }
-- PLUGIN: Placeholder (Hero Slot 4) - reserved/blank.
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
function PLUGINS.Placeholder()
        return nil
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


local wrap = mw.html.create("div")
-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling.
wrap:addClass("sv-source-grid")
function PLUGINS.SourceType(rec, ctx)
wrap:addClass("sv-compact-root")
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


if hasMod then
local basisWord = nil
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
local sourceKind = nil
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
local sourceVal  = nil
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
local scaling    = nil
end


if hasSource then
-- sourceValueForLevel: dynamic formatting for structured Source blocks.
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
local function sourceValueForLevel(src)
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
if type(src) ~= "table" then
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
return nil
end
end


if hasScaling then
local per = src["Per Level"]
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
if type(per) == "table" and #per > 0 then
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")
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


local list = scalingCol:tag("div"):addClass("sv-scaling-list")
local series = {}
for _, line in ipairs(scalingLines) do
for _, v in ipairs(per) do
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
end
end


return {
return valuePairDynamicValueOnly(src, maxLevel, level)
inner = tostring(wrap),
end
classes = extra,
}
end


-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
if type(rec.Source) == "table" then
-- NOTE: Hits does NOT live here (it lives in SkillType).
local src = rec.Source
function PLUGINS.QuickStats(rec, ctx)
local atkFlag  = (src["ATK-Based"] == true)
local level = ctx.level or 1
local matkFlag = (src["MATK-Based"] == true)
local maxLevel = ctx.maxLevel or 1
basisWord = basisWordFromFlags(atkFlag, matkFlag)
local promo = ctx.promo


local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
sourceVal  = sourceValueForLevel(src)
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}
scaling    = src.Scaling
end


local function dash() return "—" end
-- Fallback to legacy Damage lists if Source absent
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
local dmg = rec.Damage
scaling = scaling or dmg.Scaling


-- Range (0 => —)
local main = dmg["Main Damage"]
local rangeVal = nil
local refl = dmg["Reflect Damage"]
if mech.Range ~= nil and not isNoneLike(mech.Range) then
local flat = dmg["Flat Damage"]
local n = toNum(mech.Range)
 
if n ~= nil then
if type(main) == "table" and #main > 0 then
if n ~= 0 then
local pick = nil
rangeVal = mw.text.nowiki(formatUnitValue(mech.Range) or tostring(mech.Range))
for _, d in ipairs(main) do
if type(d) == "table" and d.Type ~= "Healing" then
pick = d
break
end
end
end
else
pick = pick or main[1]
local t = mw.text.trim(tostring(mech.Range))
if t ~= "" and not isNoneLike(t) then
rangeVal = mw.text.nowiki(t)
end
end
end


-- Area
if type(pick) == "table" then
local areaVal = formatAreaSize(mech.Area)
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


-- Timings
sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
sourceVal  = legacyPercentAtLevel(pick, level)
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"],  maxLevel), level)
end
local durVal  = displayFromSeries(seriesFromValuePair(bt["Duration"],  maxLevel), level)
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)


-- Promote status duration if needed
sourceKind = "Reflect"
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
sourceVal  = legacyPercentAtLevel(pick, level)
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
end
local pick = flat[1]
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


-- Cost: MP + HP
sourceKind = "Flat"
local function labeledSeries(block, label)
sourceVal  = legacyPercentAtLevel(pick, level)
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")
local scalingLines = formatScalingCompactLines(scaling)
local hpS = labeledSeries(rc["Health Cost"], "HP")
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)


local costSeries = {}
if (not hasSource) and (not hasScaling) then
for lv = 1, maxLevel do
return nil
local mp = mpS and mpS[lv] or "—"
end
local hp = hpS and hpS[lv] or "—"


if mp ~= "—" and hp ~= "—" then
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
costSeries[lv] = mp .. " + " .. hp
elseif mp ~= "—" then
costSeries[lv] = mp
elseif hp ~= "—" then
costSeries[lv] = hp
else
costSeries[lv] = "—"
end
end


local costVal = displayFromSeries(costSeries, level)
local extra = { "skill-source-module", "module-source-type" }
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")


local grid = mw.html.create("div")
if hasSource and (not hasScaling) then
grid:addClass("sv-m4-grid")
table.insert(extra, "sv-only-source")
grid:addClass("sv-compact-root")
elseif hasScaling and (not hasSource) then
 
table.insert(extra, "sv-only-scaling")
local function addCell(label, val)
local cell = grid:tag("div"):addClass("sv-m4-cell")
cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label))
cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash())
end
end


addCell("Range",    rangeVal)
local wrap = mw.html.create("div")
addCell("Area",      areaVal)
wrap:addClass("sv-source-grid")
addCell("Cost",      costVal)
wrap:addClass("sv-compact-root")
addCell("Cast Time", castVal)
addCell("Cooldown",  cdVal)
addCell("Duration",  durVal)


return {
if hasMod then
inner = tostring(grid),
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
classes = "module-quick-stats",
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
}
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
end
end


-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
if hasSource then
-- Shows:
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
--   - Flags (deduped)
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
--   - Special mechanics (mech.Effects)
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
-- NOTE: Combo lives in SkillType (Hero Bar Slot 2).
end
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 {}
if hasScaling then
local effects = (type(mech.Effects) == "table") and mech.Effects or nil
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
local mods    = (type(rec.Modifiers) == "table") and rec.Modifiers or nil
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")


------------------------------------------------------------------
local list = scalingCol:tag("div"):addClass("sv-scaling-list")
-- Hits guard (we want Hits ONLY in SkillType)
for _, line in ipairs(scalingLines) do
------------------------------------------------------------------
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
local function isHitsKey(name)
end
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
end


------------------------------------------------------------------
return {
-- Flags (flat, de-duped)
inner = tostring(wrap),
------------------------------------------------------------------
classes = extra,
local flagSet = {}
}
end


local denyFlags = {
-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
["self centered"] = true,
-- NOTE: Hits does NOT live here (it lives in SkillType).
["self-centred"] = true,
function PLUGINS.QuickStats(rec, ctx)
["bond"] = true,
local level = ctx.level or 1
["combo"] = true,
local maxLevel = ctx.maxLevel or 1
local promo = ctx.promo


-- hits variants
local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
["hit"] = true,
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
["hits"] = true,
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}
["hit count"] = true,
["hits count"] = true,
["hitcount"] = true,
["hitscount"] = true,
}


local function allowFlag(name)
local function dash() return "—" end
if not name then return false end
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
if k == "" then return false end
if denyFlags[k] then return false end
return true
end


local function addFlags(sub)
-- Range (0 => —)
if type(sub) ~= "table" then return end
local rangeVal = nil
for k, v in pairs(sub) do
if mech.Range ~= nil and not isNoneLike(mech.Range) then
if v and allowFlag(k) then
local n = toNum(mech.Range)
flagSet[tostring(k)] = true
if n ~= nil then
if n ~= 0 then
rangeVal = mw.text.nowiki(formatUnitValue(mech.Range) or tostring(mech.Range))
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
end
end


if mods then
-- Area
addFlags(mods["Movement Modifiers"])
local areaVal = formatAreaSize(mech.Area, maxLevel, level)
addFlags(mods["Combat Modifiers"])
 
addFlags(mods["Special Modifiers"])
-- Timings
for k, v in pairs(mods) do
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
if type(v) == "boolean" and v and allowFlag(k) then
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"],  maxLevel), level)
flagSet[tostring(k)] = true
local durVal  = displayFromSeries(seriesFromValuePair(bt["Duration"],  maxLevel), level)
 
-- Promote status duration if needed
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
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
end
return any and s or nil
end
end


local flags = {}
local mpS = labeledSeries(rc["Mana Cost"], "MP")
for k, _ in pairs(flagSet) do table.insert(flags, k) end
local hpS = labeledSeries(rc["Health Cost"], "HP")
table.sort(flags)


------------------------------------------------------------------
local costSeries = {}
-- Special mechanics (name => value)
for lv = 1, maxLevel do
------------------------------------------------------------------
local mp = mpS and mpS[lv] or "—"
local mechItems = {}
local hp = hpS and hpS[lv] or "—"


if effects then
if mp ~= "—" and hp ~= "—" then
local keys = {}
costSeries[lv] = mp .. " + " .. hp
for k, _ in pairs(effects) do table.insert(keys, k) end
elseif mp ~= "—" then
table.sort(keys)
costSeries[lv] = mp
elseif hp ~= "—" then
costSeries[lv] = hp
else
costSeries[lv] = "—"
end
end


for _, name in ipairs(keys) do
local costVal = displayFromSeries(costSeries, level)
-- Skip Hits completely (it belongs in SkillType)
if not isHitsKey(name) then
local block = effects[name]
if type(block) == "table" then
-- 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
local grid = mw.html.create("div")
grid:addClass("sv-m4-grid")
grid:addClass("sv-compact-root")


-- If Type exists and is distinct, prefix it.
local function addCell(label, val)
if t and not isNoneLike(t) and mw.ustring.lower(t) ~= mw.ustring.lower(tostring(name)) then
local cell = grid:tag("div"):addClass("sv-m4-cell")
if value then
cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label))
value = mw.text.nowiki(t) .. ": " .. value
cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash())
else
end
value = mw.text.nowiki(t)
end
end


if value then
addCell("Range",    rangeVal)
table.insert(mechItems, { label = tostring(name), value = value })
addCell("Area",     areaVal)
end
addCell("Cost",      costVal)
end
addCell("Cast Time", castVal)
end
addCell("Cooldown",  cdVal)
end
addCell("Duration",  durVal)
end
end


local hasFlags = (#flags > 0)
return {
local hasMech  = (#mechItems > 0)
inner = tostring(grid),
classes = "module-quick-stats",
}
end


if (not hasFlags) and (not hasMech) then
-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
local root = mw.html.create("div")
-- Shows:
root:addClass("sv-sm-root")
--  - Flags (deduped)
root:addClass("sv-compact-root")
--  - Special mechanics (mech.Effects)
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")
-- 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 {}
local effects = (type(mech.Effects) == "table") and mech.Effects or nil
local mods    = (type(rec.Modifiers) == "table") and rec.Modifiers or nil


return {
------------------------------------------------------------------
inner = tostring(root),
-- Hits guard (we want Hits ONLY in SkillType)
classes = "module-special-mechanics",
------------------------------------------------------------------
}
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
end


local count = 0
------------------------------------------------------------------
if hasFlags then count = count + 1 end
-- Flags (flat, de-duped)
if hasMech  then count = count + 1 end
------------------------------------------------------------------
local flagSet = {}


local root = mw.html.create("div")
local denyFlags = {
root:addClass("sv-sm-root")
["self centered"] = true,
root:addClass("sv-compact-root")
["self-centred"] = true,
["bond"] = true,
["combo"] = true,
        ["hybrid"] = true,


local layout = root:tag("div"):addClass("sv-sm-layout")
-- hits variants
layout:addClass("sv-sm-count-" .. tostring(count))
["hit"] = true,
["hits"] = true,
["hit count"] = true,
["hits count"] = true,
["hitcount"] = true,
["hitscount"] = true,
}


-- Column 1: Flags
local function allowFlag(name)
if hasFlags then
if not name then return false end
local fcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-flags")
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
for _, f in ipairs(flags) do
if k == "" then return false end
fcol:tag("div"):addClass("sv-sm-flag"):wikitext(mw.text.nowiki(f))
if denyFlags[k] then return false end
return true
end
 
local function addFlags(sub)
if type(sub) ~= "table" then return end
for k, v in pairs(sub) do
if v and allowFlag(k) then
flagSet[tostring(k)] = true
end
end
end
end
end


-- Column 2: Special Mechanics (stacked)
if mods then
if hasMech then
addFlags(mods["Movement Modifiers"])
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech")
addFlags(mods["Combat Modifiers"])
for _, it in ipairs(mechItems) do
addFlags(mods["Special Modifiers"])
local one = mcol:tag("div"):addClass("sv-sm-mech")
for k, v in pairs(mods) do
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label))
if type(v) == "boolean" and v and allowFlag(k) then
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—")
flagSet[tostring(k)] = true
end
end
end
end
end


return {
local flags = {}
inner = tostring(root),
for k, _ in pairs(flagSet) do table.insert(flags, k) end
classes = "module-special-mechanics",
table.sort(flags)
}
end


-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
------------------------------------------------------------------
function PLUGINS.LevelSelector(rec, ctx)
-- Special mechanics (name => value)
local level = ctx.level or 1
------------------------------------------------------------------
local maxLevel = ctx.maxLevel or 1
local mechItems = {}


local inner = mw.html.create("div")
if effects then
inner:addClass("sv-level-ui")
local keys = {}
for k, _ in pairs(effects) do table.insert(keys, k) end
table.sort(keys)


inner:tag("div")
for _, name in ipairs(keys) do
:addClass("sv-level-label")
-- Skip Hits completely (it belongs in SkillType)
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
if not isHitsKey(name) then
local block = effects[name]
if type(block) == "table" then
-- 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 slider = inner:tag("div"):addClass("sv-level-slider")
local value = disp


if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
-- If Type exists and is distinct, prefix it.
slider:tag("input")
if t and not isNoneLike(t) and mw.ustring.lower(t) ~= mw.ustring.lower(tostring(name)) then
:attr("type", "range")
if value then
:attr("min", "1")
value = mw.text.nowiki(t) .. ": " .. value
:attr("max", tostring(maxLevel))
else
:attr("value", tostring(level))
value = mw.text.nowiki(t)
:addClass("sv-level-range")
end
:attr("aria-label", "Skill level select")
end
else
inner:addClass("sv-level-ui-single")
slider:addClass("sv-level-slider-single")
end


return {
if value then
inner = tostring(inner),
table.insert(mechItems, { label = tostring(name), value = value })
classes = "module-level-selector",
end
}
end
end
end
end
end
end


----------------------------------------------------------------------
local hasFlags = (#flags > 0)
-- Generic slot renderers
local hasMech  = (#mechItems > 0)
----------------------------------------------------------------------


-- normalizeResult: normalize plugin return values into {inner, classes}.
if (not hasFlags) and (not hasMech) then
local function normalizeResult(res)
local root = mw.html.create("div")
if res == nil then return nil end
root:addClass("sv-sm-root")
if type(res) == "string" then
root:addClass("sv-compact-root")
return { inner = res, classes = nil }
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")
end
if type(res) == "table" then
local inner = res.inner
if type(inner) ~= "string" then
inner = (inner ~= nil) and tostring(inner) or ""
end
return { inner = inner, classes = res.classes }
end
return { inner = tostring(res), classes = nil }
end


-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors.
return {
local function safeCallPlugin(name, rec, ctx)
inner = tostring(root),
local fn = PLUGINS[name]
classes = "module-special-mechanics",
if type(fn) ~= "function" then
}
return nil
end
end
local ok, out = pcall(fn, rec, ctx)
if not ok then
return nil
end
return normalizeResult(out)
end


-- renderHeroBarSlot: render a hero-bar slot by plugin assignment.
local count = 0
local function renderHeroBarSlot(slotIndex, rec, ctx)
if hasFlags then count = count + 1 end
local pluginName = HERO_BAR_SLOT_ASSIGNMENT[slotIndex]
if hasMech  then count = count + 1 end
if not pluginName then
return heroBarBox(slotIndex, nil, "", true)
end


local res = safeCallPlugin(pluginName, rec, ctx)
local root = mw.html.create("div")
if not res or not res.inner or res.inner == "" then
root:addClass("sv-sm-root")
return heroBarBox(slotIndex, nil, "", true)
root:addClass("sv-compact-root")
end


return heroBarBox(slotIndex, res.classes, res.inner, false)
local layout = root:tag("div"):addClass("sv-sm-layout")
end
layout:addClass("sv-sm-count-" .. tostring(count))


-- renderModuleSlot: render a hero-module slot by plugin assignment.
-- Column 1: Flags
local function renderModuleSlot(slotIndex, rec, ctx)
if hasFlags then
local pluginName = HERO_MODULE_SLOT_ASSIGNMENT[slotIndex]
local fcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-flags")
if not pluginName then
for _, f in ipairs(flags) do
return moduleBox(slotIndex, nil, "", true)
fcol:tag("div"):addClass("sv-sm-flag"):wikitext(mw.text.nowiki(f))
end
end
end


local res = safeCallPlugin(pluginName, rec, ctx)
-- Column 2: Special Mechanics (stacked)
if not res or not res.inner or res.inner == "" then
if hasMech then
return moduleBox(slotIndex, nil, "", true)
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
end


return moduleBox(slotIndex, res.classes, res.inner, false)
return {
inner = tostring(root),
classes = "module-special-mechanics",
}
end
end


----------------------------------------------------------------------
-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
-- UI builders
function PLUGINS.LevelSelector(rec, ctx)
----------------------------------------------------------------------
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


-- buildHeroBarUI: build the top hero bar (2 slots).
local inner = mw.html.create("div")
local function buildHeroBarUI(rec, ctx)
inner:addClass("sv-level-ui")
local bar = mw.html.create("div")
 
bar:addClass("hero-bar-grid")
inner:tag("div")
bar:wikitext(renderHeroBarSlot(1, rec, ctx))
:addClass("sv-level-label")
bar:wikitext(renderHeroBarSlot(2, rec, ctx))
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
return tostring(bar)
end


-- buildHeroModulesUI: build the 2x2 module grid row (4 slots).
local slider = inner:tag("div"):addClass("sv-level-slider")
local function buildHeroModulesUI(rec, ctx)
local grid = mw.html.create("div")
grid:addClass("hero-modules-grid")
for slot = 1, 4 do
grid:wikitext(renderModuleSlot(slot, rec, ctx))
end
return tostring(grid)
end


-- addHeroModulesRow: add the hero-modules row into the infobox table.
if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
local function addHeroModulesRow(tbl, modulesUI)
slider:tag("input")
if not modulesUI or modulesUI == "" then
:attr("type", "range")
return
:attr("min", "1")
:attr("max", tostring(maxLevel))
:attr("value", tostring(level))
:addClass("sv-level-range")
:attr("aria-label", "Skill level select")
else
inner:addClass("sv-level-ui-single")
slider:addClass("sv-level-slider-single")
end
end


local row = tbl:tag("tr")
return {
row:addClass("hero-modules-row")
inner = tostring(inner),
 
classes = "module-level-selector",
local cell = row:tag("td")
}
cell:attr("colspan", 2)
cell:addClass("hero-modules-cell")
cell:wikitext(modulesUI)
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Infobox builder
-- Generic slot renderers
----------------------------------------------------------------------
----------------------------------------------------------------------


-- buildInfobox: render a single skill infobox.
-- normalizeResult: normalize plugin return values into {inner, classes}.
local function buildInfobox(rec, opts)
local function normalizeResult(res)
opts = opts or {}
if res == nil then return nil end
local showUsers = (opts.showUsers ~= false)
if type(res) == "string" then
return { inner = res, classes = nil }
end
if type(res) == "table" then
local inner = res.inner
if type(inner) ~= "string" then
inner = (inner ~= nil) and tostring(inner) or ""
end
return { inner = inner, classes = res.classes }
end
return { inner = tostring(res), classes = nil }
end


local maxLevel = tonumber(rec["Max Level"]) or 1
-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors.
if maxLevel < 1 then maxLevel = 1 end
local function safeCallPlugin(name, rec, ctx)
local level = clamp(maxLevel, 1, maxLevel)
        local fn = PLUGINS[name]
        if type(fn) ~= "function" then
                return nil
        end
        local ok, out = pcall(fn, rec, ctx)
        if not ok then
                return nil
        end
        return normalizeResult(out)
end


local ctx = {
-- isEmptySlotContent: true when a slot has no meaningful content.
maxLevel = maxLevel,
-- NOTE: JS placeholders (sv-dyn spans, slider markup) are considered content.
level = level,
local function isEmptySlotContent(inner)
nonDamaging = false,
        if inner == nil then return true end
promo = nil,
 
}
        local raw = tostring(inner)


-- Non-damaging hides Damage/Element/Hits in SkillType
        -- Guard rails for JS-injected regions.
do
        for _, pat in ipairs({ "sv%-dyn", "data%-series", "sv%-level%-range", "sv%-level%-slider", "sv%-level%-ui" }) do
local dmgVal = nil
                if mw.ustring.find(raw, pat) then
if type(rec.Type) == "table" then
                        return false
dmgVal = rec.Type.Damage or rec.Type["Damage Type"]
                end
if type(dmgVal) == "table" then
        end
dmgVal = dmgVal.Name or dmgVal.ID or dmgVal.Value
end
end
ctx.nonDamaging = isNoneLike(dmgVal) or (not skillHasAnyDamage(rec, maxLevel))
end


ctx.promo = computeDurationPromotion(rec, maxLevel)
        local trimmed = mw.text.trim(raw)
        if trimmed == "" or trimmed == "—" then
                return true
        end


local root = mw.html.create("table")
        local withoutTags = mw.text.trim(mw.ustring.gsub(trimmed, "<[^>]+>", ""))
root:addClass("spiritvale-skill-infobox")
        return (withoutTags == "" or withoutTags == "—")
root:addClass("sv-skill-card")
end
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-level", tostring(level))


if opts.inList then
-- renderHeroSlot: render a standardized hero slot by plugin assignment.
root:addClass("sv-skill-inlist")
local function renderHeroSlot(slotIndex, rec, ctx)
end
        local pluginName = HERO_SLOT_ASSIGNMENT[slotIndex]
        if not pluginName then
                return nil
        end


local internalId = trim(rec["Internal Name"] or rec.InternalID or rec.ID)
        local res = safeCallPlugin(pluginName, rec, ctx)
if internalId then
        if not res or isEmptySlotContent(res.inner) then
root:attr("data-skill-id", internalId)
                return nil
end
        end


local desc  = rec.Description or ""
        return {
                inner = res.inner,
                classes = res.classes,
        }
end


-- Hero Title Bar
----------------------------------------------------------------------
local heroRow = root:tag("tr")
-- UI builders
heroRow:addClass("spiritvale-infobox-main")
----------------------------------------------------------------------
heroRow:addClass("sv-hero-title-row")
heroRow:addClass("hero-title-bar")


local heroCell = heroRow:tag("th")
-- buildHeroSlotsUI: build the standardized 4-row slot grid (2 columns).
heroCell:attr("colspan", 2)
local function buildHeroSlotsUI(rec, ctx)
heroCell:addClass("sv-hero-title-cell")
        local grid = mw.html.create("div")
heroCell:wikitext(buildHeroBarUI(rec, ctx))
        grid:addClass("sv-slot-grid")


-- Description Bar
        local slots = {}
if desc ~= "" then
        for slot = 1, 8 do
local descRow = root:tag("tr")
                slots[slot] = renderHeroSlot(slot, rec, ctx)
descRow:addClass("spiritvale-infobox-main")
        end
descRow:addClass("sv-hero-desc-row")
descRow:addClass("hero-description-bar")


local descCell = descRow:tag("td")
        local hasSlots = false
descCell:attr("colspan", 2)
        for _, pair in ipairs({ { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }) do
descCell:addClass("sv-hero-desc-cell")
                local left  = slots[pair[1]]
                local right = slots[pair[2]]


local descInner = descCell:tag("div")
                if left or right then
descInner:addClass("spiritvale-infobox-main-right-inner")
                        hasSlots = true


descInner:tag("div")
                        if left and right then
:addClass("spiritvale-infobox-description")
                                grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isEmpty = false }))
:wikitext(string.format("''%s''", desc))
                                grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isEmpty = false }))
end
                        elseif left then
                                grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isFull = true }))
                        elseif right then
                                grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isFull = true }))
                        end
                end
        end


-- Modules row
        if not hasSlots then
addHeroModulesRow(root, buildHeroModulesUI(rec, ctx))
                return ""
        end


-- Users (hide on direct skill page)
        return tostring(grid)
if showUsers then
end
local users = rec.Users or {}
addRow(root, "Classes",  listToText(users.Classes),  "sv-row-users", "Users.Classes")
addRow(root, "Summons",  listToText(users.Summons),  "sv-row-users", "Users.Summons")
addRow(root, "Monsters", listToText(users.Monsters), "sv-row-users", "Users.Monsters")
addRow(root, "Events",  listToText(users.Events),  "sv-row-users", "Users.Events")
end


-- Requirements
-- addHeroSlotsRow: add the standardized slot grid into the infobox table.
local req = rec.Requirements or {}
local function addHeroSlotsRow(tbl, slotsUI)
local hasReq =
        if not slotsUI or slotsUI == "" then
(type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0) or
                return
(type(req["Required Weapons"]) == "table" and #req["Required Weapons"] > 0) or
        end
(type(req["Required Stances"]) == "table" and #req["Required Stances"] > 0)


if hasReq then
        local row = tbl:tag("tr")
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
        row:addClass("sv-slot-row")
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")
        local cell = row:tag("td")
addRow(root, "Required Stances", listToText(req["Required Stances"]), "sv-row-req", "Requirements.Required Stances")
        cell:attr("colspan", 2)
end
        cell:addClass("sv-slot-cell")
        cell:wikitext(slotsUI)
end


-- Mechanics (keep small extras only)
----------------------------------------------------------------------
local mech = rec.Mechanics or {}
-- Infobox builder
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)
-- buildInfobox: render a single skill infobox.
if type(rec.Source) ~= "table" then
local function buildInfobox(rec, opts)
local dmg = rec.Damage or {}
opts = opts or {}
if next(dmg) ~= nil then
local showUsers = (opts.showUsers ~= false)
local main = dmg["Main Damage"]
 
local mainNonHeal, healOnly = {}, {}
local maxLevel = tonumber(rec["Max Level"]) or 1
 
if maxLevel < 1 then maxLevel = 1 end
if type(main) == "table" then
local level = clamp(maxLevel, 1, maxLevel)
for _, d in ipairs(main) do
 
if type(d) == "table" and d.Type == "Healing" then
local ctx = {
table.insert(healOnly, d)
maxLevel = maxLevel,
else
level = level,
table.insert(mainNonHeal, d)
nonDamaging = false,
end
promo = nil,
end
}
end
 
 
-- Non-damaging hides Damage/Element/Hits in SkillType
addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)), "sv-row-source", "Damage.Main Damage")
do
addRow(root, "Flat Damage",    formatDamageList(dmg["Flat Damage"], maxLevel, level, false),        "sv-row-source", "Damage.Flat Damage")
local dmgVal = nil
addRow(root, "Reflect Damage", formatDamageList(dmg["Reflect Damage"], maxLevel, level, false),    "sv-row-source", "Damage.Reflect Damage")
if type(rec.Type) == "table" then
addRow(root, "Healing",        formatDamageList(healOnly, maxLevel, level, false),                  "sv-row-source", "Damage.Healing")
dmgVal = rec.Type.Damage or rec.Type["Damage Type"]
end
if type(dmgVal) == "table" then
end
dmgVal = dmgVal.Name or dmgVal.ID or dmgVal.Value
end
end
ctx.nonDamaging = isNoneLike(dmgVal) or (not skillHasAnyDamage(rec, maxLevel))
end
 
ctx.promo = computeDurationPromotion(rec, maxLevel)
 
local root = mw.html.create("table")
root:addClass("spiritvale-skill-infobox")
root:addClass("sv-skill-card")
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-level", tostring(level))
 
if opts.inList then
root:addClass("sv-skill-inlist")
end
 
local internalId = trim(rec["Internal Name"] or rec.InternalID or rec.ID)
if internalId then
root:attr("data-skill-id", internalId)
end
 
-- Standardized slot grid
addHeroSlotsRow(root, buildHeroSlotsUI(rec, ctx))
 
-- Users (hide on direct skill page)
        if showUsers then
                local users = rec.Users or {}
                addRow(root, "Classes",  listToText(users.Classes),  "sv-row-users", "Users.Classes")
                addRow(root, "Summons",  listToText(users.Summons),  "sv-row-users", "Users.Summons")
                addRow(root, "Monsters", listToText(users.Monsters), "sv-row-users", "Users.Monsters")
                do
                        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
 
        -- 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)
if type(rec.Source) ~= "table" then
local dmg = rec.Damage or {}
if next(dmg) ~= nil then
local main = dmg["Main Damage"]
local mainNonHeal, healOnly = {}, {}
 
if type(main) == "table" then
for _, d in ipairs(main) do
if type(d) == "table" and d.Type == "Healing" then
table.insert(healOnly, d)
else
table.insert(mainNonHeal, d)
end
end
end
 
addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)), "sv-row-source", "Damage.Main Damage")
addRow(root, "Flat Damage",    formatDamageList(dmg["Flat Damage"], maxLevel, level, false),        "sv-row-source", "Damage.Flat Damage")
addRow(root, "Reflect Damage", formatDamageList(dmg["Reflect Damage"], maxLevel, level, false),    "sv-row-source", "Damage.Reflect Damage")
addRow(root, "Healing",        formatDamageList(healOnly, maxLevel, level, false),                  "sv-row-source", "Damage.Healing")
end
end


-- Status rows
-- Status rows
Line 1,830: Line 2,074:
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,849: 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


Line 1,886: Line 2,125:
end
end


local root = mw.html.create("div")
local out = {}
root:addClass("sv-skill-collection")


for _, rec in ipairs(matches) do
for _, rec in ipairs(matches) do
local item = root:tag("div"):addClass("sv-skill-item")
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
item:wikitext(buildInfobox(rec, { showUsers = false, inList = true }))
 
-- List mode: emit a raw H3 heading before each standalone card so TOC/anchors work.
table.insert(out, string.format("=== %s ===", title))
 
-- List mode cards are independent (no single wrapper container).
table.insert(out, buildInfobox(rec, { showUsers = false, inList = true }))
end
end


return tostring(root)
return table.concat(out, "\n")
end
end


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