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
 
(13 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
--  - 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
--
--
-- Requires the JS you installed in MediaWiki:Common.js.
-- NOTE: We add a small amount of inline styling on the top-band inner panels
-- (Level Select + Type box) so light mode remains readable even if a skin/theme
-- class selector isn’t reliable.


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


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


Line 25: 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 75: 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 85: 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 94: 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 116: 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 130: Line 136:
return nil
return nil
end
end
level = clamp(level or #series, 1, #series)
level = clamp(level or #series, 1, #series)


Line 154: 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 169: Line 180:
end
end


-- Like your old valuePairLines/valuePairText, but:
-- Base/Per Level renderer:
-- - if Per Level is a list, we 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" and "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 180: 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 209: 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 232: 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 242: 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 265: Line 301:
end
end
end
end
return nil
return nil
end
end
Line 276: 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 285: 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 296: 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 315: 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 335: 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 369: 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 397: 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 407: Line 502:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 419: 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 429: Line 522:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 443: 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 456: 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 466: Line 557:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 478: 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 488: Line 577:
return nil
return nil
end
end
local parts = {}
local parts = {}


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


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 555: 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
-- Keep old behavior here (usually not huge)
local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
local txt = valuePairRawText(block)
if txt then
if txt then
table.insert(parts, mw.text.nowiki(tostring(name) .. ": " .. txt))
table.insert(parts, txt)
end
end
end
end
Line 577: 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 587: Line 661:
return nil
return nil
end
end
local parts = {}
local parts = {}


Line 593: 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 600: 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 609: 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 619: 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 636: 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 649: 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 659: 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 664: 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 672: Line 743:
end
end


local amt = nil
local amt
-- If this removal has a Per Level list, make it dynamic
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
if type(r["Per Level"]) == "table" and #r["Per Level"] > 0 and not isFlatList(r["Per Level"]) then
local series = {}
local series = {}
Line 682: 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 692: 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 702: 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 710: 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 744: 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 762: 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 772: 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 UI
----------------------------------------------------------------------
----------------------------------------------------------------------


local function buildLevelSelectUI(level, maxLevel)
local function buildLevelSelectUI(level, maxLevel)
-- Matches the 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")


local label = wrap:tag("div"):addClass("sv-level-label")
-- Inline “light-mode-safe” panel styling (works in both modes)
label:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel))
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")
wrap:tag("div"):addClass("sv-level-slider")
return tostring(wrap)
return tostring(wrap)
end
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
-- 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
----------------------------------------------------------------------
-- Infobox builder
----------------------------------------------------------------------


local function buildInfobox(rec, opts)
local function buildInfobox(rec, opts)
Line 805: 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
 
local level = clamp(maxLevel, 1, maxLevel)
-- Always default to max level (your requirement)
local level = maxLevel
level = clamp(level, 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))


-- ==========================================================
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),
buildTypeTableUI(rec.Type or {})
)


-- Replace Max Level -> Level Select (slider)
-- Users
addRow(root, "Level Select", buildLevelSelectUI(level, maxLevel))
 
-- Hide Users on:
--  - 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 873: 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 nameReq = 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 lvlReq = rs["Required Level"]
local lvlReq = rs["Required Level"]
if lvlReq then
if lvlReq then
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
table.insert(skillParts, string.format("%s (Lv.%s)", nameReq, lvlReq))
Line 901: 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, maxLevel, level)
addRow(root, "Area", areaText)


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


local btText = formatTimingBlock(mech["Basic Timings"], maxLevel, level)
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))
addRow(root, "Special Mechanics", formatMechanicEffects(mech.Effects, maxLevel, level))
end


local rcText = formatResourceCost(mech["Resource Cost"], maxLevel, level)
-- Source (new) + Scaling, with backcompat for old Damage
addRow(root, "Resource Cost", rcText)
if type(rec.Source) == "table" then
addRow(root, "Source", formatSource(rec.Source, maxLevel, level))


local comboText = formatCombo(mech.Combo)
local basisOverride =
addRow(root, "Combo", comboText)
(rec.Source.Type == "Healing" or rec.Source.Healing == true) and "Healing" or nil


local effText = formatMechanicEffects(mech.Effects)
addRow(root, "Scaling", formatScaling(rec.Source.Scaling, basisOverride))
addRow(root, "Special Mechanics", effText)
else
end
local dmg = rec.Damage or {}
if next(dmg) ~= nil then
local main = dmg["Main Damage"]
local mainNonHeal, healOnly = {}, {}


------------------------------------------------------------------
if type(main) == "table" then
-- Damage & Scaling
for _, d in ipairs(main) do
------------------------------------------------------------------
if type(d) == "table" and d.Type == "Healing" then
local dmg = rec.Damage or {}
table.insert(healOnly, d)
if next(dmg) ~= nil then
else
addSectionHeader(root, "Damage and Scaling")
table.insert(mainNonHeal, d)
 
end
-- Split healing out of Main Damage (Type == "Healing")
local main = dmg["Main Damage"]
local mainNonHeal = {}
local healOnly = {}
 
if type(main) == "table" then
for _, d in ipairs(main) do
if type(d) == "table" and d.Type == "Healing" then
table.insert(healOnly, d)
else
table.insert(mainNonHeal, d)
end
end
end
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, level, (#mainNonHeal > 1))
addRow(root, "Main Damage",    formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)))
addRow(root, "Main Damage", mainText)
addRow(root, "Flat Damage",    formatDamageList(flatList, maxLevel, level, false))
addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false))
addRow(root, "Healing",        formatDamageList(healOnly, maxLevel, level, false))


local flatText = formatDamageList(flatList, maxLevel, level, false)
addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
addRow(root, "Flat Damage", flatText)
end
 
local reflText = formatDamageList(reflList, maxLevel, level, false)
addRow(root, "Reflect Damage", reflText)
 
local healText = formatDamageList(healOnly, maxLevel, level, false)
addRow(root, "Healing", healText)
 
local scaleText = formatScaling(dmg.Scaling, pureHealing and "Healing" or nil)
addRow(root, "Scaling", scaleText)
end
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,079: 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


Line 1,100: Line 1,187:


local rec
local rec
if name and name ~= "" then
if name and name ~= "" then
rec = findSkillByName(name)
rec = findSkillByName(name)
Retrieved from "https://spiritvale.info/wiki/Module:GameSkills"