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
 
(17 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: ReservedInfo (Hero Bar Slot 2 placeholder) - kept for future.
local reqStances = {}
function PLUGINS.ReservedInfo(rec, ctx)
for _, s in ipairs(reqStancesRaw) do
local wrap = mw.html.create("div")
local sn = trim(s)
wrap:addClass("sv-herobar-2-wrap")
if sn then table.insert(reqStances, mw.text.nowiki(sn)) end
return {
end
inner = tostring(wrap),
classes = "module-herobar-2",
}
end


-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
local hasNotes = (#notesList > 0)
function PLUGINS.LevelSelector(rec, ctx)
local hasReq = (#reqSkills > 0) or (#reqWeapons > 0) or (#reqStances > 0)
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")
local wrap = mw.html.create("div")
:addClass("sv-level-label")
wrap:addClass("sv-herobar-1-wrap")
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
wrap:addClass("sv-tip-scope")


local slider = inner:tag("div"):addClass("sv-level-slider")
local iconBox = wrap:tag("div")
iconBox:addClass("sv-herobar-icon")


if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
if icon and icon ~= "" then
slider:tag("input")
iconBox:wikitext(string.format("[[File:%s|80px|link=]]", icon))
:attr("type", "range")
: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


return {
local textBox = wrap:tag("div")
inner = tostring(inner),
textBox:addClass("sv-herobar-text")
classes = "module-level-selector",
}
end


-- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile).
local titleRow = textBox:tag("div")
-- Rules:
titleRow:addClass("sv-herobar-title-row")
--  - 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 titleBox = titleRow:tag("div")
local maxLevel = ctx.maxLevel or 1
titleBox:addClass("spiritvale-infobox-title")
titleBox:wikitext(title)


local hideDamageBundle = (ctx.nonDamaging == true)
if hasNotes then
local notesBtn = mw.html.create("span")
notesBtn:addClass("sv-tip-btn sv-tip-btn--notes")
notesBtn:attr("role", "button")
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


-- valName: extract a display string from typical {Name/ID/Value} objects.
if hasNotes then
local function valName(x)
local notesContent = wrap:tag("div")
if x == nil then return nil end
notesContent:addClass("sv-tip-content")
if type(x) == "table" then
notesContent:attr("data-sv-tip-content", "notes")
if x.Name and x.Name ~= "" then return tostring(x.Name) end
notesContent:tag("div"):addClass("sv-tip-title"):wikitext("Notes")
if x.ID and x.ID ~= "" then return tostring(x.ID) end
notesContent:tag("div"):wikitext(table.concat(notesList, "<br />"))
if x.Value ~= nil then return tostring(x.Value) end
end
if type(x) == "string" and x ~= "" then
return x
end
return nil
end
end


-- hitsDisplay: find + render Hits from multiple possible structured locations.
if hasReq then
local function hitsDisplay()
local reqContent = wrap:tag("div")
local h =
reqContent:addClass("sv-tip-content")
typeBlock.Hits or typeBlock["Hits"] or typeBlock["Hit Count"] or typeBlock["Hits Count"] or
reqContent:attr("data-sv-tip-content", "req")
mech.Hits or mech["Hits"] or mech["Hit Count"] or mech["Hits Count"] or
rec.Hits or rec["Hits"]


if h == nil or isNoneLike(h) then
if #reqSkills > 0 then
return nil
local section = reqContent:tag("div")
section:addClass("sv-tip-section")
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Skills")
section:tag("div"):wikitext(table.concat(reqSkills, "<br />"))
end
end


-- ValuePair-style table (Base/Per Level) => dynamic series
if #reqWeapons > 0 then
if type(h) == "table" then
local section = reqContent:tag("div")
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
section:addClass("sv-tip-section")
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Weapons")
end
section:tag("div"):wikitext(table.concat(reqWeapons, ", "))
 
end
-- Unit block {Value, Unit}
if h.Value ~= nil then
local t = formatUnitValue(h)
return t and mw.text.nowiki(t) or nil
end
 
-- Fallback name extraction
local vn = valName(h)
if vn and not isNoneLike(vn) then
return mw.text.nowiki(vn)
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
 
-- 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 typ = trim(c.Type)
local level    = ctx.level or 1
if not typ or isNoneLike(typ) then
local maxLevel = ctx.maxLevel or 1
return nil
end


local details = {}
local hideDamageBundle = (ctx.nonDamaging == true)


local pct = formatUnitValue(c.Percent)
-- valName: extract a display string from typical {Name/ID/Value} objects.
if pct and not isZeroish(pct) then
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped.
table.insert(details, mw.text.nowiki(pct))
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
local dur = formatUnitValue(c.Duration)
return tostring(x)
if dur and not isZeroish(dur) then
table.insert(details, mw.text.nowiki(dur))
end
end
 
if type(x) == "string" and x ~= "" then
if #details > 0 then
return x
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
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
-- addChunk: add one labeled value cell (key drives CSS ordering).
mech.Hits or mech["Hits"] or mech["Hit Count"] or mech["Hits Count"] or
local function addChunk(key, label, valueHtml)
effects.Hits or effects["Hits"] or effects["Hit Count"] or effects["Hits Count"] or
if valueHtml == nil or valueHtml == "" then return end
rec.Hits or rec["Hits"]
added = true


local chunk = grid:tag("div")
if h == nil or isNoneLike(h) then
:addClass("sv-type-chunk")
return nil
:addClass("sv-type-" .. tostring(key))
end
:attr("data-type-key", tostring(key))


chunk:tag("div")
-- ValuePair-style table (Base/Per Level) => dynamic series
:addClass("sv-type-label")
if type(h) == "table" then
:wikitext(mw.text.nowiki(label))
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
end


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


-- Damage + Element + Hits bundle (hidden when non-damaging)
-- Fallback name extraction
if not hideDamageBundle then
local function valName(x)
local dmg = valName(typeBlock.Damage or typeBlock["Damage Type"])
if x == nil then return nil end
local ele = valName(typeBlock.Element or typeBlock["Element Type"])
if type(x) == "table" then
local hits = hitsDisplay()
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


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
-- Hits: only render when present and meaningful
if type(h) == "string" then
if hits then
local t = trim(h)
addChunk("hits", "Hits", hits)
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil
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 (moved here)
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


-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling.
local dur = formatUnitValue(c.Duration)
function PLUGINS.SourceType(rec, ctx)
if dur and not isZeroish(dur) then
local level = ctx.level or 1
table.insert(details, mw.text.nowiki(dur))
local maxLevel = ctx.maxLevel or 1
end


local basisWord = nil
if #details > 0 then
local sourceKind = nil
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
local sourceVal  = nil
end
local scaling    = nil
return mw.text.nowiki(typ)
end


-- sourceValueForLevel: dynamic formatting for structured Source blocks.
local grid = mw.html.create("div")
local function sourceValueForLevel(src)
grid:addClass("sv-type-grid")
if type(src) ~= "table" then
grid:addClass("sv-compact-root")
return nil
end


local per = src["Per Level"]
local added = false
if type(per) == "table" and #per > 0 then
 
if isFlatList(per) then
-- addChunk: add one labeled value cell (key drives CSS ordering).
local one  = formatUnitValue(per[1]) or tostring(per[1])
local function addChunk(key, label, valueHtml)
local show = formatUnitValue(src.Base) or one
if valueHtml == nil or valueHtml == "" then return end
return show and mw.text.nowiki(show) or nil
added = true
end
 
local chunk = grid:tag("div")
:addClass("sv-type-chunk")
:addClass("sv-type-" .. tostring(key))
:attr("data-type-key", tostring(key))


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


return valuePairDynamicValueOnly(src, maxLevel, level)
chunk:tag("div")
:addClass("sv-type-value")
:wikitext(valueHtml)
end
end


if type(rec.Source) == "table" then
-- Damage + Element + Hits bundle (hidden when non-damaging)
local src = rec.Source
if not hideDamageBundle then
local atkFlag = (src["ATK-Based"] == true)
local dmg = valName(typeBlock.Damage or typeBlock["Damage Type"])
local matkFlag = (src["MATK-Based"] == true)
local ele  = valName(typeBlock.Element or typeBlock["Element Type"])
basisWord = basisWordFromFlags(atkFlag, matkFlag)
local hits = hitsDisplay()


sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
if dmg and not isNoneLike(dmg) then
sourceVal  = sourceValueForLevel(src)
addChunk("damage", "Damage", mw.text.nowiki(dmg))
scaling    = src.Scaling
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


-- Fallback to legacy Damage lists if Source absent
-- Target + Cast
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
local tgt = valName(typeBlock.Target or typeBlock["Target Type"])
local dmg = rec.Damage
local cst = valName(typeBlock.Cast  or typeBlock["Cast Type"])
scaling = scaling or dmg.Scaling


local main = dmg["Main Damage"]
if tgt and not isNoneLike(tgt) then
local refl = dmg["Reflect Damage"]
addChunk("target", "Target", mw.text.nowiki(tgt))
local flat = dmg["Flat Damage"]
end
if cst and not isNoneLike(cst) then
addChunk("cast", "Cast", mw.text.nowiki(cst))
end
 
-- Combo
local combo = comboDisplay()
if combo then
addChunk("combo", "Combo", combo)
end


if type(main) == "table" and #main > 0 then
        return {
local pick = nil
                inner = added and tostring(grid) or "",
for _, d in ipairs(main) do
                classes = "module-skill-type",
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: Description (Hero Slot 3) - primary description text.
local atkFlag  = (pick["ATK-Based"] == true)
function PLUGINS.Description(rec)
local matkFlag = (pick["MATK-Based"] == true)
        local desc = trim(rec.Description)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
        if not desc then
                return nil
        end


sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
        local body = mw.html.create("div")
sourceVal  = legacyPercentAtLevel(pick, level)
        body:addClass("sv-description")
end
        body:wikitext(string.format("''%s''", desc))
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"
        return {
sourceVal  = legacyPercentAtLevel(pick, level)
                inner = tostring(body),
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
                classes = "module-description",
local pick = flat[1]
        }
local atkFlag  = (pick["ATK-Based"] == true)
end
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


sourceKind = "Flat"
-- PLUGIN: Placeholder (Hero Slot 4) - reserved/blank.
sourceVal  = legacyPercentAtLevel(pick, level)
function PLUGINS.Placeholder()
end
        return nil
end
end


local scalingLines = formatScalingCompactLines(scaling)
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)


if (not hasSource) and (not hasScaling) then
-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling.
return nil
function PLUGINS.SourceType(rec, ctx)
end
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1


local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
local basisWord = nil
local sourceKind = nil
local sourceVal  = nil
local scaling    = nil


local extra = { "skill-source-module" }
-- sourceValueForLevel: dynamic formatting for structured Source blocks.
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
local function sourceValueForLevel(src)
if type(src) ~= "table" then
return nil
end


if hasSource and (not hasScaling) then
local per = src["Per Level"]
table.insert(extra, "sv-only-source")
if type(per) == "table" and #per > 0 then
elseif hasScaling and (not hasSource) then
if isFlatList(per) then
table.insert(extra, "sv-only-scaling")
local one  = formatUnitValue(per[1]) or tostring(per[1])
end
local show = formatUnitValue(src.Base) or one
return show and mw.text.nowiki(show) or nil
end


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


if hasMod then
return valuePairDynamicValueOnly(src, maxLevel, level)
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
end
end


if hasSource then
if type(rec.Source) == "table" then
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
local src = rec.Source
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
local atkFlag  = (src["ATK-Based"] == true)
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
local matkFlag = (src["MATK-Based"] == true)
basisWord = basisWordFromFlags(atkFlag, matkFlag)
 
sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
sourceVal  = sourceValueForLevel(src)
scaling    = src.Scaling
end
end


if hasScaling then
-- Fallback to legacy Damage lists if Source absent
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")
local dmg = rec.Damage
scaling = scaling or dmg.Scaling


local list = scalingCol:tag("div"):addClass("sv-scaling-list")
local main = dmg["Main Damage"]
for _, line in ipairs(scalingLines) do
local refl = dmg["Reflect Damage"]
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
local flat = dmg["Flat Damage"]
end
end


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


-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
if type(pick) == "table" then
function PLUGINS.QuickStats(rec, ctx)
local atkFlag  = (pick["ATK-Based"] == true)
local level = ctx.level or 1
local matkFlag = (pick["MATK-Based"] == true)
local maxLevel = ctx.maxLevel or 1
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
local promo = ctx.promo


local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
sourceVal  = legacyPercentAtLevel(pick, level)
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}
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)


local function dash() return "—" end
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)


-- Range (0 => —)
sourceKind = "Flat"
local rangeVal = nil
sourceVal  = legacyPercentAtLevel(pick, level)
if mech.Range ~= nil and not isNoneLike(mech.Range) then
local n = toNum(mech.Range)
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


-- Area
local scalingLines = formatScalingCompactLines(scaling)
local areaVal = formatAreaSize(mech.Area)
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)


-- Timings
if (not hasSource) and (not hasScaling) then
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
return nil
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"],  maxLevel), level)
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
end


-- Cost: MP + HP
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
local function labeledSeries(block, label)
 
local s = seriesFromValuePair(block, maxLevel)
local extra = { "skill-source-module", "module-source-type" }
if not s then return nil end
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
local any = false
 
for i, v in ipairs(s) do
if hasSource and (not hasScaling) then
if v ~= "—" then
table.insert(extra, "sv-only-source")
s[i] = tostring(v) .. " " .. label
elseif hasScaling and (not hasSource) then
any = true
table.insert(extra, "sv-only-scaling")
else
s[i] = "—"
end
end
return any and s or nil
end
end


local mpS = labeledSeries(rc["Mana Cost"], "MP")
local wrap = mw.html.create("div")
local hpS = labeledSeries(rc["Health Cost"], "HP")
wrap:addClass("sv-source-grid")
wrap:addClass("sv-compact-root")


local costSeries = {}
if hasMod then
for lv = 1, maxLevel do
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
local mp = mpS and mpS[lv] or "—"
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
local hp = hpS and hpS[lv] or "—"
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
end


if mp ~= "—" and hp ~= "—" then
if hasSource then
costSeries[lv] = mp .. " + " .. hp
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
elseif mp ~= "—" then
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
costSeries[lv] = mp
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
elseif hp ~= "—" then
costSeries[lv] = hp
else
costSeries[lv] = "—"
end
end
end


local costVal = displayFromSeries(costSeries, level)
if hasScaling then
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")


local grid = mw.html.create("div")
local list = scalingCol:tag("div"):addClass("sv-scaling-list")
grid:addClass("sv-m4-grid")
for _, line in ipairs(scalingLines) do
grid:addClass("sv-compact-root")
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
 
end
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)
addCell("Area",      areaVal)
addCell("Cost",      costVal)
addCell("Cast Time", castVal)
addCell("Cooldown",  cdVal)
addCell("Duration",  durVal)


return {
return {
inner = tostring(grid),
inner = tostring(wrap),
classes = "module-quick-stats",
classes = extra,
}
}
end
end


-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
-- Shows:
-- NOTE: Hits does NOT live here (it lives in SkillType).
--  - Flags (deduped)
function PLUGINS.QuickStats(rec, ctx)
--  - Special mechanics (mech.Effects)
-- NOTE: Combo has been moved to SkillType (Hero Bar Slot 2).
function PLUGINS.SpecialMechanics(rec, ctx)
local level = ctx.level or 1
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
local maxLevel = ctx.maxLevel or 1
local promo = ctx.promo


local mech   = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
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 bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
local mods    = (type(rec.Modifiers) == "table") and rec.Modifiers or nil
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}


------------------------------------------------------------------
local function dash() return "—" end
-- Flags (flat, de-duped)
------------------------------------------------------------------
local flagSet = {}


-- Filter out mechanics you said to remove/ignore here.
-- Range (0 => —)
local denyFlags = {
local rangeVal = nil
["self centered"] = true,
if mech.Range ~= nil and not isNoneLike(mech.Range) then
["self-centred"] = true,
local n = toNum(mech.Range)
["self centered"] = true,
if n ~= nil then
["bond"] = true,
if n ~= 0 then
["combo"] = true,
rangeVal = mw.text.nowiki(formatUnitValue(mech.Range) or tostring(mech.Range))
["hits"] = true,
end
}
else
 
local t = mw.text.trim(tostring(mech.Range))
local function allowFlag(name)
if t ~= "" and not isNoneLike(t) then
if not name then return false end
rangeVal = mw.text.nowiki(t)
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)
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
end


if mods then
-- Area
addFlags(mods["Movement Modifiers"])
local areaVal = formatAreaSize(mech.Area, maxLevel, level)
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


local flags = {}
-- Timings
for k, _ in pairs(flagSet) do table.insert(flags, k) end
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
table.sort(flags)
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"], maxLevel), level)
local durVal  = displayFromSeries(seriesFromValuePair(bt["Duration"],  maxLevel), level)


------------------------------------------------------------------
-- Promote status duration if needed
-- Special mechanics (name => value)
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
------------------------------------------------------------------
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
local mechItems = {}
 
if effects then
local keys = {}
for k, _ in pairs(effects) do table.insert(keys, k) end
table.sort(keys)
 
for _, name in ipairs(keys) do
local block = effects[name]
if type(block) == "table" 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
 
if value then
table.insert(mechItems, { label = tostring(name), value = value })
end
end
end
end
end


local hasFlags = (#flags > 0)
-- Cost: MP + HP
local hasMech  = (#mechItems > 0)
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
return any and s or nil
end


if (not hasFlags) and (not hasMech) then
local mpS = labeledSeries(rc["Mana Cost"], "MP")
local root = mw.html.create("div")
local hpS = labeledSeries(rc["Health Cost"], "HP")
root:addClass("sv-sm-root")
root:addClass("sv-compact-root")
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")


return {
local costSeries = {}
inner = tostring(root),
for lv = 1, maxLevel do
classes = "module-special-mechanics",
local mp = mpS and mpS[lv] or "—"
}
local hp = hpS and hpS[lv] or "—"
 
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
end


local count = 0
local costVal = displayFromSeries(costSeries, level)
if hasFlags then count = count + 1 end
if hasMech  then count = count + 1 end


local root = mw.html.create("div")
local grid = mw.html.create("div")
root:addClass("sv-sm-root")
grid:addClass("sv-m4-grid")
root:addClass("sv-compact-root")
grid:addClass("sv-compact-root")


local layout = root:tag("div"):addClass("sv-sm-layout")
local function addCell(label, val)
layout:addClass("sv-sm-count-" .. tostring(count))
local cell = grid:tag("div"):addClass("sv-m4-cell")
 
cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label))
-- Column 1: Flags
cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash())
if hasFlags then
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
end


-- Column 2: Special Mechanics (stacked)
addCell("Range",    rangeVal)
if hasMech then
addCell("Area",      areaVal)
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech")
addCell("Cost",     costVal)
for _, it in ipairs(mechItems) do
addCell("Cast Time", castVal)
local one = mcol:tag("div"):addClass("sv-sm-mech")
addCell("Cooldown",  cdVal)
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label))
addCell("Duration",  durVal)
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—")
end
end


return {
return {
inner = tostring(root),
inner = tostring(grid),
classes = "module-special-mechanics",
classes = "module-quick-stats",
}
}
end
end


----------------------------------------------------------------------
-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
-- Generic slot renderers
-- 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 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


-- normalizeResult: normalize plugin return values into {inner, classes}.
------------------------------------------------------------------
local function normalizeResult(res)
-- Hits guard (we want Hits ONLY in SkillType)
if res == nil then return nil end
------------------------------------------------------------------
if type(res) == "string" then
local function isHitsKey(name)
return { inner = res, classes = nil }
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
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.
------------------------------------------------------------------
local function safeCallPlugin(name, rec, ctx)
-- Flags (flat, de-duped)
local fn = PLUGINS[name]
------------------------------------------------------------------
if type(fn) ~= "function" then
local flagSet = {}
return nil
 
end
local denyFlags = {
local ok, out = pcall(fn, rec, ctx)
["self centered"] = true,
if not ok then
["self-centred"] = true,
return nil
["bond"] = true,
end
["combo"] = true,
return normalizeResult(out)
        ["hybrid"] = true,
end


-- renderHeroBarSlot: render a hero-bar slot by plugin assignment.
-- hits variants
local function renderHeroBarSlot(slotIndex, rec, ctx)
["hit"] = true,
local pluginName = HERO_BAR_SLOT_ASSIGNMENT[slotIndex]
["hits"] = true,
if not pluginName then
["hit count"] = true,
return heroBarBox(slotIndex, nil, "", true)
["hits count"] = true,
end
["hitcount"] = true,
["hitscount"] = true,
}


local res = safeCallPlugin(pluginName, rec, ctx)
local function allowFlag(name)
if not res or not res.inner or res.inner == "" then
if not name then return false end
return heroBarBox(slotIndex, nil, "", true)
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
end
if k == "" then return false end
 
if denyFlags[k] then return false end
return heroBarBox(slotIndex, res.classes, res.inner, false)
return true
end
end


-- renderModuleSlot: render a hero-module slot by plugin assignment.
local function addFlags(sub)
local function renderModuleSlot(slotIndex, rec, ctx)
if type(sub) ~= "table" then return end
local pluginName = HERO_MODULE_SLOT_ASSIGNMENT[slotIndex]
for k, v in pairs(sub) do
if not pluginName then
if v and allowFlag(k) then
return moduleBox(slotIndex, nil, "", true)
flagSet[tostring(k)] = true
end
end
end
end


local res = safeCallPlugin(pluginName, rec, ctx)
if mods then
if not res or not res.inner or res.inner == "" then
addFlags(mods["Movement Modifiers"])
return moduleBox(slotIndex, nil, "", true)
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
end


return moduleBox(slotIndex, res.classes, res.inner, false)
local flags = {}
end
for k, _ in pairs(flagSet) do table.insert(flags, k) end
table.sort(flags)


----------------------------------------------------------------------
------------------------------------------------------------------
-- UI builders
-- Special mechanics (name => value)
----------------------------------------------------------------------
------------------------------------------------------------------
local mechItems = {}


-- buildHeroBarUI: build the top hero bar (2 slots).
if effects then
local function buildHeroBarUI(rec, ctx)
local keys = {}
local bar = mw.html.create("div")
for k, _ in pairs(effects) do table.insert(keys, k) end
bar:addClass("hero-bar-grid")
table.sort(keys)
bar:wikitext(renderHeroBarSlot(1, rec, ctx))
bar:wikitext(renderHeroBarSlot(2, rec, ctx))
return tostring(bar)
end


-- buildHeroModulesUI: build the 2x2 module grid row (4 slots).
for _, name in ipairs(keys) do
local function buildHeroModulesUI(rec, ctx)
-- Skip Hits completely (it belongs in SkillType)
local grid = mw.html.create("div")
if not isHitsKey(name) then
grid:addClass("hero-modules-grid")
local block = effects[name]
for slot = 1, 4 do
if type(block) == "table" then
grid:wikitext(renderModuleSlot(slot, rec, ctx))
-- Also skip if the block's Type is "Hits" (some data may encode it that way)
end
if not isHitsKey(block.Type) then
return tostring(grid)
local disp = displayFromSeries(seriesFromValuePair(block, maxLevel), level)
end
local t = trim(block.Type)


-- addHeroModulesRow: add the hero-modules row into the infobox table.
local value = disp
local function addHeroModulesRow(tbl, modulesUI)
if not modulesUI or modulesUI == "" then
return
end


local row = tbl:tag("tr")
-- If Type exists and is distinct, prefix it.
row:addClass("hero-modules-row")
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


local cell = row:tag("td")
if value then
cell:attr("colspan", 2)
table.insert(mechItems, { label = tostring(name), value = value })
cell:addClass("hero-modules-cell")
end
cell:wikitext(modulesUI)
end
end
end
end
end
end


----------------------------------------------------------------------
local hasFlags = (#flags > 0)
-- Infobox builder
local hasMech  = (#mechItems > 0)
----------------------------------------------------------------------


-- buildInfobox: render a single skill infobox.
if (not hasFlags) and (not hasMech) then
local function buildInfobox(rec, opts)
local root = mw.html.create("div")
opts = opts or {}
root:addClass("sv-sm-root")
local showUsers = (opts.showUsers ~= false)
root:addClass("sv-compact-root")
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")


local maxLevel = tonumber(rec["Max Level"]) or 1
return {
if maxLevel < 1 then maxLevel = 1 end
inner = tostring(root),
local level = clamp(maxLevel, 1, maxLevel)
classes = "module-special-mechanics",
}
end


local ctx = {
local count = 0
maxLevel = maxLevel,
if hasFlags then count = count + 1 end
level = level,
if hasMech  then count = count + 1 end
nonDamaging = false,
promo = nil,
}


-- Non-damaging hides Damage/Element/Hits in SkillType
local root = mw.html.create("div")
do
root:addClass("sv-sm-root")
local dmgVal = nil
root:addClass("sv-compact-root")
if type(rec.Type) == "table" then
 
dmgVal = rec.Type.Damage or rec.Type["Damage Type"]
local layout = root:tag("div"):addClass("sv-sm-layout")
if type(dmgVal) == "table" then
layout:addClass("sv-sm-count-" .. tostring(count))
dmgVal = dmgVal.Name or dmgVal.ID or dmgVal.Value
 
end
-- Column 1: Flags
if hasFlags then
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
ctx.nonDamaging = isNoneLike(dmgVal) or (not skillHasAnyDamage(rec, maxLevel))
end
end


ctx.promo = computeDurationPromotion(rec, maxLevel)
-- Column 2: Special Mechanics (stacked)
 
if hasMech then
local root = mw.html.create("table")
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech")
root:addClass("spiritvale-skill-infobox")
for _, it in ipairs(mechItems) do
root:addClass("sv-skill-card")
local one = mcol:tag("div"):addClass("sv-sm-mech")
root:attr("data-max-level", tostring(maxLevel))
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label))
root:attr("data-level", tostring(level))
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—")
 
end
if opts.inList then
root:addClass("sv-skill-inlist")
end
end


local internalId = trim(rec["Internal Name"] or rec.InternalID or rec.ID)
return {
if internalId then
inner = tostring(root),
root:attr("data-skill-id", internalId)
classes = "module-special-mechanics",
end
}
end


local desc  = rec.Description or ""
-- 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


-- Hero Title Bar
local inner = mw.html.create("div")
local heroRow = root:tag("tr")
inner:addClass("sv-level-ui")
heroRow:addClass("spiritvale-infobox-main")
heroRow:addClass("sv-hero-title-row")
heroRow:addClass("hero-title-bar")


local heroCell = heroRow:tag("th")
inner:tag("div")
heroCell:attr("colspan", 2)
:addClass("sv-level-label")
heroCell:addClass("sv-hero-title-cell")
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
heroCell:wikitext(buildHeroBarUI(rec, ctx))


-- Description Bar
local slider = inner:tag("div"):addClass("sv-level-slider")
if desc ~= "" then
local descRow = root:tag("tr")
descRow:addClass("spiritvale-infobox-main")
descRow:addClass("sv-hero-desc-row")
descRow:addClass("hero-description-bar")


local descCell = descRow:tag("td")
if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
descCell:attr("colspan", 2)
slider:tag("input")
descCell:addClass("sv-hero-desc-cell")
:attr("type", "range")
 
:attr("min", "1")
local descInner = descCell:tag("div")
:attr("max", tostring(maxLevel))
descInner:addClass("spiritvale-infobox-main-right-inner")
:attr("value", tostring(level))
 
:addClass("sv-level-range")
descInner:tag("div")
:attr("aria-label", "Skill level select")
:addClass("spiritvale-infobox-description")
else
:wikitext(string.format("''%s''", desc))
inner:addClass("sv-level-ui-single")
end
slider:addClass("sv-level-slider-single")
 
end
-- Modules row
 
addHeroModulesRow(root, buildHeroModulesUI(rec, ctx))
return {
 
inner = tostring(inner),
-- Users (hide on direct skill page)
classes = "module-level-selector",
if showUsers then
}
local users = rec.Users or {}
end
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")
-- Generic slot renderers
addRow(root, "Events",  listToText(users.Events),  "sv-row-users", "Users.Events")
----------------------------------------------------------------------
end
 
 
-- normalizeResult: normalize plugin return values into {inner, classes}.
-- Requirements
local function normalizeResult(res)
local req = rec.Requirements or {}
if res == nil then return nil end
local hasReq =
if type(res) == "string" then
(type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0) or
return { inner = res, classes = nil }
(type(req["Required Weapons"]) == "table" and #req["Required Weapons"] > 0) or
end
(type(req["Required Stances"]) == "table" and #req["Required Stances"] > 0)
if type(res) == "table" then
 
local inner = res.inner
if hasReq then
if type(inner) ~= "string" then
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
inner = (inner ~= nil) and tostring(inner) or ""
local skillParts = {}
end
for _, rs in ipairs(req["Required Skills"]) do
return { inner = inner, classes = res.classes }
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
end
local lvlReq  = rs["Required Level"]
return { inner = tostring(res), classes = nil }
if lvlReq then
end
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
 
else
-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors.
table.insert(skillParts, nameReq)
local function safeCallPlugin(name, rec, ctx)
end
        local fn = PLUGINS[name]
end
        if type(fn) ~= "function" then
addRow(root, "Required Skills", table.concat(skillParts, ", "), "sv-row-req", "Requirements.Required Skills")
                return nil
end
        end
 
        local ok, out = pcall(fn, rec, ctx)
addRow(root, "Required Weapons", listToText(req["Required Weapons"]), "sv-row-req", "Requirements.Required Weapons")
        if not ok then
addRow(root, "Required Stances", listToText(req["Required Stances"]), "sv-row-req", "Requirements.Required Stances")
                return nil
end
        end
 
        return normalizeResult(out)
-- Mechanics (keep small extras only)
end
local mech = rec.Mechanics or {}
 
if next(mech) ~= nil then
-- isEmptySlotContent: true when a slot has no meaningful content.
if mech["Autocast Multiplier"] ~= nil then
-- NOTE: JS placeholders (sv-dyn spans, slider markup) are considered content.
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier")
local function isEmptySlotContent(inner)
end
        if inner == nil then return true end
end
 
 
        local raw = tostring(inner)
-- Legacy damage breakdown (only when Source absent)
 
        -- Guard rails for JS-injected regions.
        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
                        return false
                end
        end
 
        local trimmed = mw.text.trim(raw)
        if trimmed == "" or trimmed == "—" then
                return true
        end
 
        local withoutTags = mw.text.trim(mw.ustring.gsub(trimmed, "<[^>]+>", ""))
        return (withoutTags == "" or withoutTags == "—")
end
 
-- renderHeroSlot: render a standardized hero slot by plugin assignment.
local function renderHeroSlot(slotIndex, rec, ctx)
        local pluginName = HERO_SLOT_ASSIGNMENT[slotIndex]
        if not pluginName then
                return nil
        end
 
        local res = safeCallPlugin(pluginName, rec, ctx)
        if not res or isEmptySlotContent(res.inner) then
                return nil
        end
 
        return {
                inner = res.inner,
                classes = res.classes,
        }
end
 
----------------------------------------------------------------------
-- UI builders
----------------------------------------------------------------------
 
-- buildHeroSlotsUI: build the standardized 4-row slot grid (2 columns).
local function buildHeroSlotsUI(rec, ctx)
        local grid = mw.html.create("div")
        grid:addClass("sv-slot-grid")
 
        local slots = {}
        for slot = 1, 8 do
                slots[slot] = renderHeroSlot(slot, rec, ctx)
        end
 
        local hasSlots = false
        for _, pair in ipairs({ { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }) do
                local left  = slots[pair[1]]
                local right = slots[pair[2]]
 
                if left or right then
                        hasSlots = true
 
                        if left and right then
                                grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isEmpty = false }))
                                grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isEmpty = false }))
                        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
 
        if not hasSlots then
                return ""
        end
 
        return tostring(grid)
end
 
-- addHeroSlotsRow: add the standardized slot grid into the infobox table.
local function addHeroSlotsRow(tbl, slotsUI)
        if not slotsUI or slotsUI == "" then
                return
        end
 
        local row = tbl:tag("tr")
        row:addClass("sv-slot-row")
 
        local cell = row:tag("td")
        cell:attr("colspan", 2)
        cell:addClass("sv-slot-cell")
        cell:wikitext(slotsUI)
end
 
----------------------------------------------------------------------
-- Infobox builder
----------------------------------------------------------------------
 
-- buildInfobox: render a single skill infobox.
local function buildInfobox(rec, opts)
opts = opts or {}
local showUsers = (opts.showUsers ~= false)
 
local maxLevel = tonumber(rec["Max Level"]) or 1
if maxLevel < 1 then maxLevel = 1 end
local level = clamp(maxLevel, 1, maxLevel)
 
local ctx = {
maxLevel = maxLevel,
level = level,
nonDamaging = false,
promo = nil,
}
 
-- Non-damaging hides Damage/Element/Hits in SkillType
do
local dmgVal = nil
if type(rec.Type) == "table" then
dmgVal = rec.Type.Damage or rec.Type["Damage Type"]
if type(dmgVal) == "table" then
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
if type(rec.Source) ~= "table" then
local dmg = rec.Damage or {}
local dmg = rec.Damage or {}
Line 1,794: 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,813: 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,850: 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"