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
 
(36 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:GameSkills
-- Module:GameSkills
--
--
-- Renders active skill data (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 (page name).
--
--
-- Standard Hero Layout (reused across the wiki):
-- Layout:
--  1) hero-title-bar        (icon + name)
--  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)
--        - Slot 1: module-level-selector
--   Row 4: Slot 7 + Slot 8 (SpecialMechanics + LevelSelector)
--        - Slot 2: module-skill-type
--        - Slot 3: skill-source-module (Basis + Source + Scaling) OR blank
--       - Slot 4: empty (reserved)
--
--
-- Requires Common.js logic that updates:
-- Requires Common.js:
--  - .sv-dyn spans via data-series
--  - updates .sv-dyn spans via data-series
--  - .sv-level-num + data-level on .sv-skill-card
--  - updates .sv-level-num + data-level on .sv-skill-card
--  - binds to input.sv-level-range inside each card
--  - binds to input.sv-level-range inside each card


Line 27: Line 23:


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
 
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 39: Line 49:
----------------------------------------------------------------------
----------------------------------------------------------------------


-- getArgs: read args from parent frame when invoked from a template.
local function getArgs(frame)
local function getArgs(frame)
local parent = frame:getParent()
local parent = frame:getParent()
Line 44: Line 55:
end
end


-- trim: normalize strings (nil if empty).
local function trim(s)
local function trim(s)
if type(s) ~= "string" then
if type(s) ~= "string" then
Line 52: Line 64:
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
if type(v) == "number" then
Line 65: Line 78:
end
end


-- clamp: clamp a number into [lo, hi].
local function clamp(n, lo, hi)
local function clamp(n, lo, hi)
if type(n) ~= "number" then
if type(n) ~= "number" then
Line 74: Line 88:
end
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
Line 89: Line 104:
end
end


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


-- Add a labeled infobox row (with optional hooks for future)
-- addRow: add a standard <tr><th>Label</th><td>Value</td></tr> row.
local function addRow(tbl, label, value, rowClass, dataKey)
local function addRow(tbl, label, value, rowClass, dataKey)
if value == nil or value == "" then
if value == nil or value == "" then
Line 104: Line 215:
local row = tbl:tag("tr")
local row = tbl:tag("tr")
row:addClass("sv-row")
row:addClass("sv-row")
if rowClass then
if rowClass then row:addClass(rowClass) end
row:addClass(rowClass)
if dataKey then row:attr("data-field", dataKey) end
end
if dataKey then
row:attr("data-field", dataKey)
end


row:tag("th"):wikitext(label):done()
row:tag("th"):wikitext(label):done()
Line 115: Line 222:
end
end


-- Handles either a scalar OR { Value = ..., Unit = ... }
-- formatUnitValue: format {Value, Unit} blocks (or scalar) for display.
-- IMPORTANT: wikiprep often converts unit-wrapped pairs into strings already.
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
Line 144: Line 250:
----------------------------------------------------------------------
----------------------------------------------------------------------


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


-- isFlatList: true if all values in list are identical.
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 172: 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
if v == nil then return false end
return false
if type(v) == "number" then return v ~= 0 end
end
if type(v) == "number" then
return v ~= 0
end
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 192: Line 295:
end
end


-- Base/Per Level renderer:
-- isZeroish: aggressively treat common “zero” text forms as zero.
-- - Per Level list -> dynamic span (or single value if flat)
local function isZeroish(v)
-- - Per Level scalar -> "Base" + "Per Level" lines
if v == nil then return true end
local function valuePairDynamicLines(name, block, maxLevel, level)
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 203: Line 323:
local per  = block["Per Level"]
local per  = block["Per Level"]


-- Per Level list (expanded by wikiprep)
if type(per) == "table" then
if type(per) == "table" then
if #per == 0 then
if #per == 0 then
local baseText = formatUnitValue(base)
return formatUnitValue(base)
return baseText and { string.format("%s: %s", name, mw.text.nowiki(baseText)) } or {}
end
end
if isFlatList(per) then
if isFlatList(per) then
local baseText = formatUnitValue(base)
return formatUnitValue(base) or tostring(per[1])
local one = formatUnitValue(per[1]) or tostring(per[1])
local show = baseText or one
return show and { string.format("%s: %s", name, mw.text.nowiki(show)) } or {}
end
end


local series = {}
local vals = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
table.insert(vals, formatUnitValue(v) or tostring(v))
end
end
 
return (#vals > 0) and table.concat(vals, " / ") or nil
local dyn = dynSpan(series, level)
return dyn and { string.format("%s: %s", name, dyn) } or {}
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, mw.text.nowiki(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, mw.text.nowiki(perText)))
end
end


return lines
return baseText or perText
end
end


local function valuePairDynamicText(name, block, maxLevel, level, sep)
-- valuePairDynamicValueOnly: render Base/Per Level blocks using dyn spans where possible.
local lines = valuePairDynamicLines(name, block, maxLevel, level)
local function valuePairDynamicValueOnly(block, maxLevel, level)
return (#lines > 0) and table.concat(lines, sep or "<br />") or nil
end
 
local function valuePairRawText(block)
if type(block) ~= "table" then
if type(block) ~= "table" then
return nil
return nil
Line 256: 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
 
if baseText and perText and isNonZeroScalar(per) then
return string.format("%s (Per Level: %s)", baseText, perText)
end
 
return baseText or perText
end
end


Line 283: Line 384:
----------------------------------------------------------------------
----------------------------------------------------------------------


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


-- findSkillByName: locate a skill by external/display name.
local function findSkillByName(name)
local function findSkillByName(name)
name = trim(name)
name = trim(name)
if not name then
if not name then return nil end
return nil
end


local dataset = getSkills()
local dataset = getSkills()
Line 317: Line 416:


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Formatting helpers
-- Legacy damage helpers
----------------------------------------------------------------------
----------------------------------------------------------------------


-- basisLabel: label ATK/MATK basis in legacy damage blocks.
local function basisLabel(entry, isHealing)
local function basisLabel(entry, isHealing)
if isHealing then
if isHealing then
Line 339: Line 439:
end
end


local function valuePairDynamicValueOnly(block, maxLevel, level)
-- formatDamageEntry: legacy percent damage formatting (dynamic by level).
if type(block) ~= "table" then
return nil
end
 
local base = block.Base
local per  = block["Per Level"]
 
if type(per) == "table" then
if #per == 0 then
local baseText = formatUnitValue(base)
return baseText and mw.text.nowiki(baseText) or nil
end
 
if isFlatList(per) then
local one  = formatUnitValue(per[1]) or tostring(per[1])
local show = formatUnitValue(base) or one
return show and mw.text.nowiki(show) or nil
end
 
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
 
local txt = valuePairRawText(block)
return txt and mw.text.nowiki(txt) or nil
end
 
-- Source (new unified Damage/Flat/Reflect/Healing) formatter (for infobox rows)
local function formatSource(src, maxLevel, level)
if type(src) ~= "table" then
return nil
end
 
local kind = src.Type or "Damage"
local isHealing = (kind == "Healing") or (src.Healing == true)
 
local basis = basisLabel(src, isHealing)
if basis and mw.ustring.lower(tostring(basis)) == mw.ustring.lower(tostring(kind)) then
basis = nil
end
 
local val = valuePairDynamicValueOnly(src, maxLevel, level)
if not val then
return nil
end
 
local out = mw.text.nowiki(tostring(kind)) .. ": " .. val
if basis then
out = out .. " " .. mw.text.nowiki(tostring(basis))
end
 
return out
end
 
-- BACKCOMPAT: old damage list formatter (for infobox rows)
local function formatDamageEntry(entry, maxLevel, level)
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
if type(entry) ~= "table" then
Line 449: Line 491:
end
end


-- formatDamageList: render a list of legacy damage entries into <br/> blocks.
local function formatDamageList(list, maxLevel, level, includeTypePrefix)
local function formatDamageList(list, maxLevel, level, includeTypePrefix)
if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
Line 471: Line 514:
end
end


-- Scaling supports either a single dict or a list (for infobox rows)
----------------------------------------------------------------------
local function formatScaling(scaling, basisOverride)
-- 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
 
return tostring(box)
end
 
----------------------------------------------------------------------
-- Shared helpers (Source + QuickStats + SpecialMechanics)
----------------------------------------------------------------------
 
-- formatScalingCompactLines: build compact “Scaling” lines for SourceType.
local function formatScalingCompactLines(scaling)
if type(scaling) ~= "table" then
if type(scaling) ~= "table" then
return nil
return {}
end
end


Line 482: Line 638:
list = { scaling }
list = { scaling }
else
else
return nil
return {}
end
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 492: Line 648:
local pct  = s.Percent
local pct  = s.Percent
local pctN = toNum(pct)
local pctN = toNum(pct)
local basis = basisOverride or basisLabel(s, false)


if pctN ~= nil and pctN ~= 0 then
if pctN ~= nil and pctN ~= 0 then
table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
table.insert(out, string.format("%s%% %s", fmtNum(pctN), 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


return (#parts > 0) and table.concat(parts, "<br />") or nil
return out
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
return nil
end
end


local function formatArea(area, maxLevel, level)
-- legacyPercentAtLevel: compute “Base% + PerLevel%*level” for legacy entries.
if type(area) ~= "table" then
local function legacyPercentAtLevel(entry, level)
if type(entry) ~= "table" then
return nil
return nil
end
end


local parts = {}
local baseRaw = entry["Base %"]
local perRaw  = entry["Per Level %"]
local baseN  = toNum(baseRaw)
local perN    = toNum(perRaw)


local distLine = valuePairDynamicText("Distance", area["Area Distance"], maxLevel, level, "<br />")
if perN ~= nil and perN ~= 0 then
if distLine then
local total = (baseN or 0) + (perN * level)
table.insert(parts, distLine)
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: " .. mw.text.nowiki(tostring(size)))
end
if baseRaw ~= nil and tostring(baseRaw) ~= "" then
return tostring(baseRaw) .. "%"
end
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
return nil
end
end


local function formatTimingBlock(bt, maxLevel, level)
-- seriesFromValuePair: normalize Base/Per Level blocks into a level-indexed series.
if type(bt) ~= "table" then
local function seriesFromValuePair(block, maxLevel)
if type(block) ~= "table" then
return nil
return nil
end
end


local parts = {}
local base = block.Base
local per  = block["Per Level"]


local function add(label, key)
local function pickUnit(v)
local block = bt[key]
if type(v) == "table" and v.Unit and v.Unit ~= "" then
if type(block) ~= "table" then
return v.Unit
return
end
local lines = valuePairDynamicLines(label, block, maxLevel, level)
for _, line in ipairs(lines) do
table.insert(parts, line)
end
end
return nil
end
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
end


add("Cast Time", "Cast Time")
local series = {}
add("Cooldown",  "Cooldown")
add("Duration",  "Duration")


if bt["Effect Cast Time"] ~= nil then
-- Expanded per-level series (wikiprep)
table.insert(parts, "Effect Cast Time: " .. mw.text.nowiki(tostring(bt["Effect Cast Time"])))
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
end
if bt["Damage Delay"] ~= nil then
 
table.insert(parts, "Damage Delay: " .. mw.text.nowiki(tostring(bt["Damage Delay"])))
-- Empty per-list -> base only
if type(per) == "table" and #per == 0 then
local one = fmtAny(base)
if one == nil or isZeroish(base) or isZeroish(one) then
one = "—"
end
for lv = 1, maxLevel do
series[lv] = one
end
return series
end
end
if bt["Effect Remove Delay"] ~= nil then
 
table.insert(parts, "Effect Remove Delay: " .. mw.text.nowiki(tostring(bt["Effect Remove Delay"])))
-- Scalar per -> compute base + per*level (fallback)
local baseN = toNum(base) or 0
local perN  = toNum(per)
 
if perN ~= nil then
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
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
-- Base-only scalar
end
local raw = (base ~= nil) and base or per
 
local one = fmtAny(raw)
local function formatResourceCost(rc, maxLevel, level)
if one == nil then
if type(rc) ~= "table" then
return nil
return nil
end
end
 
if isZeroish(raw) or isZeroish(one) then
local parts = {}
one = "—"
 
local manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
for _, line in ipairs(manaLines) do
table.insert(parts, line)
end
end
 
for lv = 1, maxLevel do
local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
series[lv] = one
for _, line in ipairs(hpLines) do
table.insert(parts, line)
end
end
 
return series
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
end


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


local parts = {}
local any = false
 
for _, v in ipairs(series) do
if combo.Type then
if v ~= "—" then
table.insert(parts, "Type: " .. mw.text.nowiki(tostring(combo.Type)))
any = true
break
end
end
end
 
if not any then
local durText = formatUnitValue(combo.Duration)
return nil
if durText then
table.insert(parts, "Duration: " .. mw.text.nowiki(durText))
end
end


if combo.Percent ~= nil then
if isFlatList(series) then
local pctText = formatUnitValue(combo.Percent)
return mw.text.nowiki(series[1])
if pctText then
table.insert(parts, "Bonus: " .. mw.text.nowiki(pctText))
end
end
end
 
return dynSpan(series, level)
return (#parts > 0) and table.concat(parts, ", ") or nil
end
end


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


local keys = {}
-- Helper: pull a number from scalar/unit/valuepair-ish things.
for k, _ in pairs(effects) do
local function extractNumber(v)
table.insert(keys, k)
if v == nil then return nil end
end
table.sort(keys)


local parts = {}
-- Unit block {Value, Unit}
if type(v) == "table" and v.Value ~= nil then
local n = toNum(v.Value)
return n
end


local function effectAmount(block)
-- ValuePair {Base, Per Level} -> prefer Base at current level if series exists
if type(block) ~= "table" then
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
return nil
end
end


local per = block["Per Level"]
-- Plain scalar
if type(per) == "table" and #per > 0 then
if type(v) == "number" then return v end
if isFlatList(per) then
if type(v) == "string" then
return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
local num = tonumber((mw.ustring.gsub(mw.text.trim(v), "[^0-9%.%-]", "")))
end
return num
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
end


local txt = valuePairRawText(block)
return nil
return txt and mw.text.nowiki(txt) or nil
end
end


for _, name in ipairs(keys) do
-- 1) Read Area Size label/name
local block = effects[name]
local rawSize = area["Area Size"]
if type(block) == "table" then
if rawSize == nil then
local t = block.Type
return nil
end


if t ~= nil and tostring(t) ~= "" then
local sizeName = nil
local amt = effectAmount(block)
if type(rawSize) == "table" then
local seg = mw.text.nowiki(tostring(t) .. " - " .. tostring(name))
sizeName = rawSize.Name or rawSize.ID or rawSize.Value
if amt then
elseif type(rawSize) == "string" then
seg = seg .. " + " .. amt
sizeName = rawSize
end
elseif type(rawSize) == "number" then
table.insert(parts, seg)
-- uncommon; treat as numeric-only label
else
sizeName = tostring(rawSize)
local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
if txt then
table.insert(parts, txt)
end
end
end
end
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
sizeName = sizeName and mw.text.trim(tostring(sizeName)) or nil
end
if not sizeName or sizeName == "" or isNoneLike(sizeName) then
 
local function formatModifiers(mods)
if type(mods) ~= "table" then
return nil
return nil
end
end


local parts = {}
-- 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 function collect(label, sub)
local dist = area["Area Distance"]
if type(sub) ~= "table" then
if type(dist) == "table" then
return
-- 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


local flags = {}
if not num or num == 0 then
for k, v in pairs(sub) do
num =
if v then
extractNumber(area["Area Value"]) or
table.insert(flags, k)
extractNumber(area["Area Size Value"]) or
end
extractNumber(area["Area Number"]) or
end
extractNumber(area["Area Radius"])
table.sort(flags)
end


if #flags > 0 then
-- 3) Render
table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
-- If size already contains parentheses, assume it already includes the numeric.
end
if mw.ustring.find(sizeName, "%(") then
return mw.text.nowiki(sizeName)
end
end


collect("Movement", mods["Movement Modifiers"])
if num and num ~= 0 then
collect("Combat",  mods["Combat Modifiers"])
return mw.text.nowiki(string.format("%s (%s)", sizeName, fmtNum(num)))
collect("Special",  mods["Special Modifiers"])
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
return mw.text.nowiki(sizeName)
end
end


local function formatStatusApplications(list, maxLevel, level)
-- skillHasAnyDamage: determine if a skill has any meaningful damage (for non-damaging rules).
if type(list) ~= "table" or #list == 0 then
local function skillHasAnyDamage(rec, maxLevel)
return nil
if type(rec.Source) == "table" then
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


local parts = {}
if type(rec.Damage) == "table" then
for _, s in ipairs(list) do
local dmg = rec.Damage
if type(s) == "table" then
for _, key in ipairs({ "Main Damage", "Flat Damage", "Reflect Damage" }) do
local typ  = s.Type or s.Scope or "Target"
local lst = dmg[key]
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"
if type(lst) == "table" and #lst > 0 then
 
return true
local seg = tostring(typ) .. " – " .. tostring(name)
local detail = {}
 
if type(s.Duration) == "table" then
local t = valuePairDynamicText("Duration", s.Duration, maxLevel, level, "; ")
if t then table.insert(detail, t) end
end
 
if type(s.Chance) == "table" then
local t = valuePairDynamicText("Chance", s.Chance, maxLevel, level, "; ")
if t then table.insert(detail, t) end
end
 
if #detail > 0 then
seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
end
end
table.insert(parts, seg)
end
end
end
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
return false
end
end


local function formatStatusRemoval(list, maxLevel, level)
-- computeDurationPromotion: promote status-duration into QuickStats when a skill is non-damaging.
if type(list) ~= "table" or #list == 0 then
local function computeDurationPromotion(rec, maxLevel)
return nil
if type(rec) ~= "table" then return nil end
end
if skillHasAnyDamage(rec, maxLevel) then return nil end


local parts = {}
local mech = (type(rec.Mechanics) == "table") and rec.Mechanics or {}
for _, r in ipairs(list) do
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
if type(r) == "table" then
local durS = seriesFromValuePair(bt["Duration"], maxLevel)
local names = r["Status External Name"]
local label


if type(names) == "table" then
if durS ~= nil then
label = table.concat(names, ", ")
local any = false
elseif type(names) == "string" then
for _, v in ipairs(durS) do
label = names
if v ~= "—" then any = true break end
else
end
label = "Status"
if any then
end
return nil
 
local amt
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
local series = {}
for _, v in ipairs(r["Per Level"]) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
amt = dynSpan(series, level)
else
amt = valuePairRawText(r)
amt = amt and mw.text.nowiki(amt) or nil
end
 
local seg = mw.text.nowiki(label)
if amt then
seg = seg .. " – " .. amt
end
table.insert(parts, seg)
end
end
end
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
local apps = rec["Status Applications"]
end
if type(apps) ~= "table" then return nil end


local function formatEvents(list)
for idx, app in ipairs(apps) do
if type(list) ~= "table" or #list == 0 then
if type(app) == "table" and type(app.Duration) == "table" then
return nil
local s = seriesFromValuePair(app.Duration, maxLevel)
end
if s then
 
for _, v in ipairs(s) do
local parts = {}
if v ~= "—" then
for _, ev in ipairs(list) do
return {
if type(ev) == "table" then
durationBlock = app.Duration,
local action = ev.Action or "On event"
suppressDurationIndex = idx,
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
end
end
end
end


return (#parts > 0) and table.concat(parts, "<br />") or nil
return nil
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- User matching (for auto lists on class pages)
-- Plug-ins
----------------------------------------------------------------------
----------------------------------------------------------------------


local function skillMatchesUser(rec, userName)
local PLUGINS = {}
if type(rec) ~= "table" or not userName or userName == "" then
 
return false
-- PLUGIN: IconName (Hero Bar Slot 1) - icon + name.
end
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 users = rec.Users
local notesList = {}
if type(users) ~= "table" then
if type(rec.Notes) == "table" then
return false
for _, note in ipairs(rec.Notes) do
local n = trim(note)
if n then
table.insert(notesList, mw.text.nowiki(n))
end
end
elseif type(rec.Notes) == "string" then
local n = trim(rec.Notes)
if n then
notesList = { mw.text.nowiki(n) }
end
end
end


local userLower = mw.ustring.lower(userName)
local req = rec.Requirements or {}
local reqSkillsRaw = (type(req["Required Skills"]) == "table") and req["Required Skills"] or {}
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 function listHas(list)
local reqSkills = {}
if type(list) ~= "table" then
for _, rs in ipairs(reqSkillsRaw) do
return false
if type(rs) == "table" then
end
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
for _, v in ipairs(list) do
local lvlReq  = rs["Required Level"]
if type(v) == "string" and mw.ustring.lower(v) == userLower then
if lvlReq then
return true
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
end
return false
end
end


return listHas(users.Classes) or listHas(users.Summons) or listHas(users.Monsters) or listHas(users.Events)
local reqWeapons = {}
end
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)
-- Direct page detection (hide Users on the skill's own page)
local hasReq = (#reqSkills > 0) or (#reqWeapons > 0) or (#reqStances > 0)
----------------------------------------------------------------------


local function isDirectSkillPage(rec)
if type(rec) ~= "table" then
return false
end


local pageTitle = mw.title.getCurrentTitle()
local wrap = mw.html.create("div")
local pageName  = pageTitle and pageTitle.text or ""
wrap:addClass("sv-herobar-1-wrap")
pageName = trim(pageName)
wrap:addClass("sv-tip-scope")
if not pageName then
return false
end


pageName = mw.ustring.lower(pageName)
local iconBox = wrap:tag("div")
iconBox:addClass("sv-herobar-icon")


local ext = trim(rec["External Name"] or rec.Name or rec["Display Name"])
if icon and icon ~= "" then
local internal = trim(rec["Internal Name"] or rec.InternalName or rec.InternalID)
iconBox:wikitext(string.format("[[File:%s|80px|link=]]", icon))
end


return (ext and mw.ustring.lower(ext) == pageName) or (internal and mw.ustring.lower(internal) == pageName) or false
local textBox = wrap:tag("div")
end
textBox:addClass("sv-herobar-text")


----------------------------------------------------------------------
local titleRow = textBox:tag("div")
-- Hero modules (4-slot scaffold)
titleRow:addClass("sv-herobar-title-row")
----------------------------------------------------------------------


local function moduleBox(slot, extraClasses, innerHtml, isEmpty)
local titleBox = titleRow:tag("div")
local box = mw.html.create("div")
titleBox:addClass("spiritvale-infobox-title")
box:addClass("hero-module")
titleBox:wikitext(title)
box:addClass("hero-module-" .. tostring(slot))
box:attr("data-hero-module", tostring(slot))


if extraClasses then
if hasNotes then
if type(extraClasses) == "string" then
local notesBtn = mw.html.create("span")
box:addClass(extraClasses)
notesBtn:addClass("sv-tip-btn sv-tip-btn--notes")
elseif type(extraClasses) == "table" then
notesBtn:attr("role", "button")
for _, c in ipairs(extraClasses) do
notesBtn:attr("tabindex", "0")
box:addClass(c)
notesBtn:attr("data-sv-tip", "notes")
end
notesBtn:attr("aria-label", "Notes")
end
notesBtn:attr("aria-expanded", "false")
notesBtn:tag("span"):addClass("sv-ico sv-ico--info"):attr("aria-hidden", "true"):wikitext("i")
titleRow:node(notesBtn)
end
end


if isEmpty then
if hasReq then
box:addClass("hero-module-empty")
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
end


local body = box:tag("div"):addClass("hero-module-body")
if hasNotes then
if innerHtml and innerHtml ~= "" then
local notesContent = wrap:tag("div")
body:wikitext(innerHtml)
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
end


return tostring(box)
if hasReq then
end
local reqContent = wrap:tag("div")
reqContent:addClass("sv-tip-content")
reqContent:attr("data-sv-tip-content", "req")


-- Helper: render an intentionally-empty hero module slot (keeps the 2x2 grid stable)
if #reqSkills > 0 then
local function buildEmptyModule(slot)
local section = reqContent:tag("div")
return moduleBox(slot, nil, "", true)
section:addClass("sv-tip-section")
end
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Skills")
section:tag("div"):wikitext(table.concat(reqSkills, "<br />"))
end


-- ------------------------------------------------------------
if #reqWeapons > 0 then
-- Module 1 – Level Selector
local section = reqContent:tag("div")
-- FIX: If maxLevel == 1, do NOT emit a range input (prevents JS edge-cases)
section:addClass("sv-tip-section")
-- ------------------------------------------------------------
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Weapons")
local function buildModuleLevelSelector(level, maxLevel)
section:tag("div"):wikitext(table.concat(reqWeapons, ", "))
local inner = mw.html.create("div")
end
inner:addClass("sv-level-ui")


inner:tag("div")
if #reqStances > 0 then
:addClass("sv-level-title")
local section = reqContent:tag("div")
:wikitext("Level Select")
section:addClass("sv-tip-section")
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Stances")
section:tag("div"):wikitext(table.concat(reqStances, ", "))
end
end


inner:tag("div")
return {
:addClass("sv-level-label")
inner = tostring(wrap),
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
classes = "module-icon-name",
 
}
local slider = inner:tag("div"):addClass("sv-level-slider")
end


if tonumber(maxLevel) and tonumber(maxLevel) > 1 then
-- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile).
slider:tag("input")
-- Rules:
:attr("type", "range")
--  - If skill is non-damaging, hide Damage/Element/Hits.
:attr("min", "1")
--  - If Hits is empty, hide Hits.
:attr("max", tostring(maxLevel))
--  - If Combo is empty, hide Combo.
:attr("value", tostring(level))
-- Ordering:
:addClass("sv-level-range")
--  - Desktop: Damage, Element, Hits, Target, Cast, Combo
:attr("aria-label", "Skill level select")
--  - Mobile: Damage, Element, Target, Cast, Hits, Combo (CSS reorder)
else
function PLUGINS.SkillType(rec, ctx)
-- single-level skills: keep layout but no <input>
local typeBlock = (type(rec.Type) == "table") and rec.Type or {}
inner:addClass("sv-level-ui-single")
local mech      = (type(rec.Mechanics) == "table") and rec.Mechanics or {}
slider:addClass("sv-level-slider-single")
end


return moduleBox(1, "module-level-selector", tostring(inner), false)
local level    = ctx.level or 1
end
local maxLevel = ctx.maxLevel or 1


-- ------------------------------------------------------------
local hideDamageBundle = (ctx.nonDamaging == true)
-- Module 2 – Skill Type
-- ------------------------------------------------------------
local function buildModuleSkillType(typeBlock)
typeBlock = (type(typeBlock) == "table") and typeBlock or {}


-- 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)
local function valName(x)
if x == nil then
if x == nil then return nil end
return nil
end
if type(x) == "table" then
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
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.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
end
if type(x) == "string" and x ~= "" then
if type(x) == "string" and x ~= "" then
Line 938: Line 1,147:
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()
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"]


local added = false
if h == nil or isNoneLike(h) then
local function addChunk(label, rawVal)
return nil
local v = valName(rawVal)
if not v or v == "" then
return
end
end
added = true


local chunk = grid:tag("div"):addClass("sv-type-chunk")
-- ValuePair-style table (Base/Per Level) => dynamic series
chunk:tag("div"):addClass("sv-type-label"):wikitext(mw.text.nowiki(label))
if type(h) == "table" then
chunk:tag("div"):addClass("sv-type-value"):wikitext(mw.text.nowiki(v))
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then
end
return displayFromSeries(seriesFromValuePair(h, maxLevel), level)
end
 
-- Unit block {Value, Unit}
if h.Value ~= nil then
local t = formatUnitValue(h)
return t and mw.text.nowiki(t) or nil
end


addChunk("Damage",  typeBlock.Damage  or typeBlock["Damage Type"])
-- Fallback name extraction
addChunk("Element", typeBlock.Element or typeBlock["Element Type"])
local function valName(x)
addChunk("Target",  typeBlock.Target  or typeBlock["Target Type"])
if x == nil then return nil end
addChunk("Cast",    typeBlock.Cast    or typeBlock["Cast Type"])
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


local body = added and tostring(grid) or ""
local vn = valName(h)
return moduleBox(2, "module-skill-type", body, false)
if vn and not isNoneLike(vn) then
end
return mw.text.nowiki(vn)
end
end


-- ============================================================
-- Scalar number/string
-- Module 3 – Skill Source (Modifier + Source + Scaling)
if type(h) == "number" then
-- - Modifier column (optional): "Modifier" pill + Attack/Magic Attack/Hybrid
return mw.text.nowiki(fmtNum(h))
-- - Source column: Kind pill + big % value
end
-- - Scaling column: "Scaling" pill + compact lines
if type(h) == "string" then
--
local t = trim(h)
-- RULE: If BOTH Source and Scaling are missing -> return nil (slot stays blank)
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil
-- - Supports BOTH new (rec.Source) and legacy (rec.Damage) formats.
end
-- ============================================================


local function formatScalingCompactLines(scaling)
return nil
if type(scaling) ~= "table" then
return {}
end
end


local list = scaling
-- comboDisplay: render Combo as a compact text block (Type (+ details)).
if #list == 0 then
local function comboDisplay()
if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then
local c = (type(mech.Combo) == "table") and mech.Combo or nil
list = { scaling }
if not c then return nil end
else
 
return {}
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
end
end


local out = {}
local dur = formatUnitValue(c.Duration)
for _, s in ipairs(list) do
if dur and not isZeroish(dur) then
if type(s) == "table" then
table.insert(details, mw.text.nowiki(dur))
local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
end
local pct  = s.Percent
local pctN = toNum(pct)


if pctN ~= nil and pctN ~= 0 then
if #details > 0 then
table.insert(out, string.format("%s%% %s", fmtNum(pctN), stat))
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")"
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
table.insert(out, string.format("%s%% %s", tostring(pct), stat))
end
end
end
return mw.text.nowiki(typ)
end
end


return out
local grid = mw.html.create("div")
end
grid:addClass("sv-type-grid")
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))


local function basisWordFromFlags(atkFlag, matkFlag)
chunk:tag("div")
if atkFlag and matkFlag then
:addClass("sv-type-label")
return "Hybrid"
:wikitext(mw.text.nowiki(label))
elseif atkFlag then
return "Attack"
elseif matkFlag then
return "Magic Attack"
end
return nil
end


-- Prefer the “current level value” (dynSpan when we have a series list)
chunk:tag("div")
local function sourceValueForLevel(src, maxLevel, level)
:addClass("sv-type-value")
if type(src) ~= "table" then
:wikitext(valueHtml)
return nil
end
end


local base = src.Base
-- Damage + Element + Hits bundle (hidden when non-damaging)
local per = src["Per Level"]
if not hideDamageBundle then
local dmg  = valName(typeBlock.Damage or typeBlock["Damage Type"])
local ele = valName(typeBlock.Element or typeBlock["Element Type"])
local hits = hitsDisplay()


-- Preferred: expanded series list (wikiprep)
if dmg and not isNoneLike(dmg) then
if type(per) == "table" and #per > 0 then
addChunk("damage", "Damage", mw.text.nowiki(dmg))
if isFlatList(per) then
end
local one  = formatUnitValue(per[1]) or tostring(per[1])
if ele and not isNoneLike(ele) then
local show = formatUnitValue(base) or one
addChunk("element", "Element", mw.text.nowiki(ele))
return show and mw.text.nowiki(show) or nil
end
end
 
if hits then
local series = {}
addChunk("hits", "Hits", hits)
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
end
return dynSpan(series, level)
end
end


-- Fallback: may show "X (Per Level: Y)" if not expanded
-- Target + Cast
return valuePairDynamicValueOnly(src, maxLevel, level)
local tgt = valName(typeBlock.Target or typeBlock["Target Type"])
end
local cst = valName(typeBlock.Cast  or typeBlock["Cast Type"])
 
if tgt and not isNoneLike(tgt) then
addChunk("target", "Target", mw.text.nowiki(tgt))
end
if cst and not isNoneLike(cst) then
addChunk("cast", "Cast", mw.text.nowiki(cst))
end


-- Legacy (pre-Source) damage entry: compute a simple % at the current level
-- Combo
local function legacyPercentAtLevel(entry, level)
local combo = comboDisplay()
if type(entry) ~= "table" then
if combo then
return nil
addChunk("combo", "Combo", combo)
end
end


local baseRaw = entry["Base %"]
        return {
local perRaw  = entry["Per Level %"]
                inner = added and tostring(grid) or "",
local baseN  = toNum(baseRaw)
                classes = "module-skill-type",
local perN    = toNum(perRaw)
        }
end
 
-- PLUGIN: Description (Hero Slot 3) - primary description text.
function PLUGINS.Description(rec)
        local desc = trim(rec.Description)
        if not desc then
                return nil
        end


-- If Per Level exists, level 1 shows at least per*1 even when base is 0/missing.
        local body = mw.html.create("div")
if perN ~= nil and perN ~= 0 then
        body:addClass("sv-description")
local total = (baseN or 0) + (perN * level)
        body:wikitext(string.format("''%s''", desc))
return fmtNum(total) .. "%"
end


if baseN ~= nil then
        return {
return fmtNum(baseN) .. "%"
                inner = tostring(body),
end
                classes = "module-description",
if baseRaw ~= nil and tostring(baseRaw) ~= "" then
        }
return tostring(baseRaw) .. "%"
end
end


return nil
-- PLUGIN: Placeholder (Hero Slot 4) - reserved/blank.
function PLUGINS.Placeholder()
        return nil
end
end


local function buildModuleSkillSource(rec, level, maxLevel)
 
-- 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 basisWord = nil
local sourceKind = nil
local sourceKind = nil
Line 1,077: Line 1,330:
local scaling    = nil
local scaling    = nil


-- Preferred: new unified Source block
-- 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
 
return valuePairDynamicValueOnly(src, maxLevel, level)
end
 
if type(rec.Source) == "table" then
if type(rec.Source) == "table" then
local src = rec.Source
local src = rec.Source
local atkFlag  = (src["ATK-Based"] == true)
local atkFlag  = (src["ATK-Based"] == true)
local matkFlag = (src["MATK-Based"] == true)
local matkFlag = (src["MATK-Based"] == true)
Line 1,086: Line 1,361:


sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage"
sourceVal  = sourceValueForLevel(src, maxLevel, level)
sourceVal  = sourceValueForLevel(src)
scaling    = src.Scaling
scaling    = src.Scaling
end
end


-- Backcompat: legacy Damage block
-- Fallback to legacy Damage lists if Source absent
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then
local dmg = rec.Damage
local dmg = rec.Damage
Line 1,099: Line 1,374:
local flat = dmg["Flat Damage"]
local flat = dmg["Flat Damage"]


-- priority: Main Damage > Reflect > Flat
if type(main) == "table" and #main > 0 then
if type(main) == "table" and #main > 0 then
local pick = nil
local pick = nil
Line 1,141: Line 1,415:
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)
local hasScaling  = (type(scalingLines) == "table" and #scalingLines > 0)


-- RULE: if neither exists, leave module 3 blank
if (not hasSource) and (not hasScaling) then
if (not hasSource) and (not hasScaling) then
return nil
return nil
Line 1,148: Line 1,421:
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "")


-- Classes drive grid layout in CSS
local extra = { "skill-source-module", "module-source-type" }
local extra = { "skill-source-module" }
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod")


Line 1,160: Line 1,432:
local wrap = mw.html.create("div")
local wrap = mw.html.create("div")
wrap:addClass("sv-source-grid")
wrap:addClass("sv-source-grid")
wrap:addClass("sv-compact-root")


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


-- Column 2: Source (optional)
if hasSource then
if hasSource then
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main")
sourceCol:tag("div")
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source"))
:addClass("sv-source-pill")
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal)
:wikitext(mw.text.nowiki(sourceKind or "Source"))
sourceCol:tag("div")
:addClass("sv-source-value")
:wikitext(sourceVal)
end
end


-- Column 3: Scaling (optional)
if hasScaling then
if hasScaling then
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling")
scalingCol:tag("div")
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling")
:addClass("sv-source-pill")
:wikitext("Scaling")


local list = scalingCol:tag("div"):addClass("sv-scaling-list")
local list = scalingCol:tag("div"):addClass("sv-scaling-list")
for _, line in ipairs(scalingLines) do
for _, line in ipairs(scalingLines) do
list:tag("div")
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line))
:addClass("sv-scaling-item")
:wikitext(mw.text.nowiki(line))
end
end
end
end


return moduleBox(3, extra, tostring(wrap), false)
return {
inner = tostring(wrap),
classes = extra,
}
end
end


local function buildHeroModulesUI(rec, level, maxLevel)
-- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration).
-- 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 mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {}
local bt  = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {}
local rc  = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {}
 
local function dash() return "—" end
 
-- Range (0 => —)
local rangeVal = nil
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
 
-- Area
local areaVal = formatAreaSize(mech.Area, maxLevel, level)
 
-- Timings
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)
 
-- Promote status duration if needed
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level)
end
 
-- Cost: MP + HP
local function labeledSeries(block, label)
local s = seriesFromValuePair(block, maxLevel)
if not s then return nil end
local any = false
for i, v in ipairs(s) do
if v ~= "—" then
s[i] = tostring(v) .. " " .. label
any = true
else
s[i] = "—"
end
end
return any and s or nil
end
 
local mpS = labeledSeries(rc["Mana Cost"], "MP")
local hpS = labeledSeries(rc["Health Cost"], "HP")
 
local costSeries = {}
for lv = 1, maxLevel do
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
 
local costVal = displayFromSeries(costSeries, level)
 
local grid = mw.html.create("div")
local grid = mw.html.create("div")
grid:addClass("hero-modules-grid")
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
 
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
 
------------------------------------------------------------------
-- Hits guard (we want Hits ONLY in SkillType)
------------------------------------------------------------------
local function isHitsKey(name)
if not name then return false end
local k = mw.ustring.lower(mw.text.trim(tostring(name)))
return (
k == "hit" or
k == "hits" or
k == "hit count" or
k == "hits count" or
k == "hitcount" or
k == "hitscount"
)
end
 
------------------------------------------------------------------
-- Flags (flat, de-duped)
------------------------------------------------------------------
local flagSet = {}
 
local denyFlags = {
["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,
}
 
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
 
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
 
if mods then
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
 
local flags = {}
for k, _ in pairs(flagSet) do table.insert(flags, k) end
table.sort(flags)
 
------------------------------------------------------------------
-- Special mechanics (name => value)
------------------------------------------------------------------
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
-- 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
 
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))
 
-- 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
 
-- Column 2: Special Mechanics (stacked)
if hasMech then
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech")
for _, it in ipairs(mechItems) do
local one = mcol:tag("div"):addClass("sv-sm-mech")
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label))
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—")
end
end
 
return {
inner = tostring(root),
classes = "module-special-mechanics",
}
end
 
-- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider.
function PLUGINS.LevelSelector(rec, ctx)
local level = ctx.level or 1
local maxLevel = ctx.maxLevel or 1
 
local inner = mw.html.create("div")
inner:addClass("sv-level-ui")


grid:wikitext(buildModuleLevelSelector(level, maxLevel))
inner:tag("div")
grid:wikitext(buildModuleSkillType(rec.Type or {}))
:addClass("sv-level-label")
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))


local m3 = buildModuleSkillSource(rec, level, maxLevel)
local slider = inner:tag("div"):addClass("sv-level-slider")
grid:wikitext(m3 or buildEmptyModule(3))


grid:wikitext(buildEmptyModule(4))
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 tostring(grid)
return {
inner = tostring(inner),
classes = "module-level-selector",
}
end
end


local function addHeroModulesRow(tbl, modulesUI)
----------------------------------------------------------------------
if not modulesUI or modulesUI == "" then
-- Generic slot renderers
return
----------------------------------------------------------------------
 
-- 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
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.
local function safeCallPlugin(name, rec, ctx)
        local fn = PLUGINS[name]
        if type(fn) ~= "function" then
                return nil
        end
        local ok, out = pcall(fn, rec, ctx)
        if not ok then
                return nil
        end
        return normalizeResult(out)
end
-- 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


local row = tbl:tag("tr")
-- addHeroSlotsRow: add the standardized slot grid into the infobox table.
row:addClass("hero-modules-row")
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")
        local cell = row:tag("td")
cell:attr("colspan", 2)
        cell:attr("colspan", 2)
cell:addClass("hero-modules-cell")
        cell:addClass("sv-slot-cell")
cell:wikitext(modulesUI)
        cell:wikitext(slotsUI)
end
end


Line 1,234: Line 1,902:
----------------------------------------------------------------------
----------------------------------------------------------------------


-- buildInfobox: render a single skill infobox.
local function buildInfobox(rec, opts)
local function buildInfobox(rec, opts)
opts = opts or {}
opts = opts or {}
Line 1,241: Line 1,910:
if maxLevel < 1 then maxLevel = 1 end
if maxLevel < 1 then maxLevel = 1 end
local level = clamp(maxLevel, 1, maxLevel)
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")
local root = mw.html.create("table")
Line 1,257: Line 1,947:
end
end


local icon  = rec.Icon
-- Standardized slot grid
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
addHeroSlotsRow(root, buildHeroSlotsUI(rec, ctx))
local desc  = rec.Description or ""
 
-- 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


local heroRow = root:tag("tr")
        -- Mechanics (keep small extras only)
heroRow:addClass("spiritvale-infobox-main")
        local mech = rec.Mechanics or {}
heroRow:addClass("sv-hero-title-row")
        if next(mech) ~= nil then
heroRow:addClass("hero-title-bar")
                if mech["Autocast Multiplier"] ~= nil then
                        addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier")
                end
        end


local heroCell = heroRow:tag("th")
-- Legacy damage breakdown (only when Source absent)
heroCell:attr("colspan", 2)
if type(rec.Source) ~= "table" then
heroCell:addClass("sv-hero-title-cell")
local dmg = rec.Damage or {}
if next(dmg) ~= nil then
local main = dmg["Main Damage"]
local mainNonHeal, healOnly = {}, {}


local heroInner = heroCell:tag("div")
if type(main) == "table" then
heroInner:addClass("spiritvale-infobox-main-left-inner")
for _, d in ipairs(main) do
if type(d) == "table" and d.Type == "Healing" then
table.insert(healOnly, d)
else
table.insert(mainNonHeal, d)
end
end
end


if icon and icon ~= "" then
addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)), "sv-row-source", "Damage.Main Damage")
heroInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
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


heroInner:tag("div")
-- Status rows
:addClass("spiritvale-infobox-title")
local function formatStatusApplications(list, suppressDurationIndex)
:wikitext(title)
if type(list) ~= "table" or #list == 0 then return nil end


if desc ~= "" then
local parts = {}
local descRow = root:tag("tr")
for idx, s in ipairs(list) do
descRow:addClass("spiritvale-infobox-main")
if type(s) == "table" then
descRow:addClass("sv-hero-desc-row")
local typ  = s.Type or s.Scope or "Target"
descRow:addClass("hero-description-bar")
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"
local seg = tostring(typ) .. " – " .. tostring(name)
local detail = {}


local descCell = descRow:tag("td")
if idx ~= suppressDurationIndex and type(s.Duration) == "table" then
descCell:attr("colspan", 2)
local t = valuePairDynamicValueOnly(s.Duration, maxLevel, level)
descCell:addClass("sv-hero-desc-cell")
if t then table.insert(detail, "Duration: " .. t) end
end


local descInner = descCell:tag("div")
if type(s.Chance) == "table" then
descInner:addClass("spiritvale-infobox-main-right-inner")
local t = valuePairDynamicValueOnly(s.Chance, maxLevel, level)
if t then table.insert(detail, "Chance: " .. t) end
end


descInner:tag("div")
if #detail > 0 then
:addClass("spiritvale-infobox-description")
seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
:wikitext(string.format("''%s''", desc))
end
end


addHeroModulesRow(root, buildHeroModulesUI(rec, level, maxLevel))
table.insert(parts, seg)
 
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")
addRow(root, "Events",  listToText(users.Events),  "sv-row-users", "Users.Events")
end
 
local req = rec.Requirements or {}
local hasReq =
(type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0) or
(type(req["Required Weapons"]) == "table" and #req["Required Weapons"] > 0) or
(type(req["Required Stances"]) == "table" and #req["Required Stances"] > 0)
 
if hasReq then
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
local skillParts = {}
for _, rs in ipairs(req["Required Skills"]) do
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
local lvlReq  = rs["Required Level"]
if lvlReq then
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
else
table.insert(skillParts, nameReq)
end
end
end
addRow(root, "Required Skills", table.concat(skillParts, ", "), "sv-row-req", "Requirements.Required Skills")
end
end


addRow(root, "Required Weapons", listToText(req["Required Weapons"]), "sv-row-req", "Requirements.Required Weapons")
return (#parts > 0) and table.concat(parts, "<br />") or nil
addRow(root, "Required Stances", listToText(req["Required Stances"]), "sv-row-req", "Requirements.Required Stances")
end
end


local mech = rec.Mechanics or {}
local function formatStatusRemoval(list)
if next(mech) ~= nil then
if type(list) ~= "table" or #list == 0 then return nil end
addRow(root, "Range", formatUnitValue(mech.Range), "sv-row-mech", "Mechanics.Range")
addRow(root, "Area",  formatArea(mech.Area, maxLevel, level), "sv-row-mech", "Mechanics.Area")


if mech["Autocast Multiplier"] ~= nil then
local parts = {}
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier")
for _, r in ipairs(list) do
end
if type(r) == "table" then
local names = r["Status External Name"]
local label


addRow(root, "Timing",            formatTimingBlock(mech["Basic Timings"], maxLevel, level), "sv-row-mech", "Mechanics.Basic Timings")
if type(names) == "table" then
addRow(root, "Resource Cost",     formatResourceCost(mech["Resource Cost"], maxLevel, level), "sv-row-mech", "Mechanics.Resource Cost")
label = table.concat(names, ", ")
addRow(root, "Combo",            formatCombo(mech.Combo), "sv-row-mech", "Mechanics.Combo")
elseif type(names) == "string" then
addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level), "sv-row-mech", "Mechanics.Effects")
label = names
end
else
label = "Status"
end


-- Source + Scaling are displayed in Module 3 now, so we do NOT repeat them as body rows.
local amt = valuePairRawText(r)
-- Keep the detailed legacy damage breakdown rows only (Main/Flat/Reflect/Healing).
amt = amt and mw.text.nowiki(amt) or nil
if type(rec.Source) ~= "table" then
local dmg = rec.Damage or {}
if next(dmg) ~= nil then
local main = dmg["Main Damage"]
local mainNonHeal, healOnly = {}, {}


if type(main) == "table" then
local seg = mw.text.nowiki(label)
for _, d in ipairs(main) do
if amt then
if type(d) == "table" and d.Type == "Healing" then
seg = seg .. " – " .. amt
table.insert(healOnly, d)
else
table.insert(mainNonHeal, d)
end
end
table.insert(parts, seg)
end
end
end
end


local flatList = dmg["Flat Damage"]
return (#parts > 0) and table.concat(parts, "<br />") or nil
local reflList = dmg["Reflect Damage"]
 
addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)), "sv-row-source", "Damage.Main Damage")
addRow(root, "Flat Damage",    formatDamageList(flatList, maxLevel, level, false), "sv-row-source", "Damage.Flat Damage")
addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false), "sv-row-source", "Damage.Reflect Damage")
addRow(root, "Healing",        formatDamageList(healOnly, maxLevel, level, false), "sv-row-source", "Damage.Healing")
end
end
 
 
local modsText = formatModifiers(rec.Modifiers)
if modsText then
addRow(root, "Flags", modsText, "sv-row-meta", "Modifiers")
end
end


local statusApps = formatStatusApplications(rec["Status Applications"], maxLevel, level)
local suppressIdx = (type(ctx.promo) == "table") and ctx.promo.suppressDurationIndex or nil
local statusRem  = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
local statusApps = formatStatusApplications(rec["Status Applications"], suppressIdx)
local statusRem  = formatStatusRemoval(rec["Status Removal"])
if statusApps or statusRem then
if statusApps or statusRem then
addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications")
addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications")
addRow(root, "Removes", statusRem,  "sv-row-status", "Status Removal")
addRow(root, "Removes", statusRem,  "sv-row-status", "Status Removal")
end
end
        -- Events
        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)
Line 1,395: Line 2,093:
end
end


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


Line 1,431: 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"