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
 
(10 intermediate revisions by the same user not shown)
Line 1: Line 1:
-- Module:GameSkills
-- Module:GameSkills
--
--
-- Upgrades:
-- Renders active skill data (Data:skills.json) into an infobox-style table,
--  - Adds a per-skill Level Select slider (client-side JS updates fields)
-- and can also list all skills for a given user/class (page name).
--
-- Features:
--  - Per-skill Level Select slider (client-side JS updates .sv-dyn spans)
--  - Default level = Max Level
--  - Default level = Max Level
--  - Adds .sv-skill-card + data-max-level / data-level hooks for JS
--  - .sv-skill-card + data-max-level / data-level hooks for JS
--  - Replaces large Lv1/Lv2/... lists with data-series dynamic spans
--  - Uses dynamic spans instead of long Lv1/Lv2/... lists
--  - NEW: Removes "General" + "Type" section bars and merges Level Select + Type into one unified top band
--  - Unified top band: Level Select (left) + Type/Element/Target/Cast (right)
--        (Level Select on the left; Type/Element/Target/Cast Type list on the right)
--  - List-mode: wraps all skills in one wrapper panel + stable .sv-skill-item divs
--
--
-- Requires the JS you installed in MediaWiki:Common.js.
-- NOTE: We add a small amount of inline styling on the top-band inner panels
-- Uses the Common.css classes you added:
-- (Level Select + Type box) so light mode remains readable even if a skin/theme
--   .sv-topband-cell, .sv-topband-table, .sv-type-table, .sv-level-ui, .sv-level-title, .sv-level-label, .sv-level-slider
-- 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 ", ")
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
local function addSectionHeader(tbl, label)
local row = tbl:tag("tr")
local cell = row:tag("th")
cell:attr("colspan", 2)
cell:addClass("spiritvale-infobox-section-header")
cell:wikitext(label)
end
local function trim(s)
if type(s) ~= "string" then return nil end
s = mw.text.trim(s)
s = mw.text.trim(s)
if s == "" then return nil end
return (s ~= "" and s) or nil
return s
end
end


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


local function clamp(n, lo, hi)
local function clamp(n, lo, hi)
if type(n) ~= "number" then return lo end
if type(n) ~= "number" then
return lo
end
if n < lo then return lo end
if n < lo then return lo end
if n > hi then return hi end
if n > hi then return hi end
Line 89: 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 98: 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 120: Line 125:
end
end


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


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


Line 134: Line 136:
return nil
return nil
end
end
level = clamp(level or #series, 1, #series)
level = clamp(level or #series, 1, #series)


Line 158: 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 173: Line 180:
end
end


-- Like your old valuePairLines/valuePairText, but:
-- Base/Per Level renderer:
-- - if Per Level is a list, render a dynamic span instead of "v1 / v2 / ..."
-- - Per Level list -> dynamic span (or single value if flat)
-- - scalar Per Level stays as the old "Base" + "Per Level" lines (still short)
-- - Per Level scalar -> "Base" + "Per Level" lines
local function valuePairDynamicLines(name, block, maxLevel, level)
local function valuePairDynamicLines(name, block, maxLevel, level)
if type(block) ~= "table" then
if type(block) ~= "table" then
Line 184: Line 191:
local per  = block["Per Level"]
local per  = block["Per Level"]


-- Per Level list (expanded)
-- Per Level list (expanded by wikiprep)
if type(per) == "table" then
if type(per) == "table" then
-- empty list -> show Base only
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, mw.text.nowiki(baseText)) }
end
return {}
end
end


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


-- dynamic series
local series = {}
local series = {}
for _, v in ipairs(per) do
for _, v in ipairs(per) do
Line 213: Line 211:


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


-- scalar Per Level (keep old style)
-- scalar Per Level
local lines = {}
local lines = {}
local baseText = formatUnitValue(base)
local baseText = formatUnitValue(base)
Line 236: Line 231:
local function valuePairDynamicText(name, block, maxLevel, level, sep)
local function valuePairDynamicText(name, block, maxLevel, level, sep)
local lines = valuePairDynamicLines(name, block, maxLevel, level)
local lines = valuePairDynamicLines(name, block, maxLevel, level)
if #lines == 0 then return nil end
return (#lines > 0) and table.concat(lines, sep or "<br />") or nil
return table.concat(lines, sep or "<br />")
end
 
-- Raw text for a Base/Per Level block (used by Special Mechanics & Source fallbacks)
local function valuePairRawText(block)
if type(block) ~= "table" then
return nil
end
 
local base = block.Base
local per  = block["Per Level"]
 
if type(per) == "table" then
if #per == 0 then
return formatUnitValue(base)
end
if isFlatList(per) then
return formatUnitValue(base) or tostring(per[1])
end
 
local vals = {}
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
end
return (#vals > 0) and table.concat(vals, " / ") or nil
end
 
local baseText = formatUnitValue(base)
local perText  = formatUnitValue(per)
 
if baseText and perText and isNonZeroScalar(per) then
return string.format("%s (Per Level: %s)", baseText, perText)
end
 
return baseText or perText
end
end


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


local function findSkillByName(name)
local function findSkillByName(name)
name = trim(name)
name = trim(name)
if not name then return nil end
if not name then
return nil
end
 
local dataset = getSkills()
local dataset = getSkills()
local byName = dataset.byName or {}


local byName = dataset.byName or {}
if byName[name] then
if byName[name] then
return byName[name]
return byName[name]
Line 269: Line 301:
end
end
end
end
return nil
return nil
end
end
Line 280: 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 289: Line 324:
return "Magic Attack"
return "Magic Attack"
end
end
return "Damage"
return "Damage"
end
end


-- Dynamic damage entry:
-- Build a value-only output for a Base/Per Level block, using dyn spans when needed
-- Build a series for Lv1..LvMax, and show only the selected one.
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)
local function formatDamageEntry(entry, maxLevel, level)
if type(entry) ~= "table" then
if type(entry) ~= "table" then
Line 300: Line 394:


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


local baseRaw = entry["Base %"]
local baseRaw = entry["Base %"]
Line 319: 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


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


-- Build series strings for each level
local series = {}
local series = {}
for lv = 1, maxLevel do
for lv = 1, maxLevel do
Line 339: Line 427:


if baseText and baseN ~= nil then
if baseText and baseN ~= nil then
-- numeric base: show total
local total = baseN + perPart
local total = baseN + perPart
table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
table.insert(series, string.format("%s%% %s", fmtNum(total), basis))
elseif baseText then
elseif baseText then
-- nonnumeric base: can't total, show additive
table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
table.insert(series, string.format("%s + %s%% %s", baseText, fmtNum(perPart), basis))
else
else
-- no base: show perPart only
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis))
end
end
Line 373: 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, basisOverride)
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 401: 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


Line 411: Line 502:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 423: Line 515:
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 433: Line 522:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 447: 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
Line 460: Line 550:
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 470: Line 557:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 482: Line 570:
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 492: Line 577:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 510: Line 596:
end
end


if #parts == 0 then
return (#parts > 0) and table.concat(parts, ", ") or nil
return nil
end
return table.concat(parts, ", ")
end
 
local function valuePairRawText(block)
if type(block) ~= "table" then
return nil
end
 
local base = block.Base
local per  = block["Per Level"]
 
if type(per) == "table" then
if #per == 0 then
return formatUnitValue(base)
end
if isFlatList(per) then
return formatUnitValue(base) or tostring(per[1])
end
local vals = {}
for _, v in ipairs(per) do
table.insert(vals, formatUnitValue(v) or tostring(v))
end
return (#vals > 0) and table.concat(vals, " / ") or nil
end
 
local baseText = formatUnitValue(base)
local perText  = formatUnitValue(per)
 
if baseText and perText and isNonZeroScalar(per) then
return string.format("%s (Per Level: %s)", baseText, perText)
end
return baseText or perText
end
end


-- Special Mechanics supports dynamic Per Level lists
local function formatMechanicEffects(effects, maxLevel, level)
local function formatMechanicEffects(effects, maxLevel, level)
if type(effects) ~= "table" then
if type(effects) ~= "table" then
Line 567: Line 618:


local per = block["Per Level"]
local per = block["Per Level"]
if type(per) == "table" and #per > 0 then
if type(per) == "table" and #per > 0 then
if isFlatList(per) then
if isFlatList(per) then
Line 579: Line 629:
end
end


local pair = { Base = block.Base, ["Per Level"] = block["Per Level"] }
local txt = valuePairRawText(block)
local txt = valuePairRawText(pair)
return txt and mw.text.nowiki(txt) or nil
return txt and mw.text.nowiki(txt) or nil
end
end
Line 605: 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 615: Line 661:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 621: 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 628: 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 637: 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


Line 647: Line 693:
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 = {}


Line 664: Line 711:
local t = valuePairDynamicText("Chance", s.Chance, maxLevel, level, "; ")
local t = valuePairDynamicText("Chance", s.Chance, maxLevel, level, "; ")
if t then table.insert(detail, t) end
if t then table.insert(detail, t) end
end
if s["Fixed Duration"] then
table.insert(detail, "Fixed duration")
end
end


Line 677: 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


Line 687: Line 728:
return nil
return nil
end
end
local parts = {}
local parts = {}
for _, r in ipairs(list) do
for _, r in ipairs(list) do
Line 692: 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 700: Line 743:
end
end


local amt = nil
local amt
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
local series = {}
local series = {}
Line 709: Line 752:
else
else
amt = valuePairRawText(r)
amt = valuePairRawText(r)
if amt then amt = mw.text.nowiki(amt) end
amt = amt and mw.text.nowiki(amt) or nil
end
end


Line 719: 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 729: 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 737: 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 771: 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 789: 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 799: 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
if internal and mw.ustring.lower(internal) == pageName then
return true
end
return false
end
end


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


local function buildLevelSelectUI(level, maxLevel)
local function buildLevelSelectUI(level, maxLevel)
-- JS expectations:
--  .sv-level-slider placeholder for the <input type="range">
--  .sv-level-num span for updating the number
local wrap = mw.html.create("div")
local wrap = mw.html.create("div")
wrap:addClass("sv-level-ui")
wrap:addClass("sv-level-ui")


-- Title (matches Common.css)
-- 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")
wrap:tag("div")
:addClass("sv-level-title")
:addClass("sv-level-title")
:wikitext("Level Select")
:wikitext("Level Select")


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


-- Slider placeholder (JS will insert the input)
wrap:tag("div"):addClass("sv-level-slider")
wrap:tag("div"):addClass("sv-level-slider")


Line 840: Line 869:
end
end


local t = mw.html.create("table")
local wrap = mw.html.create("div")
t:addClass("sv-type-table")
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 added = false


local function valName(x)
local function valName(x)
if x == nil then return nil end
if x == nil then
return nil
end
if type(x) == "table" then
if type(x) == "table" then
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.Name and x.Name ~= "" then return tostring(x.Name) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
if x.ID and x.ID ~= "" then return tostring(x.ID) end
end
end
if type(x) == "string" and x ~= "" then return x end
if type(x) == "string" and x ~= "" then
return x
end
return nil
return nil
end
end


local function addRowKV(k, v)
local function addChunk(label, rawVal)
if not v or v == "" then return end
local v = valName(rawVal)
if not v or v == "" then
return
end
added = true
added = true
local r = t:tag("tr")
 
r:tag("th"):wikitext(mw.text.nowiki(k)):done()
local chunk = wrap:tag("div"):addClass("sv-type-chunk")
r:tag("td"):wikitext(mw.text.nowiki(v)):done()
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


addRowKV("Type",     valName(typeBlock["Damage Type"]))  -- renamed from "Damage Type"
-- NEW keys (with fallback to old keys)
addRowKV("Element",   valName(typeBlock["Element Type"]))
addChunk("Damage", typeBlock.Damage  or typeBlock["Damage Type"])
addRowKV("Target",   valName(typeBlock["Target Type"]))
addChunk("Element", typeBlock.Element or typeBlock["Element Type"])
addRowKV("Cast Type", valName(typeBlock["Cast Type"]))
addChunk("Target", typeBlock.Target  or typeBlock["Target Type"])
addChunk("Cast",   typeBlock.Cast    or typeBlock["Cast Type"])


if not added then
if not added then
return nil
return nil
end
end
return tostring(t)
 
return tostring(wrap)
end
end


Line 884: Line 928:
cell:addClass("sv-topband-cell")
cell:addClass("sv-topband-cell")


-- Nested table (this is what your new CSS targets)
-- Keep nested table (your CSS targets it)
local inner = cell:tag("table")
local inner = cell:tag("table")
inner:addClass("sv-topband-table")
inner:addClass("sv-topband-table")
Line 899: Line 943:
end
end
end
end
----------------------------------------------------------------------
-- Infobox builder
----------------------------------------------------------------------


local function buildInfobox(rec, opts)
local function buildInfobox(rec, opts)
Line 906: Line 954:
local maxLevel = tonumber(rec["Max Level"]) or 1
local maxLevel = tonumber(rec["Max Level"]) or 1
if maxLevel < 1 then maxLevel = 1 end
if maxLevel < 1 then maxLevel = 1 end
-- Always default to max level
local level = clamp(maxLevel, 1, maxLevel)
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")
 
-- JS hook: treat the table itself as the "card"
root:addClass("sv-skill-card")
root:addClass("sv-skill-card")
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-max-level", tostring(maxLevel))
root:attr("data-level", tostring(level))
root:attr("data-level", tostring(level))


-- Top "hero" row
if opts.inList then
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 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
-- Unified top band (Level Select left, Type list right)
addTopBand(
------------------------------------------------------------------
root,
local levelUI = buildLevelSelectUI(level, maxLevel)
buildLevelSelectUI(level, maxLevel),
local typeUI  = buildTypeTableUI(rec.Type or {})
buildTypeTableUI(rec.Type or {})
addTopBand(root, levelUI, typeUI)
)


------------------------------------------------------------------
-- Users
-- Users (kept as rows; hidden on lists or skill page)
------------------------------------------------------------------
if showUsers then
if showUsers then
local users = rec.Users or {}
local users = rec.Users or {}
Line 970: 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
Line 998: Line 1,047:
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, "Range", formatUnitValue(mech.Range))
addRow(root, "Area", formatArea(mech.Area, maxLevel, level))
addRow(root, "Area", formatArea(mech.Area, maxLevel, level))


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


addRow(root, "Timing", formatTimingBlock(mech["Basic Timings"], maxLevel, level))
addRow(root, "Timing",           formatTimingBlock(mech["Basic Timings"], maxLevel, level))
addRow(root, "Resource Cost", formatResourceCost(mech["Resource Cost"], maxLevel, level))
addRow(root, "Resource Cost",     formatResourceCost(mech["Resource Cost"], maxLevel, level))
addRow(root, "Combo", formatCombo(mech.Combo))
addRow(root, "Combo",             formatCombo(mech.Combo))
addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level))
addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level))
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
local basisOverride =
addSectionHeader(root, "Damage and Scaling")
(rec.Source.Type == "Healing" or rec.Source.Healing == true) and "Healing" or nil


local main = dmg["Main Damage"]
addRow(root, "Scaling", formatScaling(rec.Source.Scaling, basisOverride))
local mainNonHeal, healOnly = {}, {}
else
local dmg = rec.Damage or {}
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)


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)


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


addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
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"], maxLevel, level)
local statusRem  = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
local statusRem  = formatStatusRemoval(rec["Status Removal"], maxLevel, level)
if statusApps or statusRem then
if statusApps or statusRem then
addSectionHeader(root, "Status Effects")
addRow(root, "Applies", statusApps)
addRow(root, "Applies", statusApps)
addRow(root, "Removes", statusRem)
addRow(root, "Removes", statusRem)
end
end


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


------------------------------------------------------------------
-- Notes
-- Notes
------------------------------------------------------------------
if type(rec.Notes) == "table" and #rec.Notes > 0 then
if type(rec.Notes) == "table" and #rec.Notes > 0 then
addSectionHeader(root, "Notes")
addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
addRow(root, "Notes", table.concat(rec.Notes, "<br />"))
end
end
Line 1,127: 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")


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


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