Module:GameSkills: Difference between revisions
From SpiritVale Wiki
More actions
No edit summary |
No edit summary |
||
| (51 intermediate revisions by the same user not shown) | |||
| Line 1: | Line 1: | ||
--Module: GameSkills | -- Module:GameSkills | ||
-- | -- | ||
-- | -- Phase 6.5+ (Plug-in Slot Architecture) | ||
- | |||
-- | -- | ||
-- | -- Layout: | ||
-- | -- Row 1: Slot 1 + Slot 2 (Icon + SkillType) | ||
-- | -- Row 2: Slot 3 + Slot 4 (Description + Placeholder) | ||
-- | -- Row 3: Slot 5 + Slot 6 (SourceType + QuickStats) | ||
-- Row 4: Slot 7 + Slot 8 (SpecialMechanics + LevelSelector) | |||
-- | |||
-- Requires Common.js: | |||
-- - updates .sv-dyn spans via data-series | |||
-- - updates .sv-level-num + data-level on .sv-skill-card | |||
-- - binds to input.sv-level-range inside each card | |||
local GameData = require("Module:GameData") | local GameData = require("Module:GameData") | ||
| Line 21: | Line 19: | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
-- | -- Data cache | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
local skillsCache | |||
local eventsCache | |||
-- getSkills: lazy-load + cache skill dataset from GameData. | |||
local function getSkills() | local function getSkills() | ||
if not skillsCache then | if not skillsCache then | ||
skillsCache = GameData.loadSkills() | skillsCache = GameData.loadSkills() | ||
end | |||
return skillsCache | |||
end | end | ||
return | |||
local function getEvents() | |||
if eventsCache == nil then | |||
if type(GameData.loadEvents) == "function" then | |||
eventsCache = GameData.loadEvents() | |||
else | |||
eventsCache = false | |||
end | |||
end | |||
return eventsCache | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- Small utilities | |||
---------------------------------------------------------------------- | |||
-- getArgs: read args from parent frame when invoked from a template. | |||
local function getArgs(frame) | local function getArgs(frame) | ||
local parent = frame: getParent() | local parent = frame:getParent() | ||
return (parent and parent.args) or frame.args | |||
end | end | ||
return | |||
-- trim: normalize strings (nil if empty). | |||
local function trim(s) | |||
if type(s) ~= "string" then | |||
return nil | |||
end | |||
s = mw.text.trim(s) | |||
return (s ~= "" and s) or nil | |||
end | end | ||
local function | -- toNum: convert common scalar/table forms to a Lua number. | ||
if type( | local function toNum(v) | ||
return nil | 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 | end | ||
-- clamp: clamp a number into [lo, hi]. | |||
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 | end | ||
local function | -- fmtNum: consistent number formatting (trim trailing zeros). | ||
if | local function fmtNum(n) | ||
return | 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 | end | ||
-- listToText: join an array into a readable string. | |||
local function listToText(list, sep) | |||
if type(list) ~= "table" or #list == 0 then | |||
return nil | |||
end | |||
return table.concat(list, sep or ", ") | |||
end | end | ||
local function | local function resolveDisplayName(v, kind) | ||
if v == nil then return nil end | |||
local function firstString(keys, source) | |||
for _, key in ipairs(keys) do | |||
local candidate = source[key] | |||
if type(candidate) == "string" and candidate ~= "" then | |||
return candidate | |||
end | |||
end | |||
return nil | |||
end | |||
if type(v) == "table" then | |||
local primaryKeys = { "External Name", "Display Name", "Name" } | |||
local extendedKeys = { "Skill External Name", "Status External Name" } | |||
local internalKeys = { "Internal Name", "Internal ID", "ID", "InternalID", "Skill Internal Name", "InternalID" } | |||
return firstString(primaryKeys, v) | |||
or firstString(extendedKeys, v) | |||
or firstString(internalKeys, v) | |||
end | |||
if type(v) == "string" then | |||
if kind == "event" then | |||
local events = getEvents() | |||
if events and events.byId and events.byId[v] then | |||
local mapped = resolveDisplayName(events.byId[v], "event") | |||
if mapped then | |||
return mapped | |||
end | |||
end | |||
end | |||
return v | |||
end | |||
return tostring(v) | |||
end | end | ||
local function | local function resolveEventName(v) | ||
if type( | local resolved = resolveDisplayName(v, "event") | ||
if type(resolved) == "string" then | |||
return resolved | |||
end | |||
return (resolved ~= nil) and tostring(resolved) or nil | |||
end | end | ||
local function | local function resolveSkillNameFromEvent(ev) | ||
if type( | if type(ev) ~= "table" then | ||
return resolveDisplayName(ev, "skill") or "Unknown skill" | |||
if type( | end | ||
return | |||
local displayKeys = { | |||
"Skill External Name", | |||
"External Name", | |||
"Display Name", | |||
"Name", | |||
"Skill Name", | |||
} | |||
for _, key in ipairs(displayKeys) do | |||
local candidate = resolveDisplayName(ev[key], "skill") | |||
if candidate then | |||
return candidate | |||
end | |||
end | |||
local internalKeys = { | |||
"Skill Internal Name", | |||
"Skill ID", | |||
"Internal Name", | |||
"Internal ID", | |||
"ID", | |||
} | |||
for _, key in ipairs(internalKeys) do | |||
local candidate = ev[key] | |||
if type(candidate) == "string" and candidate ~= "" then | |||
return candidate | |||
end | |||
end | |||
return "Unknown skill" | |||
end | end | ||
return | |||
-- isNoneLike: treat common "none" spellings as empty. | |||
local function isNoneLike(v) | |||
if v == nil then return true end | |||
local s = mw.text.trim(tostring(v)) | |||
if s == "" then return true end | |||
s = mw.ustring.lower(s) | |||
return (s == "none" or s == "no" or s == "n/a" or s == "na" or s == "null") | |||
end | end | ||
local function | -- addRow: add a standard <tr><th>Label</th><td>Value</td></tr> row. | ||
if | local function addRow(tbl, label, value, rowClass, dataKey) | ||
if | if value == nil or value == "" then | ||
if | return | ||
end | |||
end | |||
local row = tbl:tag("tr") | |||
row:addClass("sv-row") | |||
if rowClass then row:addClass(rowClass) end | |||
if dataKey then row:attr("data-field", dataKey) end | |||
row:tag("th"):wikitext(label):done() | |||
row:tag("td"):wikitext(value):done() | |||
end | end | ||
-- | -- formatUnitValue: format {Value, Unit} blocks (or scalar) for display. | ||
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 | ||
return tostring(val).. "%" | return tostring(val) .. "%" | ||
elseif unit == "seconds" then | elseif unit == "seconds" then | ||
return tostring(val).. "s" | return tostring(val) .. "s" | ||
elseif unit == "meters" then | elseif unit == "meters" then | ||
return tostring(val).. "m" | return tostring(val) .. "m" | ||
elseif unit == "tiles" then | elseif unit == "tiles" then | ||
return tostring(val).. " tiles" | return tostring(val) .. " tiles" | ||
elseif unit and unit ~= "" then | elseif unit and unit ~= "" then | ||
return tostring(val).. " "..tostring(unit) | return tostring(val) .. " " .. tostring(unit) | ||
else | else | ||
return tostring(val) | return tostring(val) | ||
end | end | ||
end | end | ||
return (v ~= nil) and tostring(v) or nil | |||
end | end | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
--Dynamic | -- Dynamic spans (JS-driven) | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
-- dynSpan: render a JS-updated span for a level series. | |||
if type(series) ~= "table" or #series == 0 then | local function dynSpan(series, level) | ||
return nil | if type(series) ~= "table" or #series == 0 then | ||
end | return nil | ||
level = clamp(level or #series, 1, #series) | end | ||
level = clamp(level or #series, 1, #series) | |||
local span = mw.html.create("span") | local span = mw.html.create("span") | ||
span: addClass("sv-dyn") | span:addClass("sv-dyn") | ||
span: attr("data-series", mw.text.jsonEncode(series)) | span:attr("data-series", mw.text.jsonEncode(series)) | ||
span: wikitext(mw.text.nowiki(series[level] or "")) | span:wikitext(mw.text.nowiki(series[level] or "")) | ||
return tostring(span) | return tostring(span) | ||
end | end | ||
-- isFlatList: true if all values in list are identical. | |||
local function isFlatList(list) | local function isFlatList(list) | ||
if type(list) ~= "table" or #list == 0 then | if type(list) ~= "table" or #list == 0 then | ||
return false | return false | ||
end | end | ||
local first = tostring(list[1]) | local first = tostring(list[1]) | ||
for i = 2, #list do | for i = 2, #list do | ||
if tostring(list[i]) ~= first then | |||
return false | return false | ||
end | end | ||
end | end | ||
return true | return true | ||
end | end | ||
-- isNonZeroScalar: detect if a value is present and not effectively zero. | |||
local function isNonZeroScalar(v) | local function isNonZeroScalar(v) | ||
if v == nil then return false end | if v == nil then return false end | ||
if type(v) == "number" then return v ~= 0 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) | ||
if n == nil then | if n == nil then return v ~= "" end | ||
return v ~= "" | return n ~= 0 | ||
end | end | ||
return n ~= 0 | if type(v) == "table" and v.Value ~= nil then | ||
end | return isNonZeroScalar(v.Value) | ||
if type(v) == "table" and v.Value ~= nil then | end | ||
return isNonZeroScalar(v.Value) | return true | ||
end | |||
return true | |||
end | end | ||
-- | -- isZeroish: aggressively treat common “zero” text forms as zero. | ||
local function isZeroish(v) | |||
if v == nil then return true end | |||
if type(v) == "number" then return v == 0 end | |||
if type( | if type(v) == "table" and v.Value ~= nil then | ||
return | return isZeroish(v.Value) | ||
end | end | ||
local | local s = mw.text.trim(tostring(v)) | ||
if s == "" then return true end | |||
if s == "0" or s == "0.0" or s == "0.00" then return true end | |||
if s == "0s" or s == "0 s" then return true end | |||
if s == "0m" or s == "0 m" then return true end | |||
if s == "0%" or s == "0 %" then return true end | |||
local n = tonumber((mw.ustring.gsub(s, "[^0-9%.%-]", ""))) | |||
return (n ~= nil and n == 0) | |||
return | |||
end | end | ||
-- | -- valuePairRawText: render Base/Per Level blocks into readable text (fallback). | ||
local function valuePairRawText(block) | |||
if type(block) ~= "table" then | |||
return nil | |||
end | |||
return | local base = block.Base | ||
end | 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 | end | ||
local | local vals = {} | ||
for _, v in ipairs(per) do | |||
return | table.insert(vals, formatUnitValue(v) or tostring(v)) | ||
end | |||
return (#vals > 0) and table.concat(vals, " / ") or nil | |||
end | end | ||
local baseText = formatUnitValue(base) | local baseText = formatUnitValue(base) | ||
local perText = formatUnitValue(per) | 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 | ||
return | -- valuePairDynamicValueOnly: render Base/Per Level blocks using dyn spans where possible. | ||
end | 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) | |||
local | return txt and mw.text.nowiki(txt) or nil | ||
end | end | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
--Lookups | -- Lookups | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
-- getSkillById: locate a skill by internal ID. | |||
id = trim(id) | local function getSkillById(id) | ||
if not id then return nil end | id = trim(id) | ||
if not id then return nil end | |||
local dataset = getSkills() | local dataset = getSkills() | ||
return (dataset.byId or {})[id] | |||
end | end | ||
-- findSkillByName: locate a skill by external/display name. | |||
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 {} | |||
if byName[name] then | |||
return byName[name] | |||
end | |||
for _, rec in ipairs(dataset.records or {}) do | |||
if | if type(rec) == "table" then | ||
return | if rec["External Name"] == name or rec.Name == name or rec["Display Name"] == name then | ||
end | return rec | ||
end | |||
end | |||
end | |||
return nil | |||
return nil | |||
end | end | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
-- | -- Legacy damage helpers | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
-- basisLabel: label ATK/MATK basis in legacy damage blocks. | |||
if isHealing then | local function basisLabel(entry, isHealing) | ||
return "Healing" | if isHealing then | ||
end | return "Healing" | ||
local atk = entry and entry["ATK-Based"] | end | ||
local atk = entry and entry["ATK-Based"] | |||
local matk = entry and entry["MATK-Based"] | local matk = entry and entry["MATK-Based"] | ||
if atk and matk then | |||
return "Attack/Magic Attack" | if atk and matk then | ||
return "Attack/Magic Attack" | |||
elseif atk then | elseif atk then | ||
return "Attack" | return "Attack" | ||
elseif matk then | elseif matk then | ||
return "Magic Attack" | return "Magic Attack" | ||
end | end | ||
return "Damage" | |||
return "Damage" | |||
end | end | ||
-- | -- formatDamageEntry: legacy percent damage formatting (dynamic by level). | ||
local function formatDamageEntry(entry, maxLevel, level) | local function formatDamageEntry(entry, maxLevel, level) | ||
if type(entry) ~= "table" then | if type(entry) ~= "table" then | ||
return nil | return nil | ||
end | end | ||
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 %"] | ||
local perRaw = entry["Per Level %"] | local perRaw = entry["Per Level %"] | ||
local baseN = toNum(baseRaw) | local baseN = toNum(baseRaw) | ||
local perN = toNum(perRaw) | local perN = toNum(perRaw) | ||
local function baseIsPresent() | local function baseIsPresent() | ||
if baseN ~= nil then | if baseN ~= nil then | ||
return baseN ~= 0 | return baseN ~= 0 | ||
end | end | ||
if baseRaw ~= nil then | if baseRaw ~= nil then | ||
local s = tostring(baseRaw) | local s = tostring(baseRaw) | ||
return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00") | return (s ~= "" and s ~= "0" and s ~= "0.0" and s ~= "0.00") | ||
end | end | ||
return false | return false | ||
end | end | ||
local baseText | local baseText | ||
if baseIsPresent() then | if baseIsPresent() then | ||
baseText = (baseN ~= nil) and (fmtNum(baseN) .. "%") or (tostring(baseRaw) .. "%") | |||
end | |||
end | |||
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then | |||
if perN == nil or perN == 0 or not maxLevel or maxLevel <= 0 then | return baseText and mw.text.nowiki(baseText .. " " .. basis) or nil | ||
return baseText and mw.text.nowiki(baseText.. " "..basis) or nil | end | ||
end | |||
local series = {} | local series = {} | ||
for lv = 1, maxLevel do | for lv = 1, maxLevel do | ||
local perPart = perN * lv | local perPart = perN * lv | ||
if baseText and baseN ~= nil then | if baseText and baseN ~= nil then | ||
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 | ||
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 | ||
table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis)) | table.insert(series, string.format("%s%% %s", fmtNum(perPart), basis)) | ||
end | end | ||
end | end | ||
return dynSpan(series, level) | return dynSpan(series, level) | ||
end | end | ||
-- formatDamageList: render a list of legacy damage entries into <br/> blocks. | |||
local function formatDamageList(list, maxLevel, level, includeTypePrefix) | local function formatDamageList(list, maxLevel, level, includeTypePrefix) | ||
if type(list) ~= "table" or #list == 0 then | if type(list) ~= "table" or #list == 0 then | ||
return nil | return nil | ||
end | end | ||
local parts = {} | local parts = {} | ||
for _, d in ipairs(list) do | for _, d in ipairs(list) do | ||
if type(d) == "table" then | |||
local txt = formatDamageEntry(d, maxLevel, level) | local txt = formatDamageEntry(d, maxLevel, level) | ||
if txt then | if txt then | ||
if includeTypePrefix and d.Type and d.Type ~= "" then | if includeTypePrefix and d.Type and d.Type ~= "" then | ||
table.insert(parts, mw.text.nowiki(tostring(d.Type).. ": ")..txt) | table.insert(parts, mw.text.nowiki(tostring(d.Type) .. ": ") .. txt) | ||
else | else | ||
table.insert(parts, txt) | table.insert(parts, txt) | ||
end | |||
end | |||
end | |||
end | |||
return (#parts > 0) and table.concat(parts, "<br />") or nil | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- Users matching | |||
---------------------------------------------------------------------- | |||
-- skillMatchesUser: check if a skill is used by a specific class/monster/summon/event. | |||
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 | |||
return listHas(users.Classes) or listHas(users.Summons) or listHas(users.Monsters) or listHas(users.Events) | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- Hide Users on direct skill pages | |||
---------------------------------------------------------------------- | |||
-- isDirectSkillPage: hide Users rows when viewing the skill page itself. | |||
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) | |||
return (ext and mw.ustring.lower(ext) == pageName) or (internal and mw.ustring.lower(internal) == pageName) or false | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- Slot config (edit these tables only to rearrange layout) | |||
---------------------------------------------------------------------- | |||
local HERO_SLOT_ASSIGNMENT = { | |||
[1] = "IconName", | |||
[2] = "Description", | |||
[3] = "LevelSelector", | |||
[4] = "SkillType", | |||
[5] = "SourceType", | |||
[6] = "QuickStats", | |||
[7] = "SpecialMechanics", | |||
[8] = "Placeholder", | |||
} | |||
---------------------------------------------------------------------- | |||
-- Slot scaffolds | |||
---------------------------------------------------------------------- | |||
-- slotBox: standardized wrapper for all hero card slots. | |||
local function slotBox(slot, extraClasses, innerHtml, opts) | |||
opts = opts or {} | |||
local box = mw.html.create("div") | |||
box:addClass("sv-slot") | |||
box:addClass("sv-slot--" .. tostring(slot)) | |||
box:attr("data-hero-slot", tostring(slot)) | |||
if opts.isFull then | |||
box:addClass("sv-slot--full") | |||
end | |||
if extraClasses then | |||
if type(extraClasses) == "string" then | |||
box:addClass(extraClasses) | |||
elseif type(extraClasses) == "table" then | |||
for _, c in ipairs(extraClasses) do box:addClass(c) end | |||
end | |||
end | |||
if opts.isEmpty then | |||
box:addClass("sv-slot--empty") | |||
end | |||
local body = box:tag("div"):addClass("sv-slot__body") | |||
if innerHtml and innerHtml ~= "" then | |||
body:wikitext(innerHtml) | |||
end | |||
return tostring(box) | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- Shared helpers (Source + QuickStats + SpecialMechanics) | |||
---------------------------------------------------------------------- | |||
end | -- formatScalingCompactLines: build compact “Scaling” lines for SourceType. | ||
local function formatScalingCompactLines(scaling) | |||
if type(scaling) ~= "table" then | |||
return {} | |||
end | |||
local | local list = scaling | ||
if | if #list == 0 then | ||
return | if scaling.Percent ~= nil or scaling["Scaling ID"] or scaling["Scaling Name"] then | ||
end | list = { scaling } | ||
else | |||
return {} | |||
end | |||
end | |||
local | local out = {} | ||
for _, s in ipairs(list) do | for _, s in ipairs(list) do | ||
if type(s) == "table" then | |||
local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown" | local stat = s["Scaling Name"] or s["Scaling ID"] or "Unknown" | ||
local pct = s.Percent | local pct = s.Percent | ||
local pctN = toNum(pct) | local pctN = toNum(pct) | ||
if pctN ~= nil and pctN ~= 0 then | |||
table.insert(out, string.format("%s%% %s", fmtNum(pctN), stat)) | |||
elseif pct ~= nil and tostring(pct) ~= "" and tostring(pct) ~= "0" then | |||
table.insert(out, string.format("%s%% %s", tostring(pct), stat)) | |||
end | |||
end | |||
end | |||
return out | |||
end | end | ||
-- basisWordFromFlags: compute “Attack/Magic/Hybrid” from ATK/MATK booleans. | |||
local function basisWordFromFlags(atkFlag, matkFlag) | |||
if atkFlag and matkFlag then | |||
return "Hybrid" | |||
elseif atkFlag then | |||
return "Attack" | |||
elseif matkFlag then | |||
return "Magic Attack" | |||
end | |||
return nil | |||
end | end | ||
if | -- legacyPercentAtLevel: compute “Base% + PerLevel%*level” for legacy entries. | ||
return | local function legacyPercentAtLevel(entry, level) | ||
end | if type(entry) ~= "table" then | ||
return | return nil | ||
end | |||
local baseRaw = entry["Base %"] | |||
local perRaw = entry["Per Level %"] | |||
local baseN = toNum(baseRaw) | |||
local perN = toNum(perRaw) | |||
if perN ~= nil and perN ~= 0 then | |||
local total = (baseN or 0) + (perN * level) | |||
return fmtNum(total) .. "%" | |||
end | |||
if baseN ~= nil then | |||
return fmtNum(baseN) .. "%" | |||
end | |||
if baseRaw ~= nil and tostring(baseRaw) ~= "" then | |||
return tostring(baseRaw) .. "%" | |||
end | |||
return nil | |||
end | end | ||
local function | -- seriesFromValuePair: normalize Base/Per Level blocks into a level-indexed series. | ||
if type( | local function seriesFromValuePair(block, maxLevel) | ||
return nil | if type(block) ~= "table" then | ||
end | return nil | ||
end | |||
local | local base = block.Base | ||
local per = block["Per Level"] | |||
local | local function pickUnit(v) | ||
if type(v) == "table" and v.Unit and v.Unit ~= "" then | |||
return v.Unit | |||
end | |||
return nil | |||
end | |||
local unit = pickUnit(base) or pickUnit(per) | |||
local function fmtAny(v) | |||
return nil | local t = formatUnitValue(v) | ||
return t and tostring(t) or (v ~= nil and tostring(v) or nil) | |||
end | |||
end | |||
local series = {} | |||
local | |||
-- Expanded per-level series (wikiprep) | |||
if type(per) == "table" and #per > 0 then | |||
if type( | for lv = 1, maxLevel do | ||
local raw = per[lv] or per[#per] | |||
local one = fmtAny(raw) | |||
if one == nil or isZeroish(raw) or isZeroish(one) then | |||
one = "—" | |||
end | |||
series[lv] = one | |||
end | end | ||
return series | |||
end | end | ||
-- Empty per-list -> base only | |||
if type(per) == "table" and #per == 0 then | |||
local one = fmtAny(base) | |||
if one == nil or isZeroish(base) or isZeroish(one) then | |||
one = "—" | |||
end | |||
for lv = 1, maxLevel do | |||
series[lv] = one | |||
end | |||
return series | |||
end | |||
-- Scalar per -> compute base + per*level (fallback) | |||
local baseN = toNum(base) or 0 | |||
local perN = toNum(per) | |||
if | if perN ~= nil then | ||
for lv = 1, maxLevel do | |||
end | local total = baseN + (perN * lv) | ||
return | local v = unit and { Value = total, Unit = unit } or total | ||
end | local one = fmtAny(v) | ||
if one == nil or total == 0 or isZeroish(one) then | |||
one = "—" | |||
end | |||
series[lv] = one | |||
end | |||
return series | |||
end | |||
local | -- Base-only scalar | ||
if | local raw = (base ~= nil) and base or per | ||
return | local one = fmtAny(raw) | ||
if one == nil then | |||
return nil | |||
end | |||
if isZeroish(raw) or isZeroish(one) then | |||
one = "—" | |||
end | |||
for lv = 1, maxLevel do | |||
series[lv] = one | |||
end | |||
return series | |||
end | end | ||
-- displayFromSeries: render a series as fixed text or dynSpan (nil if all “—”). | |||
local function displayFromSeries(series, level) | |||
if type(series) ~= "table" or #series == 0 then | |||
return nil | |||
end | end | ||
local | local any = false | ||
for _, | for _, v in ipairs(series) do | ||
if v ~= "—" then | |||
any = true | |||
break | |||
end | |||
end | |||
if not any then | |||
return nil | |||
end | end | ||
if | if isFlatList(series) then | ||
return | return mw.text.nowiki(series[1]) | ||
end | end | ||
return | return dynSpan(series, level) | ||
end | end | ||
local function | -- formatAreaSize: human readable area sizing for QuickStats. | ||
if type( | -- Shows: "<Area Size> (<number>)" e.g. "Medium (4)" | ||
return nil | local function formatAreaSize(area, maxLevel, level) | ||
end | if type(area) ~= "table" then | ||
local | return nil | ||
end | |||
-- Helper: pull a number from scalar/unit/valuepair-ish things. | |||
local function extractNumber(v) | |||
if v == nil then return nil end | |||
-- Unit block {Value, Unit} | |||
if type(v) == "table" and v.Value ~= nil then | |||
local n = toNum(v.Value) | |||
return n | |||
end | |||
-- ValuePair {Base, Per Level} -> prefer Base at current level if series exists | |||
if type(v) == "table" and (v.Base ~= nil or v["Per Level"] ~= nil) then | |||
local s = seriesFromValuePair(v, maxLevel or 1) | |||
if type(s) == "table" and #s > 0 then | |||
local idx = clamp(level or 1, 1, #s) | |||
local txt = s[idx] | |||
if txt and txt ~= "—" then | |||
-- try parse numeric from string (e.g. "4 tiles" -> 4) | |||
local num = tonumber((mw.ustring.gsub(tostring(txt), "[^0-9%.%-]", ""))) | |||
return num | |||
end | |||
end | |||
return nil | |||
end | |||
if | -- Plain scalar | ||
if type(v) == "number" then return v end | |||
end | if type(v) == "string" then | ||
local num = tonumber((mw.ustring.gsub(mw.text.trim(v), "[^0-9%.%-]", ""))) | |||
return num | |||
end | |||
return nil | |||
end | |||
end | |||
-- 1) Read Area Size label/name | |||
local rawSize = area["Area Size"] | |||
if | if rawSize == nil then | ||
return nil | |||
end | |||
end | |||
if | local sizeName = nil | ||
if type(rawSize) == "table" then | |||
sizeName = rawSize.Name or rawSize.ID or rawSize.Value | |||
elseif type(rawSize) == "string" then | |||
end | sizeName = rawSize | ||
elseif type(rawSize) == "number" then | |||
-- uncommon; treat as numeric-only label | |||
sizeName = tostring(rawSize) | |||
end | |||
sizeName = sizeName and mw.text.trim(tostring(sizeName)) or nil | |||
if | if not sizeName or sizeName == "" or isNoneLike(sizeName) then | ||
return nil | return nil | ||
end | end | ||
-- 2) Find the numeric “exact number” to append | |||
local | -- Prefer the explicit Area Distance block, then fall back to other known numeric keys. | ||
local num = nil | |||
if type( | local dist = area["Area Distance"] | ||
if | if type(dist) == "table" then | ||
-- Prefer Effective Distance if present and non-zero, else Base | |||
num = extractNumber(dist["Effective Distance"]) or extractNumber(dist.Effective) or extractNumber(dist["Effective"]) | |||
if not num or num == 0 then | |||
num = extractNumber(dist.Base) or extractNumber(dist["Base"]) | |||
end | end | ||
end | |||
end | |||
if not num or num == 0 then | |||
num = | |||
extractNumber(area["Area Value"]) or | |||
extractNumber(area["Area Size Value"]) or | |||
extractNumber(area["Area Number"]) or | |||
extractNumber(area["Area Radius"]) | |||
end | |||
-- 3) Render | |||
-- If size already contains parentheses, assume it already includes the numeric. | |||
if mw.ustring.find(sizeName, "%(") then | |||
return mw.text.nowiki(sizeName) | |||
end | |||
if | if num and num ~= 0 then | ||
return string.format("%s ( | return mw.text.nowiki(string.format("%s (%s)", sizeName, fmtNum(num))) | ||
end | |||
end | |||
return mw.text.nowiki(sizeName) | |||
end | end | ||
local | -- skillHasAnyDamage: determine if a skill has any meaningful damage (for non-damaging rules). | ||
for | local function skillHasAnyDamage(rec, maxLevel) | ||
if type(rec.Source) == "table" then | |||
local s = seriesFromValuePair(rec.Source, maxLevel) | |||
if s then | |||
for _, v in ipairs(s) do | |||
if v ~= "—" then return true end | |||
end | |||
end | |||
end | end | ||
local | if type(rec.Damage) == "table" then | ||
local dmg = rec.Damage | |||
for _, key in ipairs({ "Main Damage", "Flat Damage", "Reflect Damage" }) do | |||
local lst = dmg[key] | |||
if type(lst) == "table" and #lst > 0 then | |||
return true | |||
end | |||
end | |||
end | |||
return false | |||
return | |||
end | end | ||
-- computeDurationPromotion: promote status-duration into QuickStats when a skill is non-damaging. | |||
local function computeDurationPromotion(rec, maxLevel) | |||
if type(rec) ~= "table" then return nil end | |||
if skillHasAnyDamage(rec, maxLevel) then return nil end | |||
local mech = (type(rec.Mechanics) == "table") and rec.Mechanics or {} | |||
local bt = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {} | |||
local durS = seriesFromValuePair(bt["Duration"], maxLevel) | |||
end | |||
local | if durS ~= nil then | ||
for | local any = false | ||
for _, v in ipairs(durS) do | |||
if v ~= "—" then any = true break end | |||
end | |||
if any then | |||
return nil | |||
end | |||
end | |||
local apps = rec["Status Applications"] | |||
if type(apps) ~= "table" then return nil end | |||
for idx, app in ipairs(apps) do | |||
if type(app) == "table" and type(app.Duration) == "table" then | |||
local s = seriesFromValuePair(app.Duration, maxLevel) | |||
if s then | |||
for _, v in ipairs(s) do | |||
if v ~= "—" then | |||
return { | |||
durationBlock = app.Duration, | |||
suppressDurationIndex = idx, | |||
} | |||
end | |||
end | |||
end | end | ||
end | |||
end | |||
return nil | |||
end | end | ||
---------------------------------------------------------------------- | |||
local | -- Plug-ins | ||
---------------------------------------------------------------------- | |||
end | |||
local PLUGINS = {} | |||
-- PLUGIN: IconName (Hero Bar Slot 1) - icon + name. | |||
function PLUGINS.IconName(rec, ctx) | |||
local icon = rec.Icon | |||
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill" | |||
local notesList = {} | |||
if type(rec.Notes) == "table" then | |||
for _, note in ipairs(rec.Notes) do | |||
local n = trim(note) | |||
if n then | |||
table.insert(notesList, mw.text.nowiki(n)) | |||
end | |||
end | |||
elseif type(rec.Notes) == "string" then | |||
local n = trim(rec.Notes) | |||
if n then | |||
notesList = { mw.text.nowiki(n) } | |||
end | |||
end | |||
local req = rec.Requirements or {} | |||
local reqSkillsRaw = (type(req["Required Skills"]) == "table") and req["Required Skills"] or {} | |||
local reqWeaponsRaw = (type(req["Required Weapons"]) == "table") and req["Required Weapons"] or {} | |||
local reqStancesRaw = (type(req["Required Stances"]) == "table") and req["Required Stances"] or {} | |||
if | local reqSkills = {} | ||
for _, rs in ipairs(reqSkillsRaw) do | |||
if type(rs) == "table" then | |||
if | local nameReq = rs["Skill External Name"] or rs["Skill Internal Name"] or "Unknown" | ||
local lvlReq = rs["Required Level"] | |||
if lvlReq then | |||
table.insert(reqSkills, string.format("%s (Lv.%s)", mw.text.nowiki(nameReq), mw.text.nowiki(tostring(lvlReq)))) | |||
else | else | ||
local | table.insert(reqSkills, mw.text.nowiki(nameReq)) | ||
if | end | ||
table. | end | ||
end | end | ||
end | |||
end | local reqWeapons = {} | ||
for _, w in ipairs(reqWeaponsRaw) do | |||
local wn = trim(w) | |||
if wn then table.insert(reqWeapons, mw.text.nowiki(wn)) end | |||
end | |||
local reqStances = {} | |||
for _, s in ipairs(reqStancesRaw) do | |||
local sn = trim(s) | |||
if sn then table.insert(reqStances, mw.text.nowiki(sn)) end | |||
end | |||
local hasNotes = (#notesList > 0) | |||
local hasReq = (#reqSkills > 0) or (#reqWeapons > 0) or (#reqStances > 0) | |||
local wrap = mw.html.create("div") | |||
wrap:addClass("sv-herobar-1-wrap") | |||
wrap:addClass("sv-tip-scope") | |||
local iconBox = wrap:tag("div") | |||
iconBox:addClass("sv-herobar-icon") | |||
if icon and icon ~= "" then | |||
iconBox:wikitext(string.format("[[File:%s|80px|link=]]", icon)) | |||
end | |||
local textBox = wrap:tag("div") | |||
textBox:addClass("sv-herobar-text") | |||
local titleRow = textBox:tag("div") | |||
titleRow:addClass("sv-herobar-title-row") | |||
local titleBox = titleRow:tag("div") | |||
titleBox:addClass("spiritvale-infobox-title") | |||
titleBox:wikitext(title) | |||
if hasNotes then | |||
local notesBtn = mw.html.create("span") | |||
notesBtn:addClass("sv-tip-btn sv-tip-btn--notes") | |||
notesBtn:attr("role", "button") | |||
notesBtn:attr("tabindex", "0") | |||
notesBtn:attr("data-sv-tip", "notes") | |||
notesBtn:attr("aria-label", "Notes") | |||
notesBtn:attr("aria-expanded", "false") | |||
notesBtn:tag("span"):addClass("sv-ico sv-ico--info"):attr("aria-hidden", "true"):wikitext("i") | |||
titleRow:node(notesBtn) | |||
end | |||
if hasReq then | |||
local pillRow = wrap:tag("div") | |||
pillRow:addClass("sv-pill-row") | |||
pillRow:addClass("sv-pill-row--req") | |||
local pill = pillRow:tag("span") | |||
pill:addClass("sv-pill sv-pill--req sv-tip-btn") | |||
pill:attr("role", "button") | |||
pill:attr("tabindex", "0") | |||
pill:attr("data-sv-tip", "req") | |||
pill:attr("aria-label", "Requirements") | |||
pill:attr("aria-expanded", "false") | |||
pill:wikitext("Requirements") | |||
end | |||
if hasNotes then | |||
local notesContent = wrap:tag("div") | |||
notesContent:addClass("sv-tip-content") | |||
notesContent:attr("data-sv-tip-content", "notes") | |||
notesContent:tag("div"):addClass("sv-tip-title"):wikitext("Notes") | |||
notesContent:tag("div"):wikitext(table.concat(notesList, "<br />")) | |||
end | |||
if hasReq then | |||
local reqContent = wrap:tag("div") | |||
reqContent:addClass("sv-tip-content") | |||
reqContent:attr("data-sv-tip-content", "req") | |||
if #reqSkills > 0 then | |||
local section = reqContent:tag("div") | |||
section:addClass("sv-tip-section") | |||
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Skills") | |||
section:tag("div"):wikitext(table.concat(reqSkills, "<br />")) | |||
end | |||
if #reqWeapons > 0 then | |||
local section = reqContent:tag("div") | |||
section:addClass("sv-tip-section") | |||
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Weapons") | |||
section:tag("div"):wikitext(table.concat(reqWeapons, ", ")) | |||
end | |||
if #reqStances > 0 then | |||
local section = reqContent:tag("div") | |||
section:addClass("sv-tip-section") | |||
section:tag("span"):addClass("sv-tip-label"):wikitext("Required Stances") | |||
section:tag("div"):wikitext(table.concat(reqStances, ", ")) | |||
end | |||
end | |||
return { | |||
inner = tostring(wrap), | |||
classes = "module-icon-name", | |||
} | |||
end | end | ||
if | -- PLUGIN: SkillType (Hero Bar Slot 2) - 2 rows x 3 cells (desktop + mobile). | ||
return nil | -- Rules: | ||
end | -- - If skill is non-damaging, hide Damage/Element/Hits. | ||
return table. | -- - If Hits is empty, hide Hits. | ||
end | -- - If Combo is empty, hide Combo. | ||
-- Ordering: | |||
-- - Desktop: Damage, Element, Hits, Target, Cast, Combo | |||
-- - Mobile: Damage, Element, Target, Cast, Hits, Combo (CSS reorder) | |||
function PLUGINS.SkillType(rec, ctx) | |||
local typeBlock = (type(rec.Type) == "table") and rec.Type or {} | |||
local mech = (type(rec.Mechanics) == "table") and rec.Mechanics or {} | |||
local level = ctx.level or 1 | |||
local maxLevel = ctx.maxLevel or 1 | |||
local hideDamageBundle = (ctx.nonDamaging == true) | |||
-- valName: extract a display string from typical {Name/ID/Value} objects. | |||
-- NOTE: Includes number support so Hits=2 (number) doesn't get dropped. | |||
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 | |||
if x.Value ~= nil then return tostring(x.Value) end | |||
end | |||
if type(x) == "number" then | |||
return tostring(x) | |||
end | |||
if type(x) == "string" and x ~= "" then | |||
return x | |||
end | |||
return nil | |||
end | |||
-- hitsDisplay: find + render Hits from multiple possible structured locations. | |||
local function hitsDisplay() | |||
local effects = (type(mech.Effects) == "table") and mech.Effects or {} | |||
local h = | |||
typeBlock.Hits or typeBlock["Hits"] or typeBlock["Hit Count"] or typeBlock["Hits Count"] or | |||
mech.Hits or mech["Hits"] or mech["Hit Count"] or mech["Hits Count"] or | |||
effects.Hits or effects["Hits"] or effects["Hit Count"] or effects["Hits Count"] or | |||
rec.Hits or rec["Hits"] | |||
if h == nil or isNoneLike(h) then | |||
return nil | |||
end | |||
-- ValuePair-style table (Base/Per Level) => dynamic series | |||
if type(h) == "table" then | |||
if h.Base ~= nil or h["Per Level"] ~= nil or type(h["Per Level"]) == "table" then | |||
return displayFromSeries(seriesFromValuePair(h, maxLevel), level) | |||
end | |||
-- Unit block {Value, Unit} | |||
if h.Value ~= nil then | |||
local t = formatUnitValue(h) | |||
return t and mw.text.nowiki(t) or nil | |||
end | |||
local function | -- Fallback name extraction | ||
if type( | local function valName(x) | ||
return nil | if x == nil then return nil end | ||
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 | |||
if x.Value ~= nil then return tostring(x.Value) end | |||
end | |||
if type(x) == "number" then return tostring(x) end | |||
if type(x) == "string" and x ~= "" then return x end | |||
return nil | |||
end | |||
local vn = valName(h) | |||
if | if vn and not isNoneLike(vn) then | ||
return | return mw.text.nowiki(vn) | ||
end | end | ||
end | |||
-- Scalar number/string | |||
if type(h) == "number" then | |||
return mw.text.nowiki(fmtNum(h)) | |||
end | |||
if type(h) == "string" then | |||
local t = trim(h) | |||
return (t and not isNoneLike(t)) and mw.text.nowiki(t) or nil | |||
end | |||
return nil | |||
end | |||
-- comboDisplay: render Combo as a compact text block (Type (+ details)). | |||
local function comboDisplay() | |||
local c = (type(mech.Combo) == "table") and mech.Combo or nil | |||
if not c then return nil end | |||
local typ = trim(c.Type) | |||
if not typ or isNoneLike(typ) then | |||
return nil | |||
end | |||
local details = {} | |||
local pct = formatUnitValue(c.Percent) | |||
if pct and not isZeroish(pct) then | |||
table.insert(details, mw.text.nowiki(pct)) | |||
end | |||
local dur = formatUnitValue(c.Duration) | |||
if dur and not isZeroish(dur) then | |||
table.insert(details, mw.text.nowiki(dur)) | |||
end | |||
if #details > 0 then | |||
return mw.text.nowiki(typ) .. " (" .. table.concat(details, ", ") .. ")" | |||
end | |||
return mw.text.nowiki(typ) | |||
end | |||
local grid = mw.html.create("div") | |||
grid:addClass("sv-type-grid") | |||
grid:addClass("sv-compact-root") | |||
local added = false | |||
-- addChunk: add one labeled value cell (key drives CSS ordering). | |||
local function addChunk(key, label, valueHtml) | |||
if valueHtml == nil or valueHtml == "" then return end | |||
added = true | |||
local chunk = grid:tag("div") | |||
:addClass("sv-type-chunk") | |||
:addClass("sv-type-" .. tostring(key)) | |||
:attr("data-type-key", tostring(key)) | |||
chunk:tag("div") | |||
:addClass("sv-type-label") | |||
:wikitext(mw.text.nowiki(label)) | |||
chunk:tag("div") | |||
:addClass("sv-type-value") | |||
:wikitext(valueHtml) | |||
end | |||
-- Damage + Element + Hits bundle (hidden when non-damaging) | |||
if not hideDamageBundle then | |||
local dmg = valName(typeBlock.Damage or typeBlock["Damage Type"]) | |||
local ele = valName(typeBlock.Element or typeBlock["Element Type"]) | |||
local hits = hitsDisplay() | |||
if dmg and not isNoneLike(dmg) then | |||
addChunk("damage", "Damage", mw.text.nowiki(dmg)) | |||
end | |||
if ele and not isNoneLike(ele) then | |||
addChunk("element", "Element", mw.text.nowiki(ele)) | |||
end | |||
if hits then | |||
addChunk("hits", "Hits", hits) | |||
end | |||
end | |||
-- Target + Cast | |||
local tgt = valName(typeBlock.Target or typeBlock["Target Type"]) | |||
local cst = valName(typeBlock.Cast or typeBlock["Cast Type"]) | |||
if tgt and not isNoneLike(tgt) then | |||
addChunk("target", "Target", mw.text.nowiki(tgt)) | |||
end | |||
if cst and not isNoneLike(cst) then | |||
addChunk("cast", "Cast", mw.text.nowiki(cst)) | |||
end | |||
-- Combo | |||
local combo = comboDisplay() | |||
if combo then | |||
addChunk("combo", "Combo", combo) | |||
end | |||
return { | |||
inner = added and tostring(grid) or "", | |||
classes = "module-skill-type", | |||
} | |||
end | end | ||
if | -- PLUGIN: Description (Hero Slot 3) - primary description text. | ||
function PLUGINS.Description(rec) | |||
local desc = trim(rec.Description) | |||
if not desc then | |||
return nil | |||
end | |||
local body = mw.html.create("div") | |||
body:addClass("sv-description") | |||
body:wikitext(string.format("''%s''", desc)) | |||
return { | |||
inner = tostring(body), | |||
classes = "module-description", | |||
} | |||
end | end | ||
-- PLUGIN: Placeholder (Hero Slot 4) - reserved/blank. | |||
function PLUGINS.Placeholder() | |||
return nil | |||
end | end | ||
-- PLUGIN: SourceType (Hero Module Slot 1) - Modifier + Source + Scaling. | |||
function PLUGINS.SourceType(rec, ctx) | |||
local level = ctx.level or 1 | |||
local maxLevel = ctx.maxLevel or 1 | |||
local | local basisWord = nil | ||
local sourceKind = nil | |||
local sourceVal = nil | |||
local scaling = nil | |||
local | |||
-- sourceValueForLevel: dynamic formatting for structured Source blocks. | |||
local function sourceValueForLevel(src) | |||
if type(src) ~= "table" then | |||
return nil | |||
end | |||
if type( | local per = src["Per Level"] | ||
local | if type(per) == "table" and #per > 0 then | ||
if isFlatList(per) then | |||
end | local one = formatUnitValue(per[1]) or tostring(per[1]) | ||
local show = formatUnitValue(src.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 | |||
return valuePairDynamicValueOnly(src, maxLevel, level) | |||
end | |||
end | |||
if | if type(rec.Source) == "table" then | ||
local src = rec.Source | |||
local atkFlag = (src["ATK-Based"] == true) | |||
local matkFlag = (src["MATK-Based"] == true) | |||
basisWord = basisWordFromFlags(atkFlag, matkFlag) | |||
sourceKind = src.Type or ((src.Healing == true) and "Healing") or "Damage" | |||
sourceVal = sourceValueForLevel(src) | |||
end | scaling = src.Scaling | ||
end | |||
-- Fallback to legacy Damage lists if Source absent | |||
if (sourceVal == nil or sourceVal == "") and type(rec.Damage) == "table" then | |||
local dmg = rec.Damage | |||
if | scaling = scaling or dmg.Scaling | ||
local | local main = dmg["Main Damage"] | ||
local refl = dmg["Reflect Damage"] | |||
local flat = dmg["Flat Damage"] | |||
if type(main) == "table" and #main > 0 then | |||
if type( | local pick = nil | ||
for _, d in ipairs(main) do | |||
for _, | if type(d) == "table" and d.Type ~= "Healing" then | ||
pick = d | |||
break | |||
end | end | ||
end | |||
pick = pick or main[1] | |||
if type(pick) == "table" then | |||
end | local atkFlag = (pick["ATK-Based"] == true) | ||
local matkFlag = (pick["MATK-Based"] == true) | |||
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag) | |||
sourceKind = (pick.Type == "Healing") and "Healing" or "Damage" | |||
sourceVal = legacyPercentAtLevel(pick, level) | |||
end | |||
elseif type(refl) == "table" and #refl > 0 and type(refl[1]) == "table" then | |||
local pick = refl[1] | |||
local atkFlag = (pick["ATK-Based"] == true) | |||
local matkFlag = (pick["MATK-Based"] == true) | |||
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag) | |||
sourceKind = "Reflect" | |||
sourceVal = legacyPercentAtLevel(pick, level) | |||
elseif type(flat) == "table" and #flat > 0 and type(flat[1]) == "table" then | |||
local pick = flat[1] | |||
local atkFlag = (pick["ATK-Based"] == true) | |||
local matkFlag = (pick["MATK-Based"] == true) | |||
basisWord = basisWord or basisWordFromFlags(atkFlag, matkFlag) | |||
sourceKind = "Flat" | |||
sourceVal = legacyPercentAtLevel(pick, level) | |||
end | |||
end | |||
local scalingLines = formatScalingCompactLines(scaling) | |||
local hasSource = (sourceVal ~= nil and tostring(sourceVal) ~= "") | |||
local hasScaling = (type(scalingLines) == "table" and #scalingLines > 0) | |||
if (not hasSource) and (not hasScaling) then | |||
return nil | |||
end | |||
local hasMod = (basisWord ~= nil and tostring(basisWord) ~= "") | |||
local | local extra = { "skill-source-module", "module-source-type" } | ||
table.insert(extra, hasMod and "sv-has-mod" or "sv-no-mod") | |||
table.insert( | |||
-- | if hasSource and (not hasScaling) then | ||
table.insert(extra, "sv-only-source") | |||
-- | elseif hasScaling and (not hasSource) then | ||
table.insert(extra, "sv-only-scaling") | |||
end | |||
local | local wrap = mw.html.create("div") | ||
wrap:addClass("sv-source-grid") | |||
wrap:addClass("sv-compact-root") | |||
local | if hasMod then | ||
local modCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-modifier") | |||
modCol:tag("div"):addClass("sv-source-pill"):wikitext("Modifier") | |||
end | modCol:tag("div"):addClass("sv-modifier-value"):wikitext(mw.text.nowiki(basisWord)) | ||
end | |||
local | if hasSource then | ||
local sourceCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-main") | |||
sourceCol:tag("div"):addClass("sv-source-pill"):wikitext(mw.text.nowiki(sourceKind or "Source")) | |||
sourceCol:tag("div"):addClass("sv-source-value"):wikitext(sourceVal) | |||
end | |||
local | if hasScaling then | ||
local scalingCol = wrap:tag("div"):addClass("sv-source-col"):addClass("sv-source-scaling") | |||
scalingCol:tag("div"):addClass("sv-source-pill"):wikitext("Scaling") | |||
local list = scalingCol:tag("div"):addClass("sv-scaling-list") | |||
for _, line in ipairs(scalingLines) do | |||
list:tag("div"):addClass("sv-scaling-item"):wikitext(mw.text.nowiki(line)) | |||
end | |||
end | |||
return | return { | ||
inner = tostring(wrap), | |||
classes = extra, | |||
} | |||
end | end | ||
----- | -- PLUGIN: QuickStats (Hero Module Slot 2) - 3x2 grid (range/area/cost/cast/cd/duration). | ||
-- NOTE: Hits does NOT live here (it lives in SkillType). | |||
function PLUGINS.QuickStats(rec, ctx) | |||
local level = ctx.level or 1 | |||
local maxLevel = ctx.maxLevel or 1 | |||
local promo = ctx.promo | |||
local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {} | |||
local bt = (type(mech["Basic Timings"]) == "table") and mech["Basic Timings"] or {} | |||
local rc = (type(mech["Resource Cost"]) == "table") and mech["Resource Cost"] or {} | |||
local function | local function dash() return "—" end | ||
end | |||
local | -- Range (0 => —) | ||
local rangeVal = nil | |||
if mech.Range ~= nil and not isNoneLike(mech.Range) then | |||
if not | local n = toNum(mech.Range) | ||
if n ~= nil then | |||
if n ~= 0 then | |||
rangeVal = mw.text.nowiki(formatUnitValue(mech.Range) or tostring(mech.Range)) | |||
end | |||
else | |||
local t = mw.text.trim(tostring(mech.Range)) | |||
if t ~= "" and not isNoneLike(t) then | |||
rangeVal = mw.text.nowiki(t) | |||
end | |||
end | |||
end | |||
-- Area | |||
local areaVal = formatAreaSize(mech.Area, maxLevel, level) | |||
-- Timings | |||
local castVal = displayFromSeries(seriesFromValuePair(bt["Cast Time"], maxLevel), level) | |||
local cdVal = displayFromSeries(seriesFromValuePair(bt["Cooldown"], maxLevel), level) | |||
local durVal = displayFromSeries(seriesFromValuePair(bt["Duration"], maxLevel), level) | |||
-- | -- Promote status duration if needed | ||
if (durVal == nil) and type(promo) == "table" and type(promo.durationBlock) == "table" then | |||
durVal = displayFromSeries(seriesFromValuePair(promo.durationBlock, maxLevel), level) | |||
end | |||
local function | -- Cost: MP + HP | ||
local function labeledSeries(block, label) | |||
local s = seriesFromValuePair(block, maxLevel) | |||
if not s then return nil end | |||
local any = false | |||
for i, v in ipairs(s) do | |||
if v ~= "—" then | |||
s[i] = tostring(v) .. " " .. label | |||
any = true | |||
else | |||
s[i] = "—" | |||
end | |||
end | |||
return any and s or nil | |||
end | |||
local mpS = labeledSeries(rc["Mana Cost"], "MP") | |||
local hpS = labeledSeries(rc["Health Cost"], "HP") | |||
local costSeries = {} | |||
for lv = 1, maxLevel do | |||
local mp = mpS and mpS[lv] or "—" | |||
local hp = hpS and hpS[lv] or "—" | |||
if mp ~= "—" and hp ~= "—" then | |||
costSeries[lv] = mp .. " + " .. hp | |||
elseif mp ~= "—" then | |||
costSeries[lv] = mp | |||
elseif hp ~= "—" then | |||
costSeries[lv] = hp | |||
else | |||
costSeries[lv] = "—" | |||
end | |||
end | |||
local costVal = displayFromSeries(costSeries, level) | |||
local | local grid = mw.html.create("div") | ||
grid:addClass("sv-m4-grid") | |||
grid:addClass("sv-compact-root") | |||
local | local function addCell(label, val) | ||
local cell = grid:tag("div"):addClass("sv-m4-cell") | |||
cell:tag("div"):addClass("sv-m4-label"):wikitext(mw.text.nowiki(label)) | |||
cell:tag("div"):addClass("sv-m4-value"):wikitext(val or dash()) | |||
end | |||
addCell("Range", rangeVal) | |||
addCell("Area", areaVal) | |||
addCell("Cost", costVal) | |||
addCell("Cast Time", castVal) | |||
addCell("Cooldown", cdVal) | |||
addCell("Duration", durVal) | |||
return { | |||
inner = tostring(grid), | |||
classes = "module-quick-stats", | |||
} | |||
end | end | ||
-- PLUGIN: SpecialMechanics (Hero Module Slot 3) | |||
-- Shows: | |||
-- - Flags (deduped) | |||
-- - Special mechanics (mech.Effects) | |||
-- NOTE: Combo lives in SkillType (Hero Bar Slot 2). | |||
function PLUGINS.SpecialMechanics(rec, ctx) | |||
local level = ctx.level or 1 | |||
local maxLevel = ctx.maxLevel or 1 | |||
local mech = (type(rec) == "table" and type(rec.Mechanics) == "table") and rec.Mechanics or {} | |||
local effects = (type(mech.Effects) == "table") and mech.Effects or nil | |||
local mods = (type(rec.Modifiers) == "table") and rec.Modifiers or nil | |||
if not | ------------------------------------------------------------------ | ||
return | -- Hits guard (we want Hits ONLY in SkillType) | ||
------------------------------------------------------------------ | |||
return | local function isHitsKey(name) | ||
end | if not name then return false end | ||
local k = mw.ustring.lower(mw.text.trim(tostring(name))) | |||
return ( | |||
k == "hit" or | |||
k == "hits" or | |||
k == "hit count" or | |||
k == "hits count" or | |||
k == "hitcount" or | |||
k == "hitscount" | |||
) | |||
end | |||
------------------------------------------------------------------ | |||
-- Flags (flat, de-duped) | |||
------------------------------------------------------------------ | |||
local flagSet = {} | |||
local | local denyFlags = { | ||
["self centered"] = true, | |||
["self-centred"] = true, | |||
["bond"] = true, | |||
["combo"] = true, | |||
["hybrid"] = true, | |||
-- | -- hits variants | ||
["hit"] = true, | |||
["hits"] = true, | |||
["hit count"] = true, | |||
["hits count"] = true, | |||
["hitcount"] = true, | |||
["hitscount"] = true, | |||
} | |||
local | local function allowFlag(name) | ||
if not name then return false end | |||
local k = mw.ustring.lower(mw.text.trim(tostring(name))) | |||
if k == "" then return false end | |||
if denyFlags[k] then return false end | |||
return true | |||
end | |||
local function addFlags(sub) | |||
if type(sub) ~= "table" then return end | |||
for k, v in pairs(sub) do | |||
if v and allowFlag(k) then | |||
flagSet[tostring(k)] = true | |||
end | |||
end | |||
end | end | ||
end | |||
if mods then | |||
addFlags(mods["Movement Modifiers"]) | |||
addFlags(mods["Combat Modifiers"]) | |||
addFlags(mods["Special Modifiers"]) | |||
for k, v in pairs(mods) do | |||
if type(v) == "boolean" and v and allowFlag(k) then | |||
flagSet[tostring(k)] = true | |||
end | |||
end | |||
end | |||
local | local flags = {} | ||
for k, _ in pairs(flagSet) do table.insert(flags, k) end | |||
table.sort(flags) | |||
-- | ------------------------------------------------------------------ | ||
local | -- Special mechanics (name => value) | ||
------------------------------------------------------------------ | |||
local mechItems = {} | |||
local | if effects then | ||
local keys = {} | |||
for k, _ in pairs(effects) do table.insert(keys, k) end | |||
table.sort(keys) | |||
-- | for _, name in ipairs(keys) do | ||
-- | -- Skip Hits completely (it belongs in SkillType) | ||
if not isHitsKey(name) then | |||
local block = effects[name] | |||
if type(block) == "table" then | |||
-- Also skip if the block's Type is "Hits" (some data may encode it that way) | |||
if not isHitsKey(block.Type) then | |||
local disp = displayFromSeries(seriesFromValuePair(block, maxLevel), level) | |||
local t = trim(block.Type) | |||
local value = disp | |||
-- | -- If Type exists and is distinct, prefix it. | ||
if t and not isNoneLike(t) and mw.ustring.lower(t) ~= mw.ustring.lower(tostring(name)) then | |||
if value then | |||
end | value = mw.text.nowiki(t) .. ": " .. value | ||
else | |||
value = mw.text.nowiki(t) | |||
end | |||
end | |||
if value then | |||
table.insert(mechItems, { label = tostring(name), value = value }) | |||
end | |||
end | |||
end | |||
end | |||
end | |||
end | |||
local hasFlags = (#flags > 0) | |||
local hasMech = (#mechItems > 0) | |||
local | |||
local | |||
local | if (not hasFlags) and (not hasMech) then | ||
local root = mw.html.create("div") | |||
root:addClass("sv-sm-root") | |||
root:addClass("sv-compact-root") | |||
root:tag("div"):addClass("sv-sm-empty"):wikitext("No Special Mechanics") | |||
return { | |||
inner = tostring(root), | |||
classes = "module-special-mechanics", | |||
} | |||
end | |||
local | local count = 0 | ||
if hasFlags then count = count + 1 end | |||
if hasMech then count = count + 1 end | |||
local root = mw.html.create("div") | |||
root:addClass("sv-sm-root") | |||
root:addClass("sv-compact-root") | |||
local layout = root:tag("div"):addClass("sv-sm-layout") | |||
layout:addClass("sv-sm-count-" .. tostring(count)) | |||
local | -- Column 1: Flags | ||
if hasFlags then | |||
local fcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-flags") | |||
for _, f in ipairs(flags) do | |||
fcol:tag("div"):addClass("sv-sm-flag"):wikitext(mw.text.nowiki(f)) | |||
end | |||
end | |||
local | -- Column 2: Special Mechanics (stacked) | ||
if hasMech then | |||
local mcol = layout:tag("div"):addClass("sv-sm-col"):addClass("sv-sm-col-mech") | |||
for _, it in ipairs(mechItems) do | |||
local one = mcol:tag("div"):addClass("sv-sm-mech") | |||
one:tag("div"):addClass("sv-sm-label"):wikitext(mw.text.nowiki(it.label)) | |||
one:tag("div"):addClass("sv-sm-value"):wikitext(it.value or "—") | |||
end | |||
end | |||
return { | |||
inner = tostring(root), | |||
classes = "module-special-mechanics", | |||
} | |||
end | end | ||
--- | -- PLUGIN: LevelSelector (Hero Module Slot 4) - JS level slider. | ||
function PLUGINS.LevelSelector(rec, ctx) | |||
local level = ctx.level or 1 | |||
local | local maxLevel = ctx.maxLevel or 1 | ||
local | |||
local inner = mw.html.create("div") | |||
-- | inner:addClass("sv-level-ui") | ||
inner:tag("div") | |||
:addClass("sv-level-label") | |||
:wikitext("Level <span class=\"sv-level-num\">" .. tostring(level) .. "</span> / " .. tostring(maxLevel)) | |||
local slider = inner:tag("div"):addClass("sv-level-slider") | |||
local | |||
if tonumber(maxLevel) and tonumber(maxLevel) > 1 then | |||
slider:tag("input") | |||
:attr("type", "range") | |||
:attr("min", "1") | |||
:attr("max", tostring(maxLevel)) | |||
:attr("value", tostring(level)) | |||
:addClass("sv-level-range") | |||
:attr("aria-label", "Skill level select") | |||
else | |||
inner:addClass("sv-level-ui-single") | |||
slider:addClass("sv-level-slider-single") | |||
end | |||
return { | |||
inner = tostring(inner), | |||
classes = "module-level-selector", | |||
} | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- Generic slot renderers | |||
---------------------------------------------------------------------- | |||
-- normalizeResult: normalize plugin return values into {inner, classes}. | |||
local function normalizeResult(res) | |||
if res == nil then return nil end | |||
if type(res) == "string" then | |||
return { inner = res, classes = nil } | |||
end | |||
if type(res) == "table" then | |||
local inner = res.inner | |||
if type(inner) ~= "string" then | |||
inner = (inner ~= nil) and tostring(inner) or "" | |||
end | |||
return { inner = inner, classes = res.classes } | |||
end | |||
return { inner = tostring(res), classes = nil } | |||
end | end | ||
-- safeCallPlugin: pcall wrapper to prevent infobox failure on plugin errors. | |||
local function safeCallPlugin(name, rec, ctx) | |||
local fn = PLUGINS[name] | |||
if type(fn) ~= "function" then | |||
return nil | |||
end | |||
local ok, out = pcall(fn, rec, ctx) | |||
if not ok then | |||
return nil | |||
end | |||
return normalizeResult(out) | |||
end | end | ||
-- isEmptySlotContent: true when a slot has no meaningful content. | |||
-- NOTE: JS placeholders (sv-dyn spans, slider markup) are considered content. | |||
local function isEmptySlotContent(inner) | |||
if inner == nil then return true end | |||
local raw = tostring(inner) | |||
-- Guard rails for JS-injected regions. | |||
for _, pat in ipairs({ "sv%-dyn", "data%-series", "sv%-level%-range", "sv%-level%-slider", "sv%-level%-ui" }) do | |||
if mw.ustring.find(raw, pat) then | |||
return false | |||
end | |||
end | |||
local trimmed = mw.text.trim(raw) | |||
if trimmed == "" or trimmed == "—" then | |||
return true | |||
end | |||
local withoutTags = mw.text.trim(mw.ustring.gsub(trimmed, "<[^>]+>", "")) | |||
return (withoutTags == "" or withoutTags == "—") | |||
end | end | ||
-- | -- renderHeroSlot: render a standardized hero slot by plugin assignment. | ||
local function renderHeroSlot(slotIndex, rec, ctx) | |||
local pluginName = HERO_SLOT_ASSIGNMENT[slotIndex] | |||
if not pluginName then | |||
if | return nil | ||
end | |||
local res = safeCallPlugin(pluginName, rec, ctx) | |||
if not res or isEmptySlotContent(res.inner) then | |||
return nil | |||
end | |||
return { | |||
inner = res.inner, | |||
classes = res.classes, | |||
} | |||
end | end | ||
---------------------------------------------------------------------- | |||
-- UI builders | |||
---------------------------------------------------------------------- | |||
-- buildHeroSlotsUI: build the standardized 4-row slot grid (2 columns). | |||
local function buildHeroSlotsUI(rec, ctx) | |||
local grid = mw.html.create("div") | |||
grid:addClass("sv-slot-grid") | |||
local slots = {} | |||
for slot = 1, 8 do | |||
slots[slot] = renderHeroSlot(slot, rec, ctx) | |||
end | |||
local hasSlots = false | |||
for _, pair in ipairs({ { 1, 2 }, { 3, 4 }, { 5, 6 }, { 7, 8 } }) do | |||
local left = slots[pair[1]] | |||
local right = slots[pair[2]] | |||
if left or right then | |||
hasSlots = true | |||
if left and right then | |||
grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isEmpty = false })) | |||
grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isEmpty = false })) | |||
elseif left then | |||
grid:wikitext(slotBox(pair[1], left.classes, left.inner, { isFull = true })) | |||
elseif right then | |||
grid:wikitext(slotBox(pair[2], right.classes, right.inner, { isFull = true })) | |||
end | |||
end | |||
end | |||
if not hasSlots then | |||
return "" | |||
end | |||
return tostring(grid) | |||
end | end | ||
-- | -- addHeroSlotsRow: add the standardized slot grid into the infobox table. | ||
local function addHeroSlotsRow(tbl, slotsUI) | |||
if not slotsUI or slotsUI == "" then | |||
return | |||
if | end | ||
local row = tbl:tag("tr") | |||
row:addClass("sv-slot-row") | |||
local cell = row:tag("td") | |||
cell:attr("colspan", 2) | |||
cell:addClass("sv-slot-cell") | |||
cell:wikitext(slotsUI) | |||
end | end | ||
local | ---------------------------------------------------------------------- | ||
-- Infobox builder | |||
---------------------------------------------------------------------- | |||
-- buildInfobox: render a single skill infobox. | |||
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 | |||
local level = clamp(maxLevel, 1, maxLevel) | |||
local ctx = { | |||
maxLevel = maxLevel, | |||
level = level, | |||
nonDamaging = false, | |||
promo = nil, | |||
} | |||
-- Non-damaging hides Damage/Element/Hits in SkillType | |||
do | |||
local dmgVal = nil | |||
if type(rec.Type) == "table" then | |||
dmgVal = rec.Type.Damage or rec.Type["Damage Type"] | |||
if type(dmgVal) == "table" then | |||
dmgVal = dmgVal.Name or dmgVal.ID or dmgVal.Value | |||
end | |||
end | |||
ctx.nonDamaging = isNoneLike(dmgVal) or (not skillHasAnyDamage(rec, maxLevel)) | |||
end | |||
ctx.promo = computeDurationPromotion(rec, maxLevel) | |||
local root = mw.html.create("table") | |||
root:addClass("spiritvale-skill-infobox") | |||
root:addClass("sv-skill-card") | |||
root:attr("data-max-level", tostring(maxLevel)) | |||
root:attr("data-level", tostring(level)) | |||
if opts.inList then | |||
root:addClass("sv-skill-inlist") | |||
end | |||
local internalId = trim(rec["Internal Name"] or rec.InternalID or rec.ID) | |||
if internalId then | |||
root:attr("data-skill-id", internalId) | |||
end | |||
-- Standardized slot grid | |||
addHeroSlotsRow(root, buildHeroSlotsUI(rec, ctx)) | |||
-- Users (hide on direct skill page) | |||
if showUsers then | |||
local users = rec.Users or {} | |||
addRow(root, "Classes", listToText(users.Classes), "sv-row-users", "Users.Classes") | |||
addRow(root, "Summons", listToText(users.Summons), "sv-row-users", "Users.Summons") | |||
addRow(root, "Monsters", listToText(users.Monsters), "sv-row-users", "Users.Monsters") | |||
do | |||
local eventsList = {} | |||
if type(users.Events) == "table" then | |||
for _, ev in ipairs(users.Events) do | |||
local name = resolveEventName(ev) or ev | |||
if name ~= nil then | |||
table.insert(eventsList, mw.text.nowiki(tostring(name))) | |||
end | |||
end | |||
end | |||
addRow(root, "Events", listToText(eventsList), "sv-row-users", "Users.Events") | |||
end | |||
end | |||
-- Mechanics (keep small extras only) | |||
local mech = rec.Mechanics or {} | |||
if next(mech) ~= nil then | |||
if mech["Autocast Multiplier"] ~= nil then | |||
addRow(root, "Autocast Multiplier", tostring(mech["Autocast Multiplier"]), "sv-row-mech", "Mechanics.Autocast Multiplier") | |||
end | |||
end | |||
-- Legacy damage breakdown (only when Source absent) | |||
if type(rec.Source) ~= "table" then | |||
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 | |||
addRow(root, "Main Damage", formatDamageList(mainNonHeal, maxLevel, level, (#mainNonHeal > 1)), "sv-row-source", "Damage.Main Damage") | |||
addRow(root, "Flat Damage", formatDamageList(dmg["Flat Damage"], maxLevel, level, false), "sv-row-source", "Damage.Flat Damage") | |||
addRow(root, "Reflect Damage", formatDamageList(dmg["Reflect Damage"], maxLevel, level, false), "sv-row-source", "Damage.Reflect Damage") | |||
addRow(root, "Healing", formatDamageList(healOnly, maxLevel, level, false), "sv-row-source", "Damage.Healing") | |||
end | |||
end | |||
-- Status rows | |||
local function formatStatusApplications(list, suppressDurationIndex) | |||
if type(list) ~= "table" or #list == 0 then return nil end | |||
local parts = {} | |||
for idx, s in ipairs(list) do | |||
if type(s) == "table" then | |||
local typ = s.Type or s.Scope or "Target" | |||
local name = s["Status External Name"] or s["Status Internal Name"] or "Unknown status" | |||
local seg = tostring(typ) .. " – " .. tostring(name) | |||
local detail = {} | |||
if idx ~= suppressDurationIndex and type(s.Duration) == "table" then | |||
local t = valuePairDynamicValueOnly(s.Duration, maxLevel, level) | |||
if t then table.insert(detail, "Duration: " .. t) end | |||
end | |||
if type(s.Chance) == "table" then | |||
local t = valuePairDynamicValueOnly(s.Chance, maxLevel, level) | |||
if t then table.insert(detail, "Chance: " .. t) end | |||
end | |||
if #detail > 0 then | |||
seg = seg .. " (" .. table.concat(detail, ", ") .. ")" | |||
end | |||
table.insert(parts, seg) | |||
end | |||
end | |||
return (#parts > 0) and table.concat(parts, "<br />") or nil | |||
end | |||
local function formatStatusRemoval(list) | |||
if type(list) ~= "table" or #list == 0 then return nil end | |||
local | 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 = valuePairRawText(r) | |||
amt = amt and mw.text.nowiki(amt) or nil | |||
local seg = mw.text.nowiki(label) | |||
end | if amt then | ||
seg = seg .. " – " .. amt | |||
end | |||
table.insert(parts, seg) | |||
end | |||
end | |||
return (#parts > 0) and table.concat(parts, "<br />") or nil | |||
end | |||
local suppressIdx = (type(ctx.promo) == "table") and ctx.promo.suppressDurationIndex or nil | |||
local statusApps = formatStatusApplications(rec["Status Applications"], suppressIdx) | |||
local statusRem = formatStatusRemoval(rec["Status Removal"]) | |||
local | if statusApps or statusRem then | ||
if | addRow(root, "Applies", statusApps, "sv-row-status", "Status Applications") | ||
addRow(root, " | addRow(root, "Removes", statusRem, "sv-row-status", "Status Removal") | ||
end | end | ||
-- | -- Events | ||
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 = resolveDisplayName(ev.Action, "event") or ev.Action or "On event" | |||
local name = resolveSkillNameFromEvent(ev) | |||
end | table.insert(parts, string.format("%s → %s", mw.text.nowiki(action), mw.text.nowiki(name))) | ||
end | |||
end | |||
return (#parts > 0) and table.concat(parts, "<br />") or nil | |||
end | |||
local eventsText = formatEvents(rec.Events) | local eventsText = formatEvents(rec.Events) | ||
if eventsText then | if eventsText then | ||
addRow(root, "Triggers", eventsText | addRow(root, "Triggers", eventsText, "sv-row-meta", "Events") | ||
end | |||
end | |||
return tostring(root) | return tostring(root) | ||
| Line 1,097: | Line 2,097: | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
--Public: list all skills for a given user / class | -- Public: list all skills for a given user/class | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
function p.listForUser(frame) | |||
local args = getArgs(frame) | local args = getArgs(frame) | ||
local userName = args.user or args[1] | local userName = args.user or args[1] | ||
if not userName or userName == "" then | if not userName or userName == "" then | ||
userName = mw.title.getCurrentTitle().text | userName = mw.title.getCurrentTitle().text | ||
end | end | ||
if not userName or userName == "" then | if not userName or userName == "" then | ||
return "<strong>No user name provided to Skill list.</strong>" | return "<strong>No user name provided to Skill list.</strong>" | ||
end | end | ||
local dataset = getSkills() | local dataset = getSkills() | ||
local matches = {} | local matches = {} | ||
for _, rec in ipairs(dataset.records or {}) do | for _, rec in ipairs(dataset.records or {}) do | ||
if skillMatchesUser(rec, userName) then | |||
table.insert(matches, rec) | table.insert(matches, rec) | ||
end | end | ||
end | end | ||
if #matches == 0 then | |||
return string.format("<strong>No skills found for:</strong> %s", mw.text.nowiki(userName)) | |||
end | |||
local out = {} | |||
for _, rec in ipairs(matches) do | |||
local title = rec["External Name"] or rec.Name or rec["Internal Name"] or "Unknown Skill" | |||
-- | -- List mode: emit a raw H3 heading before each standalone card so TOC/anchors work. | ||
table.insert(out, string.format("=== %s ===", title)) | |||
-- List mode cards are independent (no single wrapper container). | |||
table.insert(out, buildInfobox(rec, { showUsers = false, inList = true })) | |||
end | |||
end | |||
return | return table.concat(out, "\n") | ||
end | end | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
--Public: single - skill or auto - list dispatcher | -- Public: single-skill or auto-list dispatcher | ||
---------------------------------------------------------------------- | ---------------------------------------------------------------------- | ||
function p.infobox(frame) | |||
local args = getArgs(frame) | local args = getArgs(frame) | ||
local raw1 = args[1] | local raw1 = args[1] | ||
local name = args.name or raw1 | local name = args.name or raw1 | ||
local id = args.id | local id = args.id | ||
local rec | local rec | ||
if name and name ~= "" then | if name and name ~= "" then | ||
rec = findSkillByName(name) | rec = findSkillByName(name) | ||
end | end | ||
if not rec and id and id ~= "" then | if not rec and id and id ~= "" then | ||
rec = getSkillById(id) | rec = getSkillById(id) | ||
end | end | ||
if not rec then | if not rec then | ||
local pageTitle = mw.title.getCurrentTitle() | local pageTitle = mw.title.getCurrentTitle() | ||
local pageName = pageTitle and pageTitle.text or "" | local pageName = pageTitle and pageTitle.text or "" | ||
local noExplicitArgs = | local noExplicitArgs = | ||
(not raw1 or raw1 == "") and | |||
(not args.name or args.name == "") and | |||
(not id or id == "") | (not id or id == "") | ||
if noExplicitArgs then | if noExplicitArgs then | ||
return p.listForUser(frame) | return p.listForUser(frame) | ||
end | end | ||
if name and name ~= "" and name == pageName and(not id or id == "") then | if name and name ~= "" and name == pageName and (not id or id == "") then | ||
return p.listForUser(frame) | return p.listForUser(frame) | ||
end | end | ||
local label = name or id or "?" | local label = name or id or "?" | ||
return string.format( | return string.format( | ||
"<strong>Unknown Skill:</strong> %s[[Category:Pages with unknown skill|%s]]", | |||
mw.text.nowiki(label), | |||
label | |||
) | ) | ||
end | end | ||
local showUsers = not isDirectSkillPage(rec) | local showUsers = not isDirectSkillPage(rec) | ||
return buildInfobox(rec, { showUsers = showUsers }) | return buildInfobox(rec, { showUsers = showUsers }) | ||
end | end | ||
return p | return p | ||