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
 
(61 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:GameSkills
-- Module:GameSkills
--
--
-- Renders active skill data (from Data:skills.json) into an infobox-style table
-- Phase 6.5+ (Plug-in Slot Architecture)
-- and can also list all skills for a given user/class.
--
--
-- Usage (single skill):
-- Layout:
--  {{Skill|Heal}}
--  Row 1: Slot 1 + Slot 2 (Icon + SkillType)
--  {{Skill|name=Heal}}
--  Row 2: Slot 3 + Slot 4 (Description + Placeholder)
--  {{Skill|id=Heal_InternalId}}
--  Row 3: Slot 5 + Slot 6 (SourceType + QuickStats)
--  Row 4: Slot 7 + Slot 8 (SpecialMechanics + LevelSelector)
--
--
-- Usage (auto-list on class page, e.g. "Acolyte"):
-- Requires Common.js:
--  {{Skill}}                  -> lists all Acolyte skills (page name)
--  - updates .sv-dyn spans via data-series
--  {{Skill|Acolyte}}          -> same, if no skill literally called "Acolyte"
--  - updates .sv-level-num + data-level on .sv-skill-card
--  - binds to input.sv-level-range inside each card


local GameData = require("Module:GameData")
local GameData = require("Module:GameData")
Line 18: Line 19:


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Internal helpers
-- Data cache
----------------------------------------------------------------------
----------------------------------------------------------------------


local skillsCache
local skillsCache
local eventsCache


-- 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
end


local function getArgs(frame)
local function getEvents()
local parent = frame:getParent()
        if eventsCache == nil then
if parent then
                if type(GameData.loadEvents) == "function" then
return parent.args
                        eventsCache = GameData.loadEvents()
end
                else
return frame.args
                        eventsCache = false
end
                end
        end


local function listToText(list, sep)
        return eventsCache
if type(list) ~= "table" or #list == 0 then
return nil
end
return table.concat(list, sep or ", ")
end
end


local function addRow(tbl, label, value)
----------------------------------------------------------------------
if value == nil or value == "" then
-- Small utilities
return
----------------------------------------------------------------------
end
local row = tbl:tag("tr")
row:tag("th"):wikitext(label):done()
row:tag("td"):wikitext(value):done()
end


local function addSectionHeader(tbl, label)
-- getArgs: read args from parent frame when invoked from a template.
local row = tbl:tag("tr")
local function getArgs(frame)
local cell = row:tag("th")
local parent = frame:getParent()
cell:attr("colspan", 2)
return (parent and parent.args) or frame.args
cell:addClass("spiritvale-infobox-section-header")
cell:wikitext(label)
end
end


-- trim: normalize strings (nil if empty).
local function trim(s)
local function trim(s)
if type(s) ~= "string" then return nil end
if type(s) ~= "string" then
return nil
end
s = mw.text.trim(s)
s = mw.text.trim(s)
if s == "" then return nil end
return (s ~= "" and s) or nil
return s
end
end


-- toNum: convert common scalar/table forms to a Lua number.
local function toNum(v)
local function toNum(v)
if type(v) == "number" then return v end
if type(v) == "number" then
if type(v) == "string" then return tonumber(v) end
return v
end
if type(v) == "string" then
return tonumber(v)
end
if type(v) == "table" and v.Value ~= nil then
return toNum(v.Value)
end
return nil
return nil
end
end


-- clamp: clamp a number into [lo, hi].
local function clamp(n, lo, hi)
if type(n) ~= "number" then
return lo
end
if n < lo then return lo end
if n > hi then return hi end
return n
end
-- fmtNum: consistent number formatting (trim trailing zeros).
local function fmtNum(n)
local function fmtNum(n)
if type(n) ~= "number" then
if type(n) ~= "number" then
return (n ~= nil) and tostring(n) or nil
return (n ~= nil) and tostring(n) or nil
end
end
if math.abs(n - math.floor(n)) < 1e-9 then
if math.abs(n - math.floor(n)) < 1e-9 then
return tostring(math.floor(n))
return tostring(math.floor(n))
end
end
local s = string.format("%.4f", n)
local s = string.format("%.4f", n)
s = mw.ustring.gsub(s, "0+$", "")
s = mw.ustring.gsub(s, "0+$", "")
Line 88: Line 104:
end
end


-- Handles either a scalar OR {Value=..., Unit=...}
-- listToText: join an array into a readable string.
-- IMPORTANT: do NOT convert percent_decimal/percent_whole; just format around stored values.
local function listToText(list, sep)
        if type(list) ~= "table" or #list == 0 then
                return nil
        end
        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
 
-- isNoneLike: treat common "none" spellings as empty.
local function isNoneLike(v)
if v == nil then return true end
local s = mw.text.trim(tostring(v))
if s == "" then return true end
s = mw.ustring.lower(s)
return (s == "none" or s == "no" or s == "n/a" or s == "na" or s == "null")
end
 
-- addRow: add a standard <tr><th>Label</th><td>Value</td></tr> row.
local function addRow(tbl, label, value, rowClass, dataKey)
if value == nil or value == "" then
return
end
 
local row = tbl:tag("tr")
row:addClass("sv-row")
if rowClass then row:addClass(rowClass) end
if dataKey then row:attr("data-field", dataKey) end
 
row:tag("th"):wikitext(label):done()
row:tag("td"):wikitext(value):done()
end
 
-- formatUnitValue: format {Value, Unit} blocks (or scalar) for display.
local function formatUnitValue(v)
local function formatUnitValue(v)
if type(v) == "table" and v.Value ~= nil then
if type(v) == "table" and v.Value ~= nil then
local unit = v.Unit
local unit = v.Unit
local val = v.Value
local val = v.Value


if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
Line 110: Line 243:
end
end


if v == nil then
return (v ~= nil) and tostring(v) or nil
return nil
end
return tostring(v)
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Lookups
-- Dynamic spans (JS-driven)
----------------------------------------------------------------------
----------------------------------------------------------------------


-- Lookup by Internal Name
-- dynSpan: render a JS-updated span for a level series.
local function getSkillById(id)
local function dynSpan(series, level)
id = trim(id)
if type(series) ~= "table" or #series == 0 then
if not id then return nil end
return nil
local dataset = getSkills()
end
local byId = dataset.byId or {}
return byId[id]
end


-- Lookup by display/external Name (for editors)
level = clamp(level or #series, 1, #series)
local function findSkillByName(name)
name = trim(name)
if not name then return nil end
local dataset = getSkills()


-- Fast path if GameData built byName
local span = mw.html.create("span")
local byName = dataset.byName or {}
span:addClass("sv-dyn")
if byName[name] then
span:attr("data-series", mw.text.jsonEncode(series))
return byName[name]
span:wikitext(mw.text.nowiki(series[level] or ""))
end


-- Fallback scan (older GameData)
return tostring(span)
for _, rec in ipairs(dataset.records or {}) do
if type(rec) == "table" then
if rec["External Name"] == name or rec["Name"] == name or rec["Display Name"] == name then
return rec
end
end
end
return nil
end
end


----------------------------------------------------------------------
-- isFlatList: true if all values in list are identical.
-- Formatting helpers
----------------------------------------------------------------------
 
local function isFlatList(list)
local function isFlatList(list)
if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
Line 169: Line 280:
end
end


-- isNonZeroScalar: detect if a value is present and not effectively zero.
local function isNonZeroScalar(v)
local function isNonZeroScalar(v)
if v == nil then return false end
if v == nil then return false end
Line 174: Line 286:
if type(v) == "string" then
if type(v) == "string" then
local n = tonumber(v)
local n = tonumber(v)
if n == nil then
if n == nil then return v ~= "" end
return v ~= ""
end
return n ~= 0
return n ~= 0
end
end
Line 185: Line 295:
end
end


-- Turns a {Base, Per Level} block into lines:
-- isZeroish: aggressively treat common “zero” text forms as zero.
--  - If Per Level is a list: "Name: v1 / v2 / v3 ..."
local function isZeroish(v)
--   - If Per Level scalar and non-zero: add "Name Per Level: X"
if v == nil then return true end
local function valuePairLines(name, block)
if type(v) == "number" then return v == 0 end
if type(v) == "table" and v.Value ~= nil then
return isZeroish(v.Value)
end
 
local s = mw.text.trim(tostring(v))
if s == "" then return true end
if s == "0" or s == "0.0" or s == "0.00" then return true end
if s == "0s" or s == "0 s" then return true end
if s == "0m" or s == "0 m" then return true end
if s == "0%" or s == "0 %" then return true end
 
local n = tonumber((mw.ustring.gsub(s, "[^0-9%.%-]", "")))
return (n ~= nil and n == 0)
end
 
-- valuePairRawText: render Base/Per Level blocks into readable text (fallback).
local function valuePairRawText(block)
if type(block) ~= "table" then
if type(block) ~= "table" then
return {}
return nil
end
end


Line 196: Line 323:
local per  = block["Per Level"]
local per  = block["Per Level"]


-- Per Level list (wikiprep expansion)
if type(per) == "table" then
if type(per) == "table" then
if #per == 0 then
if #per == 0 then
local baseText = formatUnitValue(base)
return formatUnitValue(base)
if baseText then
return { string.format("%s: %s", name, baseText) }
end
return {}
end
end
-- If it's a flat list, treat as "no scaling" (show single value)
if isFlatList(per) then
if isFlatList(per) then
local baseText = formatUnitValue(base)
return formatUnitValue(base) or tostring(per[1])
local one = tostring(per[1])
local show = baseText or one
if show then
return { string.format("%s: %s", name, show) }
end
return {}
end
end


Line 221: Line 335:
table.insert(vals, formatUnitValue(v) or tostring(v))
table.insert(vals, formatUnitValue(v) or tostring(v))
end
end
if #vals == 0 then
return (#vals > 0) and table.concat(vals, " / ") or nil
return {}
end
return { string.format("%s: %s", name, table.concat(vals, " / ")) }
end
end


-- Scalar Per Level
local lines = {}
local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
local perText  = formatUnitValue(per)
local perText  = formatUnitValue(per)


if baseText then
if baseText and perText and isNonZeroScalar(per) then
table.insert(lines, string.format("%s: %s", name, baseText))
return string.format("%s (Per Level: %s)", baseText, perText)
end
if perText and isNonZeroScalar(per) then
table.insert(lines, string.format("%s Per Level: %s", name, perText))
end
end


return lines
return baseText or perText
end
end


local function valuePairText(name, block, sep)
-- valuePairDynamicValueOnly: render Base/Per Level blocks using dyn spans where possible.
local lines = valuePairLines(name, block)
local function valuePairDynamicValueOnly(block, maxLevel, level)
if #lines == 0 then
return nil
end
return table.concat(lines, sep or "<br />")
end
 
local function valuePairRawText(block)
if type(block) ~= "table" then
if type(block) ~= "table" then
return nil
return nil
Line 260: Line 359:
if type(per) == "table" then
if type(per) == "table" then
if #per == 0 then
if #per == 0 then
return formatUnitValue(base)
local baseText = formatUnitValue(base)
return baseText and mw.text.nowiki(baseText) or nil
end
end
if isFlatList(per) then
if isFlatList(per) then
return formatUnitValue(base) or tostring(per[1])
local one  = formatUnitValue(per[1]) or tostring(per[1])
local show = formatUnitValue(base) or one
return show and mw.text.nowiki(show) or nil
end
end
local vals = {}
 
local series = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
table.insert(series, formatUnitValue(v) or tostring(v))
end
end
return (#vals > 0) and table.concat(vals, " / ") or nil
return dynSpan(series, level)
end
end


local baseText = formatUnitValue(base)
local txt = valuePairRawText(block)
local perText  = formatUnitValue(per)
return txt and mw.text.nowiki(txt) or nil
end
 
----------------------------------------------------------------------
-- Lookups
----------------------------------------------------------------------
 
-- getSkillById: locate a skill by internal ID.
local function getSkillById(id)
id = trim(id)
if not id then return nil end
local dataset = getSkills()
return (dataset.byId or {})[id]
end
 
-- findSkillByName: locate a skill by external/display name.
local function findSkillByName(name)
name = trim(name)
if not name then return nil end
 
local dataset = getSkills()
local byName = dataset.byName or {}
 
if byName[name] then
return byName[name]
end


if baseText and perText and isNonZeroScalar(per) then
for _, rec in ipairs(dataset.records or {}) do
return string.format("%s (Per Level: %s)", baseText, perText)
if type(rec) == "table" then
if rec["External Name"] == name or rec.Name == name or rec["Display Name"] == name then
return rec
end
end
end
end
return baseText or perText
 
return nil
end
end


local function basisLabel(entry)
----------------------------------------------------------------------
local atk = entry and entry["ATK-Based"]
-- Legacy damage helpers
----------------------------------------------------------------------
 
-- basisLabel: label ATK/MATK basis in legacy damage blocks.
local function basisLabel(entry, isHealing)
if isHealing then
return "Healing"
end
 
local atk = entry and entry["ATK-Based"]
local matk = entry and entry["MATK-Based"]
local matk = entry and entry["MATK-Based"]
if atk and matk then
if atk and matk then
return "Attack/Magic Attack"
return "Attack/Magic Attack"
Line 291: Line 435:
return "Magic Attack"
return "Magic Attack"
end
end
return "Damage"
return "Damage"
end
end


local function formatDamageEntry(entry, maxLevel)
-- formatDamageEntry: legacy percent damage formatting (dynamic by level).
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
if type(entry) ~= "table" then
return nil
return nil
end
end


local baseN = toNum(entry["Base %"])
local isHealing = (entry.Type == "Healing")
local perN  = toNum(entry["Per Level %"])
local basis = isHealing and "Healing" or basisLabel(entry, false)


if baseN == nil and perN == nil then
local baseRaw = entry["Base %"]
return nil
local perRaw  = entry["Per Level %"]
 
local baseN = toNum(baseRaw)
local perN  = toNum(perRaw)
 
local function baseIsPresent()
if baseN ~= nil then
return baseN ~= 0
end
if baseRaw ~= nil then
local s = tostring(baseRaw)
return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
end
return false
end
end


local baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(entry["Base %"]) .. "%")
local baseText
local basis = basisLabel(entry)
if baseIsPresent() then
baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(baseRaw) .. "%")
end


if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
return string.format("%s %s", baseText, basis)
return baseText and mw.text.nowiki(baseText .. " " .. basis) or nil
end
end


local inc = {}
local series = {}
for lv = 1, maxLevel do
for lv = 1, maxLevel do
table.insert(inc, fmtNum(perN * lv))
local perPart = perN * lv
 
if baseText and baseN ~= nil then
local total = baseN + perPart
table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
elseif baseText then
table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
else
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
end
end
end


-- Match requested style: "100% + 40 / 80 / 120 ... Attack Per Level"
return dynSpan(series, level)
return string.format("%s + %s %s Per Level", baseText, table.concat(inc, " / "), basis)
end
end


local function formatDamageList(list, maxLevel, includeTypePrefix)
-- formatDamageList: render a list of legacy damage entries into <br/> blocks.
local function formatDamageList(list, maxLevel, level, includeTypePrefix)
if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
return nil
return nil
Line 330: Line 500:
for _, d in ipairs(list) do
for _, d in ipairs(list) do
if type(d) == "table" then
if type(d) == "table" then
local txt = formatDamageEntry(d, maxLevel)
local txt = formatDamageEntry(d, maxLevel, level)
if txt then
if txt then
if includeTypePrefix and d.Type and d.Type ~= "" then
if includeTypePrefix and d.Type and d.Type ~= "" then
table.insert(parts, tostring(d.Type) .. ": " .. txt)
table.insert(parts, mw.text.nowiki(tostring(d.Type) .. ": ") .. txt)
else
else
table.insert(parts, txt)
table.insert(parts, txt)
Line 341: Line 511:
end
end


if #parts == 0 then
return (#parts > 0) and table.concat(parts, "<br />") or nil
return nil
end
 
----------------------------------------------------------------------
-- Users matching
----------------------------------------------------------------------
 
-- skillMatchesUser: check if a skill is used by a specific class/monster/summon/event.
local function skillMatchesUser(rec, userName)
if type(rec) ~= "table" or not userName or userName == "" then
return false
end
 
local users = rec.Users
if type(users) ~= "table" then
return false
end
 
local userLower = mw.ustring.lower(userName)
 
local function listHas(list)
if type(list) ~= "table" then
return false
end
for _, v in ipairs(list) do
if type(v) == "string" and mw.ustring.lower(v) == userLower then
return true
end
end
return false
end
 
return listHas(users.Classes) or listHas(users.Summons) or listHas(users.Monsters) or listHas(users.Events)
end
 
----------------------------------------------------------------------
-- Hide Users on direct skill pages
----------------------------------------------------------------------
 
-- isDirectSkillPage: hide Users rows when viewing the skill page itself.
local function isDirectSkillPage(rec)
if type(rec) ~= "table" then
return false
end
 
local pageTitle = mw.title.getCurrentTitle()
local pageName  = pageTitle and pageTitle.text or ""
pageName = trim(pageName)
if not pageName then
return false
end
 
pageName = mw.ustring.lower(pageName)
 
local ext = trim(rec["External Name"] or rec.Name or rec["Display Name"])
local internal = trim(rec["Internal Name"] or rec.InternalName or rec.InternalID)
 
return (ext and mw.ustring.lower(ext) == pageName) or (internal and mw.ustring.lower(internal) == pageName) or false
end
 
----------------------------------------------------------------------
-- Slot config (edit these tables only to rearrange layout)
----------------------------------------------------------------------
 
local HERO_SLOT_ASSIGNMENT = {
[1] = "IconName",
[2] = "Description",
[3] = "LevelSelector",
[4] = "SkillType",
[5] = "SourceType",
[6] = "QuickStats",
[7] = "SpecialMechanics",
[8] = "Placeholder",
}
 
----------------------------------------------------------------------
-- Slot scaffolds
----------------------------------------------------------------------
 
-- slotBox: standardized wrapper for all hero card slots.
local function slotBox(slot, extraClasses, innerHtml, opts)
opts = opts or {}
 
local box = mw.html.create("div")
box:addClass("sv-slot")
box:addClass("sv-slot--" .. tostring(slot))
box:attr("data-hero-slot", tostring(slot))
 
if opts.isFull then
box:addClass("sv-slot--full")
end
 
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 opts.isEmpty then
box:addClass("sv-slot--empty")
end
 
local body = box:tag("div"):addClass("sv-slot__body")
if innerHtml and innerHtml ~= "" then
body:wikitext(innerHtml)
end
end
return table.concat(parts, "<br />")
 
return tostring(box)
end
end


local function formatScaling(list)
----------------------------------------------------------------------
if type(list) ~= "table" or #list == 0 then
-- Shared helpers (Source + QuickStats + SpecialMechanics)
return nil
----------------------------------------------------------------------
 
-- formatScalingCompactLines: build compact “Scaling” lines for SourceType.
local function formatScalingCompactLines(scaling)
if type(scaling) ~= "table" then
return {}
end
 
local list = scaling
if #list == 0 then
if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then
list = { scaling }
else
return {}
end
end
end


local parts = {}
local out = {}
for _, s in ipairs(list) do
for _, s in ipairs(list) do
if type(s) == "table" then
if type(s) == "table" then
Line 358: Line 648:
local pct  = s.Percent
local pct  = s.Percent
local pctN = toNum(pct)
local pctN = toNum(pct)
local basis = basisLabel(s)


if pctN ~= nil and pctN ~= 0 then
if pctN ~= nil and pctN ~= 0 then
-- IMPORTANT: do not convert percent values; just display stored value.
table.insert(out, string.format("%s%% %s", fmtNum(pctN), stat))
table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
table.insert(parts, string.format("%s%% %s Per %s", tostring(pct), basis, stat))
table.insert(out, string.format("%s%% %s", tostring(pct), stat))
end
end
end
end
end
end


if #parts == 0 then
return out
return nil
end
 
-- basisWordFromFlags: compute “Attack/Magic/Hybrid” from ATK/MATK booleans.
local function basisWordFromFlags(atkFlag, matkFlag)
if atkFlag and matkFlag then
return "Hybrid"
elseif atkFlag then
return "Attack"
elseif matkFlag then
return "Magic Attack"
end
end
return table.concat(parts, "<br />")
return nil
end
end


-- Area: Distance then Size (no Effective)
-- legacyPercentAtLevel: compute “Base% + PerLevel%*level” for legacy entries.
local function formatArea(area)
local function legacyPercentAtLevel(entry, level)
if type(area) ~= "table" then
if type(entry) ~= "table" then
return nil
return nil
end
end
local parts = {}


local distLine = valuePairText("Distance", area["Area Distance"], "<br />")
local baseRaw = entry["Base %"]
if distLine then
local perRaw  = entry["Per Level %"]
table.insert(parts, distLine)
local baseN  = toNum(baseRaw)
local perN    = toNum(perRaw)
 
if perN ~= nil and perN ~= 0 then
local total = (baseN or 0) + (perN * level)
return fmtNum(total) .. "%"
end
end


local size = area["Area Size"]
if baseN ~= nil then
if size and size ~= "" then
return fmtNum(baseN) .. "%"
table.insert(parts, "Size: " .. tostring(size))
end
if baseRaw ~= nil and tostring(baseRaw) ~= "" then
return tostring(baseRaw) .. "%"
end
end


if #parts == 0 then
return nil
end
 
-- seriesFromValuePair: normalize Base/Per Level blocks into a level-indexed series.
local function seriesFromValuePair(block, maxLevel)
if type(block) ~= "table" then
return nil
return nil
end
end
return table.concat(parts, "<br />")
end


local function formatTimingBlock(bt)
local base = block.Base
if type(bt) ~= "table" then
local per  = block["Per Level"]
 
local function pickUnit(v)
if type(v) == "table" and v.Unit and v.Unit ~= "" then
return v.Unit
end
return nil
return nil
end
end
local parts = {}
local unit = pickUnit(base) or pickUnit(per)
 
local function fmtAny(v)
local t = formatUnitValue(v)
return t and tostring(t) or (v ~= nil and tostring(v) or nil)
end
 
local series = {}
 
-- Expanded per-level series (wikiprep)
if type(per) == "table" and #per > 0 then
for lv = 1, maxLevel do
local raw = per[lv] or per[#per]
local one = fmtAny(raw)
if one == nil or isZeroish(raw) or isZeroish(one) then
one = "—"
end
series[lv] = one
end
return series
end


local function add(label, key)
-- Empty per-list -> base only
local block = bt[key]
if type(per) == "table" and #per == 0 then
if type(block) ~= "table" then
local one = fmtAny(base)
return
if one == nil or isZeroish(base) or isZeroish(one) then
one = "—"
end
end
local lines = valuePairLines(label, block)
for lv = 1, maxLevel do
for _, line in ipairs(lines) do
series[lv] = one
table.insert(parts, line)
end
end
return series
end
end


add("Cast Time", "Cast Time")
-- Scalar per -> compute base + per*level (fallback)
add("Cooldown", "Cooldown")
local baseN = toNum(base) or 0
add("Duration", "Duration")
local perN  = toNum(per)


if bt["Effect Cast Time"] ~= nil then
if perN ~= nil then
table.insert(parts, "Effect Cast Time: " .. tostring(bt["Effect Cast Time"]))
for lv = 1, maxLevel do
local total = baseN + (perN * lv)
local v = unit and { Value = total, Unit = unit } or total
local one = fmtAny(v)
if one == nil or total == 0 or isZeroish(one) then
one = "—"
end
series[lv] = one
end
return series
end
 
-- Base-only scalar
local raw = (base ~= nil) and base or per
local one = fmtAny(raw)
if one == nil then
return nil
end
end
if bt["Damage Delay"] ~= nil then
if isZeroish(raw) or isZeroish(one) then
table.insert(parts, "Damage Delay: " .. tostring(bt["Damage Delay"]))
one = "—"
end
end
if bt["Effect Remove Delay"] ~= nil then
for lv = 1, maxLevel do
table.insert(parts, "Effect Remove Delay: " .. tostring(bt["Effect Remove Delay"]))
series[lv] = one
end
end
return series
end


if #parts == 0 then
-- displayFromSeries: render a series as fixed text or dynSpan (nil if all “—”).
local function displayFromSeries(series, level)
if type(series) ~= "table" or #series == 0 then
return nil
return nil
end
end
return table.concat(parts, "<br />")
end


local function formatResourceCost(rc)
local any = false
if type(rc) ~= "table" then
for _, v in ipairs(series) do
if v ~= "—" then
any = true
break
end
end
if not any then
return nil
return nil
end
end
local parts = {}


local manaLines = valuePairLines("MP", rc["Mana Cost"])
if isFlatList(series) then
for _, line in ipairs(manaLines) do
return mw.text.nowiki(series[1])
table.insert(parts, line)
end
end
return dynSpan(series, level)
end


local hpLines = valuePairLines("HP", rc["Health Cost"])
-- formatAreaSize: human readable area sizing for QuickStats.
for _, line in ipairs(hpLines) do
-- Shows: "<Area Size> (<number>)" e.g. "Medium (4)"
table.insert(parts, line)
local function formatAreaSize(area, maxLevel, level)
if type(area) ~= "table" then
return nil
end
end


if #parts == 0 then
-- Helper: pull a number from scalar/unit/valuepair-ish things.
local function extractNumber(v)
if v == nil then return nil end
 
-- Unit block {Value, Unit}
if type(v) == "table" and v.Value ~= nil then
local n = toNum(v.Value)
return n
end
 
-- ValuePair {Base, Per Level} -> prefer Base at current level if series exists
if type(v) == "table" and (v.Base ~= nil or v["Per Level"] ~= nil) then
local s = seriesFromValuePair(v, maxLevel or 1)
if type(s) == "table" and #s > 0 then
local idx = clamp(level or 1, 1, #s)
local txt = s[idx]
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
end
 
-- 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
 
return nil
return nil
end
end
return table.concat(parts, "<br />")
end


local function formatCombo(combo)
-- 1) Read Area Size label/name
if type(combo) ~= "table" then
local rawSize = area["Area Size"]
if rawSize == nil then
return nil
return nil
end
end
local parts = {}


if combo.Type then
local sizeName = nil
table.insert(parts, "Type: " .. tostring(combo.Type))
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
end


local durText = formatUnitValue(combo.Duration)
sizeName = sizeName and mw.text.trim(tostring(sizeName)) or nil
if durText then
if not sizeName or sizeName == "" or isNoneLike(sizeName) then
table.insert(parts, "Duration: " .. durText)
return nil
end
end


if combo.Percent ~= nil then
-- 2) Find the numeric “exact number” to append
local pctText = formatUnitValue(combo.Percent)
-- Prefer the explicit Area Distance block, then fall back to other known numeric keys.
if pctText then
local num = nil
table.insert(parts, "Bonus: " .. pctText)
 
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
end
end


if #parts == 0 then
if not num or num == 0 then
return nil
num =
extractNumber(area["Area Value"]) or
extractNumber(area["Area Size Value"]) or
extractNumber(area["Area Number"]) or
extractNumber(area["Area Radius"])
end
end
return table.concat(parts, ", ")
end


local function formatMechanicEffects(effects)
-- 3) Render
if type(effects) ~= "table" then
-- If size already contains parentheses, assume it already includes the numeric.
return nil
if mw.ustring.find(sizeName, "%(") then
return mw.text.nowiki(sizeName)
end
end


local keys = {}
if num and num ~= 0 then
for k, _ in pairs(effects) do
return mw.text.nowiki(string.format("%s (%s)", sizeName, fmtNum(num)))
table.insert(keys, k)
end
end
table.sort(keys)


local parts = {}
return mw.text.nowiki(sizeName)
for _, name in ipairs(keys) do
end
local block = effects[name]
 
if type(block) == "table" then
-- skillHasAnyDamage: determine if a skill has any meaningful damage (for non-damaging rules).
local txt = valuePairText(name, block, ", ")
local function skillHasAnyDamage(rec, maxLevel)
if txt then
if type(rec.Source) == "table" then
table.insert(parts, txt)
local s = seriesFromValuePair(rec.Source, maxLevel)
if s then
for _, v in ipairs(s) do
if v ~= "—" then return true end
end
end
end
end
end
end


if #parts == 0 then
if type(rec.Damage) == "table" then
return nil
local dmg = rec.Damage
for _, key in ipairs({ "Main Damage", "Flat Damage", "Reflect Damage" }) do
local lst = dmg[key]
if type(lst) == "table" and #lst > 0 then
return true
end
end
end
end
return table.concat(parts, "<br />")
 
return false
end
end


local function formatModifiers(mods)
-- computeDurationPromotion: promote status-duration into QuickStats when a skill is non-damaging.
if type(mods) ~= "table" then
local function computeDurationPromotion(rec, maxLevel)
return nil
if type(rec) ~= "table" then return nil end
if skillHasAnyDamage(rec, maxLevel) then return nil end
 
local mech = (type(rec.Mechanics) == "table") and rec.Mechanics or {}
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
local durS = seriesFromValuePair(bt["Duration"], maxLevel)
 
if durS ~= nil then
local any = false
for _, v in ipairs(durS) do
if v ~= "—" then any = true break end
end
if any then
return nil
end
end
end
local parts = {}


local function collect(label, sub)
local apps = rec["Status Applications"]
if type(sub) ~= "table" then
if type(apps) ~= "table" then return nil end
return
 
for idx, app in ipairs(apps) do
if type(app) == "table" and type(app.Duration) == "table" then
local s = seriesFromValuePair(app.Duration, maxLevel)
if s then
for _, v in ipairs(s) do
if v ~= "—" then
return {
durationBlock = app.Duration,
suppressDurationIndex = idx,
}
end
end
end
end
end
local flags = {}
end
for k, v in pairs(sub) do
 
if v then
return nil
table.insert(flags, k)
end
 
----------------------------------------------------------------------
-- Plug-ins
----------------------------------------------------------------------
 
local PLUGINS = {}
 
-- PLUGIN: IconName (Hero Bar Slot 1) - icon + name.
function PLUGINS.IconName(rec, ctx)
local icon  = rec.Icon
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
 
local notesList = {}
if type(rec.Notes) == "table" then
for _, note in ipairs(rec.Notes) do
local n = trim(note)
if n then
table.insert(notesList, mw.text.nowiki(n))
end
end
end
end
table.sort(flags)
elseif type(rec.Notes) == "string" then
if #flags > 0 then
local n = trim(rec.Notes)
table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
if n then
notesList = { mw.text.nowiki(n) }
end
end
end
end


collect("Movement", mods["Movement Modifiers"])
local req = rec.Requirements or {}
collect("Combat",   mods["Combat Modifiers"])
local reqSkillsRaw = (type(req["Required Skills"]) == "table") and req["Required Skills"] or {}
collect("Special", mods["Special Modifiers"])
local reqWeaponsRaw = (type(req["Required Weapons"]) == "table") and req["Required Weapons"] or {}
local reqStancesRaw = (type(req["Required Stances"]) == "table") and req["Required Stances"] or {}
 
local reqSkills = {}
for _, rs in ipairs(reqSkillsRaw) do
if type(rs) == "table" then
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
local lvlReq  = rs["Required Level"]
if lvlReq then
table.insert(reqSkills, string.format("%s (Lv.%s)", mw.text.nowiki(nameReq), mw.text.nowiki(tostring(lvlReq))))
else
table.insert(reqSkills, mw.text.nowiki(nameReq))
end
end
end
 
local reqWeapons = {}
for _, w in ipairs(reqWeaponsRaw) do
local wn = trim(w)
if wn then table.insert(reqWeapons, mw.text.nowiki(wn)) end
end
 
local reqStances = {}
for _, s in ipairs(reqStancesRaw) do
local sn = trim(s)
if sn then table.insert(reqStances, mw.text.nowiki(sn)) end
end
 
local hasNotes = (#notesList > 0)
local hasReq = (#reqSkills > 0) or (#reqWeapons > 0) or (#reqStances > 0)
 
 
local wrap = mw.html.create("div")
wrap:addClass("sv-herobar-1-wrap")
wrap:addClass("sv-tip-scope")
 
local iconBox = wrap:tag("div")
iconBox:addClass("sv-herobar-icon")
 
if icon and icon ~= "" then
iconBox:wikitext(string.format("[[File:%s|80px|link=]]", icon))
end
 
local textBox = wrap:tag("div")
textBox:addClass("sv-herobar-text")
 
local titleRow = textBox:tag("div")
titleRow:addClass("sv-herobar-title-row")
 
local titleBox = titleRow:tag("div")
titleBox:addClass("spiritvale-infobox-title")
titleBox:wikitext(title)
 
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
 
if hasNotes then
local notesContent = wrap:tag("div")
notesContent:addClass("sv-tip-content")
notesContent:attr("data-sv-tip-content", "notes")
notesContent:tag("div"):addClass("sv-tip-title"):wikitext("Notes")
notesContent:tag("div"):wikitext(table.concat(notesList, "<br />"))
end


if #parts == 0 then
if hasReq then
return nil
local reqContent = wrap:tag("div")
reqContent:addClass("sv-tip-content")
reqContent:attr("data-sv-tip-content", "req")
 
if #reqSkills > 0 then
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
 
if #reqWeapons > 0 then
local section = reqContent:tag("div")
section:addClass("sv-tip-section")
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Weapons")
section:tag("div"):wikitext(table.concat(reqWeapons, ", "))
end
 
if #reqStances > 0 then
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
end
return table.concat(parts, "<br />")
 
return {
inner = tostring(wrap),
classes = "module-icon-name",
}
end
end


local function formatStatusApplications(list)
-- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile).
if type(list) ~= "table" or #list == 0 then
-- Rules:
--  - If skill is non-damaging, hide Damage/Element/Hits.
--  - If Hits is empty, hide Hits.
--  - If Combo is empty, hide Combo.
-- Ordering:
--  - Desktop: Damage, Element, Hits, Target, Cast, Combo
--  - Mobile:  Damage, Element, Target, Cast, Hits, Combo (CSS reorder)
function PLUGINS.SkillType(rec, ctx)
local typeBlock = (type(rec.Type) == "table") and rec.Type or {}
local mech      = (type(rec.Mechanics) == "table") and rec.Mechanics or {}
 
local level    = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
 
local hideDamageBundle = (ctx.nonDamaging == true)
 
-- valName: extract a display string from typical {Name/ID/Value} objects.
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped.
local function valName(x)
if x == nil then return nil end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if x.Value ~= nil then return tostring(x.Value) end
end
if type(x) == "number" then
return tostring(x)
end
if type(x) == "string" and x ~= "" then
return x
end
return nil
return nil
end
end
local parts = {}
for _, s in ipairs(list) do
if type(s) == "table" then
local scope = s.Scope or "Target"
local name  = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"


local seg = scope .. " – " .. tostring(name)
-- hitsDisplay: find + render Hits from multiple possible structured locations.
local detail = {}
local function hitsDisplay()
local effects = (type(mech.Effects) == "table") and mech.Effects or {}
 
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"]
 
if h == nil or isNoneLike(h) then
return nil
end


if type(s.Duration) == "table" then
-- ValuePair-style table (Base/Per Level) => dynamic series
local t = valuePairText("Duration", s.Duration, "; ")
if type(h) == "table" then
if t then table.insert(detail, t) end
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
end
end


if type(s.Chance) == "table" then
-- Unit block {Value, Unit}
local t = valuePairText("Chance", s.Chance, "; ")
if h.Value ~= nil then
if t then table.insert(detail, t) end
local t = formatUnitValue(h)
return t and mw.text.nowiki(t) or nil
end
end


if s["Fixed Duration"] then
-- Fallback name extraction
table.insert(detail, "Fixed duration")
local function valName(x)
if x == nil then return nil end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if x.Value ~= nil then return tostring(x.Value) end
end
if type(x) == "number" then return tostring(x) end
if type(x) == "string" and x ~= "" then return x end
return nil
end
end


if #detail > 0 then
local vn = valName(h)
seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
if vn and not isNoneLike(vn) then
return mw.text.nowiki(vn)
end
end
end


table.insert(parts, seg)
-- Scalar number/string
if type(h) == "number" then
return mw.text.nowiki(fmtNum(h))
end
end
if type(h) == "string" then
local t = trim(h)
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil
end
return nil
end
end
if #parts == 0 then
 
return nil
-- comboDisplay: render Combo as a compact text block (Type (+ details)).
local function comboDisplay()
local c = (type(mech.Combo) == "table") and mech.Combo or nil
if not c then return nil end
 
local typ = trim(c.Type)
if not typ or isNoneLike(typ) then
return nil
end
 
local details = {}
 
local pct = formatUnitValue(c.Percent)
if pct and not isZeroish(pct) then
table.insert(details, mw.text.nowiki(pct))
end
 
local dur = formatUnitValue(c.Duration)
if dur and not isZeroish(dur) then
table.insert(details, mw.text.nowiki(dur))
end
 
if #details > 0 then
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
end
return mw.text.nowiki(typ)
end
end
return table.concat(parts, "<br />")
end


local function formatStatusRemoval(list)
local grid = mw.html.create("div")
if type(list) ~= "table" or #list == 0 then
grid:addClass("sv-type-grid")
return nil
grid:addClass("sv-compact-root")
 
local added = false
 
-- addChunk: add one labeled value cell (key drives CSS ordering).
local function addChunk(key, label, valueHtml)
if valueHtml == nil or valueHtml == "" then return end
added = true
 
local chunk = grid:tag("div")
:addClass("sv-type-chunk")
: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
local parts = {}
for _, r in ipairs(list) do
if type(r) == "table" then
local names = r["Status External Name"]
local label
if type(names) == "table" then
label = table.concat(names, ", ")
elseif type(names) == "string" then
label = names
else
label = "Status"
end


local amt = valuePairRawText(r)
-- Damage + Element + Hits bundle (hidden when non-damaging)
local seg = label
if not hideDamageBundle then
if amt then
local dmg  = valName(typeBlock.Damage or typeBlock["Damage Type"])
seg = seg .. " – " .. amt
local ele  = valName(typeBlock.Element or typeBlock["Element Type"])
end
local hits = hitsDisplay()
table.insert(parts, seg)
 
if dmg and not isNoneLike(dmg) then
addChunk("damage", "Damage", mw.text.nowiki(dmg))
end
if ele and not isNoneLike(ele) then
addChunk("element", "Element", mw.text.nowiki(ele))
end
if hits then
addChunk("hits", "Hits", hits)
end
end
end
end
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end


local function formatEvents(list)
-- Target + Cast
if type(list) ~= "table" or #list == 0 then
local tgt = valName(typeBlock.Target or typeBlock["Target Type"])
return nil
local cst = valName(typeBlock.Cast  or typeBlock["Cast Type"])
 
if tgt and not isNoneLike(tgt) then
addChunk("target", "Target", mw.text.nowiki(tgt))
end
end
local parts = {}
if cst and not isNoneLike(cst) then
for _, ev in ipairs(list) do
addChunk("cast", "Cast", mw.text.nowiki(cst))
if type(ev) == "table" then
local action = ev.Action or "On event"
local name  = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
table.insert(parts, string.format("%s → %s", action, name))
end
end
end
if #parts == 0 then
 
return nil
-- Combo
local combo = comboDisplay()
if combo then
addChunk("combo", "Combo", combo)
end
end
return table.concat(parts, "<br />")
 
        return {
                inner = added and tostring(grid) or "",
                classes = "module-skill-type",
        }
end
end


----------------------------------------------------------------------
-- PLUGIN: Description (Hero Slot 3) - primary description text.
-- User matching (for auto lists on class pages)
function PLUGINS.Description(rec)
----------------------------------------------------------------------
        local desc = trim(rec.Description)
        if not desc then
                return nil
        end
 
        local body = mw.html.create("div")
        body:addClass("sv-description")
        body:wikitext(string.format("''%s''", desc))
 
        return {
                inner = tostring(body),
                classes = "module-description",
        }
end
 
-- PLUGIN: Placeholder (Hero Slot 4) - reserved/blank.
function PLUGINS.Placeholder()
        return nil
end
 
 
-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling.
function PLUGINS.SourceType(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
 
local basisWord = nil
local sourceKind = nil
local sourceVal  = nil
local scaling    = nil
 
-- sourceValueForLevel: dynamic formatting for structured Source blocks.
local function sourceValueForLevel(src)
if type(src) ~= "table" then
return nil
end
 
local per = src["Per Level"]
if type(per) == "table" and #per > 0 then
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 series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end


local function skillMatchesUser(rec, userName)
return valuePairDynamicValueOnly(src, maxLevel, level)
if type(rec) ~= "table" or not userName or userName == "" then
return false
end
end


local users = rec.Users
if type(rec.Source) == "table" then
if type(users) ~= "table" then
local src = rec.Source
return false
local atkFlag  = (src["ATK-Based"] == true)
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


local userLower = mw.ustring.lower(userName)
-- 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
 
local main = dmg["Main Damage"]
local refl = dmg["Reflect Damage"]
local flat = dmg["Flat Damage"]
 
if type(main) == "table" and #main > 0 then
local pick = nil
for _, d in ipairs(main) do
if type(d) == "table" and d.Type ~= "Healing" then
pick = d
break
end
end
pick = pick or main[1]
 
if type(pick) == "table" then
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)


local function listHas(list)
sourceKind = (pick.Type == "Healing") and "Healing" or "Damage"
if type(list) ~= "table" then
sourceVal  = legacyPercentAtLevel(pick, level)
return false
end
for _, v in ipairs(list) do
if type(v) == "string" and mw.ustring.lower(v) == userLower then
return true
end
end
elseif type(refl) == "table" and #refl > 0 and type(refl[1]) == "table" then
local pick = refl[1]
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
sourceKind = "Reflect"
sourceVal  = legacyPercentAtLevel(pick, level)
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then
local pick = flat[1]
local atkFlag  = (pick["ATK-Based"] == true)
local matkFlag = (pick["MATK-Based"] == true)
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag)
sourceKind = "Flat"
sourceVal  = legacyPercentAtLevel(pick, level)
end
end
return false
end
end


if listHas(users.Classes) then return true end
local scalingLines = formatScalingCompactLines(scaling)
if listHas(users.Summons) then return true end
local hasSource    = (sourceVal ~= nil and tostring(sourceVal) ~= "")
if listHas(users.Monsters) then return true end
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)
if listHas(users.Events)   then return true end
 
if (not hasSource) and (not hasScaling) then
return nil
end
 
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")


return false
local extra = { "skill-source-module", "module-source-type" }
end
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
 
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")
-- Direct page detection (hide Users on the skill's own page)
wrap:addClass("sv-source-grid")
----------------------------------------------------------------------
wrap:addClass("sv-compact-root")


local function isDirectSkillPage(rec)
if hasMod then
if type(rec) ~= "table" then
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier")
return false
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier")
modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord))
end
end


local pageTitle = mw.title.getCurrentTitle()
if hasSource then
local pageName = pageTitle and pageTitle.text or ""
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
pageName = trim(pageName)
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
if not pageName then
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
return false
end
end
pageName = mw.ustring.lower(pageName)


local ext = trim(rec["External Name"] or rec["Name"] or rec["Display Name"])
if hasScaling then
local internal = trim(rec["Internal Name"] or rec["InternalName"] or rec["InternalID"])
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")


if ext and mw.ustring.lower(ext) == pageName then
local list = scalingCol:tag("div"):addClass("sv-scaling-list")
return true
for _, line in ipairs(scalingLines) do
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
end
end
end
if internal and mw.ustring.lower(internal) == pageName then
 
return true
return {
end
inner = tostring(wrap),
return false
classes = extra,
}
end
end


----------------------------------------------------------------------
-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
-- Infobox builder
-- NOTE: Hits does NOT live here (it lives in SkillType).
----------------------------------------------------------------------
function PLUGINS.QuickStats(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
local promo = ctx.promo


local function buildInfobox(rec, opts)
local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
opts = opts or {}
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
local showUsers = (opts.showUsers ~= false)
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}


local root = mw.html.create("table")
local function dash() return "—" end
root:addClass("wikitable spiritvale-skill-infobox")


-- ==========================================================
-- Range (0 => —)
-- Top "hero" row: icon + name (left), description (right)
local rangeVal = nil
-- ==========================================================
if mech.Range ~= nil and not isNoneLike(mech.Range) then
local icon  = rec.Icon
local n = toNum(mech.Range)
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
if n ~= nil then
local desc  = rec.Description or ""
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


local headerRow = root:tag("tr")
-- Area
headerRow:addClass("spiritvale-infobox-main")
local areaVal = formatAreaSize(mech.Area, maxLevel, level)


local leftCell = headerRow:tag("th")
-- Timings
leftCell:addClass("spiritvale-infobox-main-left")
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level)
local cdVal  = displayFromSeries(seriesFromValuePair(bt["Cooldown"],  maxLevel), level)
local durVal  = displayFromSeries(seriesFromValuePair(bt["Duration"],  maxLevel), level)


local leftInner = leftCell:tag("div")
-- Promote status duration if needed
leftInner:addClass("spiritvale-infobox-main-left-inner")
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
end


if icon and icon ~= "" then
-- Cost: MP + HP
leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
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
end


leftInner:tag("div")
local mpS = labeledSeries(rc["Mana Cost"], "MP")
:addClass("spiritvale-infobox-title")
local hpS = labeledSeries(rc["Health Cost"], "HP")
:wikitext(title)


local rightCell = headerRow:tag("td")
local costSeries = {}
rightCell:addClass("spiritvale-infobox-main-right")
for lv = 1, maxLevel do
local mp = mpS and mpS[lv] or "—"
local hp = hpS and hpS[lv] or "—"


local rightInner = rightCell:tag("div")
if mp ~= "—" and hp ~= "—" then
rightInner:addClass("spiritvale-infobox-main-right-inner")
costSeries[lv] = mp .. " + " .. hp
elseif mp ~= "—" then
costSeries[lv] = mp
elseif hp ~= "—" then
costSeries[lv] = hp
else
costSeries[lv] = "—"
end
end


if desc ~= "" then
local costVal = displayFromSeries(costSeries, level)
rightInner:tag("div")
 
:addClass("spiritvale-infobox-description")
local grid = mw.html.create("div")
:wikitext(string.format("''%s''", desc))
grid:addClass("sv-m4-grid")
grid:addClass("sv-compact-root")
 
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 {
inner = tostring(grid),
classes = "module-quick-stats",
}
end
-- PLUGIN: SpecialMechanics (Hero Module Slot 3)
-- Shows:
--  - Flags (deduped)
--  - Special mechanics (mech.Effects)
-- NOTE: Combo lives in SkillType (Hero Bar Slot 2).
function PLUGINS.SpecialMechanics(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
local 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


------------------------------------------------------------------
------------------------------------------------------------------
-- General
-- Hits guard (we want Hits ONLY in SkillType)
------------------------------------------------------------------
------------------------------------------------------------------
addSectionHeader(root, "General")
local function isHitsKey(name)
addRow(root, "Max Level", rec["Max Level"] and tostring(rec["Max Level"]))
if not name then return false end
 
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
-- Hide Users on:
return (
--  - list pages (opts.showUsers=false)
k == "hit" or
--  - the skill's own page (handled by caller)
k == "hits" or
if showUsers then
k == "hit count" or
local users = rec.Users or {}
k == "hits count" or
addRow(root, "Classes",  listToText(users.Classes))
k == "hitcount" or
addRow(root, "Summons",  listToText(users.Summons))
k == "hitscount"
addRow(root, "Monsters", listToText(users.Monsters))
)
addRow(root, "Events",  listToText(users.Events))
end
end


------------------------------------------------------------------
------------------------------------------------------------------
-- Requirements
-- Flags (flat, de-duped)
------------------------------------------------------------------
------------------------------------------------------------------
local req = rec.Requirements or {}
local flagSet = {}
if (req["Required Skills"] and #req["Required Skills"] > 0)
 
or (req["Required Weapons"] and #req["Required Weapons"] > 0)
local denyFlags = {
or (req["Required Stances"] and #req["Required Stances"] > 0) then
["self centered"] = true,
["self-centred"] = true,
["bond"] = true,
["combo"] = true,
        ["hybrid"] = true,
 
-- hits variants
["hit"] = true,
["hits"] = true,
["hit count"] = true,
["hits count"] = true,
["hitcount"] = true,
["hitscount"] = true,
}


addSectionHeader(root, "Requirements")
local function allowFlag(name)
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


if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
local function addFlags(sub)
local skillParts = {}
if type(sub) ~= "table" then return end
for _, rs in ipairs(req["Required Skills"]) do
for k, v in pairs(sub) do
local name  = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
if v and allowFlag(k) then
local level = rs["Required Level"]
flagSet[tostring(k)] = true
if level then
table.insert(skillParts, string.format("%s (Lv.%s)", name, level))
else
table.insert(skillParts, name)
end
end
end
addRow(root, "Required Skills", table.concat(skillParts, ", "))
end
end
end


addRow(root, "Required Weapons", listToText(req["Required Weapons"]))
if mods then
addRow(root, "Required Stances", listToText(req["Required Stances"]))
addFlags(mods["Movement Modifiers"])
addFlags(mods["Combat Modifiers"])
addFlags(mods["Special Modifiers"])
for k, v in pairs(mods) do
if type(v) == "boolean" and v and allowFlag(k) then
flagSet[tostring(k)] = true
end
end
end
end
local flags = {}
for k, _ in pairs(flagSet) do table.insert(flags, k) end
table.sort(flags)


------------------------------------------------------------------
------------------------------------------------------------------
-- Type
-- Special mechanics (name => value)
------------------------------------------------------------------
------------------------------------------------------------------
local typeBlock = rec.Type or {}
local mechItems = {}
if next(typeBlock) ~= nil then
addSectionHeader(root, "Type")


local dt = typeBlock["Damage Type"]
if effects then
if type(dt) == "table" and dt.Name then
local keys = {}
addRow(root, "Damage Type", dt.Name)
for k, _ in pairs(effects) do table.insert(keys, k) end
table.sort(keys)
 
for _, name in ipairs(keys) do
-- 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
 
-- 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
end
end
local hasFlags = (#flags > 0)
local hasMech  = (#mechItems > 0)
if (not hasFlags) and (not hasMech) then
local root = mw.html.create("div")
root:addClass("sv-sm-root")
root:addClass("sv-compact-root")
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics")
return {
inner = tostring(root),
classes = "module-special-mechanics",
}
end
local count = 0
if hasFlags then count = count + 1 end
if hasMech  then count = count + 1 end
local root = mw.html.create("div")
root:addClass("sv-sm-root")
root:addClass("sv-compact-root")
local layout = root:tag("div"):addClass("sv-sm-layout")
layout:addClass("sv-sm-count-" .. tostring(count))


local et = typeBlock["Element Type"]
-- Column 1: Flags
if type(et) == "table" and et.Name then
if hasFlags then
addRow(root, "Element", et.Name)
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


local tt = typeBlock["Target Type"]
-- Column 2: Special Mechanics (stacked)
if type(tt) == "table" and tt.Name then
if hasMech then
addRow(root, "Target", tt.Name)
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


local ct = typeBlock["Cast Type"]
return {
if type(ct) == "table" and ct.Name then
inner = tostring(root),
addRow(root, "Cast Type", ct.Name)
classes = "module-special-mechanics",
}
end
 
-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
function PLUGINS.LevelSelector(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
 
local inner = mw.html.create("div")
inner:addClass("sv-level-ui")
 
inner:tag("div")
:addClass("sv-level-label")
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
 
local slider = inner:tag("div"):addClass("sv-level-slider")
 
if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
slider:tag("input")
: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
 
return {
inner = tostring(inner),
classes = "module-level-selector",
}
end
 
----------------------------------------------------------------------
-- Generic slot renderers
----------------------------------------------------------------------
 
-- normalizeResult: normalize plugin return values into {inner, classes}.
local function normalizeResult(res)
if res == nil then return nil end
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
end
return { inner = inner, classes = res.classes }
end
end
return { inner = tostring(res), classes = nil }
end


------------------------------------------------------------------
-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors.
-- Mechanics
local function safeCallPlugin(name, rec, ctx)
------------------------------------------------------------------
        local fn = PLUGINS[name]
local mech = rec.Mechanics or {}
        if type(fn) ~= "function" then
if next(mech) ~= nil then
                return nil
addSectionHeader(root, "Mechanics")
        end
        local ok, out = pcall(fn, rec, ctx)
        if not ok then
                return nil
        end
        return normalizeResult(out)
end
 
-- isEmptySlotContent: true when a slot has no meaningful content.
-- NOTE: JS placeholders (sv-dyn spans, slider markup) are considered content.
local function isEmptySlotContent(inner)
        if inner == nil then return true end
 
        local raw = tostring(inner)
 
        -- 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 rangeText = formatUnitValue(mech.Range)
local maxLevel = tonumber(rec["Max Level"]) or 1
addRow(root, "Range", rangeText)
if maxLevel < 1 then maxLevel = 1 end
local level = clamp(maxLevel, 1, maxLevel)


local areaText = formatArea(mech.Area)
local ctx = {
addRow(root, "Area", areaText)
maxLevel = maxLevel,
level = level,
nonDamaging = false,
promo = nil,
}


if mech["Autocast Multiplier"] ~= nil then
-- Non-damaging hides Damage/Element/Hits in SkillType
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
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
end
ctx.nonDamaging = isNoneLike(dmgVal) or (not skillHasAnyDamage(rec, maxLevel))
end


local btText = formatTimingBlock(mech["Basic Timings"])
ctx.promo = computeDurationPromotion(rec, maxLevel)
addRow(root, "Timing", btText)


local rcText = formatResourceCost(mech["Resource Cost"])
local root = mw.html.create("table")
addRow(root, "Resource Cost", rcText)
root:addClass("spiritvale-skill-infobox")
root:addClass("sv-skill-card")
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-level", tostring(level))


local comboText = formatCombo(mech.Combo)
if opts.inList then
addRow(root, "Combo", comboText)
root:addClass("sv-skill-inlist")
end


local effText = formatMechanicEffects(mech.Effects)
local internalId = trim(rec["Internal Name"] or rec.InternalID or rec.ID)
addRow(root, "Special Mechanics", effText)
if internalId then
root:attr("data-skill-id", internalId)
end
end


------------------------------------------------------------------
-- Standardized slot grid
-- Damage & Scaling
addHeroSlotsRow(root, buildHeroSlotsUI(rec, ctx))
------------------------------------------------------------------
 
local dmg = rec.Damage or {}
-- Users (hide on direct skill page)
if next(dmg) ~= nil then
        if showUsers then
addSectionHeader(root, "Damage and Scaling")
                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


local maxLevel = tonumber(rec["Max Level"]) or 0
        -- 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


-- Split healing out of Main Damage (Type == "Healing")
-- Legacy damage breakdown (only when Source absent)
local main = dmg["Main Damage"]
if type(rec.Source) ~= "table" then
local mainNonHeal = {}
local dmg = rec.Damage or {}
local healOnly = {}
if next(dmg) ~= nil then
local main = dmg["Main Damage"]
local mainNonHeal, healOnly = {}, {}


if type(main) == "table" then
if type(main) == "table" then
for _, d in ipairs(main) do
for _, d in ipairs(main) do
if type(d) == "table" and d.Type == "Healing" then
if type(d) == "table" and d.Type == "Healing" then
table.insert(healOnly, d)
table.insert(healOnly, d)
else
else
table.insert(mainNonHeal, d)
table.insert(mainNonHeal, d)
end
end
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
end


local mainText = formatDamageList(mainNonHeal, maxLevel, (#mainNonHeal > 1))
-- Status rows
addRow(root, "Main Damage", mainText)
local function formatStatusApplications(list, suppressDurationIndex)
if type(list) ~= "table" or #list == 0 then return nil end


local flatText = formatDamageList(dmg["Flat Damage"], maxLevel, false)
local parts = {}
addRow(root, "Flat Damage", flatText)
for idx, s in ipairs(list) do
if type(s) == "table" then
local typ  = s.Type or s.Scope or "Target"
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"
local seg = tostring(typ) .. " – " .. tostring(name)
local detail = {}


local reflText = formatDamageList(dmg["Reflect Damage"], maxLevel, false)
if idx ~= suppressDurationIndex and type(s.Duration) == "table" then
addRow(root, "Reflect Damage", reflText)
local t = valuePairDynamicValueOnly(s.Duration, maxLevel, level)
if t then table.insert(detail, "Duration: " .. t) end
end


local healText = formatDamageList(healOnly, maxLevel, false)
if type(s.Chance) == "table" then
addRow(root, "Healing", healText)
local t = valuePairDynamicValueOnly(s.Chance, maxLevel, level)
if t then table.insert(detail, "Chance: " .. t) end
end


local scaleText = formatScaling(dmg.Scaling)
if #detail > 0 then
addRow(root, "Scaling", scaleText)
seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
end
 
table.insert(parts, seg)
end
end
 
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
end


------------------------------------------------------------------
local function formatStatusRemoval(list)
-- Modifiers
if type(list) ~= "table" or #list == 0 then return nil end
------------------------------------------------------------------
 
local modsText = formatModifiers(rec.Modifiers)
local parts = {}
if modsText then
for _, r in ipairs(list) do
addSectionHeader(root, "Modifiers")
if type(r) == "table" then
addRow(root, "Flags", modsText)
local names = r["Status External Name"]
local label
 
if type(names) == "table" then
label = table.concat(names, ", ")
elseif type(names) == "string" then
label = names
else
label = "Status"
end
 
local amt = valuePairRawText(r)
amt = amt and mw.text.nowiki(amt) or nil
 
local seg = mw.text.nowiki(label)
if amt then
seg = seg .. " – " .. amt
end
table.insert(parts, seg)
end
end
 
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
end


------------------------------------------------------------------
local suppressIdx = (type(ctx.promo) == "table") and ctx.promo.suppressDurationIndex or nil
-- Status
local statusApps = formatStatusApplications(rec["Status Applications"], suppressIdx)
------------------------------------------------------------------
local statusApps = formatStatusApplications(rec["Status Applications"])
local statusRem  = formatStatusRemoval(rec["Status Removal"])
local statusRem  = formatStatusRemoval(rec["Status Removal"])
if statusApps or statusRem then
if statusApps or statusRem then
addSectionHeader(root, "Status Effects")
addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications")
addRow(root, "Applies", statusApps)
addRow(root, "Removes", statusRem,  "sv-row-status", "Status Removal")
addRow(root, "Removes", statusRem)
end
end


------------------------------------------------------------------
        -- Events
-- Events
        local function formatEvents(list)
------------------------------------------------------------------
                if type(list) ~= "table" or #list == 0 then return nil end
                local parts = {}
                for _, ev in ipairs(list) do
                        if type(ev) == "table" then
                                local action = resolveDisplayName(ev.Action, "event") or ev.Action or "On event"
                                local name  = resolveSkillNameFromEvent(ev)
                                table.insert(parts, string.format("%s → %s", mw.text.nowiki(action), mw.text.nowiki(name)))
                        end
                end
                return (#parts > 0) and table.concat(parts, "<br />") or nil
        end
 
local eventsText = formatEvents(rec.Events)
local eventsText = formatEvents(rec.Events)
if eventsText then
if eventsText then
addSectionHeader(root, "Events")
addRow(root, "Triggers", eventsText, "sv-row-meta", "Events")
addRow(root, "Triggers", eventsText)
end
 
------------------------------------------------------------------
-- Notes
------------------------------------------------------------------
if type(rec.Notes) == "table" and #rec.Notes > 0 then
addSectionHeader(root, "Notes")
addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
end
end


return tostring(root)
return tostring(root)
end
end


Line 936: Line 2,103:
local args = getArgs(frame)
local args = getArgs(frame)


-- Prefer explicit param, then unnamed, then fall back to the current page name.
local userName = args.user or args[1]
local userName = args.user or args[1]
if not userName or userName == "" then
if not userName or userName == "" then
Line 956: Line 2,122:


if #matches == 0 then
if #matches == 0 then
return string.format(
return string.format("<strong>No skills found for:</strong> %s", mw.text.nowiki(userName))
"<strong>No skills found for:</strong> %s",
mw.text.nowiki(userName)
)
end
end


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


-- IMPORTANT: On class pages / list mode, hide Users (redundant on that page).
for _, rec in ipairs(matches) do
for _, rec in ipairs(matches) do
root:wikitext(buildInfobox(rec, { showUsers = false }))
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
 
-- 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


Line 980: Line 2,147:
local args = getArgs(frame)
local args = getArgs(frame)


-- Allow three styles:
--  {{Skill|Bash}}              -> args[1] = "Bash"  (External Name)
--  {{Skill|name=Bash}}        -> args.name = "Bash"
--  {{Skill|id=Bash_Internal}}  -> args.id = "Bash_Internal"
local raw1 = args[1]
local raw1 = args[1]
local name = args.name or raw1
local name = args.name or raw1
Line 989: Line 2,152:


local rec
local rec
-- 1) Prefer External/Display Name
if name and name ~= "" then
if name and name ~= "" then
rec = findSkillByName(name)
rec = findSkillByName(name)
end
end
-- 2) Fallback: internal ID
if not rec and id and id ~= "" then
if not rec and id and id ~= "" then
rec = getSkillById(id)
rec = getSkillById(id)
end
end


-- 3) If still nothing, decide if this is "list mode" or truly unknown.
if not rec then
if not rec then
local pageTitle = mw.title.getCurrentTitle()
local pageTitle = mw.title.getCurrentTitle()
Line 1,010: Line 2,168:
(not id or id == "")
(not id or id == "")


-- Case A: {{Skill}} with no parameters on a page → list for that page name.
if noExplicitArgs then
if noExplicitArgs then
return p.listForUser(frame)
return p.listForUser(frame)
end
end


-- Case B: {{Skill|Acolyte}} on the "Acolyte" page and no id → treat as list.
if name and name ~= "" and name == pageName and (not id or id == "") then
if name and name ~= "" and name == pageName and (not id or id == "") then
return p.listForUser(frame)
return p.listForUser(frame)
end
end


-- Otherwise, genuinely unknown skill.
local label = name or id or "?"
local label = name or id or "?"
return string.format(
return string.format(
Line 1,029: Line 2,184:
end
end


-- For single-skill rendering:
-- - hide Users if this is the skill's own page
-- - otherwise show Users
local showUsers = not isDirectSkillPage(rec)
local showUsers = not isDirectSkillPage(rec)
return buildInfobox(rec, { showUsers = showUsers })
return buildInfobox(rec, { showUsers = showUsers })
Retrieved from "https://spiritvale.info/wiki/Module:GameSkills"