Toggle search
Toggle menu
110
215
16
2.1K
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 editNewer edit →
No edit summary
No edit summary
(9 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:GameSkills
--Module: GameSkills
--
--
-- Upgrades:
--Upgrades:
--  - Adds a per-skill Level Select slider (client-side JS updates fields)
--  - Adds a per - skill Level Select slider(client - side JS updates fields)
--  - Default level = Max Level
--  - Default level = Max Level
--  - Adds .sv-skill-card + data-max-level/data-level hooks for JS
--  - Adds.sv - skill - card + data - max - level / data - level hooks for JS
--  - Replaces large Lv1/Lv2/... lists with data-series dynamic spans
--  - 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.
--
--
-- Requires the JS you installed in MediaWiki:Common.js.
--Requires the JS you installed in MediaWiki: Common.js.
--Uses Common.css classes:
--  .sv - topband - cell, .sv - topband - table, .sv - type - table, .sv - level - ui, .sv - level - title, .sv - level - label, .sv - level - slider
--  .sv - skill - collection, .sv - skill - item


local GameData = require("Module:GameData")
local GameData = require("Module:GameData")
Line 14: 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


local function trim(s)
local function trim(s)
if type(s) ~= "string" then return nil end
if type(s) ~= "string" then return nil end
s = mw.text.trim(s)
s = mw.text.trim(s)
if s == "" then return nil end
if s == "" then return nil end
return s
return s
end
end


local function toNum(v)
local function toNum(v)
if type(v) == "number" then return v end
if type(v) == "number" then return v end
if type(v) == "string" then return tonumber(v) end
if type(v) == "string" then return tonumber(v) end
if type(v) == "table" and v.Value ~= nil then
if type(v) == "table" and v.Value ~= nil then
return toNum(v.Value)
return toNum(v.Value)
end
end
return nil
return nil
end
end


local function clamp(n, lo, hi)
local function clamp(n, lo, hi)
if type(n) ~= "number" then return lo end
if type(n) ~= "number" then return lo end
if n < lo then return lo end
if n < lo then return lo end
if n > hi then return hi end
if n > hi then return hi end
return n
return n
end
end


local function fmtNum(n)
local function fmtNum(n)
if type(n) ~= "number" then
if type(n) ~= "number" then
return (n ~= nil) and tostring(n) or nil
return (n ~= nil) and tostring(n) or nil
end
end
if math.abs(n - math.floor(n)) < 1e-9 then
if math.abs(n - math.floor(n)) < 1e-9 then
return tostring(math.floor(n))
return tostring(math.floor(n))
end
end
local s = string.format("%.4f", n)
local s = string.format("%.4f", n)
s = mw.ustring.gsub(s, "0+$", "")
s = mw.ustring.gsub(s, "0+$", "")
s = mw.ustring.gsub(s, "%.$", "")
s = mw.ustring.gsub(s, "%.$", "")
return s
return s
end
end


-- Handles either a scalar OR {Value=..., Unit=...}
--Handles either a scalar OR { Value =..., Unit =... }
-- IMPORTANT: do NOT convert percent_decimal/percent_whole; just format around stored values.
--IMPORTANT: do NOT convert percent_decimal / percent_whole; just format around stored values.
local function formatUnitValue(v)
local function formatUnitValue(v)
if type(v) == "table" and v.Value ~= nil then
if type(v) == "table" and v.Value ~= nil then
local unit = v.Unit
local unit = v.Unit
local val = v.Value
local val = v.Value


if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
if unit == "percent_decimal" or unit == "percent_whole" or unit == "percent" then
return tostring(val) .. "%"
return tostring(val).. "%"
elseif unit == "seconds" then
elseif unit == "seconds" then
return tostring(val) .. "s"
return tostring(val).. "s"
elseif unit == "meters" then
elseif unit == "meters" then
return tostring(val) .. "m"
return tostring(val).. "m"
elseif unit == "tiles" then
elseif unit == "tiles" then
return tostring(val) .. " tiles"
return tostring(val).. " tiles"
elseif unit and unit ~= "" then
elseif unit and unit ~= "" then
return tostring(val) .. " " .. tostring(unit)
return tostring(val).. " "..tostring(unit)
else
else
return tostring(val)
return tostring(val)
end
end
end
end


if v == nil then
if v == nil then
return nil
return nil
end
end
return tostring(v)
return tostring(v)
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Dynamic field helpers (JS-driven)
--Dynamic field helpers(JS - driven)
----------------------------------------------------------------------
----------------------------------------------------------------------


local function dynSpan(series, level)
local function dynSpan(series, level)
if type(series) ~= "table" or #series == 0 then
if type(series) ~= "table" or #series == 0 then
return nil
return nil
end
end
level = clamp(level or #series, 1, #series)
level = clamp(level or #series, 1, #series)


local span = mw.html.create("span")
local span = mw.html.create("span")
span:addClass("sv-dyn")
span: addClass("sv-dyn")
span:attr("data-series", mw.text.jsonEncode(series))
span: attr("data-series", mw.text.jsonEncode(series))
span:wikitext(mw.text.nowiki(series[level] or ""))
span: wikitext(mw.text.nowiki(series[level] or ""))


return tostring(span)
return tostring(span)
end
end


local function isFlatList(list)
local function isFlatList(list)
if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
return false
return false
end
end
local first = tostring(list[1])
local first = tostring(list[1])
for i = 2, #list do
for i = 2, #list do
if tostring(list[i]) ~= first then
if tostring(list[i]) ~= first then
return false
return false
end
end
end
end
return true
return true
end
end


local function isNonZeroScalar(v)
local function isNonZeroScalar(v)
if v == nil then return false end
if v == nil then return false end
if type(v) == "number" then return v ~= 0 end
if type(v) == "number" then return v ~= 0 end
if type(v) == "string" then
if type(v) == "string" then
local n = tonumber(v)
local n = tonumber(v)
if n == nil then
if n == nil then
return v ~= ""
return v ~= ""
end
end
return n ~= 0
return n ~= 0
end
end
if type(v) == "table" and v.Value ~= nil then
if type(v) == "table" and v.Value ~= nil then
return isNonZeroScalar(v.Value)
return isNonZeroScalar(v.Value)
end
end
return true
return true
end
end


-- Like your old valuePairLines/valuePairText, but:
--Like your old valuePairLines / valuePairText, but:
-- - if Per Level is a list, we render a dynamic span instead of "v1 / v2 / ...".
-- - if Per Level is a list, render a dynamic span instead of "v1 / v2 / ..."
-- - scalar Per Level stays as the old "Base" and "Per Level" lines (still short).
-- - scalar Per Level stays as the old "Base" + "Per Level" lines(still short)
local function valuePairDynamicLines(name, block, maxLevel, level)
local function valuePairDynamicLines(name, block, maxLevel, level)
if type(block) ~= "table" then
if type(block) ~= "table" then
return {}
return {}
end
end


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


-- Per Level list (expanded)
--Per Level list(expanded)
if type(per) == "table" then
if type(per) == "table" then
-- empty list -> show Base only
--empty list -> show Base only
if #per == 0 then
if #per == 0 then
local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
if baseText then
if baseText then
return { string.format("%s: %s", name, mw.text.nowiki(baseText)) }
return { string.format("%s: %s", name, mw.text.nowiki(baseText)) }
end
end
return {}
return {}
end
end


-- Flat list -> show single value
--flat list -> show single value
if isFlatList(per) then
if isFlatList(per) then
local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
local one = formatUnitValue(per[1]) or tostring(per[1])
local one = formatUnitValue(per[1]) or tostring(per[1])
local show = baseText or one
local show = baseText or one
if show then
if show then
return { string.format("%s: %s", name, mw.text.nowiki(show)) }
return { string.format("%s: %s", name, mw.text.nowiki(show)) }
end
end
return {}
return {}
end
end


-- Dynamic series
--dynamic series
local series = {}
local series = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
table.insert(series, formatUnitValue(v) or tostring(v))
end
end


local dyn = dynSpan(series, level)
local dyn = dynSpan(series, level)
if dyn then
if dyn then
return { string.format("%s: %s", name, dyn) }
return { string.format("%s: %s", name, dyn) }
end
end
return {}
return {}
end
end


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


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


return lines
return lines
end
end


local function valuePairDynamicText(name, block, maxLevel, level, sep)
local function valuePairDynamicText(name, block, maxLevel, level, sep)
local lines = valuePairDynamicLines(name, block, maxLevel, level)
local lines = valuePairDynamicLines(name, block, maxLevel, level)
if #lines == 0 then return nil end
if #lines == 0 then return nil end
return table.concat(lines, sep or "<br />")
return table.concat(lines, sep or "<br />")
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Lookups
--Lookups
----------------------------------------------------------------------
----------------------------------------------------------------------


local function getSkillById(id)
local function getSkillById(id)
id = trim(id)
id = trim(id)
if not id then return nil end
if not id then return nil end
local dataset = getSkills()
local dataset = getSkills()
local byId = dataset.byId or {}
local byId = dataset.byId or { }
return byId[id]
return byId[id]
end
end


local function findSkillByName(name)
local function findSkillByName(name)
name = trim(name)
name = trim(name)
if not name then return nil end
if not name then return nil end
local dataset = getSkills()
local dataset = getSkills()


local byName = dataset.byName or {}
local byName = dataset.byName or { }
if byName[name] then
if byName[name] then
return byName[name]
return byName[name]
end
end


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


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


local function basisLabel(entry, isHealing)
local function basisLabel(entry, isHealing)
if isHealing then
if isHealing then
return "Healing"
return "Healing"
end
end
local atk = entry and entry["ATK-Based"]
local atk = entry and entry["ATK-Based"]
local matk = entry and entry["MATK-Based"]
local matk = entry and entry["MATK-Based"]
if atk and matk then
if atk and matk then
return "Attack/Magic Attack"
return "Attack/Magic Attack"
elseif atk then
elseif atk then
return "Attack"
return "Attack"
elseif matk then
elseif matk then
return "Magic Attack"
return "Magic Attack"
end
end
return "Damage"
return "Damage"
end
end


-- Dynamic damage entry:
--Dynamic damage entry:
-- Build a series for Lv1..LvMax, and show only the selected one.
--Build a series for Lv1..LvMax, and show only the selected one.
local function formatDamageEntry(entry, maxLevel, level)
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
if type(entry) ~= "table" then
return nil
return nil
end
end


local isHealing = (entry.Type == "Healing")
local isHealing = (entry.Type == "Healing")
Line 299: Line 306:


local baseRaw = entry["Base %"]
local baseRaw = entry["Base %"]
local perRaw = entry["Per Level %"]
local perRaw = entry["Per Level %"]


local baseN = toNum(baseRaw)
local baseN = toNum(baseRaw)
local perN = toNum(perRaw)
local perN = toNum(perRaw)


local function baseIsPresent()
local function baseIsPresent()
if baseN ~= nil then
if baseN ~= nil then
return baseN ~= 0
return baseN ~= 0
end
end
if baseRaw ~= nil then
if baseRaw ~= nil then
local s = tostring(baseRaw)
local s = tostring(baseRaw)
return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00")
end
end
return false
return false
end
end


local baseText = nil
local baseText = nil
if baseIsPresent() then
if baseIsPresent() then
if baseN ~= nil then
if baseN ~= nil then
baseText = fmtNum(baseN) .. "%"
baseText = fmtNum(baseN).. "%"
else
else
baseText = tostring(baseRaw) .. "%"
baseText = tostring(baseRaw).. "%"
end
end
end
end


-- No scaling -> just show base
--No scaling -> just show base
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then
return baseText and (mw.text.nowiki(baseText .. " " .. basis)) or nil
return baseText and mw.text.nowiki(baseText.. " "..basis) or nil
end
end


-- Build series strings for each level
--Build series strings for each level
local series = {}
local series = {}
for lv = 1, maxLevel do
for lv = 1, maxLevel do
local perPart = perN * lv
local perPart = perN * lv


if baseText and baseN ~= nil then
if baseText and baseN ~= nil then
-- numeric base: show total
local total = baseN + perPart
local total = baseN + perPart
table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
elseif baseText then
elseif baseText then
-- nonnumeric base: can't total, show additive
table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
else
else
-- no base: show perPart only
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
end
end
end
end


return dynSpan(series, level)
return dynSpan(series, level)
end
end


local function formatDamageList(list, maxLevel, level, includeTypePrefix)
local function formatDamageList(list, maxLevel, level, includeTypePrefix)
if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
return nil
return nil
end
end


local parts = {}
local parts = {}
for _, d in ipairs(list) do
for _, d in ipairs(list) do
if type(d) == "table" then
if type(d) == "table" then
local txt = formatDamageEntry(d, maxLevel, level)
local txt = formatDamageEntry(d, maxLevel, level)
if txt then
if txt then
if includeTypePrefix and d.Type and d.Type ~= "" then
if includeTypePrefix and d.Type and d.Type ~= "" then
table.insert(parts, mw.text.nowiki(tostring(d.Type) .. ": ") .. txt)
table.insert(parts, mw.text.nowiki(tostring(d.Type).. ": ")..txt)
else
else
table.insert(parts, txt)
table.insert(parts, txt)
end
end
end
end
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


local function formatScaling(list, basisOverride)
local function formatScaling(list, basisOverride)
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 stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
local pct = s.Percent
local pct = s.Percent
local pctN = toNum(pct)
local pctN = toNum(pct)


local basis = basisOverride or basisLabel(s, false)
local basis = basisOverride or basisLabel(s, false)


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


local function formatArea(area, maxLevel, level)
local function formatArea(area, maxLevel, level)
if type(area) ~= "table" then
if type(area) ~= "table" then
return nil
return nil
end
end
local parts = {}
local parts = {}


local distLine = valuePairDynamicText("Distance", area["Area Distance"], maxLevel, level, "<br />")
local distLine = valuePairDynamicText("Distance", area["Area Distance"], maxLevel, level, "<br />")
if distLine then
if distLine then
table.insert(parts, distLine)
table.insert(parts, distLine)
end
end


local size = area["Area Size"]
local size = area["Area Size"]
if size and size ~= "" then
if size and size ~= "" then
table.insert(parts, "Size: " .. mw.text.nowiki(tostring(size)))
table.insert(parts, "Size: "..mw.text.nowiki(tostring(size)))
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 formatTimingBlock(bt, maxLevel, level)
local function formatTimingBlock(bt, maxLevel, level)
if type(bt) ~= "table" then
if type(bt) ~= "table" then
return nil
return nil
end
end
local parts = {}
local parts = {}


local function add(label, key)
local function add(label, key)
local block = bt[key]
local block = bt[key]
if type(block) ~= "table" then
if type(block) ~= "table" then
return
return
end
end
local lines = valuePairDynamicLines(label, block, maxLevel, level)
local lines = valuePairDynamicLines(label, block, maxLevel, level)
for _, line in ipairs(lines) do
for _, line in ipairs(lines) do
table.insert(parts, line)
table.insert(parts, line)
end
end
end
end


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


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


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


local function formatResourceCost(rc, maxLevel, level)
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 manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
local manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
for _, line in ipairs(manaLines) do
for _, line in ipairs(manaLines) do
table.insert(parts, line)
table.insert(parts, line)
end
end


local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
for _, line in ipairs(hpLines) do
for _, line in ipairs(hpLines) do
table.insert(parts, line)
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
if combo.Type then
table.insert(parts, "Type: " .. mw.text.nowiki(tostring(combo.Type)))
table.insert(parts, "Type: "..mw.text.nowiki(tostring(combo.Type)))
end
end


local durText = formatUnitValue(combo.Duration)
local durText = formatUnitValue(combo.Duration)
if durText then
if durText then
table.insert(parts, "Duration: " .. mw.text.nowiki(durText))
table.insert(parts, "Duration: "..mw.text.nowiki(durText))
end
end


if combo.Percent ~= nil then
if combo.Percent ~= nil then
local pctText = formatUnitValue(combo.Percent)
local pctText = formatUnitValue(combo.Percent)
if pctText then
if pctText then
table.insert(parts, "Bonus: " .. mw.text.nowiki(pctText))
table.insert(parts, "Bonus: "..mw.text.nowiki(pctText))
end
end
end
end


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


local function valuePairRawText(block)
local function valuePairRawText(block)
if type(block) ~= "table" then
if type(block) ~= "table" then
return nil
return nil
end
end


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


if type(per) == "table" then
if type(per) == "table" then
if #per == 0 then
if #per == 0 then
return formatUnitValue(base)
return formatUnitValue(base)
end
end
if isFlatList(per) then
if isFlatList(per) then
return formatUnitValue(base) or tostring(per[1])
return formatUnitValue(base) or tostring(per[1])
end
end
local vals = {}
local vals = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
table.insert(vals, formatUnitValue(v) or tostring(v))
end
end
return (#vals > 0) and table.concat(vals, " / ") or nil
return (#vals > 0) and table.concat(vals, " / ") or nil
end
end


local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
local perText = formatUnitValue(per)
local perText = formatUnitValue(per)


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


local function formatMechanicEffects(effects)
--Special Mechanics supports dynamic Per Level lists
if type(effects) ~= "table" then
local function formatMechanicEffects(effects, maxLevel, level)
return nil
if type(effects) ~= "table" then
end
return nil
end


local keys = {}
local keys = {}
for k, _ in pairs(effects) do
for k, _ in pairs(effects) do
table.insert(keys, k)
table.insert(keys, k)
end
end
table.sort(keys)
table.sort(keys)


local parts = {}
local parts = {}
for _, name in ipairs(keys) do
 
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]
local block = effects[name]
if type(block) == "table" then
if type(block) == "table" then
local t = block.Type
local t = block.Type
if t ~= nil and tostring(t) ~= "" then
 
local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
if t ~= nil and tostring(t) ~= "" then
local amt = valuePairRawText(pair)
local amt = effectAmount(block)
if amt then
local seg = mw.text.nowiki(tostring(t).. " - "..tostring(name))
table.insert(parts, string.format("%s - %s + %s", tostring(t), tostring(name), amt))
if amt then
else
seg = seg.. " + "..amt
table.insert(parts, string.format("%s - %s", tostring(t), tostring(name)))
end
end
table.insert(parts, seg)
else
else
-- Keep old behavior here (usually not huge)
local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
local txt = valuePairRawText(block)
if txt then
if txt then
table.insert(parts, txt)
table.insert(parts, mw.text.nowiki(tostring(name) .. ": " .. txt))
end
end
end
end
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


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, maxLevel, level)
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 External Name"] or s["Status Internal Name"] or "Unknown status"
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"


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


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


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


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


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


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


local function formatStatusRemoval(list, maxLevel, level)
local function formatStatusRemoval(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 _, r in ipairs(list) do
for _, r in ipairs(list) do
if type(r) == "table" then
if type(r) == "table" then
local names = r["Status External Name"]
local names = r["Status External Name"]
local label
local label
if type(names) == "table" then
if type(names) == "table" then
label = table.concat(names, ", ")
label = table.concat(names, ", ")
elseif type(names) == "string" then
elseif type(names) == "string" then
label = names
label = names
else
else
label = "Status"
label = "Status"
end
end


local amt = nil
local amt = nil
-- If this removal has a Per Level list, make it dynamic
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
local series = {}
local series = {}
for _, v in ipairs(r["Per Level"]) do
for _, v in ipairs(r["Per Level"]) do
table.insert(series, formatUnitValue(v) or tostring(v))
table.insert(series, formatUnitValue(v) or tostring(v))
end
end
amt = dynSpan(series, level)
amt = dynSpan(series, level)
else
else
amt = valuePairRawText(r)
amt = valuePairRawText(r)
if amt then amt = mw.text.nowiki(amt) end
if amt then amt = mw.text.nowiki(amt) end
end
end


local seg = mw.text.nowiki(label)
local seg = mw.text.nowiki(label)
if amt then
if amt then
seg = seg .. " – " .. amt
seg = seg.. " – "..amt
end
end
table.insert(parts, seg)
table.insert(parts, seg)
end
end
end
end
if #parts == 0 then
if #parts == 0 then
return nil
return nil
end
end
return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
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 Internal Name"] or ev["Skill External Name"] or "Unknown skill"
local name = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
table.insert(parts, string.format("%s → %s", action, name))
table.insert(parts, string.format("%s → %s", action, name))
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


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


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


local pageTitle = mw.title.getCurrentTitle()
local pageTitle = mw.title.getCurrentTitle()
local pageName = pageTitle and pageTitle.text or ""
local pageName = pageTitle and pageTitle.text or ""
pageName = trim(pageName)
pageName = trim(pageName)
if not pageName then
if not pageName then
return false
return false
end
end
pageName = mw.ustring.lower(pageName)
pageName = mw.ustring.lower(pageName)


local ext = trim(rec["External Name"] or rec["Name"] or rec["Display Name"])
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"])
local internal = trim(rec["Internal Name"] or rec["InternalName"] or rec["InternalID"])


if ext and mw.ustring.lower(ext) == pageName then
if ext and mw.ustring.lower(ext) == pageName then
return true
return true
end
end
if internal and mw.ustring.lower(internal) == pageName then
if internal and mw.ustring.lower(internal) == pageName then
return true
return true
end
end
return false
return false
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Infobox builder
--Infobox builder(Top band: Level Select + Type)
----------------------------------------------------------------------
----------------------------------------------------------------------


local function buildLevelSelectUI(level, maxLevel)
local function buildLevelSelectUI(level, maxLevel)
-- Matches the JS expectations:
--JS expectations:
--  .sv-level-slider placeholder for the <input type="range">
--  .sv - level - slider placeholder for the < input type = "range" >
--  .sv-level-num span for updating the number
--  .sv - level - num span for updating the number
local wrap = mw.html.create("div")
local wrap = mw.html.create("div")
wrap:addClass("sv-level-ui")
wrap: addClass("sv-level-ui")
 
wrap: tag("div")
: addClass("sv-level-title")
: wikitext("Level Select")
 
wrap: tag("div")
: addClass("sv-level-label")
: wikitext("Level <span class=\"sv-level-num\">"..tostring(level).. "</span> / "..tostring(maxLevel))
 
wrap: tag("div"): addClass("sv-level-slider")


local label = wrap:tag("div"):addClass("sv-level-label")
return tostring(wrap)
label:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
end


wrap:tag("div"):addClass("sv-level-slider")
local function buildTypeTableUI(typeBlock)
return tostring(wrap)
if type(typeBlock) ~= "table" or next(typeBlock) == nil then
return nil
end
end


local function buildInfobox(rec, opts)
local wrap = mw.html.create("div")
opts = opts or {}
wrap: addClass("sv-type-grid")
local showUsers = (opts.showUsers ~= false)
 
local added = false
 
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 function addChunk(label, rawVal)
local v = valName(rawVal)
if not v or v == "" then return end
added = true
 
local chunk = wrap: tag("div"): addClass("sv-type-chunk")
chunk: tag("div"): addClass("sv-type-label"): wikitext(mw.text.nowiki(label))
chunk: tag("div"): addClass("sv-type-value"): wikitext(mw.text.nowiki(v))
end
 
addChunk("Type", typeBlock["Damage Type"])
addChunk("Element", typeBlock["Element Type"])
addChunk("Target", typeBlock["Target Type"])
addChunk("Cast Type", typeBlock["Cast Type"])
 
if not added then
return nil
end
return tostring(wrap)
end


local maxLevel = tonumber(rec["Max Level"]) or 1
local function addTopBand(tbl, levelUI, typeUI)
if maxLevel < 1 then maxLevel = 1 end
if not levelUI and not typeUI then
return
end


-- Always default to max level (your requirement)
local row = tbl: tag("tr")
local level = maxLevel
local cell = row: tag("td")
level = clamp(level, 1, maxLevel)
cell: attr("colspan", 2)
cell: addClass("sv-topband-cell")


local root = mw.html.create("table")
--Nested table(what Common.css targets)
root:addClass("wikitable spiritvale-skill-infobox")
local inner = cell: tag("table")
inner: addClass("sv-topband-table")


-- JS hook: treat the table itself as the "card"
local tr = inner: tag("tr")
root:addClass("sv-skill-card")
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-level", tostring(level))


-- ==========================================================
if levelUI and typeUI then
-- Top "hero" row: icon + name (left), description (right)
tr: tag("td"): wikitext(levelUI): done()
-- ==========================================================
tr: tag("td"): wikitext(typeUI): done()
local icon  = rec.Icon
elseif levelUI then
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
tr: tag("td"): attr("colspan", 2): wikitext(levelUI): done()
local desc  = rec.Description or ""
else
tr: tag("td"): attr("colspan", 2): wikitext(typeUI): done()
end
end


local headerRow = root:tag("tr")
local function buildInfobox(rec, opts)
headerRow:addClass("spiritvale-infobox-main")
opts = opts or { }
local showUsers = (opts.showUsers ~= false)


local leftCell = headerRow:tag("th")
local maxLevel = tonumber(rec["Max Level"]) or 1
leftCell:addClass("spiritvale-infobox-main-left")
if maxLevel < 1 then maxLevel = 1 end


local leftInner = leftCell:tag("div")
--Always default to max level
leftInner:addClass("spiritvale-infobox-main-left-inner")
local level = clamp(maxLevel, 1, maxLevel)


if icon and icon ~= "" then
local root = mw.html.create("table")
leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
end


leftInner:tag("div")
--IMPORTANT:
:addClass("spiritvale-infobox-title")
--Don't use "wikitable" here; it triggers default borders + Citizen wrapper styling.
:wikitext(title)
root: addClass("spiritvale-skill-infobox")


local rightCell = headerRow:tag("td")
--JS hook: treat the table itself as the "card"
rightCell:addClass("spiritvale-infobox-main-right")
root: addClass("sv-skill-card")


local rightInner = rightCell:tag("div")
--Helpful flag for list - mode overrides(optional, but nice)
rightInner:addClass("spiritvale-infobox-main-right-inner")
if opts and opts.inList then
root: addClass("sv-skill-inlist")
end


if desc ~= "" then
--JS hook: treat the table itself as the "card"
rightInner:tag("div")
root: addClass("sv-skill-card")
:addClass("spiritvale-infobox-description")
root: attr("data-max-level", tostring(maxLevel))
:wikitext(string.format("''%s''", desc))
root: attr("data-level", tostring(level))
end


------------------------------------------------------------------
--Top "hero" rows:
-- General
--1) Title row: icon + name centered(single cell)
------------------------------------------------------------------
--2) Description row: its own row below(still part of the hero band)
addSectionHeader(root, "General")


-- Replace Max Level -> Level Select (slider)
local icon = rec.Icon
addRow(root, "Level Select", buildLevelSelectUI(level, maxLevel))
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
local desc = rec.Description or ""


-- Hide Users on:
--Row 1: icon + title(single column)
--  - list pages (opts.showUsers=false)
local heroRow = root: tag("tr")
--  - the skill's own page (handled by caller)
heroRow: addClass("spiritvale-infobox-main")
if showUsers then
heroRow: addClass("sv-hero-title-row")
local users = rec.Users or {}
addRow(root, "Classes",  listToText(users.Classes))
addRow(root, "Summons",  listToText(users.Summons))
addRow(root, "Monsters", listToText(users.Monsters))
addRow(root, "Events",  listToText(users.Events))
end


------------------------------------------------------------------
local heroCell = heroRow: tag("th")
-- Requirements
heroCell: attr("colspan", 2)
------------------------------------------------------------------
heroCell: addClass("sv-hero-title-cell")
local req = rec.Requirements or {}
if (req["Required Skills"] and #req["Required Skills"] > 0)
or (req["Required Weapons"] and #req["Required Weapons"] > 0)
or (req["Required Stances"] and #req["Required Stances"] > 0) then


addSectionHeader(root, "Requirements")
local heroInner = heroCell: tag("div")
heroInner: addClass("spiritvale-infobox-main-left-inner")-- reuse your centered flex column


if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
if icon and icon ~= "" then
local skillParts = {}
heroInner: wikitext(string.format("[[File:%s|80px|link=]]", icon))
for _, rs in ipairs(req["Required Skills"]) do
end
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"]))
heroInner: tag("div")
addRow(root, "Required Stances", listToText(req["Required Stances"]))
: addClass("spiritvale-infobox-title")
end
: wikitext(title)


------------------------------------------------------------------
--Row 2: description(below, still hero - styled)
-- Type
if desc ~= "" then
------------------------------------------------------------------
local descRow = root: tag("tr")
local typeBlock = rec.Type or {}
descRow: addClass("spiritvale-infobox-main")
if next(typeBlock) ~= nil then
descRow: addClass("sv-hero-desc-row")
addSectionHeader(root, "Type")


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


local et = typeBlock["Element Type"]
local descInner = descCell: tag("div")
if type(et) == "table" and et.Name then
descInner: addClass("spiritvale-infobox-main-right-inner")
addRow(root, "Element", et.Name)
end


local tt = typeBlock["Target Type"]
descInner: tag("div")
if type(tt) == "table" and tt.Name then
: addClass("spiritvale-infobox-description")
addRow(root, "Target", tt.Name)
: wikitext(string.format("''%s''", desc))
end
end


local ct = typeBlock["Cast Type"]
------------------------------------------------------------------
if type(ct) == "table" and ct.Name then
--Unified top band(Level Select left, Type list right)
addRow(root, "Cast Type", ct.Name)
------------------------------------------------------------------
end
local levelUI = buildLevelSelectUI(level, maxLevel)
end
local typeUI = buildTypeTableUI(rec.Type or {})
addTopBand(root, levelUI, typeUI)


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


local rangeText = formatUnitValue(mech.Range)
------------------------------------------------------------------
addRow(root, "Range", rangeText)
--Requirements
------------------------------------------------------------------
local req = rec.Requirements or { }
if (req["Required Skills"] and #req["Required Skills"] > 0)
or(req["Required Weapons"] and #req["Required Weapons"] > 0)
or(req["Required Stances"] and #req["Required Stances"] > 0) then


local areaText = formatArea(mech.Area, maxLevel, level)
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
addRow(root, "Area", areaText)
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


if mech["Autocast Multiplier"] ~= nil then
addRow(root, "Required Weapons", listToText(req["Required Weapons"]))
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
addRow(root, "Required Stances", listToText(req["Required Stances"]))
end
end


local btText = formatTimingBlock(mech["Basic Timings"], maxLevel, level)
------------------------------------------------------------------
addRow(root, "Timing", btText)
--Mechanics
------------------------------------------------------------------
local mech = rec.Mechanics or { }
if next(mech) ~= nil then


local rcText = formatResourceCost(mech["Resource Cost"], maxLevel, level)
addRow(root, "Range", formatUnitValue(mech.Range))
addRow(root, "Resource Cost", rcText)
addRow(root, "Area", formatArea(mech.Area, maxLevel, level))


local comboText = formatCombo(mech.Combo)
if mech["Autocast Multiplier"] ~= nil then
addRow(root, "Combo", comboText)
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
end


local effText = formatMechanicEffects(mech.Effects)
addRow(root, "Timing", formatTimingBlock(mech["Basic Timings"], maxLevel, level))
addRow(root, "Special Mechanics", effText)
addRow(root, "Resource Cost", formatResourceCost(mech["Resource Cost"], maxLevel, level))
end
addRow(root, "Combo", formatCombo(mech.Combo))
addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level))
end


------------------------------------------------------------------
------------------------------------------------------------------
-- Damage & Scaling
--Damage & Scaling
------------------------------------------------------------------
------------------------------------------------------------------
local dmg = rec.Damage or {}
local dmg = rec.Damage or { }
if next(dmg) ~= nil then
if next(dmg) ~= nil then
addSectionHeader(root, "Damage and Scaling")


-- Split healing out of Main Damage (Type == "Healing")
local main = dmg["Main Damage"]
local main = dmg["Main Damage"]
local mainNonHeal = {}
local mainNonHeal, healOnly = {}, {}
local healOnly = {}


if type(main) == "table" then
if type(main) == "table" then
for _, d in ipairs(main) do
for _, d in ipairs(main) do
if type(d) == "table" and d.Type == "Healing" then
if type(d) == "table" and d.Type == "Healing" then
table.insert(healOnly, d)
table.insert(healOnly, d)
else
else
table.insert(mainNonHeal, d)
table.insert(mainNonHeal, d)
end
end
end
end
end
end


local flatList = dmg["Flat Damage"]
local flatList = dmg["Flat Damage"]
Line 987: Line 1,062:
local reflHas = (type(reflList) == "table" and #reflList > 0)
local reflHas = (type(reflList) == "table" and #reflList > 0)


-- Determine if this is effectively a "pure healing" skill for scaling wording.
local pureHealing = (#healOnly > 0) and(#mainNonHeal == 0) and(not flatHas) and(not reflHas)
local pureHealing = (#healOnly > 0) and (#mainNonHeal == 0) and (not flatHas) and (not reflHas)


local mainText = formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1))
addRow(root, "Main Damage", formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)))
addRow(root, "Main Damage", mainText)
addRow(root, "Flat Damage", formatDamageList(flatList, maxLevel, level, false))
addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false))
addRow(root, "Healing", formatDamageList(healOnly, maxLevel, level, false))


local flatText = formatDamageList(flatList, maxLevel, level, false)
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
addRow(root, "Flat Damage", flatText)
end
 
local reflText = formatDamageList(reflList, maxLevel, level, false)
addRow(root, "Reflect Damage", reflText)
 
local healText = formatDamageList(healOnly, maxLevel, level, false)
addRow(root, "Healing", healText)
 
local scaleText = formatScaling(dmg.Scaling, pureHealing and "Healing" or nil)
addRow(root, "Scaling", scaleText)
end


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


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


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


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


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


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


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


local userName = args.user or args[1]
local userName = args.user or args[1]
if not userName or userName == "" then
if not userName or userName == "" then
userName = mw.title.getCurrentTitle().text
userName = mw.title.getCurrentTitle().text
end
end


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


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


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


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


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


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


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


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


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


local raw1 = args[1]
local raw1 = args[1]
local name = args.name or raw1
local name = args.name or raw1
local id   = args.id
local id = args.id


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


if name and name ~= "" then
if not rec 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 pageTitle = mw.title.getCurrentTitle()
local pageName = pageTitle and pageTitle.text or ""
local pageName = pageTitle and pageTitle.text or ""


local noExplicitArgs =
local noExplicitArgs =
(not raw1 or raw1 == "") and
(not raw1 or raw1 == "") and
(not args.name or args.name == "") and
(not args.name or args.name == "") and
(not id or id == "")
(not id or id == "")


if noExplicitArgs then
if noExplicitArgs then
return p.listForUser(frame)
return p.listForUser(frame)
end
end


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


local label = name or id or "?"
local label = name or id or "?"
return string.format(
return string.format(
"<strong>Unknown Skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
"<strong>Unknown Skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
mw.text.nowiki(label),
mw.text.nowiki(label),
label
label
)
)
end
end


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


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