Module:GameSkills

Module:GameSkills

Module:GameSkills renders skill data from Data:skills.json into a reusable infobox-style table.

It is intended to be used via a template (for example Template:Skill) so that skills can be embedded on any page without creating individual skill pages.

This module:

• Loads data via Module:GameData → GameData.loadSkills().
• Looks up skills primarily by display "Name" (what editors use), with "Internal Name" as a fallback.
• Builds a table with only the fields that actually exist for that skill.

---

Data source

Skill data comes from Data:skills.json, which is a JSON page with this top-level structure (see Module:GameData/doc for full details):

{
  "version": "SpiritVale-0.8.2",
  "schema_version": 1,
  "generated_at": "2025-12-12T17:24:05.807675+00:00",
  "records": [
    {
      "Name": "Some Skill",
      "Internal Name": "SomeSkillInternalId",
      "...": "other fields specific to skills"
    }
  ]
}

Each record is a single skill. Important keys:

• "Name" – the display name (what players and editors will usually see and use).
• "Internal Name" – the stable ID used internally and available as an optional parameter for power users and tooling.

---

Output

For a given skill, the module renders a table with the CSS class spiritvale-skill-infobox.

Depending on what exists in the JSON record, the table may include:

• Header row with skill name (and icon, if present).
• Icon (from "Icon", as a file name like skill-example.webp).
• Description.
• Type information:
  • Damage Type
  • Element Type
  • Target Type
  • Cast Type
• Max Level.
• Users:
  • Classes
  • Summons
  • Monsters
  • Events
• Requirements:
  • Required Skills (with required level)
  • Required Weapons
  • Required Stances
• Mechanics:
  • Range
  • Cast Time / Cooldown / Duration
  • Mana Cost
• Damage and scaling:
  • Main Damage (base and per-level, where present)
  • Scaling (stat-based contributions)
• Status interactions:
  • Status Applications (status name, scope, basic duration/chance info)

Rows are only shown if the underlying field exists in the JSON for that skill.

---

Public interface

The module exposes a single entry point for templates:

GameSkills.infobox(frame)

This is usually called via #invoke from a template, not directly from pages.

It accepts the following parameters (either passed directly or via a wrapper template):

• 1 – unnamed parameter; treated as the skill "Name".
• name – explicit display "Name" of the skill (equivalent to 1).
• id – "Internal Name" of the skill (optional fallback / power use).

Lookup order:

1. If name or the first unnamed parameter is provided and matches a record’s "Name", that record is used.
2. Otherwise, if id is provided and matches an "Internal Name", that record is used.
3. If nothing is found, a small error message is returned and the page is categorized for tracking.

Example direct usage (not recommended; normally use a template):

No skills found for: GameSkills

or:

No skills found for: GameSkills

---

Template:Skill

The recommended way to use this module is via a small wrapper template, for example:

Template:Skill

 No skills found for: GameSkills

Typical usage on any page:

Bash	Delivers a crushing blow with a chance to stun the target.
Level Select Level 10 / 10 Type Melee Element Neutral Target Enemy Cast Type Target
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Required Skills	Axe Mastery (Lv.1)
Resource Cost	MP: 13
Combo	Type: Ready, Duration: 4s
Main Damage	350% Attack
Scaling	2% Attack Per Strength
Flags	Special: Self Centered
Applies	Target – Stun (Duration: 3s, Chance: 30%)

or, explicitly:

Bash	Delivers a crushing blow with a chance to stun the target.
Level Select Level 10 / 10 Type Melee Element Neutral Target Enemy Cast Type Target
Classes	Warrior, Weaver
Monsters	Ashrend, Goblin King
Required Skills	Axe Mastery (Lv.1)
Resource Cost	MP: 13
Combo	Type: Ready, Duration: 4s
Main Damage	350% Attack
Scaling	2% Attack Per Strength
Flags	Special: Self Centered
Applies	Target – Stun (Duration: 3s, Chance: 30%)

Internal IDs can still be used when needed:

Unknown Skill: Bash_InternalId

This keeps page wikitext simple while centralizing all JSON loading and formatting logic inside Lua.

---

--Module: GameSkills
--
--Upgrades:
--  - Adds a per - skill Level Select slider(client - side JS updates fields)
--  - Default level = Max Level
--  - Adds.sv - skill - card + data - max - level / data - level hooks for JS
--  - Replaces large Lv1 / Lv2 /... lists with data - series dynamic spans
--  - Removes "General" + "Type" section bars and merges Level Select + Type into one unified top band
--(Level Select on the left; Type / Element / Target / Cast Type list on the right)
--  - NEW(list - mode): Wraps all skills in ONE wrapper panel and each skill in a stable.sv - skill - item
--so CSS dividers work reliably under Citizen / table wrappers.
--
--Requires the JS you installed in MediaWiki: Common.js.
--Uses Common.css classes:
--   .sv - topband - cell, .sv - topband - table, .sv - type - table, .sv - level - ui, .sv - level - title, .sv - level - label, .sv - level - slider
--   .sv - skill - collection, .sv - skill - item

local GameData = require("Module:GameData")

local p = {}

----------------------------------------------------------------------
--Internal helpers
----------------------------------------------------------------------

	local skillsCache

local function getSkills()
if not skillsCache then
skillsCache = GameData.loadSkills()
end
return skillsCache
end

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

local function listToText(list, sep)
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

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)
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
if type(v) == "table" and v.Value ~= nil then
return toNum(v.Value)
end
return nil
end

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

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

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

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

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

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

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

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

return tostring(span)
end

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

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

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

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

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

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

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

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

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

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

return lines
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

--Build series strings for each level
	local series = {}
for lv = 1, maxLevel do
		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

return dynSpan(series, level)
end

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

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

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

local function formatScaling(list, basisOverride)
if type(list) ~= "table" or #list == 0 then
return nil
end

	local parts = {}
for _, s in ipairs(list) do
	if type(s) == "table" then
			local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
			local pct = s.Percent
			local pctN = toNum(pct)

			local basis = basisOverride or basisLabel(s, false)

if pctN ~= nil and pctN ~= 0 then
table.insert(parts, string.format("%s%% %s Per %s", fmtNum(pctN), basis, stat))
			elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then
table.insert(parts, string.format("%s%% %s Per %s", tostring(pct), basis, stat))
end
end
end

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

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

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

	local size = area["Area Size"]
if size and size ~= "" then
table.insert(parts, "Size: "..mw.text.nowiki(tostring(size)))
end

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

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

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

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

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

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

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

	local manaLines = valuePairDynamicLines("MP", rc["Mana Cost"], maxLevel, level)
for _, line in ipairs(manaLines) do
	table.insert(parts, line)
	end

	local hpLines = valuePairDynamicLines("HP", rc["Health Cost"], maxLevel, level)
for _, line in ipairs(hpLines) do
	table.insert(parts, line)
	end

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

local function formatCombo(combo)
if type(combo) ~= "table" then
return nil
end
	local parts = {}

if combo.Type then
table.insert(parts, "Type: "..mw.text.nowiki(tostring(combo.Type)))
end

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

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

if #parts == 0 then
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

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

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

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

for _, name in ipairs(keys) do
		local block = effects[name]
		if type(block) == "table" then
			local t = block.Type

if t ~= nil and tostring(t) ~= "" then
				local amt = effectAmount(block)
				local seg = mw.text.nowiki(tostring(t).. " - "..tostring(name))
if amt then
seg = seg.. " + "..amt
end
table.insert(parts, seg)
			else
				local txt = valuePairDynamicText(name, block, maxLevel, level, ", ")
if txt then
table.insert(parts, txt)
end
end
end
end

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

local function formatModifiers(mods)
if type(mods) ~= "table" then
return nil
end
	local parts = {}

	local function collect(label, sub)
if type(sub) ~= "table" then
return
end
		local flags = {}
for k, v in pairs(sub) do
	if v then
				table.insert(flags, k)
			end
end
table.sort(flags)
if #flags > 0 then
table.insert(parts, string.format("%s: %s", label, table.concat(flags, ", ")))
end
end

collect("Movement", mods["Movement Modifiers"])
collect("Combat", mods["Combat Modifiers"])
collect("Special", mods["Special Modifiers"])

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

local function formatStatusApplications(list, maxLevel, level)
if type(list) ~= "table" or #list == 0 then
return nil
end
	local parts = {}
for _, s in ipairs(list) do
	if type(s) == "table" then
			local scope = s.Scope or "Target"
			local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status"

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

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

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

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

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

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

local function formatStatusRemoval(list, maxLevel, level)
if type(list) ~= "table" or #list == 0 then
return nil
end
	local parts = {}
for _, r in ipairs(list) do
	if type(r) == "table" then
			local names = r["Status External Name"]
			local label
if type(names) == "table" then
label = table.concat(names, ", ")
			elseif type(names) == "string" then
label = names
			else
label = "Status"
end

			local amt = nil
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)
if amt then amt = mw.text.nowiki(amt) end
end

			local seg = mw.text.nowiki(label)
if amt then
seg = seg.. " – "..amt
end
table.insert(parts, seg)
end
end
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end

local function formatEvents(list)
if type(list) ~= "table" or #list == 0 then
return nil
end
	local parts = {}
for _, ev in ipairs(list) do
	if type(ev) == "table" then
			local action = ev.Action or "On event"
			local name = ev["Skill Internal Name"] or ev["Skill External Name"] or "Unknown skill"
table.insert(parts, string.format("%s → %s", action, name))
end
end
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end

----------------------------------------------------------------------
--User matching(for auto lists on class pages)
----------------------------------------------------------------------

	local function skillMatchesUser(rec, userName)
if type(rec) ~= "table" or not userName or userName == "" then
return false
end

	local users = rec.Users
if type(users) ~= "table" then
return false
end

	local userLower = mw.ustring.lower(userName)

	local function listHas(list)
if type(list) ~= "table" then
return false
end
for _, v in ipairs(list) do
	if type(v) == "string" and mw.ustring.lower(v) == userLower then
return true
end
end
return false
end

if listHas(users.Classes)  then return true end
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

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

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

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

	local ext = trim(rec["External Name"] or rec["Name"] or rec["Display Name"])
	local internal = trim(rec["Internal Name"] or rec["InternalName"] or rec["InternalID"])

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

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

	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")
wrap: addClass("sv-level-ui")

wrap: tag("div")
		: addClass("sv-level-title")
		: wikitext("Level Select")

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

wrap: tag("div"): addClass("sv-level-slider")

return tostring(wrap)
end

local function buildTypeTableUI(typeBlock)
if type(typeBlock) ~= "table" or next(typeBlock) == nil then
return nil
end

	local t = mw.html.create("table")
t: addClass("sv-type-table")

	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 addRowKV(k, v)
if not v or v == "" then return end
added = true
		local r = t: tag("tr")
r: tag("th"): wikitext(mw.text.nowiki(k)): done()
r: tag("td"): wikitext(mw.text.nowiki(v)): done()
end

addRowKV("Type", valName(typeBlock["Damage Type"]))-- renamed from "Damage Type"
addRowKV("Element", valName(typeBlock["Element Type"]))
addRowKV("Target", valName(typeBlock["Target Type"]))
addRowKV("Cast Type", valName(typeBlock["Cast Type"]))

if not added then
return nil
end
return tostring(t)
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")

--Nested table(what Common.css targets)
	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

local function buildInfobox(rec, opts)
opts = opts or { }
	local showUsers = (opts.showUsers ~= false)

	local maxLevel = tonumber(rec["Max Level"]) or 1
if maxLevel < 1 then maxLevel = 1 end

--Always default to max level
	local level = clamp(maxLevel, 1, maxLevel)

	local root = mw.html.create("table")

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

--JS hook: treat the table itself as the "card"
root: addClass("sv-skill-card")

--Helpful flag for list - mode overrides(optional, but nice)
	if opts and opts.inList then
root: addClass("sv-skill-inlist")
end

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

--Top "hero" row
	local icon = rec.Icon
	local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill"
	local desc = rec.Description or ""

	local headerRow = root: tag("tr")
headerRow: addClass("spiritvale-infobox-main")

	local leftCell = headerRow: tag("th")
leftCell: addClass("spiritvale-infobox-main-left")

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

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

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

	local rightCell = headerRow: tag("td")
rightCell: addClass("spiritvale-infobox-main-right")

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

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

------------------------------------------------------------------
	--Unified top band(Level Select left, Type list right)
------------------------------------------------------------------
	local levelUI = buildLevelSelectUI(level, maxLevel)
	local typeUI = buildTypeTableUI(rec.Type or {})
addTopBand(root, levelUI, typeUI)

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

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

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

addRow(root, "Required Weapons", listToText(req["Required Weapons"]))
addRow(root, "Required Stances", listToText(req["Required Stances"]))
end

------------------------------------------------------------------
	--Mechanics
------------------------------------------------------------------
	local mech = rec.Mechanics or { }
if next(mech) ~= nil then

addRow(root, "Range", formatUnitValue(mech.Range))
addRow(root, "Area", formatArea(mech.Area, maxLevel, level))

if mech["Autocast Multiplier"] ~= nil then
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]))
end

addRow(root, "Timing", formatTimingBlock(mech["Basic Timings"], maxLevel, level))
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

------------------------------------------------------------------
	--Damage & Scaling
------------------------------------------------------------------
	local dmg = rec.Damage or { }
if next(dmg) ~= nil then

		local main = dmg["Main Damage"]
		local mainNonHeal, 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

		local flatList = dmg["Flat Damage"]
		local reflList = dmg["Reflect Damage"]

		local flatHas = (type(flatList) == "table" and #flatList > 0)
		local reflHas = (type(reflList) == "table" and #reflList > 0)

		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, "Flat Damage", formatDamageList(flatList, maxLevel, level, false))
addRow(root, "Reflect Damage", formatDamageList(reflList, maxLevel, level, false))
addRow(root, "Healing", formatDamageList(healOnly, maxLevel, level, false))

addRow(root, "Scaling", formatScaling(dmg.Scaling, pureHealing and "Healing" or nil))
end

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

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

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

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

return tostring(root)
end

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

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

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

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

	local dataset = getSkills()
	local matches = {}

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

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

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

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

return tostring(root)
end

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

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

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

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

if not rec then
		local pageTitle = mw.title.getCurrentTitle()
		local pageName = pageTitle and pageTitle.text or ""

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

if noExplicitArgs then
return p.listForUser(frame)
end

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

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

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

return p