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 edit
No edit summary
No edit summary
 
(16 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:GameSkills
-- Module:GameSkills
--
--
-- Renders active skill data (from Data:skills.json) into an infobox-style table
-- Renders active skill data (Data:skills.json) into an infobox-style table,
-- and can also list all skills for a given user/class.
-- and can also list all skills for a given user/class (page name).
--
--
-- Usage (single skill):
-- Features:
--   {{Skill|Heal}}
--  - Per-skill Level Select slider (client-side JS updates .sv-dyn spans)
--   {{Skill|name=Heal}}
--  - Default level = Max Level
--   {{Skill|id=Heal_InternalId}}
--  - .sv-skill-card + data-max-level / data-level hooks for JS
-- - Uses dynamic spans instead of long Lv1/Lv2/... lists
-- - Unified top band: Level Select (left) + Type/Element/Target/Cast (right)
-- - List-mode: wraps all skills in one wrapper panel + stable .sv-skill-item divs
--
--
-- Usage (auto-list on class page, e.g. "Acolyte"):
-- NOTE: We add a small amount of inline styling on the top-band inner panels
--   {{Skill}}                  -> lists all Acolyte skills (page name)
-- (Level Select + Type box) so light mode remains readable even if a skin/theme
--   {{Skill|Acolyte}}          -> same, if no skill literally called "Acolyte"
-- class selector isn’t reliable.


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


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Internal helpers
-- Data cache
----------------------------------------------------------------------
----------------------------------------------------------------------


Line 29: Line 32:
return skillsCache
return skillsCache
end
end
----------------------------------------------------------------------
-- Small utilities
----------------------------------------------------------------------


local function getArgs(frame)
local function getArgs(frame)
local parent = frame:getParent()
local parent = frame:getParent()
if parent then
return (parent and parent.args) or frame.args
return parent.args
end
return frame.args
end
end


local function listToText(list, sep)
local function trim(s)
if type(list) ~= "table" or #list == 0 then
if type(s) ~= "string" then
return nil
return nil
end
end
return table.concat(list, sep or ", ")
s = mw.text.trim(s)
return (s ~= "" and s) or nil
end
end


local function addRow(tbl, label, value)
local function toNum(v)
if value == nil or value == "" then
if type(v) == "number" then
return
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
end
local row = tbl:tag("tr")
return nil
row:tag("th"):wikitext(label):done()
row:tag("td"):wikitext(value):done()
end
end


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


Line 79: Line 76:
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+$", "")
Line 88: Line 87:
end
end


-- Handles either a scalar OR {Value=..., Unit=...}
local function listToText(list, sep)
-- IMPORTANT: do NOT convert percent_decimal/percent_whole; just format around stored values.
if type(list) ~= "table" or #list == 0 then
return nil
end
return table.concat(list, sep or ", ")
end
 
local function addRow(tbl, label, value)
if value == nil or value == "" then
return
end
local row = tbl:tag("tr")
row:tag("th"):wikitext(label):done()
row:tag("td"):wikitext(value):done()
end
 
-- Handles either a scalar OR { Value = ..., Unit = ... }
-- IMPORTANT: wikiprep often converts unit-wrapped pairs into strings already.
local function formatUnitValue(v)
local function formatUnitValue(v)
if type(v) == "table" and v.Value ~= nil then
if type(v) == "table" and v.Value ~= nil then
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
Line 110: Line 125:
end
end


if v == nil then
return (v ~= nil) and tostring(v) or nil
return nil
end
return tostring(v)
end
end


----------------------------------------------------------------------
----------------------------------------------------------------------
-- Lookups
-- Dynamic spans (JS-driven)
----------------------------------------------------------------------
----------------------------------------------------------------------


-- Lookup by Internal Name
local function dynSpan(series, level)
local function getSkillById(id)
if type(series) ~= "table" or #series == 0 then
id = trim(id)
return nil
if not id then return nil end
end
local dataset = getSkills()
local byId = dataset.byId or {}
return byId[id]
end


-- Lookup by display/external Name (for editors)
level = clamp(level or #series, 1, #series)
local function findSkillByName(name)
name = trim(name)
if not name then return nil end
local dataset = getSkills()


-- Fast path if GameData built byName
local span = mw.html.create("span")
local byName = dataset.byName or {}
span:addClass("sv-dyn")
if byName[name] then
span:attr("data-series", mw.text.jsonEncode(series))
return byName[name]
span:wikitext(mw.text.nowiki(series[level] or ""))
end


-- Fallback scan (older GameData)
return tostring(span)
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
----------------------------------------------------------------------


local function isFlatList(list)
local function isFlatList(list)
Line 170: Line 161:


local function isNonZeroScalar(v)
local function isNonZeroScalar(v)
if v == nil then return false end
if v == nil then
if type(v) == "number" then return v ~= 0 end
return false
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)
Line 185: Line 180:
end
end


-- Turns a {Base, Per Level} block into lines:
-- Base/Per Level renderer:
--   - If Per Level is a list: "Name: v1 / v2 / v3 ..."
-- - Per Level list -> dynamic span (or single value if flat)
--   - If Per Level scalar and non-zero: add "Name Per Level: X"
-- - Per Level scalar -> "Base" + "Per Level" lines
local function valuePairLines(name, block)
local function valuePairDynamicLines(name, block, maxLevel, level)
if type(block) ~= "table" then
if type(block) ~= "table" then
return {}
return {}
Line 196: Line 191:
local per  = block["Per Level"]
local per  = block["Per Level"]


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


-- If it's a flat list, treat as "no scaling" (show single value)
if isFlatList(per) then
if isFlatList(per) then
local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
local one = 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
return show and { string.format("%s: %s", name, mw.text.nowiki(show)) } or {}
return { string.format("%s: %s", name, show) }
end
return {}
end
end


local vals = {}
local series = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
table.insert(series, formatUnitValue(v) or tostring(v))
end
end
if #vals == 0 then
 
return {}
local dyn = dynSpan(series, level)
end
return dyn and { string.format("%s: %s", name, dyn) } or {}
return { string.format("%s: %s", name, table.concat(vals, " / ")) }
end
end


-- Scalar Per Level
-- scalar Per Level
local lines = {}
local lines = {}
local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
Line 233: Line 220:


if baseText then
if baseText then
table.insert(lines, string.format("%s: %s", name, 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, perText))
table.insert(lines, string.format("%s Per Level: %s", name, mw.text.nowiki(perText)))
end
end


Line 242: Line 229:
end
end


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


-- Raw text for a Base/Per Level block (used by Special Mechanics & Source fallbacks)
local function valuePairRawText(block)
local function valuePairRawText(block)
if type(block) ~= "table" then
if type(block) ~= "table" then
Line 265: Line 250:
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
Line 278: Line 264:
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 basisLabel(entry)
----------------------------------------------------------------------
local atk = entry and entry["ATK-Based"]
-- Lookups
----------------------------------------------------------------------
 
local function getSkillById(id)
id = trim(id)
if not id then
return nil
end
local dataset = getSkills()
return (dataset.byId or {})[id]
end
 
local function findSkillByName(name)
name = trim(name)
if not name then
return nil
end
 
local dataset = getSkills()
local byName = dataset.byName or {}
 
if byName[name] then
return byName[name]
end
 
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
 
----------------------------------------------------------------------
-- Formatting helpers
----------------------------------------------------------------------
 
local function basisLabel(entry, isHealing)
if isHealing then
return "Healing"
end
 
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"
Line 291: Line 324:
return "Magic Attack"
return "Magic Attack"
end
end
return "Damage"
return "Damage"
end
end


local function formatDamageEntry(entry, maxLevel)
-- Build a value-only output for a Base/Per Level block, using dyn spans when needed
local function valuePairDynamicValueOnly(block, maxLevel, level)
if type(block) ~= "table" then
return nil
end
 
local base = block.Base
local per  = block["Per Level"]
 
if type(per) == "table" then
if #per == 0 then
local baseText = formatUnitValue(base)
return baseText and mw.text.nowiki(baseText) or nil
end
 
if isFlatList(per) then
local one  = formatUnitValue(per[1]) or tostring(per[1])
local show = formatUnitValue(base) or one
return show and mw.text.nowiki(show) or nil
end
 
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
 
local txt = valuePairRawText(block)
return txt and mw.text.nowiki(txt) or nil
end
 
-- Source (new unified Damage/Flat/Reflect/Healing) formatter
local function formatSource(src, maxLevel, level)
if type(src) ~= "table" then
return nil
end
 
local kind = src.Type or "Damage"
local isHealing = (kind == "Healing") or (src.Healing == true)
 
local basis = basisLabel(src, isHealing)
if basis and mw.ustring.lower(tostring(basis)) == mw.ustring.lower(tostring(kind)) then
basis = nil
end
 
local val = valuePairDynamicValueOnly(src, maxLevel, level)
if not val then
return nil
end
 
local out = mw.text.nowiki(tostring(kind)) .. ": " .. val
if basis then
out = out .. " " .. mw.text.nowiki(tostring(basis))
end
 
return out
end
 
-- BACKCOMPAT: old damage list formatter (safe to remove once migrated)
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
if type(entry) ~= "table" then
return nil
return nil
end
end


local baseN = toNum(entry["Base %"])
local isHealing = (entry.Type == "Healing")
local perN = toNum(entry["Per Level %"])
local basis = isHealing and "Healing" or basisLabel(entry, false)
 
local baseRaw = entry["Base %"]
local perRaw = entry["Per Level %"]
 
local baseN = toNum(baseRaw)
local perN  = toNum(perRaw)


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


local baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(entry["Base %"]) .. "%")
local baseText
local basis = basisLabel(entry)
if baseIsPresent() then
baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(baseRaw) .. "%")
end


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 string.format("%s %s", baseText, basis)
return baseText and mw.text.nowiki(baseText .. " " .. basis) or nil
end
end


local inc = {}
local series = {}
for lv = 1, maxLevel do
for lv = 1, maxLevel do
table.insert(inc, fmtNum(perN * lv))
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
end


-- Match requested style: "100% + 40 / 80 / 120 ... Attack Per Level"
return dynSpan(series, level)
return string.format("%s + %s %s Per Level", baseText, table.concat(inc, " / "), basis)
end
end


local function formatDamageList(list, maxLevel, 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
Line 330: Line 447:
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)
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, tostring(d.Type) .. ": " .. txt)
table.insert(parts, mw.text.nowiki(tostring(d.Type) .. ": ") .. txt)
else
else
table.insert(parts, txt)
table.insert(parts, txt)
Line 341: Line 458:
end
end


if #parts == 0 then
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
 
-- Scaling supports either:
--  - single dict: {Percent=..., Scaling ID/Name...}
--  - list of dicts: [{...},{...}]
local function formatScaling(scaling, basisOverride)
if type(scaling) ~= "table" then
return nil
return nil
end
end
return table.concat(parts, "<br />")
end


local function formatScaling(list)
local list = scaling
if type(list) ~= "table" or #list == 0 then
if #list == 0 then
return nil
if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then
list = { scaling }
else
return nil
end
end
end


Line 358: Line 484:
local pct  = s.Percent
local pct  = s.Percent
local pctN = toNum(pct)
local pctN = toNum(pct)
local basis = basisLabel(s)
 
local basis = basisOverride or basisLabel(s, false)


if pctN ~= nil and pctN ~= 0 then
if pctN ~= nil and pctN ~= 0 then
-- IMPORTANT: do not convert percent values; just display stored value.
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
Line 369: Line 495:
end
end


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


-- Area: Distance then Size (no Effective)
local function formatArea(area, maxLevel, level)
local function formatArea(area)
if type(area) ~= "table" then
if type(area) ~= "table" then
return nil
return nil
end
end
local parts = {}
local parts = {}


local distLine = valuePairText("Distance", area["Area Distance"], "<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)
Line 389: Line 512:
local size = area["Area Size"]
local size = area["Area Size"]
if size and size ~= "" then
if size and size ~= "" then
table.insert(parts, "Size: " .. tostring(size))
table.insert(parts, "Size: " .. mw.text.nowiki(tostring(size)))
end
end


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


local function formatTimingBlock(bt)
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 = {}


Line 409: Line 530:
return
return
end
end
local lines = valuePairLines(label, block)
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)
Line 416: Line 537:


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


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


if #parts == 0 then
return (#parts > 0) and table.concat(parts, "<br />") or nil
return nil
end
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 manaLines = valuePairLines("MP", rc["Mana Cost"])
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 = valuePairLines("HP", rc["Health Cost"])
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
return (#parts > 0) and table.concat(parts, "<br />") or nil
return nil
end
return table.concat(parts, "<br />")
end
end


Line 461: Line 577:
return nil
return nil
end
end
local parts = {}
local parts = {}


if combo.Type then
if combo.Type then
table.insert(parts, "Type: " .. 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: " .. durText)
table.insert(parts, "Duration: " .. mw.text.nowiki(durText))
end
end


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


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


local function formatMechanicEffects(effects)
local function formatMechanicEffects(effects, maxLevel, level)
if type(effects) ~= "table" then
if type(effects) ~= "table" then
return nil
return nil
Line 497: Line 611:


local parts = {}
local parts = {}
local function effectAmount(block)
if type(block) ~= "table" then
return nil
end
local per = block["Per Level"]
if type(per) == "table" and #per > 0 then
if isFlatList(per) then
return mw.text.nowiki(formatUnitValue(per[1]) or tostring(per[1]))
end
local series = {}
for _, v in ipairs(per) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
return dynSpan(series, level)
end
local txt = valuePairRawText(block)
return txt and mw.text.nowiki(txt) or nil
end
for _, name in ipairs(keys) do
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 txt = valuePairText(name, block, ", ")
local t = block.Type
if txt then
 
table.insert(parts, txt)
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
end
end
end


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


Line 517: Line 661:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 523: Line 668:
return
return
end
end
local flags = {}
local flags = {}
for k, v in pairs(sub) do
for k, v in pairs(sub) do
Line 530: Line 676:
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, ", ")))
Line 539: Line 686:
collect("Special",  mods["Special Modifiers"])
collect("Special",  mods["Special Modifiers"])


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


local function formatStatusApplications(list)
local function formatStatusApplications(list, maxLevel, level)
if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
return nil
return nil
end
end
local parts = {}
local parts = {}
for _, s in ipairs(list) do
for _, s in ipairs(list) do
if type(s) == "table" then
if type(s) == "table" then
local scope = s.Scope or "Target"
local typ  = s.Type or 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 = tostring(typ) .. " – " .. tostring(name)
local detail = {}
local detail = {}


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


Line 579: Line 720:
end
end
end
end
if #parts == 0 then
 
return nil
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
return table.concat(parts, "<br />")
end
end


local function formatStatusRemoval(list)
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
Line 594: Line 734:
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, ", ")
Line 602: Line 743:
end
end


local amt = valuePairRawText(r)
local amt
local seg = label
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
local series = {}
for _, v in ipairs(r["Per Level"]) do
table.insert(series, formatUnitValue(v) or tostring(v))
end
amt = dynSpan(series, level)
else
amt = valuePairRawText(r)
amt = amt and mw.text.nowiki(amt) or nil
end
 
local seg = mw.text.nowiki(label)
if amt then
if amt then
seg = seg .. " – " .. amt
seg = seg .. " – " .. amt
Line 610: Line 762:
end
end
end
end
if #parts == 0 then
 
return nil
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
return table.concat(parts, "<br />")
end
end


Line 620: Line 770:
return nil
return nil
end
end
local parts = {}
local parts = {}
for _, ev in ipairs(list) do
for _, ev in ipairs(list) do
Line 628: Line 779:
end
end
end
end
if #parts == 0 then
 
return nil
return (#parts > 0) and table.concat(parts, "<br />") or nil
end
return table.concat(parts, "<br />")
end
end


Line 662: Line 811:
end
end


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


Line 680: Line 824:


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)


Line 690: Line 835:
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
return (ext and mw.ustring.lower(ext) == pageName) or (internal and mw.ustring.lower(internal) == pageName) or false
return true
end
 
----------------------------------------------------------------------
-- Top band UI
----------------------------------------------------------------------
 
local function buildLevelSelectUI(level, maxLevel)
local wrap = mw.html.create("div")
wrap:addClass("sv-level-ui")
 
-- Inline “light-mode-safe” panel styling (works in both modes)
wrap:css("background", "rgba(90, 78, 124, 0.18)")
wrap:css("border", "1px solid rgba(55, 43, 84, 0.22)")
wrap:css("border-radius", "10px")
 
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")
 
return tostring(wrap)
end
 
local function buildTypeTableUI(typeBlock)
if type(typeBlock) ~= "table" or next(typeBlock) == nil then
return nil
end
 
local wrap = mw.html.create("div")
wrap:addClass("sv-type-grid")
 
-- Inline “light-mode-safe” panel styling (works in both modes)
wrap:css("background", "rgba(90, 78, 124, 0.18)")
wrap:css("border", "1px solid rgba(55, 43, 84, 0.22)")
wrap:css("border-radius", "10px")
 
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
end
if internal and mw.ustring.lower(internal) == pageName then
 
return true
-- NEW keys (with fallback to old keys)
addChunk("Damage",  typeBlock.Damage  or typeBlock["Damage Type"])
addChunk("Element", typeBlock.Element or typeBlock["Element Type"])
addChunk("Target",  typeBlock.Target  or typeBlock["Target Type"])
addChunk("Cast",    typeBlock.Cast    or typeBlock["Cast Type"])
 
if not added then
return nil
end
 
return tostring(wrap)
end
 
local function addTopBand(tbl, levelUI, typeUI)
if not levelUI and not typeUI then
return
end
 
local row = tbl:tag("tr")
local cell = row:tag("td")
cell:attr("colspan", 2)
cell:addClass("sv-topband-cell")
 
-- Keep nested table (your CSS targets it)
local inner = cell:tag("table")
inner:addClass("sv-topband-table")
 
local tr = inner:tag("tr")
 
if levelUI and typeUI then
tr:tag("td"):wikitext(levelUI):done()
tr:tag("td"):wikitext(typeUI):done()
elseif levelUI then
tr:tag("td"):attr("colspan", 2):wikitext(levelUI):done()
else
tr:tag("td"):attr("colspan", 2):wikitext(typeUI):done()
end
end
return false
end
end


Line 706: Line 951:
opts = opts or {}
opts = opts or {}
local showUsers = (opts.showUsers ~= false)
local showUsers = (opts.showUsers ~= false)
local maxLevel = tonumber(rec["Max Level"]) or 1
if maxLevel < 1 then maxLevel = 1 end
local level = clamp(maxLevel, 1, maxLevel)


local root = mw.html.create("table")
local root = mw.html.create("table")
root:addClass("wikitable spiritvale-skill-infobox")
root:addClass("spiritvale-skill-infobox")
root:addClass("sv-skill-card")
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-level", tostring(level))
 
if opts.inList then
root:addClass("sv-skill-inlist")
end


-- ==========================================================
-- Hero rows
-- Top "hero" row: icon + name (left), description (right)
-- ==========================================================
local icon  = rec.Icon
local icon  = rec.Icon
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
local desc  = rec.Description or ""
local desc  = rec.Description or ""


local headerRow = root:tag("tr")
local heroRow = root:tag("tr")
headerRow:addClass("spiritvale-infobox-main")
heroRow:addClass("spiritvale-infobox-main")
heroRow:addClass("sv-hero-title-row")


local leftCell = headerRow:tag("th")
local heroCell = heroRow:tag("th")
leftCell:addClass("spiritvale-infobox-main-left")
heroCell:attr("colspan", 2)
heroCell:addClass("sv-hero-title-cell")


local leftInner = leftCell:tag("div")
local heroInner = heroCell:tag("div")
leftInner:addClass("spiritvale-infobox-main-left-inner")
heroInner:addClass("spiritvale-infobox-main-left-inner")


if icon and icon ~= "" then
if icon and icon ~= "" then
leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
heroInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
end
end


leftInner:tag("div")
heroInner:tag("div")
:addClass("spiritvale-infobox-title")
:addClass("spiritvale-infobox-title")
:wikitext(title)
:wikitext(title)


local rightCell = headerRow:tag("td")
if desc ~= "" then
rightCell:addClass("spiritvale-infobox-main-right")
local descRow = root:tag("tr")
descRow:addClass("spiritvale-infobox-main")
descRow:addClass("sv-hero-desc-row")
 
local descCell = descRow:tag("td")
descCell:attr("colspan", 2)
descCell:addClass("sv-hero-desc-cell")


local rightInner = rightCell:tag("div")
local descInner = descCell:tag("div")
rightInner:addClass("spiritvale-infobox-main-right-inner")
descInner:addClass("spiritvale-infobox-main-right-inner")


if desc ~= "" then
descInner:tag("div")
rightInner:tag("div")
:addClass("spiritvale-infobox-description")
:addClass("spiritvale-infobox-description")
:wikitext(string.format("''%s''", desc))
:wikitext(string.format("''%s''", desc))
end
end


------------------------------------------------------------------
-- Unified top band
-- General
addTopBand(
------------------------------------------------------------------
root,
addSectionHeader(root, "General")
buildLevelSelectUI(level, maxLevel),
addRow(root, "Max Level", rec["Max Level"] and tostring(rec["Max Level"]))
buildTypeTableUI(rec.Type or {})
)


-- Hide Users on:
-- Users
--  - list pages (opts.showUsers=false)
--  - the skill's own page (handled by caller)
if showUsers then
if showUsers then
local users = rec.Users or {}
local users = rec.Users or {}
Line 763: Line 1,023:
end
end


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


if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
if type(req["Required Skills"]) == "table" and #req["Required Skills"] > 0 then
local skillParts = {}
local skillParts = {}
for _, rs in ipairs(req["Required Skills"]) do
for _, rs in ipairs(req["Required Skills"]) do
local name  = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown"
local level = rs["Required Level"]
local lvlReq  = rs["Required Level"]
if level then
if lvlReq then
table.insert(skillParts, string.format("%s (Lv.%s)", name, level))
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
else
else
table.insert(skillParts, name)
table.insert(skillParts, nameReq)
end
end
end
end
Line 791: Line 1,047:
end
end


------------------------------------------------------------------
-- Type
------------------------------------------------------------------
local typeBlock = rec.Type or {}
if next(typeBlock) ~= nil then
addSectionHeader(root, "Type")
local dt = typeBlock["Damage Type"]
if type(dt) == "table" and dt.Name then
addRow(root, "Damage Type", dt.Name)
end
local et = typeBlock["Element Type"]
if type(et) == "table" and et.Name then
addRow(root, "Element", et.Name)
end
local tt = typeBlock["Target Type"]
if type(tt) == "table" and tt.Name then
addRow(root, "Target", tt.Name)
end
local ct = typeBlock["Cast Type"]
if type(ct) == "table" and ct.Name then
addRow(root, "Cast Type", ct.Name)
end
end
------------------------------------------------------------------
-- Mechanics
-- Mechanics
------------------------------------------------------------------
local mech = rec.Mechanics or {}
local mech = rec.Mechanics or {}
if next(mech) ~= nil then
if next(mech) ~= nil then
addSectionHeader(root, "Mechanics")
addRow(root, "Range", formatUnitValue(mech.Range))
 
addRow(root, "Area", formatArea(mech.Area, maxLevel, level))
local rangeText = formatUnitValue(mech.Range)
addRow(root, "Range", rangeText)
 
local areaText = formatArea(mech.Area)
addRow(root, "Area", areaText)


if mech["Autocast Multiplier"] ~= nil then
if mech["Autocast Multiplier"] ~= nil then
Line 836: Line 1,057:
end
end


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


------------------------------------------------------------------
-- Source (new) + Scaling, with backcompat for old Damage
-- Damage & Scaling
if type(rec.Source) == "table" then
------------------------------------------------------------------
addRow(root, "Source", formatSource(rec.Source, maxLevel, level))
local dmg = rec.Damage or {}
if next(dmg) ~= nil then
addSectionHeader(root, "Damage and Scaling")


local maxLevel = tonumber(rec["Max Level"]) or 0
local basisOverride =
(rec.Source.Type == "Healing" or rec.Source.Healing == true) and "Healing" or nil


-- Split healing out of Main Damage (Type == "Healing")
addRow(root, "Scaling", formatScaling(rec.Source.Scaling, basisOverride))
local main = dmg["Main Damage"]
else
local mainNonHeal = {}
local dmg = rec.Damage or {}
local healOnly = {}
if next(dmg) ~= nil then
local main = dmg["Main Damage"]
local mainNonHeal, 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 mainText = formatDamageList(mainNonHeal, maxLevel, (#mainNonHeal > 1))
local flatList = dmg["Flat Damage"]
addRow(root, "Main Damage", mainText)
local reflList = dmg["Reflect Damage"]


local flatText = formatDamageList(dmg["Flat Damage"], maxLevel, false)
local flatHas = (type(flatList) == "table" and #flatList > 0)
addRow(root, "Flat Damage", flatText)
local reflHas = (type(reflList) == "table" and #reflList > 0)


local reflText = formatDamageList(dmg["Reflect Damage"], maxLevel, false)
local pureHealing = (#healOnly > 0) and (#mainNonHeal == 0) and (not flatHas) and (not reflHas)
addRow(root, "Reflect Damage", reflText)


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


local scaleText = formatScaling(dmg.Scaling)
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
addRow(root, "Scaling", scaleText)
end
end
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"])
local statusRem  = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
local statusRem  = formatStatusRemoval(rec["Status Removal"])
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
Line 936: Line 1,139:
local args = getArgs(frame)
local args = getArgs(frame)


-- Prefer explicit param, then unnamed, then fall back to the current page name.
local userName = args.user or args[1]
local userName = args.user or args[1]
if not userName or userName == "" then
if not userName or userName == "" then
Line 963: Line 1,165:


local root = mw.html.create("div")
local root = mw.html.create("div")
root:addClass("spiritvale-skill-list")
root:addClass("sv-skill-collection")


-- IMPORTANT: On class pages / list mode, hide Users (redundant on that page).
for _, rec in ipairs(matches) do
for _, rec in ipairs(matches) do
root:wikitext(buildInfobox(rec, { showUsers = false }))
local item = root:tag("div"):addClass("sv-skill-item")
item:wikitext(buildInfobox(rec, { showUsers = false, inList = true }))
end
end


Line 980: Line 1,182:
local args = getArgs(frame)
local args = getArgs(frame)


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


local rec
local rec
-- 1) Prefer External/Display Name
if name and name ~= "" then
if name and name ~= "" then
rec = findSkillByName(name)
rec = findSkillByName(name)
end
end
-- 2) Fallback: internal ID
if not rec and id and id ~= "" then
if not rec and id and id ~= "" then
rec = getSkillById(id)
rec = getSkillById(id)
end
end


-- 3) If still nothing, decide if this is "list mode" or truly unknown.
if not rec then
if not rec then
local pageTitle = mw.title.getCurrentTitle()
local pageTitle = mw.title.getCurrentTitle()
Line 1,010: Line 1,203:
(not id or id == "")
(not id or id == "")


-- Case A: {{Skill}} with no parameters on a page → list for that page name.
if noExplicitArgs then
if noExplicitArgs then
return p.listForUser(frame)
return p.listForUser(frame)
end
end


-- Case B: {{Skill|Acolyte}} on the "Acolyte" page and no id → treat as list.
if name and name ~= "" and name == pageName and (not id or id == "") then
if name and name ~= "" and name == pageName and (not id or id == "") then
return p.listForUser(frame)
return p.listForUser(frame)
end
end


-- Otherwise, genuinely unknown skill.
local label = name or id or "?"
local label = name or id or "?"
return string.format(
return string.format(
Line 1,029: Line 1,219:
end
end


-- For single-skill rendering:
-- - hide Users if this is the skill's own page
-- - otherwise show Users
local showUsers = not isDirectSkillPage(rec)
local showUsers = not isDirectSkillPage(rec)
return buildInfobox(rec, { showUsers = showUsers })
return buildInfobox(rec, { showUsers = showUsers })
Retrieved from "https://spiritvale.info/wiki/Module:GameSkills"