Toggle search
Toggle menu
110
215
16
2K
SpiritVale Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Join the Playtest on Steam Now: SpiritVale

Module:GameSkills: Difference between revisions

From SpiritVale Wiki
More actions
← Older edit
No edit summary
No edit summary
 
(17 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:GameSkills
--Module: GameSkills
--
--
-- Renders active skill data (from Data:skills.json) into an infobox-style table
--Upgrades:
-- and can also list all skills for a given user/class.
--  - Adds a per - skill Level Select slider(client - side JS updates fields)
--  - Default level = Max Level
--  - Adds.sv - skill - card + data - max - level / data - level hooks for JS
--  - Replaces large Lv1 / Lv2 /... lists with data - series dynamic spans
--  - Removes "General" + "Type" section bars and merges Level Select + Type into one unified top band
--(Level Select on the left; Type / Element / Target / Cast Type list on the right)
-- - NEW(list - mode): Wraps all skills in ONE wrapper panel and each skill in a stable.sv - skill - item
--so CSS dividers work reliably under Citizen / table wrappers.
--
--
-- Usage (single skill):
--Requires the JS you installed in MediaWiki: Common.js.
--   {{Skill|Heal}}
--Uses Common.css classes:
--  {{Skill|name=Heal}}
--  .sv - topband - cell, .sv - topband - table, .sv - type - table, .sv - level - ui, .sv - level - title, .sv - level - label, .sv - level - slider
--   {{Skill|id=Heal_InternalId}}
--  .sv - skill - collection, .sv - skill - item
--
-- Usage (auto-list on class page, e.g. "Acolyte"):
--   {{Skill}}                  -> lists all Acolyte skills (page name)
--  {{Skill|Acolyte}}          -> same, if no skill literally called "Acolyte"


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


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Internal helpers
--Internal helpers
----------------------------------------------------------------------
----------------------------------------------------------------------


local skillsCache
local skillsCache


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 getArgs(frame)
    local parent = frame:getParent()
local parent = frame: getParent()
    if parent then
if parent then
        return parent.args
return parent.args
    end
end
    return frame.args
return frame.args
end
end


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


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


local function addSectionHeader(tbl, label)
local function addSectionHeader(tbl, label)
    local row = tbl:tag("tr")
local row = tbl: tag("tr")
    local cell = row:tag("th")
local cell = row: tag("th")
    cell:attr("colspan", 2)
cell: attr("colspan", 2)
    cell:addClass("spiritvale-infobox-section-header")
cell: addClass("spiritvale-infobox-section-header")
    cell:wikitext(label)
cell: wikitext(label)
end
 
local function trim(s)
if type(s) ~= "string" then return nil end
s = mw.text.trim(s)
if s == "" then return nil end
return s
end
 
local function toNum(v)
if type(v) == "number" then 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
end
end


-- Lookup by Internal Name
local function clamp(n, lo, hi)
local function getSkillById(id)
if type(n) ~= "number" then return lo end
    if not id or id == "" then
if n < lo then return lo end
        return nil
if n > hi then return hi end
    end
return n
    local dataset = getSkills()
end
    local byId = dataset.byId or {}
 
    return byId[id]
local function fmtNum(n)
if type(n) ~= "number" then
return (n ~= nil) and tostring(n) or nil
end
if math.abs(n - math.floor(n)) < 1e-9 then
return tostring(math.floor(n))
end
local s = string.format("%.4f", n)
s = mw.ustring.gsub(s, "0+$", "")
s = mw.ustring.gsub(s, "%.$", "")
return s
end
 
--Handles either a scalar OR { Value =..., Unit =... }
--IMPORTANT: do NOT convert percent_decimal / percent_whole; just format around stored values.
local function formatUnitValue(v)
if type(v) == "table" and v.Value ~= nil then
local unit = v.Unit
local val = v.Value
 
if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
return tostring(val).. "%"
elseif unit == "seconds" then
return tostring(val).. "s"
elseif unit == "meters" then
return tostring(val).. "m"
elseif unit == "tiles" then
return tostring(val).. " tiles"
elseif unit and unit ~= "" then
return tostring(val).. " "..tostring(unit)
else
return tostring(val)
end
end
 
if v == nil then
return nil
end
return tostring(v)
end
 
----------------------------------------------------------------------
--Dynamic field helpers(JS - driven)
----------------------------------------------------------------------
 
local function dynSpan(series, level)
if type(series) ~= "table" or #series == 0 then
return nil
end
level = clamp(level or #series, 1, #series)
 
local span = mw.html.create("span")
span: addClass("sv-dyn")
span: attr("data-series", mw.text.jsonEncode(series))
span: wikitext(mw.text.nowiki(series[level] or ""))
 
return tostring(span)
end
 
local function isFlatList(list)
if type(list) ~= "table" or #list == 0 then
return false
end
local first = tostring(list[1])
for i = 2, #list do
if tostring(list[i]) ~= first then
return false
end
end
return true
end
 
local function isNonZeroScalar(v)
if v == nil then return false end
if type(v) == "number" then return v ~= 0 end
if type(v) == "string" then
local n = tonumber(v)
if n == nil then
return v ~= ""
end
return n ~= 0
end
if type(v) == "table" and v.Value ~= nil then
return isNonZeroScalar(v.Value)
end
return true
end
 
--Like your old valuePairLines / valuePairText, but:
-- - if Per Level is a list, render a dynamic span instead of "v1 / v2 / ..."
-- - scalar Per Level stays as the old "Base" + "Per Level" lines(still short)
local function valuePairDynamicLines(name, block, maxLevel, level)
if type(block) ~= "table" then
return {}
end
 
local base = block.Base
local per = block["Per Level"]
 
--Per Level list(expanded)
if type(per) == "table" then
--empty list -> show Base only
if #per == 0 then
local baseText = formatUnitValue(base)
if baseText then
return { string.format("%s: %s", name, mw.text.nowiki(baseText)) }
end
return {}
end
 
--flat list -> show single value
if isFlatList(per) then
local baseText = formatUnitValue(base)
local one = formatUnitValue(per[1]) or tostring(per[1])
local show = baseText or one
if show then
return { string.format("%s: %s", name, mw.text.nowiki(show)) }
end
return {}
end
 
--dynamic series
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
 
local dyn = dynSpan(series, level)
if dyn then
return { string.format("%s: %s", name, dyn) }
end
return {}
end
 
--scalar Per Level(keep old style)
local lines = {}
local baseText = formatUnitValue(base)
local perText = formatUnitValue(per)
 
if baseText then
table.insert(lines, string.format("%s: %s", name, mw.text.nowiki(baseText)))
end
if perText and isNonZeroScalar(per) then
table.insert(lines, string.format("%s Per Level: %s", name, mw.text.nowiki(perText)))
end
 
return lines
end
 
local function valuePairDynamicText(name, block, maxLevel, level, sep)
local lines = valuePairDynamicLines(name, block, maxLevel, level)
if #lines == 0 then return nil end
return table.concat(lines, sep or "<br />")
end
 
----------------------------------------------------------------------
--Lookups
----------------------------------------------------------------------
 
local function getSkillById(id)
id = trim(id)
if not id then return nil end
local dataset = getSkills()
local byId = dataset.byId or { }
return byId[id]
end
end


-- Lookup by display Name (for editors)
local function findSkillByName(name)
local function findSkillByName(name)
    if not name or name == "" then
name = trim(name)
        return nil
if not name then return nil end
    end
local dataset = getSkills()
    local dataset = getSkills()
 
    for _, rec in ipairs(dataset.records or {}) do
local byName = dataset.byName or { }
        if rec["Name"] == name then
if byName[name] then
            return rec
return byName[name]
        end
end
    end
 
    return nil
for _, rec in ipairs(dataset.records or {}) do
if type(rec) == "table" then
if rec["External Name"] == name or rec["Name"] == name or rec["Display Name"] == name then
return rec
end
end
end
return nil
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Formatting helpers
--Formatting helpers
----------------------------------------------------------------------
----------------------------------------------------------------------


local function formatBasePer(block)
local function basisLabel(entry, isHealing)
    if type(block) ~= "table" then
if isHealing then
        return nil
return "Healing"
    end
end
    local parts = {}
local atk = entry and entry["ATK-Based"]
    if block.Base ~= nil then
local matk = entry and entry["MATK-Based"]
        table.insert(parts, string.format("Base %s", tostring(block.Base)))
if atk and matk then
    end
return "Attack/Magic Attack"
    if block["Per Level"] ~= nil then
elseif atk then
        table.insert(parts, string.format("%s / Lv", tostring(block["Per Level"])))
return "Attack"
    end
elseif matk then
    if #parts == 0 then
return "Magic Attack"
        return nil
end
    end
return "Damage"
    return table.concat(parts, ", ")
end
 
--Dynamic damage entry:
--Build a series for Lv1..LvMax, and show only the selected one.
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
return nil
end
 
local isHealing = (entry.Type == "Healing")
local basis = isHealing and "Healing" or basisLabel(entry)
 
local baseRaw = entry["Base %"]
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
 
local baseText = nil
if baseIsPresent() then
if baseN ~= nil then
baseText = fmtNum(baseN).. "%"
else
baseText = tostring(baseRaw).. "%"
end
end
 
--No scaling -> just show base
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
return baseText and mw.text.nowiki(baseText.. " "..basis) or nil
end
 
--Build series strings for each level
local series = {}
for lv = 1, maxLevel do
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
 
return dynSpan(series, level)
end
 
local function formatDamageList(list, maxLevel, level, includeTypePrefix)
if type(list) ~= "table" or #list == 0 then
return nil
end
 
local parts = {}
for _, d in ipairs(list) do
if type(d) == "table" then
local txt = formatDamageEntry(d, maxLevel, level)
if txt then
if includeTypePrefix and d.Type and d.Type ~= "" then
table.insert(parts, mw.text.nowiki(tostring(d.Type).. ": ")..txt)
else
table.insert(parts, txt)
end
end
end
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
 
local function formatScaling(list, basisOverride)
if type(list) ~= "table" or #list == 0 then
return nil
end
end


local function formatMainDamage(list)
local parts = {}
    if type(list) ~= "table" or #list == 0 then
for _, s in ipairs(list) do
        return nil
if type(s) == "table" then
    end
local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
    local parts = {}
local pct = s.Percent
    for _, d in ipairs(list) do
local pctN = toNum(pct)
        if type(d) == "table" then
 
            local kind = d.Type or "Damage"
local basis = basisOverride or basisLabel(s, false)
            local base = d["Base %"]
 
            local per  = d["Per Level %"]
if pctN ~= nil and pctN ~= 0 then
            local seg  = kind
table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
            local detail = {}
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
            if base ~= nil then
table.insert(parts, string.format("%s%% %s Per %s", tostring(pct), basis, stat))
                table.insert(detail, string.format("Base %s%%", tostring(base)))
end
            end
end
            if per ~= nil then
                table.insert(detail, string.format("%s%% / Lv", tostring(per)))
            end
            if d["ATK-Based"] then
                table.insert(detail, "ATK-based")
            end
            if d["MATK-Based"] then
                table.insert(detail, "MATK-based")
            end
            if #detail > 0 then
                seg = seg .. " – " .. table.concat(detail, ", ")
            end
            table.insert(parts, seg)
        end
    end
    if #parts == 0 then
        return nil
    end
    return table.concat(parts, "<br />")
end
end


local function formatReflectDamage(list)
if #parts == 0 then
    if type(list) ~= "table" or #list == 0 then
return nil
        return nil
end
    end
return table.concat(parts, "<br />")
    local parts = {}
    for _, d in ipairs(list) do
        if type(d) == "table" then
            local base = d["Base %"]
            local per  = d["Per Level %"]
            local seg  = "Reflect"
            local detail = {}
            if base ~= nil then
                table.insert(detail, string.format("Base %s%%", tostring(base)))
            end
            if per ~= nil then
                table.insert(detail, string.format("%s%% / Lv", tostring(per)))
            end
            if #detail > 0 then
                seg = seg .. " – " .. table.concat(detail, ", ")
            end
            table.insert(parts, seg)
        end
    end
    if #parts == 0 then
        return nil
    end
    return table.concat(parts, "<br />")
end
end


local function formatScaling(list)
local function formatArea(area, maxLevel, level)
    if type(list) ~= "table" or #list == 0 then
if type(area) ~= "table" then
        return nil
return nil
    end
    local parts = {}
    for _, s in ipairs(list) do
        if type(s) == "table" then
            local name = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
            local pct  = s.Percent
            local seg  = name
            local detail = {}
            if pct ~= nil then
                table.insert(detail, string.format("%s%%", tostring(pct)))
            end
            if s["ATK-Based"] then
                table.insert(detail, "ATK-based")
            end
            if s["MATK-Based"] then
                table.insert(detail, "MATK-based")
            end
            if #detail > 0 then
                seg = seg .. " – " .. table.concat(detail, ", ")
            end
            table.insert(parts, seg)
        end
    end
    if #parts == 0 then
        return nil
    end
    return table.concat(parts, "<br />")
end
end
local parts = {}


local function formatArea(area)
local distLine = valuePairDynamicText("Distance", area["Area Distance"], maxLevel, level, "<br />")
    if type(area) ~= "table" then
if distLine then
        return nil
table.insert(parts, distLine)
    end
    local parts = {}
    local size = area["Area Size"]
    if size and size ~= "" then
        table.insert(parts, "Size: " .. tostring(size))
    end
    local dist = area["Area Distance"]
    local eff  = area["Effective Distance"]
    local distText = formatBasePer(dist)
    if distText then
        table.insert(parts, "Distance: " .. distText)
    end
    if eff ~= nil then
        table.insert(parts, string.format("Effective: %s", tostring(eff)))
    end
    if #parts == 0 then
        return nil
    end
    return table.concat(parts, "<br />")
end
end


local function formatTimingBlock(bt)
local size = area["Area Size"]
    if type(bt) ~= "table" then
if size and size ~= "" then
        return nil
table.insert(parts, "Size: "..mw.text.nowiki(tostring(size)))
    end
end
    local parts = {}


    local function add(name, key)
if #parts == 0 then
        local block = bt[key]
return nil
        local txt = formatBasePer(block)
end
        if txt then
return table.concat(parts, "<br />")
            table.insert(parts, name .. ": " .. txt)
end
        end
 
    end
local function formatTimingBlock(bt, maxLevel, level)
if type(bt) ~= "table" then
return nil
end
local parts = {}
 
local function add(label, key)
local block = bt[key]
if type(block) ~= "table" then
return
end
local lines = valuePairDynamicLines(label, block, maxLevel, level)
for _, line in ipairs(lines) do
table.insert(parts, line)
end
end


    add("Cast Time", "Cast Time")
add("Cast Time", "Cast Time")
    add("Cooldown", "Cooldown")
add("Cooldown", "Cooldown")
    add("Duration", "Duration")
add("Duration", "Duration")


    if bt["Effect Cast Time"] ~= nil then
if bt["Effect Cast Time"] ~= nil then
        table.insert(parts, "Effect Cast Time: " .. tostring(bt["Effect Cast Time"]))
table.insert(parts, "Effect Cast Time: "..mw.text.nowiki(tostring(bt["Effect Cast Time"])))
    end
end
    if bt["Damage Delay"] ~= nil then
if bt["Damage Delay"] ~= nil then
        table.insert(parts, "Damage Delay: " .. tostring(bt["Damage Delay"]))
table.insert(parts, "Damage Delay: "..mw.text.nowiki(tostring(bt["Damage Delay"])))
    end
end
    if bt["Effect Remove Delay"] ~= nil then
if bt["Effect Remove Delay"] ~= nil then
        table.insert(parts, "Effect Remove Delay: " .. tostring(bt["Effect Remove Delay"]))
table.insert(parts, "Effect Remove Delay: "..mw.text.nowiki(tostring(bt["Effect Remove Delay"])))
    end
end


    if #parts == 0 then
if #parts == 0 then
        return nil
return nil
    end
end
    return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
end


local function formatResourceCost(rc)
local function formatResourceCost(rc, maxLevel, level)
    if type(rc) ~= "table" then
if type(rc) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    local mana = rc["Mana Cost"]
    local hp  = rc["Health Cost"]


    local manaTxt = formatBasePer(mana)
local manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
    if manaTxt then
for _, line in ipairs(manaLines) do
        table.insert(parts, "MP: " .. manaTxt)
table.insert(parts, line)
    end
end


    local hpTxt = formatBasePer(hp)
local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
    if hpTxt then
for _, line in ipairs(hpLines) do
        table.insert(parts, "HP: " .. hpTxt)
table.insert(parts, line)
    end
end


    if #parts == 0 then
if #parts == 0 then
        return nil
return nil
    end
end
    return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
end


local function formatCombo(combo)
local function formatCombo(combo)
    if type(combo) ~= "table" then
if type(combo) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    if combo.Type then
 
        table.insert(parts, "Type: " .. tostring(combo.Type))
if combo.Type then
    end
table.insert(parts, "Type: "..mw.text.nowiki(tostring(combo.Type)))
    if combo.Duration ~= nil then
end
        table.insert(parts, "Duration: " .. tostring(combo.Duration))
 
    end
local durText = formatUnitValue(combo.Duration)
    if combo.Percent ~= nil then
if durText then
        table.insert(parts, string.format("Bonus: %s%%", tostring(combo.Percent * 100)))
table.insert(parts, "Duration: "..mw.text.nowiki(durText))
    end
end
    if #parts == 0 then
 
        return nil
if combo.Percent ~= nil then
    end
local pctText = formatUnitValue(combo.Percent)
    return table.concat(parts, ", ")
if pctText then
table.insert(parts, "Bonus: "..mw.text.nowiki(pctText))
end
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, ", ")
end
 
local function valuePairRawText(block)
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
return formatUnitValue(base)
end
if isFlatList(per) then
return formatUnitValue(base) or tostring(per[1])
end
local vals = {}
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
end
return (#vals > 0) and table.concat(vals, " / ") or nil
end
 
local baseText = formatUnitValue(base)
local perText = formatUnitValue(per)
 
if baseText and perText and isNonZeroScalar(per) then
return string.format("%s (Per Level: %s)", baseText, perText)
end
return baseText or perText
end
 
--Special Mechanics supports dynamic Per Level lists
local function formatMechanicEffects(effects, maxLevel, level)
if type(effects) ~= "table" then
return nil
end
end


local function formatMechanicEffects(effects)
local keys = {}
    if type(effects) ~= "table" then
for k, _ in pairs(effects) do
        return nil
table.insert(keys, k)
    end
end
    local parts = {}
table.sort(keys)
    for name, block in pairs(effects) do
 
        if type(block) == "table" then
local parts = {}
            local bp = formatBasePer(block)
 
            local seg = name
local function effectAmount(block)
            if bp then
if type(block) ~= "table" then
                seg = seg .. " – " .. bp
return nil
            end
end
            table.insert(parts, seg)
 
        end
local per = block["Per Level"]
    end
 
    if #parts == 0 then
if type(per) == "table" and #per > 0 then
        return nil
if isFlatList(per) then
    end
return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
    return table.concat(parts, "<br />")
end
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
 
local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
local txt = valuePairRawText(pair)
return txt and mw.text.nowiki(txt) or nil
end
 
for _, name in ipairs(keys) do
local block = effects[name]
if type(block) == "table" then
local t = block.Type
 
if t ~= nil and tostring(t) ~= "" then
local amt = effectAmount(block)
local seg = mw.text.nowiki(tostring(t).. " - "..tostring(name))
if amt then
seg = seg.. " + "..amt
end
table.insert(parts, seg)
else
local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
if txt then
table.insert(parts, txt)
end
end
end
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
end


local function formatModifiers(mods)
local function formatModifiers(mods)
    if type(mods) ~= "table" then
if type(mods) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}


    local function collect(label, sub)
local function collect(label, sub)
        if type(sub) ~= "table" then
if type(sub) ~= "table" then
            return
return
        end
end
        local flags = {}
local flags = {}
        for k, v in pairs(sub) do
for k, v in pairs(sub) do
            if v then
if v then
                table.insert(flags, k)
table.insert(flags, k)
            end
end
        end
end
        table.sort(flags)
table.sort(flags)
        if #flags > 0 then
if #flags > 0 then
            table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
        end
end
    end
end


    collect("Movement", mods["Movement Modifiers"])
collect("Movement", mods["Movement Modifiers"])
    collect("Combat",   mods["Combat Modifiers"])
collect("Combat", mods["Combat Modifiers"])
    collect("Special", mods["Special Modifiers"])
collect("Special", mods["Special Modifiers"])


    if #parts == 0 then
if #parts == 0 then
        return nil
return nil
    end
end
    return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
end


local function formatStatusApplications(list)
local function formatStatusApplications(list, maxLevel, level)
    if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    for _, s in ipairs(list) do
for _, s in ipairs(list) do
        if type(s) == "table" then
if type(s) == "table" then
            local scope = s.Scope or "Target"
local scope = s.Scope or "Target"
            local name = s["Status Name"] or s["Status ID"] or "Unknown status"
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"


            local seg = scope .. " – " .. name
local seg = scope.. " – "..tostring(name)
            local detail = {}
local detail = {}


            local dur = s.Duration
if type(s.Duration) == "table" then
            if type(dur) == "table" then
local t = valuePairDynamicText("Duration", s.Duration, maxLevel, level, "; ")
                local t = formatBasePer(dur)
if t then table.insert(detail, t) end
                if t then
end
                    table.insert(detail, "Duration " .. t)
                end
            end


            local ch = s.Chance
if type(s.Chance) == "table" then
            if type(ch) == "table" then
local t = valuePairDynamicText("Chance", s.Chance, maxLevel, level, "; ")
                local t = formatBasePer(ch)
if t then table.insert(detail, t) end
                if t then
end
                    table.insert(detail, "Chance " .. t)
                end
            end


            if s["Fixed Duration"] then
if s["Fixed Duration"] then
                table.insert(detail, "Fixed duration")
table.insert(detail, "Fixed duration")
            end
end


            if #detail > 0 then
if #detail > 0 then
                seg = seg .. " (" .. table.concat(detail, ", ") .. ")"
seg = seg.. " ("..table.concat(detail, ", ").. ")"
            end
end


            table.insert(parts, seg)
table.insert(parts, seg)
        end
end
    end
end
    if #parts == 0 then
if #parts == 0 then
        return nil
return nil
    end
end
    return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
 
local function formatStatusRemoval(list, maxLevel, level)
if type(list) ~= "table" or #list == 0 then
return nil
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
end


local function formatStatusRemoval(list)
local amt = nil
    if type(list) ~= "table" or #list == 0 then
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
        return nil
local series = {}
    end
for _, v in ipairs(r["Per Level"]) do
    local parts = {}
table.insert(series, formatUnitValue(v) or tostring(v))
    for _, r in ipairs(list) do
end
        if type(r) == "table" then
amt = dynSpan(series, level)
            local names = r["Status Name"]
else
            local label
amt = valuePairRawText(r)
            if type(names) == "table" then
if amt then amt = mw.text.nowiki(amt) end
                label = table.concat(names, ", ")
end
            elseif type(names) == "string" then
 
                label = names
local seg = mw.text.nowiki(label)
            else
if amt then
                label = "Status"
seg = seg.. " – "..amt
            end
end
            local bp = formatBasePer(r)
table.insert(parts, seg)
            local seg = label
end
            if bp then
end
                seg = seg .. " – " .. bp
if #parts == 0 then
            end
return nil
            table.insert(parts, seg)
end
        end
return table.concat(parts, "<br />")
    end
    if #parts == 0 then
        return nil
    end
    return table.concat(parts, "<br />")
end
end


local function formatEvents(list)
local function formatEvents(list)
    if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    for _, ev in ipairs(list) do
for _, ev in ipairs(list) do
        if type(ev) == "table" then
if type(ev) == "table" then
            local action = ev.Action or "On event"
local action = ev.Action or "On event"
            local name   = ev["Skill Name"] or ev["Skill ID"] or "Unknown skill"
local name = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
            local seg    = string.format("%s → %s", action, name)
table.insert(parts, string.format("%s → %s", action, name))
            table.insert(parts, seg)
end
        end
end
    end
if #parts == 0 then
    if #parts == 0 then
return nil
        return nil
end
    end
return table.concat(parts, "<br />")
    return table.concat(parts, "<br />")
end
end


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


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


    local users = rec.Users
local users = rec.Users
    if type(users) ~= "table" then
if type(users) ~= "table" then
        return false
return false
    end
end


    local userLower = mw.ustring.lower(userName)
local userLower = mw.ustring.lower(userName)


    local function listHas(list)
local function listHas(list)
        if type(list) ~= "table" then
if type(list) ~= "table" then
            return false
return false
        end
end
        for _, v in ipairs(list) do
for _, v in ipairs(list) do
            if type(v) == "string" and mw.ustring.lower(v) == userLower then
if type(v) == "string" and mw.ustring.lower(v) == userLower then
                return true
return true
            end
end
        end
end
        return false
return false
    end
end


    if listHas(users.Classes)  then return true end
if listHas(users.Classes)  then return true end
    if listHas(users.Summons)  then return true end
if listHas(users.Summons)  then return true end
    if listHas(users.Monsters) then return true end
if listHas(users.Monsters) then return true end
    if listHas(users.Events)  then return true end
if listHas(users.Events)  then return true end


    return false
return false
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Infobox builder
--Direct page detection(hide Users on the skill's own page)
----------------------------------------------------------------------
----------------------------------------------------------------------


local function buildInfobox(rec)
local function isDirectSkillPage(rec)
    local root = mw.html.create("table")
if type(rec) ~= "table" then
    root:addClass("wikitable spiritvale-skill-infobox")
return false
end


    -- Header: icon + name
local pageTitle = mw.title.getCurrentTitle()
    local icon  = rec.Icon
local pageName = pageTitle and pageTitle.text or ""
    local title = rec.Name or rec["Internal Name"] or "Unknown Skill"
pageName = trim(pageName)
if not pageName then
return false
end
pageName = mw.ustring.lower(pageName)


    local header = root:tag("tr")
local ext = trim(rec["External Name"] or rec["Name"] or rec["Display Name"])
    local headerCell = header:tag("th")
local internal = trim(rec["Internal Name"] or rec["InternalName"] or rec["InternalID"])
    headerCell:attr("colspan", 2)


    local titleText = ""
if ext and mw.ustring.lower(ext) == pageName then
    if icon and icon ~= "" then
return true
        titleText = string.format("[[File:%s|64px|link=]] ", icon)
end
    end
if internal and mw.ustring.lower(internal) == pageName then
    titleText = titleText .. title
return true
    headerCell:wikitext(titleText)
end
return false
end


    ------------------------------------------------------------------
----------------------------------------------------------------------
    -- General
--Infobox builder(Top band: Level Select + Type)
    ------------------------------------------------------------------
----------------------------------------------------------------------
    addSectionHeader(root, "General")
    addRow(root, "Description", rec.Description)
    addRow(root, "Max level", rec["Max Level"] and tostring(rec["Max Level"]))


    local users = rec.Users or {}
local function buildLevelSelectUI(level, maxLevel)
    addRow(root, "Classes",  listToText(users.Classes))
--JS expectations:
    addRow(root, "Summons",  listToText(users.Summons))
--  .sv - level - slider placeholder for the < input type = "range" >
    addRow(root, "Monsters", listToText(users.Monsters))
--  .sv - level - num span for updating the number
    addRow(root, "Events",  listToText(users.Events))
local wrap = mw.html.create("div")
wrap: addClass("sv-level-ui")


    ------------------------------------------------------------------
wrap: tag("div")
    -- Requirements
: addClass("sv-level-title")
    ------------------------------------------------------------------
: wikitext("Level Select")
    local req = rec.Requirements or {}
    if (req["Required Skills"] and #req["Required Skills"] > 0)
        or (req["Required Weapons"] and #req["Required Weapons"] > 0)
        or (req["Required Stances"] and #req["Required Stances"] > 0) then


        addSectionHeader(root, "Requirements")
wrap: tag("div")
: addClass("sv-level-label")
: wikitext("Level <span class=\"sv-level-num\">"..tostring(level).. "</span> / "..tostring(maxLevel))


        if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
wrap: tag("div"): addClass("sv-level-slider")
            local skillParts = {}
            for _, rs in ipairs(req["Required Skills"]) do
                local name  = rs["Skill Name"] or rs["Skill ID"] or "Unknown"
                local level = rs["Required Level"]
                if level then
                    table.insert(skillParts, string.format("%s (Lv.%s)", name, level))
                else
                    table.insert(skillParts, name)
                end
            end
            addRow(root, "Required skills", table.concat(skillParts, ", "))
        end


        addRow(root, "Required weapons", listToText(req["Required Weapons"]))
return tostring(wrap)
        addRow(root, "Required stances", listToText(req["Required Stances"]))
end
    end


    ------------------------------------------------------------------
local function buildTypeTableUI(typeBlock)
    -- Type
if type(typeBlock) ~= "table" or next(typeBlock) == nil then
    ------------------------------------------------------------------
return nil
    local typeBlock = rec.Type or {}
end
    if next(typeBlock) ~= nil then
        addSectionHeader(root, "Type")


        local dt = typeBlock["Damage Type"]
local t = mw.html.create("table")
        if type(dt) == "table" and dt.Name then
t: addClass("sv-type-table")
            addRow(root, "Damage type", dt.Name)
        end


        local et = typeBlock["Element Type"]
local added = false
        if type(et) == "table" and et.Name then
            addRow(root, "Element", et.Name)
        end


        local tt = typeBlock["Target Type"]
local function valName(x)
        if type(tt) == "table" and tt.Name then
if x == nil then return nil end
            addRow(root, "Target", tt.Name)
if type(x) == "table" then
        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
end
if type(x) == "string" and x ~= "" then return x end
return nil
end
 
local function addRowKV(k, v)
if not v or v == "" then return end
added = true
local r = t: tag("tr")
r: tag("th"): wikitext(mw.text.nowiki(k)): done()
r: tag("td"): wikitext(mw.text.nowiki(v)): done()
end
 
addRowKV("Type", valName(typeBlock["Damage Type"]))-- renamed from "Damage Type"
addRowKV("Element", valName(typeBlock["Element Type"]))
addRowKV("Target", valName(typeBlock["Target Type"]))
addRowKV("Cast Type", valName(typeBlock["Cast Type"]))
 
if not added then
return nil
end
return tostring(t)
end
 
local function addTopBand(tbl, levelUI, typeUI)
if not levelUI and not typeUI then
return
end
 
local row = tbl: tag("tr")
local cell = row: tag("td")
cell: attr("colspan", 2)
cell: addClass("sv-topband-cell")
 
--Nested table(what Common.css targets)
local inner = cell: tag("table")
inner: addClass("sv-topband-table")
 
local tr = inner: tag("tr")
 
if levelUI and typeUI then
tr: tag("td"): wikitext(levelUI): done()
tr: tag("td"): wikitext(typeUI): done()
elseif levelUI then
tr: tag("td"): attr("colspan", 2): wikitext(levelUI): done()
else
tr: tag("td"): attr("colspan", 2): wikitext(typeUI): done()
end
end
 
local function buildInfobox(rec, opts)
opts = opts or { }
local showUsers = (opts.showUsers ~= false)
 
local maxLevel = tonumber(rec["Max Level"]) or 1
if maxLevel < 1 then maxLevel = 1 end
 
--Always default to max level
local level = clamp(maxLevel, 1, maxLevel)
 
local root = mw.html.create("table")
 
--IMPORTANT:
--Don't use "wikitable" here; it triggers default borders + Citizen wrapper styling.
root: addClass("spiritvale-skill-infobox")
 
--JS hook: treat the table itself as the "card"
root: addClass("sv-skill-card")
 
--Helpful flag for list - mode overrides(optional, but nice)
if opts and opts.inList then
root: addClass("sv-skill-inlist")
end
 
--JS hook: treat the table itself as the "card"
root: addClass("sv-skill-card")
root: attr("data-max-level", tostring(maxLevel))
root: attr("data-level", tostring(level))
 
--Top "hero" rows:
--1) Title row: icon + name centered(single cell)
--2) Description row: its own row below(still part of the hero band)
 
local icon = rec.Icon
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
local desc = rec.Description or ""
 
--Row 1: icon + title(single column)
local heroRow = root: tag("tr")
heroRow: addClass("spiritvale-infobox-main")
heroRow: addClass("sv-hero-title-row")
 
local heroCell = heroRow: tag("th")
heroCell: attr("colspan", 2)
heroCell: addClass("sv-hero-title-cell")
 
local heroInner = heroCell: tag("div")
heroInner: addClass("spiritvale-infobox-main-left-inner")-- reuse your centered flex column
 
if icon and icon ~= "" then
heroInner: wikitext(string.format("[[File:%s|80px|link=]]", icon))
end
 
heroInner: tag("div")
: addClass("spiritvale-infobox-title")
: wikitext(title)
 
--Row 2: description(below, still hero - styled)
if desc ~= "" then
local descRow = root: tag("tr")
descRow: addClass("spiritvale-infobox-main")
descRow: addClass("sv-hero-desc-row")


        local ct = typeBlock["Cast Type"]
local descCell = descRow: tag("td")
        if type(ct) == "table" and ct.Name then
descCell: attr("colspan", 2)
            addRow(root, "Cast type", ct.Name)
descCell: addClass("sv-hero-desc-cell")
        end
    end


    ------------------------------------------------------------------
local descInner = descCell: tag("div")
    -- Mechanics
descInner: addClass("spiritvale-infobox-main-right-inner")
    ------------------------------------------------------------------
    local mech = rec.Mechanics or {}
    if next(mech) ~= nil then
        addSectionHeader(root, "Mechanics")


        if mech.Range ~= nil then
descInner: tag("div")
            addRow(root, "Range", tostring(mech.Range))
: addClass("spiritvale-infobox-description")
        end
: wikitext(string.format("''%s''", desc))
end


        local areaText = formatArea(mech.Area)
------------------------------------------------------------------
        addRow(root, "Area", areaText)
--Unified top band(Level Select left, Type list right)
------------------------------------------------------------------
local levelUI = buildLevelSelectUI(level, maxLevel)
local typeUI = buildTypeTableUI(rec.Type or {})
addTopBand(root, levelUI, typeUI)


        if mech["Autocast Multiplier"] ~= nil then
------------------------------------------------------------------
            addRow(root, "Autocast multiplier", tostring(mech["Autocast Multiplier"]))
--Users(kept as rows; caller decides show / hide)
        end
------------------------------------------------------------------
if showUsers then
local users = rec.Users or { }
addRow(root, "Classes", listToText(users.Classes))
addRow(root, "Summons", listToText(users.Summons))
addRow(root, "Monsters", listToText(users.Monsters))
addRow(root, "Events", listToText(users.Events))
end


        local btText = formatTimingBlock(mech["Basic Timings"])
------------------------------------------------------------------
        addRow(root, "Timing", btText)
--Requirements
------------------------------------------------------------------
local req = rec.Requirements or { }
if (req["Required Skills"] and #req["Required Skills"] > 0)
or(req["Required Weapons"] and #req["Required Weapons"] > 0)
or(req["Required Stances"] and #req["Required Stances"] > 0) then


        local rcText = formatResourceCost(mech["Resource Cost"])
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
        addRow(root, "Resource cost", rcText)
local skillParts = {}
for _, rs in ipairs(req["Required Skills"]) do
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
local lvlReq = rs["Required Level"]
if lvlReq then
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
else
table.insert(skillParts, nameReq)
end
end
addRow(root, "Required Skills", table.concat(skillParts, ", "))
end


        local comboText = formatCombo(mech.Combo)
addRow(root, "Required Weapons", listToText(req["Required Weapons"]))
        addRow(root, "Combo", comboText)
addRow(root, "Required Stances", listToText(req["Required Stances"]))
end
 
------------------------------------------------------------------
--Mechanics
------------------------------------------------------------------
local mech = rec.Mechanics or { }
if next(mech) ~= nil then
 
addRow(root, "Range", formatUnitValue(mech.Range))
addRow(root, "Area", formatArea(mech.Area, maxLevel, level))


        local effText = formatMechanicEffects(mech.Effects)
if mech["Autocast Multiplier"] ~= nil then
        addRow(root, "Special mechanics", effText)
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
    end
end
 
addRow(root, "Timing", formatTimingBlock(mech["Basic Timings"], maxLevel, level))
addRow(root, "Resource Cost", formatResourceCost(mech["Resource Cost"], maxLevel, level))
addRow(root, "Combo", formatCombo(mech.Combo))
addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level))
end
 
------------------------------------------------------------------
--Damage & Scaling
------------------------------------------------------------------
local dmg = rec.Damage or { }
if next(dmg) ~= nil then
 
local main = dmg["Main Damage"]
local mainNonHeal, healOnly = {}, {}
 
if type(main) == "table" then
for _, d in ipairs(main) do
if type(d) == "table" and d.Type == "Healing" then
table.insert(healOnly, d)
else
table.insert(mainNonHeal, d)
end
end
end


    ------------------------------------------------------------------
local flatList = dmg["Flat Damage"]
    -- Damage & Healing
local reflList = dmg["Reflect Damage"]
    ------------------------------------------------------------------
    local dmg = rec.Damage or {}
    if next(dmg) ~= nil then
        addSectionHeader(root, "Damage and scaling")


        if dmg["Healing Present"] then
local flatHas = (type(flatList) == "table" and #flatList > 0)
            addRow(root, "Healing", "Yes")
local reflHas = (type(reflList) == "table" and #reflList > 0)
        end


        local mainText = formatMainDamage(dmg["Main Damage"])
local pureHealing = (#healOnly > 0) and(#mainNonHeal == 0) and(not flatHas) and(not reflHas)
        addRow(root, "Main damage", mainText)


        local reflText = formatReflectDamage(dmg["Reflect Damage"])
addRow(root, "Main Damage", formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)))
        addRow(root, "Reflect damage", reflText)
addRow(root, "Flat Damage", formatDamageList(flatList, maxLevel, level, false))
addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false))
addRow(root, "Healing", formatDamageList(healOnly, maxLevel, level, false))


        local scaleText = formatScaling(dmg.Scaling)
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
        addRow(root, "Scaling", scaleText)
end
    end


    ------------------------------------------------------------------
------------------------------------------------------------------
    -- Modifiers
--Modifiers
    ------------------------------------------------------------------
------------------------------------------------------------------
    local modsText = formatModifiers(rec.Modifiers)
local modsText = formatModifiers(rec.Modifiers)
    if modsText then
if modsText then
        addSectionHeader(root, "Modifiers")
addRow(root, "Flags", modsText)
        addRow(root, "Flags", modsText)
end
    end


    ------------------------------------------------------------------
------------------------------------------------------------------
    -- Status
--Status
    ------------------------------------------------------------------
------------------------------------------------------------------
    local statusApps = formatStatusApplications(rec["Status Applications"])
local statusApps = formatStatusApplications(rec["Status Applications"], maxLevel, level)
    local statusRem = formatStatusRemoval(rec["Status Removal"])
local statusRem = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
    if statusApps or statusRem then
if statusApps or statusRem then
        addSectionHeader(root, "Status effects")
addRow(root, "Applies", statusApps)
        addRow(root, "Applies", statusApps)
addRow(root, "Removes", statusRem)
        addRow(root, "Removes", statusRem)
end
    end


    ------------------------------------------------------------------
------------------------------------------------------------------
    -- Events
--Events
    ------------------------------------------------------------------
------------------------------------------------------------------
    local eventsText = formatEvents(rec.Events)
local eventsText = formatEvents(rec.Events)
    if eventsText then
if eventsText then
        addSectionHeader(root, "Events")
addRow(root, "Triggers", eventsText)
        addRow(root, "Triggers", eventsText)
end
    end


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


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


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Public: list all skills for a given user/class
--Public: list all skills for a given user / class
----------------------------------------------------------------------
----------------------------------------------------------------------


function p.listForUser(frame)
function p.listForUser(frame)
    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
userName = mw.title.getCurrentTitle().text
        userName = mw.title.getCurrentTitle().text
end
    end


    if not userName or userName == "" then
if not userName or userName == "" then
        return "<strong>No user name provided to Skill list.</strong>"
return "<strong>No user name provided to Skill list.</strong>"
    end
end


    local dataset = getSkills()
local dataset = getSkills()
    local matches = {}
local matches = {}


    for _, rec in ipairs(dataset.records or {}) do
for _, rec in ipairs(dataset.records or {}) do
        if skillMatchesUser(rec, userName) then
if skillMatchesUser(rec, userName) then
            table.insert(matches, rec)
table.insert(matches, rec)
        end
end
    end
end


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


    local root = mw.html.create("div")
--ONE wrapper panel(table - like list mode)
    root:addClass("spiritvale-skill-list")
local root = mw.html.create("div")
root: addClass("sv-skill-collection")


    for _, rec in ipairs(matches) do
for _, rec in ipairs(matches) do
        root:wikitext(buildInfobox(rec))
--Stable per - skill wrapper so dividers work even under Citizen wrappers
    end
local item = root: tag("div"): addClass("sv-skill-item")
item: wikitext(buildInfobox(rec, { showUsers = false, inList = true }))
end


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


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Public: single-skill or auto-list dispatcher
--Public: single - skill or auto - list dispatcher
----------------------------------------------------------------------
----------------------------------------------------------------------


function p.infobox(frame)
function p.infobox(frame)
    local args = getArgs(frame)
local args = getArgs(frame)


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


    local rec
local rec
if name and name ~= "" then
rec = findSkillByName(name)
end
if not rec and id and id ~= "" then
rec = getSkillById(id)
end


    -- 1) Prefer display Name
if not rec then
    if name and name ~= "" then
local pageTitle = mw.title.getCurrentTitle()
        rec = findSkillByName(name)
local pageName = pageTitle and pageTitle.text or ""
    end


    -- 2) Fallback: internal ID
local noExplicitArgs =
    if not rec and id and id ~= "" then
(not raw1 or raw1 == "") and
        rec = getSkillById(id)
(not args.name or args.name == "") and
    end
(not id or id == "")


    -- 3) If still nothing, decide if this is "list mode" or truly unknown.
if noExplicitArgs then
    if not rec then
return p.listForUser(frame)
        local pageTitle = mw.title.getCurrentTitle()
end
        local pageName  = pageTitle and pageTitle.text or ""


        local noExplicitArgs =
if name and name ~= "" and name == pageName and(not id or id == "") then
            (not raw1 or raw1 == "") and
return p.listForUser(frame)
            (not args.name or args.name == "") and
end
            (not id or id == "")


        -- Case A: {{Skill}} with no parameters on a page → list for that page name.
local label = name or id or "?"
        if noExplicitArgs then
return string.format(
            return p.listForUser(frame)
"<strong>Unknown Skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
        end
mw.text.nowiki(label),
 
label
        -- 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
end
            return p.listForUser(frame)
        end
 
        -- Otherwise, genuinely unknown skill.
        local label = name or id or "?"
        return string.format(
            "<strong>Unknown skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
            mw.text.nowiki(label),
            label
        )
    end


    -- Normal single-skill behavior
local showUsers = not isDirectSkillPage(rec)
    return buildInfobox(rec)
return buildInfobox(rec, { showUsers = showUsers })
end
end


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