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
 
(14 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
----------------------------------------------------------------------
-- 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)
local function basisLabel(entry, isHealing)
Line 285: Line 313:
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"
Line 294: Line 324:
return "Magic Attack"
return "Magic Attack"
end
end
return "Damage"
return "Damage"
end
end


-- Damage formatting:
-- Build a value-only output for a Base/Per Level block, using dyn spans when needed
--  - Avoid "nil%" when Base is missing/0 and only Per Level exists.
local function valuePairDynamicValueOnly(block, maxLevel, level)
--   - For non-healing: "100% + 40 / 80 / 120 ... Attack Per Level"
if type(block) ~= "table" then
--  - For healing: "10 / 20 / 30 ... Healing Per Level"
return nil
local function formatDamageEntry(entry, maxLevel)
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
Line 307: Line 394:


local isHealing = (entry.Type == "Healing")
local isHealing = (entry.Type == "Healing")
local basis = isHealing and "Healing" or basisLabel(entry, false)


local baseRaw = entry["Base %"]
local baseRaw = entry["Base %"]
Line 313: Line 401:
local baseN = toNum(baseRaw)
local baseN = toNum(baseRaw)
local perN  = toNum(perRaw)
local perN  = toNum(perRaw)
local basis = isHealing and "Healing" or basisLabel(entry)


local function baseIsPresent()
local function baseIsPresent()
Line 327: Line 413:
end
end


local baseText = nil
local baseText
if baseIsPresent() then
if baseIsPresent() then
if baseN ~= nil then
baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(baseRaw) .. "%")
baseText = fmtNum(baseN) .. "%"
else
baseText = tostring(baseRaw) .. "%"
end
end
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 baseText and (baseText .. " " .. basis) or nil
return baseText and mw.text.nowiki(baseText .. " " .. basis) or nil
end
end


local vals = {}
local series = {}
for lv = 1, maxLevel do
for lv = 1, maxLevel do
table.insert(vals, 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
local listText = table.concat(vals, " / ")


if not baseText then
return dynSpan(series, level)
return string.format("%s %s Per Level", listText, basis)
end
return string.format("%s + %s %s Per Level", baseText, listText, basis)
end
end


local function formatDamageList(list, maxLevel, includeTypePrefix, isHealing)
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 360: 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, isHealing)
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 371: 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


-- Scaling should read like:
local list = scaling
--  "2% Attack Per Vitality"
if #list == 0 then
-- For pure healing skills:
if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then
--  "1% Healing Per Vitality"
list = { scaling }
local function formatScaling(list, basisOverride)
else
if type(list) ~= "table" or #list == 0 then
return nil
return nil
end
end
end


Line 403: 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 423: 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 443: 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 450: 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 495: 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 509: 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


-- Special Mechanics:
local function formatMechanicEffects(effects, maxLevel, level)
-- If effect block has Type, render like:
--  "Holy Light - Skill Area + 3"
local function formatMechanicEffects(effects)
if type(effects) ~= "table" then
if type(effects) ~= "table" then
return nil
return nil
Line 534: 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 t = block.Type
local t = block.Type
if t ~= nil and tostring(t) ~= "" then
if t ~= nil and tostring(t) ~= "" then
local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
local amt = effectAmount(block)
local amt = valuePairRawText(pair)
local seg = mw.text.nowiki(tostring(t) .. " - " .. tostring(name))
if amt then
if amt then
table.insert(parts, string.format("%s - %s + %s", tostring(t), tostring(name), amt))
seg = seg .. " + " .. amt
else
table.insert(parts, string.format("%s - %s", tostring(t), tostring(name)))
end
end
table.insert(parts, seg)
else
else
local txt = valuePairText(name, block, ", ")
local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
if txt then
if txt then
table.insert(parts, txt)
table.insert(parts, txt)
Line 555: Line 654:
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 565: Line 661:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 571: 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 578: 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 587: 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 627: 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 642: 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 650: 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 658: 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 668: 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 676: 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 710: 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 728: 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 738: 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
end
if internal and mw.ustring.lower(internal) == pageName then
 
return true
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
 
-- 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 754: 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
-- Top "hero" row: icon + name (left), description (right)
root:addClass("sv-skill-inlist")
-- ==========================================================
end
 
-- Hero rows
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 rightInner = rightCell:tag("div")
local descCell = descRow:tag("td")
rightInner:addClass("spiritvale-infobox-main-right-inner")
descCell:attr("colspan", 2)
descCell:addClass("sv-hero-desc-cell")


if desc ~= "" then
local descInner = descCell:tag("div")
rightInner:tag("div")
descInner:addClass("spiritvale-infobox-main-right-inner")
 
descInner: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 811: 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 839: 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 884: 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 flatList = dmg["Flat Damage"]
local flatList = dmg["Flat Damage"]
local reflList = dmg["Reflect Damage"]
local reflList = dmg["Reflect Damage"]


local flatHas = (type(flatList) == "table" and #flatList > 0)
local flatHas = (type(flatList) == "table" and #flatList > 0)
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, (#mainNonHeal > 1), false)
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, false, false)
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
addRow(root, "Flat Damage", flatText)
end
 
local reflText = formatDamageList(reflList, maxLevel, false, false)
addRow(root, "Reflect Damage", reflText)
 
local healText = formatDamageList(healOnly, maxLevel, false, true)
addRow(root, "Healing", healText)
 
local scaleText = formatScaling(dmg.Scaling, pureHealing and "Healing" or nil)
addRow(root, "Scaling", scaleText)
end
end


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


------------------------------------------------------------------
-- Status
-- Status
------------------------------------------------------------------
local statusApps = formatStatusApplications(rec["Status Applications"], 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 993: 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 1,020: 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")


-- 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 1,037: 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 1,046: 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,067: 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,086: 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"