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


-- Lookup by Internal Name
local function trim(s)
local function getSkillById(id)
if type(s) ~= "string" then return nil end
    if not id or id == "" then
s = mw.text.trim(s)
        return nil
if s == "" then return nil end
    end
return s
    local dataset = getSkills()
end
    local byId = dataset.byId or {}
 
    return byId[id]
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
 
local function clamp(n, lo, hi)
if type(n) ~= "number" then return lo end
if n < lo then return lo end
if n > hi then return hi end
return n
end
 
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
end


local function formatMainDamage(list)
local isHealing = (entry.Type == "Healing")
    if type(list) ~= "table" or #list == 0 then
local basis = isHealing and "Healing" or basisLabel(entry)
        return nil
 
    end
local baseRaw = entry["Base %"]
    local parts = {}
local perRaw = entry["Per Level %"]
    for _, d in ipairs(list) do
 
        if type(d) == "table" then
local baseN = toNum(baseRaw)
            local kind = d.Type or "Damage"
local perN = toNum(perRaw)
            local base = d["Base %"]
 
            local per  = d["Per Level %"]
local function baseIsPresent()
            local seg  = kind
if baseN ~= nil then
            local detail = {}
return baseN ~= 0
            if base ~= nil then
end
                table.insert(detail, string.format("Base %s%%", tostring(base)))
if baseRaw ~= nil then
            end
local s = tostring(baseRaw)
            if per ~= nil then
return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
                table.insert(detail, string.format("%s%% / Lv", tostring(per)))
end
            end
return false
            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)
local baseText = nil
    if type(list) ~= "table" or #list == 0 then
if baseIsPresent() then
        return nil
if baseN ~= nil then
    end
baseText = fmtNum(baseN).. "%"
    local parts = {}
else
    for _, d in ipairs(list) do
baseText = tostring(baseRaw).. "%"
        if type(d) == "table" then
end
            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)
--No scaling -> just show base
    if type(list) ~= "table" or #list == 0 then
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
        return nil
return baseText and mw.text.nowiki(baseText.. " "..basis) or 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 function formatArea(area)
--Build series strings for each level
    if type(area) ~= "table" then
local series = {}
        return nil
for lv = 1, maxLevel do
    end
local perPart = perN * lv
    local parts = {}
 
    local size = area["Area Size"]
if baseText and baseN ~= nil then
    if size and size ~= "" then
local total = baseN + perPart
        table.insert(parts, "Size: " .. tostring(size))
table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
    end
elseif baseText then
    local dist = area["Area Distance"]
table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
    local eff  = area["Effective Distance"]
else
    local distText = formatBasePer(dist)
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
    if distText then
end
        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)
return dynSpan(series, level)
    if type(bt) ~= "table" then
end
        return nil
    end
    local parts = {}


    local function add(name, key)
local function formatDamageList(list, maxLevel, level, includeTypePrefix)
        local block = bt[key]
if type(list) ~= "table" or #list == 0 then
        local txt = formatBasePer(block)
return nil
        if txt then
end
            table.insert(parts, name .. ": " .. txt)
        end
    end


    add("Cast Time", "Cast Time")
local parts = {}
    add("Cooldown", "Cooldown")
for _, d in ipairs(list) do
    add("Duration", "Duration")
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 bt["Effect Cast Time"] ~= nil then
if #parts == 0 then
        table.insert(parts, "Effect Cast Time: " .. tostring(bt["Effect Cast Time"]))
return nil
    end
end
    if bt["Damage Delay"] ~= nil then
return table.concat(parts, "<br />")
        table.insert(parts, "Damage Delay: " .. tostring(bt["Damage Delay"]))
end
    end
    if bt["Effect Remove Delay"] ~= nil then
        table.insert(parts, "Effect Remove Delay: " .. tostring(bt["Effect Remove Delay"]))
    end


    if #parts == 0 then
local function formatScaling(list, basisOverride)
        return nil
if type(list) ~= "table" or #list == 0 then
    end
return nil
    return table.concat(parts, "<br />")
end
end


local function formatResourceCost(rc)
local parts = {}
    if type(rc) ~= "table" 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
    local mana = rc["Mana Cost"]
local pctN = toNum(pct)
    local hp  = rc["Health Cost"]


    local manaTxt = formatBasePer(mana)
local basis = basisOverride or basisLabel(s, false)
    if manaTxt then
        table.insert(parts, "MP: " .. manaTxt)
    end


    local hpTxt = formatBasePer(hp)
if pctN ~= nil and pctN ~= 0 then
    if hpTxt then
table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
        table.insert(parts, "HP: " .. hpTxt)
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
    end
table.insert(parts, string.format("%s%% %s Per %s", tostring(pct), basis, stat))
end
end
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
 
local function formatArea(area, maxLevel, level)
if type(area) ~= "table" then
return nil
end
local parts = {}
 
local distLine = valuePairDynamicText("Distance", area["Area Distance"], maxLevel, level, "<br />")
if distLine then
table.insert(parts, distLine)
end


    if #parts == 0 then
local size = area["Area Size"]
        return nil
if size and size ~= "" then
    end
table.insert(parts, "Size: "..mw.text.nowiki(tostring(size)))
    return table.concat(parts, "<br />")
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
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("Cooldown", "Cooldown")
add("Duration", "Duration")
 
if bt["Effect Cast Time"] ~= nil then
table.insert(parts, "Effect Cast Time: "..mw.text.nowiki(tostring(bt["Effect Cast Time"])))
end
if bt["Damage Delay"] ~= nil then
table.insert(parts, "Damage Delay: "..mw.text.nowiki(tostring(bt["Damage Delay"])))
end
if bt["Effect Remove Delay"] ~= nil then
table.insert(parts, "Effect Remove Delay: "..mw.text.nowiki(tostring(bt["Effect Remove Delay"])))
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
 
local function formatResourceCost(rc, maxLevel, level)
if type(rc) ~= "table" then
return nil
end
local parts = {}
 
local manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
for _, line in ipairs(manaLines) do
table.insert(parts, line)
end
 
local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
for _, line in ipairs(hpLines) do
table.insert(parts, line)
end
 
if #parts == 0 then
return nil
end
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
end


local function formatMechanicEffects(effects)
local baseText = formatUnitValue(base)
    if type(effects) ~= "table" then
local perText = formatUnitValue(per)
        return nil
 
    end
if baseText and perText and isNonZeroScalar(per) then
    local parts = {}
return string.format("%s (Per Level: %s)", baseText, perText)
    for name, block in pairs(effects) do
end
        if type(block) == "table" then
return baseText or perText
            local bp = formatBasePer(block)
end
            local seg = name
 
            if bp then
--Special Mechanics supports dynamic Per Level lists
                seg = seg .. " – " .. bp
local function formatMechanicEffects(effects, maxLevel, level)
            end
if type(effects) ~= "table" then
            table.insert(parts, seg)
return nil
        end
end
    end
 
    if #parts == 0 then
local keys = {}
        return nil
for k, _ in pairs(effects) do
    end
table.insert(keys, k)
    return table.concat(parts, "<br />")
end
table.sort(keys)
 
local parts = {}
 
local function effectAmount(block)
if type(block) ~= "table" then
return nil
end
 
local per = block["Per Level"]
 
if type(per) == "table" and #per > 0 then
if isFlatList(per) then
return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
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.. " – "..tostring(name)
local detail = {}


            local seg = scope .. " – " .. name
if type(s.Duration) == "table" then
            local detail = {}
local t = valuePairDynamicText("Duration", s.Duration, maxLevel, level, "; ")
if t then table.insert(detail, t) end
end


            local dur = s.Duration
if type(s.Chance) == "table" then
            if type(dur) == "table" then
local t = valuePairDynamicText("Chance", s.Chance, 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 s["Fixed Duration"] then
            if type(ch) == "table" then
table.insert(detail, "Fixed duration")
                local t = formatBasePer(ch)
end
                if t then
                    table.insert(detail, "Chance " .. t)
                end
            end


            if s["Fixed Duration"] then
if #detail > 0 then
                table.insert(detail, "Fixed duration")
seg = seg.. " ("..table.concat(detail, ", ").. ")"
            end
end


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


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


    -- ==========================================================
if ext and mw.ustring.lower(ext) == pageName then
    -- Top "hero" row: icon + name (left), description (right)
return true
    -- ==========================================================
end
    local icon  = rec.Icon
if internal and mw.ustring.lower(internal) == pageName then
    local title = rec.Name or rec["Internal Name"] or "Unknown Skill"
return true
    local desc  = rec.Description or ""
end
return false
end


    local headerRow = root:tag("tr")
----------------------------------------------------------------------
    headerRow:addClass("spiritvale-infobox-main")
--Infobox builder(Top band: Level Select + Type)
----------------------------------------------------------------------


    -- Left cell: icon + name
local function buildLevelSelectUI(level, maxLevel)
    local leftCell = headerRow:tag("th")
--JS expectations:
    leftCell:addClass("spiritvale-infobox-main-left")
--  .sv - level - slider placeholder for the < input type = "range" >
--  .sv - level - num span for updating the number
local wrap = mw.html.create("div")
wrap: addClass("sv-level-ui")


    local leftInner = leftCell:tag("div")
wrap: tag("div")
    leftInner:addClass("spiritvale-infobox-main-left-inner")
: addClass("sv-level-title")
: wikitext("Level Select")


    if icon and icon ~= "" then
wrap: tag("div")
        leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
: addClass("sv-level-label")
    end
: wikitext("Level <span class=\"sv-level-num\">"..tostring(level).. "</span> / "..tostring(maxLevel))


    leftInner:tag("div")
wrap: tag("div"): addClass("sv-level-slider")
        :addClass("spiritvale-infobox-title")
        :wikitext(title)


    -- Right cell: italic description
return tostring(wrap)
    local rightCell = headerRow:tag("td")
end
    rightCell:addClass("spiritvale-infobox-main-right")


    local rightInner = rightCell:tag("div")
local function buildTypeTableUI(typeBlock)
    rightInner:addClass("spiritvale-infobox-main-right-inner")
if type(typeBlock) ~= "table" or next(typeBlock) == nil then
return nil
end


    if desc ~= "" then
local t = mw.html.create("table")
        rightInner:tag("div")
t: addClass("sv-type-table")
            :addClass("spiritvale-infobox-description")
            :wikitext(string.format("''%s''", desc))
    end


    ------------------------------------------------------------------
local added = false
    -- General
    ------------------------------------------------------------------
    addSectionHeader(root, "General")


    -- Description is now in the hero row; don't repeat it here.
local function valName(x)
    -- addRow(root, "Description", rec.Description)
if x == nil then return nil end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
end
if type(x) == "string" and x ~= "" then return x end
return nil
end


    addRow(root, "Max level", rec["Max Level"] and tostring(rec["Max Level"]))
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


    local users = rec.Users or {}
addRowKV("Type", valName(typeBlock["Damage Type"]))-- renamed from "Damage Type"
    addRow(root, "Classes", listToText(users.Classes))
addRowKV("Element", valName(typeBlock["Element Type"]))
    addRow(root, "Summons", listToText(users.Summons))
addRowKV("Target", valName(typeBlock["Target Type"]))
    addRow(root, "Monsters", listToText(users.Monsters))
addRowKV("Cast Type", valName(typeBlock["Cast Type"]))
    addRow(root, "Events",   listToText(users.Events))


    ------------------------------------------------------------------
if not added then
    -- Requirements
return nil
    ------------------------------------------------------------------
end
    local req = rec.Requirements or {}
return tostring(t)
    if (req["Required Skills"] and #req["Required Skills"] > 0)
end
        or (req["Required Weapons"] and #req["Required Weapons"] > 0)
        or (req["Required Stances"] and #req["Required Stances"] > 0) then


        addSectionHeader(root, "Requirements")
local function addTopBand(tbl, levelUI, typeUI)
if not levelUI and not typeUI then
return
end


        if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
local row = tbl: tag("tr")
            local skillParts = {}
local cell = row: tag("td")
            for _, rs in ipairs(req["Required Skills"]) do
cell: attr("colspan", 2)
                local name  = rs["Skill Name"] or rs["Skill ID"] or "Unknown"
cell: addClass("sv-topband-cell")
                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"]))
--Nested table(what Common.css targets)
        addRow(root, "Required stances", listToText(req["Required Stances"]))
local inner = cell: tag("table")
    end
inner: addClass("sv-topband-table")


    ------------------------------------------------------------------
local tr = inner: tag("tr")
    -- Type
    ------------------------------------------------------------------
    local typeBlock = rec.Type or {}
    if next(typeBlock) ~= nil then
        addSectionHeader(root, "Type")


        local dt = typeBlock["Damage Type"]
if levelUI and typeUI then
        if type(dt) == "table" and dt.Name then
tr: tag("td"): wikitext(levelUI): done()
            addRow(root, "Damage type", dt.Name)
tr: tag("td"): wikitext(typeUI): done()
        end
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 et = typeBlock["Element Type"]
local function buildInfobox(rec, opts)
        if type(et) == "table" and et.Name then
opts = opts or { }
            addRow(root, "Element", et.Name)
local showUsers = (opts.showUsers ~= false)
        end


        local tt = typeBlock["Target Type"]
local maxLevel = tonumber(rec["Max Level"]) or 1
        if type(tt) == "table" and tt.Name then
if maxLevel < 1 then maxLevel = 1 end
            addRow(root, "Target", tt.Name)
        end


        local ct = typeBlock["Cast Type"]
--Always default to max level
        if type(ct) == "table" and ct.Name then
local level = clamp(maxLevel, 1, maxLevel)
            addRow(root, "Cast type", ct.Name)
        end
    end


    ------------------------------------------------------------------
local root = mw.html.create("table")
    -- Mechanics
    ------------------------------------------------------------------
    local mech = rec.Mechanics or {}
    if next(mech) ~= nil then
        addSectionHeader(root, "Mechanics")


        if mech.Range ~= nil then
--IMPORTANT:
            addRow(root, "Range", tostring(mech.Range))
--Don't use "wikitable" here; it triggers default borders + Citizen wrapper styling.
        end
root: addClass("spiritvale-skill-infobox")


        local areaText = formatArea(mech.Area)
--JS hook: treat the table itself as the "card"
        addRow(root, "Area", areaText)
root: addClass("sv-skill-card")


        if mech["Autocast Multiplier"] ~= nil then
--Helpful flag for list - mode overrides(optional, but nice)
            addRow(root, "Autocast multiplier", tostring(mech["Autocast Multiplier"]))
if opts and opts.inList then
        end
root: addClass("sv-skill-inlist")
end


        local btText = formatTimingBlock(mech["Basic Timings"])
--JS hook: treat the table itself as the "card"
        addRow(root, "Timing", btText)
root: addClass("sv-skill-card")
root: attr("data-max-level", tostring(maxLevel))
root: attr("data-level", tostring(level))


        local rcText = formatResourceCost(mech["Resource Cost"])
--Top "hero" rows:
        addRow(root, "Resource cost", rcText)
--1) Title row: icon + name centered(single cell)
--2) Description row: its own row below(still part of the hero band)


        local comboText = formatCombo(mech.Combo)
local icon = rec.Icon
        addRow(root, "Combo", comboText)
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
local desc = rec.Description or ""


        local effText = formatMechanicEffects(mech.Effects)
--Row 1: icon + title(single column)
        addRow(root, "Special mechanics", effText)
local heroRow = root: tag("tr")
    end
heroRow: addClass("spiritvale-infobox-main")
heroRow: addClass("sv-hero-title-row")


    ------------------------------------------------------------------
local heroCell = heroRow: tag("th")
    -- Damage & Healing
heroCell: attr("colspan", 2)
    ------------------------------------------------------------------
heroCell: addClass("sv-hero-title-cell")
    local dmg = rec.Damage or {}
    if next(dmg) ~= nil then
        addSectionHeader(root, "Damage and scaling")


        if dmg["Healing Present"] then
local heroInner = heroCell: tag("div")
            addRow(root, "Healing", "Yes")
heroInner: addClass("spiritvale-infobox-main-left-inner")-- reuse your centered flex column
        end


        local mainText = formatMainDamage(dmg["Main Damage"])
if icon and icon ~= "" then
        addRow(root, "Main damage", mainText)
heroInner: wikitext(string.format("[[File:%s|80px|link=]]", icon))
end


        local reflText = formatReflectDamage(dmg["Reflect Damage"])
heroInner: tag("div")
        addRow(root, "Reflect damage", reflText)
: addClass("spiritvale-infobox-title")
: wikitext(title)


        local scaleText = formatScaling(dmg.Scaling)
--Row 2: description(below, still hero - styled)
        addRow(root, "Scaling", scaleText)
if desc ~= "" then
    end
local descRow = root: tag("tr")
descRow: addClass("spiritvale-infobox-main")
descRow: addClass("sv-hero-desc-row")


    ------------------------------------------------------------------
local descCell = descRow: tag("td")
    -- Modifiers
descCell: attr("colspan", 2)
    ------------------------------------------------------------------
descCell: addClass("sv-hero-desc-cell")
    local modsText = formatModifiers(rec.Modifiers)
    if modsText then
        addSectionHeader(root, "Modifiers")
        addRow(root, "Flags", modsText)
    end


    ------------------------------------------------------------------
local descInner = descCell: tag("div")
    -- Status
descInner: addClass("spiritvale-infobox-main-right-inner")
    ------------------------------------------------------------------
    local statusApps = formatStatusApplications(rec["Status Applications"])
    local statusRem  = formatStatusRemoval(rec["Status Removal"])
    if statusApps or statusRem then
        addSectionHeader(root, "Status effects")
        addRow(root, "Applies", statusApps)
        addRow(root, "Removes", statusRem)
    end


    ------------------------------------------------------------------
descInner: tag("div")
    -- Events
: addClass("spiritvale-infobox-description")
    ------------------------------------------------------------------
: wikitext(string.format("''%s''", desc))
    local eventsText = formatEvents(rec.Events)
end
    if eventsText then
        addSectionHeader(root, "Events")
        addRow(root, "Triggers", eventsText)
    end


    ------------------------------------------------------------------
------------------------------------------------------------------
    -- Notes
--Unified top band(Level Select left, Type list right)
    ------------------------------------------------------------------
------------------------------------------------------------------
    if type(rec.Notes) == "table" and #rec.Notes > 0 then
local levelUI = buildLevelSelectUI(level, maxLevel)
        addSectionHeader(root, "Notes")
local typeUI = buildTypeTableUI(rec.Type or {})
        addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
addTopBand(root, levelUI, typeUI)
    end


    return tostring(root)
------------------------------------------------------------------
--Users(kept as rows; caller decides show / hide)
------------------------------------------------------------------
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
end
------------------------------------------------------------------
--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
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
addRow(root, "Required Skills", table.concat(skillParts, ", "))
end
addRow(root, "Required Weapons", listToText(req["Required Weapons"]))
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))
if mech["Autocast Multiplier"] ~= nil then
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
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"]
local reflList = dmg["Reflect Damage"]
local flatHas = (type(flatList) == "table" and #flatList > 0)
local reflHas = (type(reflList) == "table" and #reflList > 0)
local pureHealing = (#healOnly > 0) and(#mainNonHeal == 0) and(not flatHas) and(not reflHas)
addRow(root, "Main Damage", formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)))
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))
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
end
------------------------------------------------------------------
--Modifiers
------------------------------------------------------------------
local modsText = formatModifiers(rec.Modifiers)
if modsText then
addRow(root, "Flags", modsText)
end
------------------------------------------------------------------
--Status
------------------------------------------------------------------
local statusApps = formatStatusApplications(rec["Status Applications"], maxLevel, level)
local statusRem = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
if statusApps or statusRem then
addRow(root, "Applies", statusApps)
addRow(root, "Removes", statusRem)
end
------------------------------------------------------------------
--Events
------------------------------------------------------------------
local eventsText = formatEvents(rec.Events)
if eventsText then
addRow(root, "Triggers", eventsText)
end
------------------------------------------------------------------
--Notes
------------------------------------------------------------------
if type(rec.Notes) == "table" and #rec.Notes > 0 then
addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
end
return tostring(root)
end
----------------------------------------------------------------------
--Public: list all skills for a given user / class
----------------------------------------------------------------------
function p.listForUser(frame)
local args = getArgs(frame)
local userName = args.user or args[1]
if not userName or userName == "" then
userName = mw.title.getCurrentTitle().text
end
if not userName or userName == "" then
return "<strong>No user name provided to Skill list.</strong>"
end
local dataset = getSkills()
local matches = {}
for _, rec in ipairs(dataset.records or {}) do
if skillMatchesUser(rec, userName) then
table.insert(matches, rec)
end
end
if #matches == 0 then
return string.format(
"<strong>No skills found for:</strong> %s",
mw.text.nowiki(userName)
)
end
--ONE wrapper panel(table - like list mode)
local root = mw.html.create("div")
root: addClass("sv-skill-collection")
for _, rec in ipairs(matches) do
--Stable per - skill wrapper so dividers work even under Citizen wrappers
local item = root: tag("div"): addClass("sv-skill-item")
item: wikitext(buildInfobox(rec, { showUsers = false, inList = true }))
end
return tostring(root)
end
----------------------------------------------------------------------
--Public: single - skill or auto - list dispatcher
----------------------------------------------------------------------
function p.infobox(frame)
local args = getArgs(frame)
local raw1 = args[1]
local name = args.name or raw1
local id = args.id
local rec
if name and name ~= "" then
rec = findSkillByName(name)
end
if not rec and id and id ~= "" then
rec = getSkillById(id)
end
if not rec then
local pageTitle = mw.title.getCurrentTitle()
local pageName = pageTitle and pageTitle.text or ""
local noExplicitArgs =
(not raw1 or raw1 == "") and
(not args.name or args.name == "") and
(not id or id == "")
if noExplicitArgs then
return p.listForUser(frame)
end
if name and name ~= "" and name == pageName and(not id or id == "") then
return p.listForUser(frame)
end
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
local showUsers = not isDirectSkillPage(rec)
return buildInfobox(rec, { showUsers = showUsers })
end
return p
Retrieved from "https://spiritvale.info/wiki/Module:GameSkills"