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


local function formatMainDamage(list)
--Dynamic damage entry:
    if type(list) ~= "table" or #list == 0 then
--Build a series for Lv1..LvMax, and show only the selected one.
        return nil
local function formatDamageEntry(entry, maxLevel, level)
    end
if type(entry) ~= "table" then
    local parts = {}
return nil
    for _, d in ipairs(list) do
        if type(d) == "table" then
            local kind = d.Type or "Damage"
            local base = d["Base %"]
            local per  = d["Per Level %"]
            local seg  = kind
            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 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 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 base = d["Base %"]
local perN = toNum(perRaw)
            local per  = d["Per Level %"]
 
            local seg  = "Reflect"
local function baseIsPresent()
            local detail = {}
if baseN ~= nil then
            if base ~= nil then
return baseN ~= 0
                table.insert(detail, string.format("Base %s%%", tostring(base)))
end
            end
if baseRaw ~= nil then
            if per ~= nil then
local s = tostring(baseRaw)
                table.insert(detail, string.format("%s%% / Lv", tostring(per)))
return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
            end
end
            if #detail > 0 then
return false
                seg = seg .. " – " .. table.concat(detail, ", ")
end
            end
 
            table.insert(parts, seg)
local baseText = nil
        end
if baseIsPresent() then
    end
if baseN ~= nil then
    if #parts == 0 then
baseText = fmtNum(baseN).. "%"
        return nil
else
    end
baseText = tostring(baseRaw).. "%"
    return table.concat(parts, "<br />")
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
 
local parts = {}
for _, s in ipairs(list) do
if type(s) == "table" then
local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
local pct = s.Percent
local pctN = toNum(pct)
 
local basis = basisOverride or basisLabel(s, false)
 
if pctN ~= nil and pctN ~= 0 then
table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
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
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


    add("Cast Time", "Cast Time")
local function formatTimingBlock(bt, maxLevel, level)
    add("Cooldown", "Cooldown")
if type(bt) ~= "table" then
    add("Duration", "Duration")
return nil
end
local parts = {}


    if bt["Effect Cast Time"] ~= nil then
local function add(label, key)
        table.insert(parts, "Effect Cast Time: " .. tostring(bt["Effect Cast Time"]))
local block = bt[key]
    end
if type(block) ~= "table" then
    if bt["Damage Delay"] ~= nil then
return
        table.insert(parts, "Damage Delay: " .. tostring(bt["Damage Delay"]))
end
    end
local lines = valuePairDynamicLines(label, block, maxLevel, level)
    if bt["Effect Remove Delay"] ~= nil then
for _, line in ipairs(lines) do
        table.insert(parts, "Effect Remove Delay: " .. tostring(bt["Effect Remove Delay"]))
table.insert(parts, line)
    end
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
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
 
local keys = {}
for k, _ in pairs(effects) do
table.insert(keys, k)
end
table.sort(keys)
 
local parts = {}
 
local function effectAmount(block)
if type(block) ~= "table" then
return nil
end
end


local function formatMechanicEffects(effects)
local per = block["Per Level"]
    if type(effects) ~= "table" then
 
        return nil
if type(per) == "table" and #per > 0 then
    end
if isFlatList(per) then
    local parts = {}
return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
    for name, block in pairs(effects) do
end
        if type(block) == "table" then
local series = {}
            local bp = formatBasePer(block)
for _, v in ipairs(per) do
            local seg = name
table.insert(series, formatUnitValue(v) or tostring(v))
            if bp then
end
                seg = seg .. " – " .. bp
return dynSpan(series, level)
            end
end
            table.insert(parts, seg)
 
        end
local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
    end
local txt = valuePairRawText(pair)
    if #parts == 0 then
return txt and mw.text.nowiki(txt) or nil
        return nil
end
    end
 
    return table.concat(parts, "<br />")
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
    return table.concat(parts, "<br />")
end
end
return table.concat(parts, "<br />")
end
local function formatStatusApplications(list, maxLevel, level)
if type(list) ~= "table" or #list == 0 then
return nil
end
local parts = {}
for _, s in ipairs(list) do
if type(s) == "table" then
local scope = s.Scope or "Target"
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"


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


            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"])
    -- Top "hero" row: icon + name (left), description (right)
local internal = trim(rec["Internal Name"] or rec["InternalName"] or rec["InternalID"])
    -- ==========================================================
    local icon  = rec.Icon
    local title = rec.Name or rec["Internal Name"] or "Unknown Skill"
    local desc  = rec.Description or ""


    local headerRow = root:tag("tr")
if ext and mw.ustring.lower(ext) == pageName then
    headerRow:addClass("spiritvale-infobox-main")
return true
end
if internal and mw.ustring.lower(internal) == pageName then
return true
end
return false
end


    -- Left cell: icon + name
----------------------------------------------------------------------
    local leftCell = headerRow:tag("th")
--Infobox builder(Top band: Level Select + Type)
    leftCell:addClass("spiritvale-infobox-main-left")
----------------------------------------------------------------------


    local leftInner = leftCell:tag("div")
local function buildLevelSelectUI(level, maxLevel)
    leftInner:addClass("spiritvale-infobox-main-left-inner")
--JS expectations:
--  .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")


    if icon and icon ~= "" then
wrap: tag("div")
        leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
: addClass("sv-level-title")
    end
: wikitext("Level Select")


    leftInner:tag("div")
wrap: tag("div")
        :addClass("spiritvale-infobox-title")
: addClass("sv-level-label")
        :wikitext(title)
: wikitext("Level <span class=\"sv-level-num\">"..tostring(level).. "</span> / "..tostring(maxLevel))


    -- Right cell: italic description
wrap: tag("div"): addClass("sv-level-slider")
    local rightCell = headerRow:tag("td")
    rightCell:addClass("spiritvale-infobox-main-right")


    local rightInner = rightCell:tag("div")
return tostring(wrap)
    rightInner:addClass("spiritvale-infobox-main-right-inner")
end


    if desc ~= "" then
local function buildTypeTableUI(typeBlock)
        rightInner:tag("div")
if type(typeBlock) ~= "table" or next(typeBlock) == nil then
            :addClass("spiritvale-infobox-description")
return nil
            :wikitext(string.format("''%s''", desc))
end
    end


    ------------------------------------------------------------------
local t = mw.html.create("table")
    -- General
t: addClass("sv-type-table")
    ------------------------------------------------------------------
    addSectionHeader(root, "General")


    -- Description is now in the hero row; don't repeat it here.
local added = false
    -- addRow(root, "Description", rec.Description)


    addRow(root, "Max level", rec["Max Level"] and tostring(rec["Max Level"]))
local function valName(x)
if x == nil then return nil end
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
end
if type(x) == "string" and x ~= "" then return x end
return nil
end


    local users = rec.Users or {}
local function addRowKV(k, v)
    addRow(root, "Classes",  listToText(users.Classes))
if not v or v == "" then return end
    addRow(root, "Summons",  listToText(users.Summons))
added = true
    addRow(root, "Monsters", listToText(users.Monsters))
local r = t: tag("tr")
    addRow(root, "Events",  listToText(users.Events))
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"
    -- Requirements
addRowKV("Element", valName(typeBlock["Element Type"]))
    ------------------------------------------------------------------
addRowKV("Target", valName(typeBlock["Target Type"]))
    local req = rec.Requirements or {}
addRowKV("Cast Type", valName(typeBlock["Cast Type"]))
    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")
if not added then
return nil
end
return tostring(t)
end


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


    ------------------------------------------------------------------
--Nested table(what Common.css targets)
    -- Type
local inner = cell: tag("table")
    ------------------------------------------------------------------
inner: addClass("sv-topband-table")
    local typeBlock = rec.Type or {}
    if next(typeBlock) ~= nil then
        addSectionHeader(root, "Type")


        local dt = typeBlock["Damage Type"]
local tr = inner: tag("tr")
        if type(dt) == "table" and dt.Name then
            addRow(root, "Damage type", dt.Name)
        end


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


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


    ------------------------------------------------------------------
--Always default to max level
    -- Mechanics
local level = clamp(maxLevel, 1, maxLevel)
    ------------------------------------------------------------------
    local mech = rec.Mechanics or {}
    if next(mech) ~= nil then
        addSectionHeader(root, "Mechanics")


        if mech.Range ~= nil then
local root = mw.html.create("table")
            addRow(root, "Range", tostring(mech.Range))
        end


        local areaText = formatArea(mech.Area)
--IMPORTANT:
        addRow(root, "Area", areaText)
--Don't use "wikitable" here; it triggers default borders + Citizen wrapper styling.
root: addClass("spiritvale-skill-infobox")


        if mech["Autocast Multiplier"] ~= nil then
--JS hook: treat the table itself as the "card"
            addRow(root, "Autocast multiplier", tostring(mech["Autocast Multiplier"]))
root: addClass("sv-skill-card")
        end


        local btText = formatTimingBlock(mech["Basic Timings"])
--Helpful flag for list - mode overrides(optional, but nice)
        addRow(root, "Timing", btText)
if opts and opts.inList then
root: addClass("sv-skill-inlist")
end


        local rcText = formatResourceCost(mech["Resource Cost"])
--JS hook: treat the table itself as the "card"
        addRow(root, "Resource cost", rcText)
root: addClass("sv-skill-card")
root: attr("data-max-level", tostring(maxLevel))
root: attr("data-level", tostring(level))


        local comboText = formatCombo(mech.Combo)
--Top "hero" rows:
        addRow(root, "Combo", comboText)
--1) Title row: icon + name centered(single cell)
--2) Description row: its own row below(still part of the hero band)


        local effText = formatMechanicEffects(mech.Effects)
local icon = rec.Icon
        addRow(root, "Special mechanics", effText)
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
    end
local desc = rec.Description or ""


    ------------------------------------------------------------------
--Row 1: icon + title(single column)
    -- Damage & Healing
local heroRow = root: tag("tr")
    ------------------------------------------------------------------
heroRow: addClass("spiritvale-infobox-main")
    local dmg = rec.Damage or {}
heroRow: addClass("sv-hero-title-row")
    if next(dmg) ~= nil then
        addSectionHeader(root, "Damage and scaling")


        if dmg["Healing Present"] then
local heroCell = heroRow: tag("th")
            addRow(root, "Healing", "Yes")
heroCell: attr("colspan", 2)
        end
heroCell: addClass("sv-hero-title-cell")


        local mainText = formatMainDamage(dmg["Main Damage"])
local heroInner = heroCell: tag("div")
        addRow(root, "Main damage", mainText)
heroInner: addClass("spiritvale-infobox-main-left-inner")-- reuse your centered flex column


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


        local scaleText = formatScaling(dmg.Scaling)
heroInner: tag("div")
        addRow(root, "Scaling", scaleText)
: addClass("spiritvale-infobox-title")
    end
: wikitext(title)


    ------------------------------------------------------------------
--Row 2: description(below, still hero - styled)
    -- Modifiers
if desc ~= "" then
    ------------------------------------------------------------------
local descRow = root: tag("tr")
    local modsText = formatModifiers(rec.Modifiers)
descRow: addClass("spiritvale-infobox-main")
    if modsText then
descRow: addClass("sv-hero-desc-row")
        addSectionHeader(root, "Modifiers")
        addRow(root, "Flags", modsText)
    end


    ------------------------------------------------------------------
local descCell = descRow: tag("td")
    -- Status
descCell: attr("colspan", 2)
    ------------------------------------------------------------------
descCell: addClass("sv-hero-desc-cell")
    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


    ------------------------------------------------------------------
local descInner = descCell: tag("div")
    -- Events
descInner: addClass("spiritvale-infobox-main-right-inner")
    ------------------------------------------------------------------
    local eventsText = formatEvents(rec.Events)
    if eventsText then
        addSectionHeader(root, "Events")
        addRow(root, "Triggers", eventsText)
    end


    ------------------------------------------------------------------
descInner: tag("div")
    -- Notes
: addClass("spiritvale-infobox-description")
    ------------------------------------------------------------------
: wikitext(string.format("''%s''", desc))
    if type(rec.Notes) == "table" and #rec.Notes > 0 then
end
        addSectionHeader(root, "Notes")
 
        addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
------------------------------------------------------------------
    end
--Unified top band(Level Select left, Type list right)
------------------------------------------------------------------
local levelUI = buildLevelSelectUI(level, maxLevel)
local typeUI = buildTypeTableUI(rec.Type or {})
addTopBand(root, levelUI, typeUI)
 
------------------------------------------------------------------
--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
 
------------------------------------------------------------------
--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


    return tostring(root)
local showUsers = not isDirectSkillPage(rec)
return buildInfobox(rec, { showUsers = showUsers })
end
end


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