Toggle search
Toggle menu
115
248
25
2.7K
SpiritVale Wiki
Toggle preferences menu
Toggle personal menu
Not logged in
Your IP address will be publicly visible if you make any edits.

Join the Playtest on Steam Now: SpiritVale

Module:GameSkills: Difference between revisions

From SpiritVale Wiki
More actions
← Older editNewer edit →
No edit summary
No edit summary
Line 24: Line 24:


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


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


local function listToText(list, sep)
local function listToText(list, sep)
    if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
        return nil
return nil
    end
end
    return table.concat(list, sep or ", ")
return table.concat(list, sep or ", ")
end
end


local function addRow(tbl, label, value)
local function addRow(tbl, label, value)
    if value == nil or value == "" then
if value == nil or value == "" then
        return
return
    end
end
    local row = tbl:tag("tr")
local row = tbl:tag("tr")
    row:tag("th"):wikitext(label):done()
row:tag("th"):wikitext(label):done()
    row:tag("td"):wikitext(value):done()
row:tag("td"):wikitext(value):done()
end
end


local function addSectionHeader(tbl, label)
local function addSectionHeader(tbl, label)
    local row = tbl:tag("tr")
local row = tbl:tag("tr")
    local cell = row:tag("th")
local cell = row:tag("th")
    cell:attr("colspan", 2)
cell:attr("colspan", 2)
    cell:addClass("spiritvale-infobox-section-header")
cell:addClass("spiritvale-infobox-section-header")
    cell:wikitext(label)
cell:wikitext(label)
end
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
-- Handles either a scalar OR {Value=..., Unit=...}
local function formatUnitValue(v)
if type(v) == "table" and v.Value ~= nil then
local unit = v.Unit
local val = v.Value
-- Best-effort formatting for common unit types
if unit == "percent_decimal" then
return tostring((val or 0) * 100) .. "%"
elseif 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
----------------------------------------------------------------------
-- Lookups
----------------------------------------------------------------------


-- Lookup by Internal Name
-- Lookup by Internal Name
local function getSkillById(id)
local function getSkillById(id)
    if not id or id == "" then
id = trim(id)
        return nil
if not id then return nil end
    end
local dataset = getSkills()
    local dataset = getSkills()
local byId = dataset.byId or {}
    local byId = dataset.byId or {}
return byId[id]
    return byId[id]
end
end


-- Lookup by display Name (for editors)
-- Lookup by display/external Name (for editors)
local function findSkillByName(name)
local function findSkillByName(name)
    if not name or name == "" then
name = trim(name)
        return nil
if not name then return nil end
    end
local dataset = getSkills()
    local dataset = getSkills()
 
    for _, rec in ipairs(dataset.records or {}) do
-- Fast path if GameData built byName
        if rec["Name"] == name then
local byName = dataset.byName or {}
            return rec
if byName[name] then
        end
return byName[name]
    end
end
    return nil
 
-- Fallback scan (older GameData)
for _, rec in ipairs(dataset.records or {}) do
if type(rec) == "table" then
if rec["External Name"] == name or rec["Name"] == name or rec["Display Name"] == name then
return rec
end
end
end
return nil
end
end


Line 89: Line 137:
-- Formatting helpers
-- Formatting helpers
----------------------------------------------------------------------
----------------------------------------------------------------------
local function isFlatPerLevel(baseStr, perList)
if type(perList) ~= "table" or #perList == 0 then
return false
end
-- If all per-level entries are identical, treat as "no scaling"
local first = tostring(perList[1])
for i = 2, #perList do
if tostring(perList[i]) ~= first then
return false
end
end
-- If base matches that identical value, definitely flat/no-op
if baseStr ~= nil and tostring(baseStr) == first then
return true
end
-- Even if base differs (sometimes Base is "0" but Lv list is constant), still no meaningful scaling
return true
end


local function formatBasePer(block)
local function formatBasePer(block)
    if type(block) ~= "table" then
if type(block) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
 
    if block.Base ~= nil then
local base = block.Base
        table.insert(parts, string.format("Base %s", tostring(block.Base)))
local per  = block["Per Level"]
    end
 
    if block["Per Level"] ~= nil then
local baseText = (base ~= nil) and formatUnitValue(base) or nil
        table.insert(parts, string.format("%s / Lv", tostring(block["Per Level"])))
 
    end
-- Per Level might be a scalar OR list (wikiprep expansion)
    if #parts == 0 then
if type(per) == "table" then
        return nil
if isFlatPerLevel(baseText, per) then
    end
-- Show only Base (or Lv1 if Base is missing)
    return table.concat(parts, ", ")
if baseText then
return "Base: " .. baseText
end
if per[1] ~= nil then
return "Lv1: " .. tostring(per[1])
end
return nil
end
 
local lines = {}
if baseText then
table.insert(lines, "Base: " .. baseText)
end
for i, v in ipairs(per) do
table.insert(lines, string.format("Lv%d: %s", i, tostring(v)))
end
return table.concat(lines, "<br />")
else
local parts = {}
if baseText then
table.insert(parts, "Base " .. baseText)
end
if per ~= nil then
table.insert(parts, tostring(per) .. " / Lv")
end
if #parts == 0 then
return nil
end
return table.concat(parts, ", ")
end
end
end


local function formatMainDamage(list)
local function formatMainDamage(list)
    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
if type(d) == "table" then
            local kind = d.Type or "Damage"
local kind = d.Type or "Damage"
            local base = d["Base %"]
local base = d["Base %"]
            local per  = d["Per Level %"]
local per  = d["Per Level %"]
            local seg  = kind
local seg  = kind
            local detail = {}
local detail = {}
            if base ~= nil then
if base ~= nil then
                table.insert(detail, string.format("Base %s%%", tostring(base)))
table.insert(detail, string.format("Base %s%%", tostring(base)))
            end
end
            if per ~= nil then
if per ~= nil then
                table.insert(detail, string.format("%s%% / Lv", tostring(per)))
table.insert(detail, string.format("%s%% / Lv", tostring(per)))
            end
end
            if d["ATK-Based"] then
if d["ATK-Based"] then
                table.insert(detail, "ATK-based")
table.insert(detail, "ATK-based")
            end
end
            if d["MATK-Based"] then
if d["MATK-Based"] then
                table.insert(detail, "MATK-based")
table.insert(detail, "MATK-based")
            end
end
            if #detail > 0 then
if #detail > 0 then
                seg = seg .. " – " .. table.concat(detail, ", ")
seg = seg .. " – " .. table.concat(detail, ", ")
            end
end
            table.insert(parts, seg)
table.insert(parts, seg)
        end
end
    end
end
    if #parts == 0 then
if #parts == 0 then
        return nil
return nil
    end
end
    return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
end


local function formatReflectDamage(list)
local function formatReflectDamage(list)
    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
if type(d) == "table" then
            local base = d["Base %"]
local base = d["Base %"]
            local per  = d["Per Level %"]
local per  = d["Per Level %"]
            local seg  = "Reflect"
local seg  = "Reflect"
            local detail = {}
local detail = {}
            if base ~= nil then
if base ~= nil then
                table.insert(detail, string.format("Base %s%%", tostring(base)))
table.insert(detail, string.format("Base %s%%", tostring(base)))
            end
end
            if per ~= nil then
if per ~= nil then
                table.insert(detail, string.format("%s%% / Lv", tostring(per)))
table.insert(detail, string.format("%s%% / Lv", tostring(per)))
            end
end
            if #detail > 0 then
if #detail > 0 then
                seg = seg .. " – " .. table.concat(detail, ", ")
seg = seg .. " – " .. table.concat(detail, ", ")
            end
end
            table.insert(parts, seg)
table.insert(parts, seg)
        end
end
    end
end
    if #parts == 0 then
if #parts == 0 then
        return nil
return nil
    end
end
    return table.concat(parts, "<br />")
return table.concat(parts, "<br />")
end
end


local function formatScaling(list)
local function formatScaling(list)
    if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    for _, s in ipairs(list) do
for _, s in ipairs(list) do
        if type(s) == "table" then
if type(s) == "table" then
            local name = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
local name = s["Scaling Name"] or s["Scaling ID"] or "Unknown"
            local pct  = s.Percent
local pct  = s.Percent
            local seg  = name
local seg  = name
            local detail = {}
local detail = {}
            if pct ~= nil then
if pct ~= nil then
                table.insert(detail, string.format("%s%%", tostring(pct)))
-- If Unit is percent_decimal, convert; otherwise assume already percent
            end
if s.Unit == "percent_decimal" then
            if s["ATK-Based"] then
table.insert(detail, string.format("%s%%", tostring((pct or 0) * 100)))
                table.insert(detail, "ATK-based")
else
            end
table.insert(detail, string.format("%s%%", tostring(pct)))
            if s["MATK-Based"] then
end
                table.insert(detail, "MATK-based")
end
            end
if s["ATK-Based"] then
            if #detail > 0 then
table.insert(detail, "ATK-based")
                seg = seg .. " – " .. table.concat(detail, ", ")
end
            end
if s["MATK-Based"] then
            table.insert(parts, seg)
table.insert(detail, "MATK-based")
        end
end
    end
if #detail > 0 then
    if #parts == 0 then
seg = seg .. " – " .. table.concat(detail, ", ")
        return nil
end
    end
table.insert(parts, seg)
    return table.concat(parts, "<br />")
end
end
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
end


local function formatArea(area)
local function formatArea(area)
    if type(area) ~= "table" then
if type(area) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    local size = area["Area Size"]
 
    if size and size ~= "" then
local size = area["Area Size"]
        table.insert(parts, "Size: " .. tostring(size))
if size and size ~= "" then
    end
table.insert(parts, "Size: " .. tostring(size))
    local dist = area["Area Distance"]
end
    local eff  = area["Effective Distance"]
 
    local distText = formatBasePer(dist)
local dist = area["Area Distance"]
    if distText then
local eff  = area["Effective Distance"]
        table.insert(parts, "Distance: " .. distText)
 
    end
local distText = formatBasePer(dist)
    if eff ~= nil then
if distText then
        table.insert(parts, string.format("Effective: %s", tostring(eff)))
table.insert(parts, "Distance: " .. distText)
    end
end
    if #parts == 0 then
 
        return nil
local effText = formatUnitValue(eff)
    end
if effText then
    return table.concat(parts, "<br />")
table.insert(parts, "Effective: " .. effText)
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
end


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


    local function add(name, key)
local function add(name, key)
        local block = bt[key]
local block = bt[key]
        local txt = formatBasePer(block)
local txt = formatBasePer(block)
        if txt then
if txt then
            table.insert(parts, name .. ": " .. txt)
table.insert(parts, name .. ": " .. txt)
        end
end
    end
end


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


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


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


local function formatResourceCost(rc)
local function formatResourceCost(rc)
    if type(rc) ~= "table" then
if type(rc) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    local mana = rc["Mana Cost"]
    local hp  = rc["Health Cost"]


    local manaTxt = formatBasePer(mana)
local manaTxt = formatBasePer(rc["Mana Cost"])
    if manaTxt then
if manaTxt then
        table.insert(parts, "MP: " .. manaTxt)
table.insert(parts, "MP: " .. manaTxt)
    end
end


    local hpTxt = formatBasePer(hp)
local hpTxt = formatBasePer(rc["Health Cost"])
    if hpTxt then
if hpTxt then
        table.insert(parts, "HP: " .. hpTxt)
table.insert(parts, "HP: " .. hpTxt)
    end
end


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


local function formatCombo(combo)
local function formatCombo(combo)
    if type(combo) ~= "table" then
if type(combo) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    if combo.Type then
 
        table.insert(parts, "Type: " .. tostring(combo.Type))
if combo.Type then
    end
table.insert(parts, "Type: " .. tostring(combo.Type))
    if combo.Duration ~= nil then
end
        table.insert(parts, "Duration: " .. tostring(combo.Duration))
 
    end
local durText = formatUnitValue(combo.Duration)
    if combo.Percent ~= nil then
if durText then
        table.insert(parts, string.format("Bonus: %s%%", tostring(combo.Percent * 100)))
table.insert(parts, "Duration: " .. durText)
    end
end
    if #parts == 0 then
 
        return nil
-- Percent may be scalar or {Value,Unit}
    end
if combo.Percent ~= nil then
    return table.concat(parts, ", ")
local pctText = formatUnitValue(combo.Percent)
if pctText then
table.insert(parts, "Bonus: " .. pctText)
end
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, ", ")
end
end


local function formatMechanicEffects(effects)
local function formatMechanicEffects(effects)
    if type(effects) ~= "table" then
if type(effects) ~= "table" then
        return nil
return nil
    end
end
    local parts = {}
 
    for name, block in pairs(effects) do
local keys = {}
        if type(block) == "table" then
for k, _ in pairs(effects) do
            local bp = formatBasePer(block)
table.insert(keys, k)
            local seg = name
end
            if bp then
table.sort(keys)
                seg = seg .. " – " .. bp
 
            end
local parts = {}
            table.insert(parts, seg)
for _, name in ipairs(keys) do
        end
local block = effects[name]
    end
if type(block) == "table" then
    if #parts == 0 then
local bp = formatBasePer(block)
        return nil
local seg = name
    end
if bp then
    return table.concat(parts, "<br />")
seg = seg .. " – " .. bp
end
table.insert(parts, seg)
end
end
 
if #parts == 0 then
return nil
end
return table.concat(parts, "<br />")
end
end


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


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


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


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


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


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


            local dur = s.Duration
local dur = s.Duration
            if type(dur) == "table" then
if type(dur) == "table" then
                local t = formatBasePer(dur)
local t = formatBasePer(dur)
                if t then
if t then
                    table.insert(detail, "Duration " .. t)
table.insert(detail, "Duration " .. t)
                end
end
            end
end


            local ch = s.Chance
local ch = s.Chance
            if type(ch) == "table" then
if type(ch) == "table" then
                local t = formatBasePer(ch)
local t = formatBasePer(ch)
                if t then
if t then
                    table.insert(detail, "Chance " .. t)
table.insert(detail, "Chance " .. t)
                end
end
            end
end


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


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


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


local function formatStatusRemoval(list)
local function formatStatusRemoval(list)
    if type(list) ~= "table" or #list == 0 then
if type(list) ~= "table" or #list == 0 then
        return nil
return nil
    end
end
    local parts = {}
local parts = {}
    for _, r in ipairs(list) do
for _, r in ipairs(list) do
        if type(r) == "table" then
if type(r) == "table" then
            local names = r["Status Name"]
local names = r["Status External Name"]
            local label
local label
            if type(names) == "table" then
if type(names) == "table" then
                label = table.concat(names, ", ")
label = table.concat(names, ", ")
            elseif type(names) == "string" then
elseif type(names) == "string" then
                label = names
label = names
            else
else
                label = "Status"
label = "Status"
            end
end
            local bp = formatBasePer(r)
 
            local seg = label
local bp = formatBasePer(r)
            if bp then
local seg = label
                seg = seg .. " – " .. bp
if bp then
            end
seg = seg .. " – " .. bp
            table.insert(parts, seg)
end
        end
table.insert(parts, seg)
    end
end
    if #parts == 0 then
end
        return nil
if #parts == 0 then
    end
return nil
    return table.concat(parts, "<br />")
end
return table.concat(parts, "<br />")
end
end


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


Line 459: Line 583:


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


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


    local userLower = mw.ustring.lower(userName)
local userLower = mw.ustring.lower(userName)


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


    if listHas(users.Classes)  then return true end
if listHas(users.Classes)  then return true end
    if listHas(users.Summons)  then return true end
if listHas(users.Summons)  then return true end
    if listHas(users.Monsters) then return true end
if listHas(users.Monsters) then return true end
    if listHas(users.Events)  then return true end
if listHas(users.Events)  then return true end


    return false
return false
end
end


Line 495: Line 619:


local function buildInfobox(rec)
local function buildInfobox(rec)
    local root = mw.html.create("table")
local root = mw.html.create("table")
    root:addClass("wikitable spiritvale-skill-infobox")
root:addClass("wikitable spiritvale-skill-infobox")
 
    -- ==========================================================
    -- Top "hero" row: icon + name (left), description (right)
    -- ==========================================================
    local icon  = rec.Icon
    local title = rec.Name or rec["Internal Name"] or "Unknown Skill"
    local desc  = rec.Description or ""
 
    local headerRow = root:tag("tr")
    headerRow:addClass("spiritvale-infobox-main")


    -- Left cell: icon + name
-- ==========================================================
    local leftCell = headerRow:tag("th")
-- Top "hero" row: icon + name (left), description (right)
    leftCell:addClass("spiritvale-infobox-main-left")
-- ==========================================================
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 leftInner = leftCell:tag("div")
local headerRow = root:tag("tr")
    leftInner:addClass("spiritvale-infobox-main-left-inner")
headerRow:addClass("spiritvale-infobox-main")


    if icon and icon ~= "" then
-- Left cell: icon + name
        leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
local leftCell = headerRow:tag("th")
    end
leftCell:addClass("spiritvale-infobox-main-left")


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


    -- Right cell: italic description
if icon and icon ~= "" then
    local rightCell = headerRow:tag("td")
leftInner:wikitext(string.format("[[File:%s|80px|link=]]", icon))
    rightCell:addClass("spiritvale-infobox-main-right")
end


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


    if desc ~= "" then
-- Right cell: italic description
        rightInner:tag("div")
local rightCell = headerRow:tag("td")
            :addClass("spiritvale-infobox-description")
rightCell:addClass("spiritvale-infobox-main-right")
            :wikitext(string.format("''%s''", desc))
    end


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


    -- Description now lives in the hero row.
if desc ~= "" then
    -- addRow(root, "Description", rec.Description)
rightInner:tag("div")
:addClass("spiritvale-infobox-description")
:wikitext(string.format("''%s''", desc))
end


    addRow(root, "Max level", rec["Max Level"] and tostring(rec["Max Level"]))
------------------------------------------------------------------
-- General
------------------------------------------------------------------
addSectionHeader(root, "General")
addRow(root, "Max level", rec["Max Level"] and tostring(rec["Max Level"]))


    local users = rec.Users or {}
local users = rec.Users or {}
    addRow(root, "Classes",  listToText(users.Classes))
addRow(root, "Classes",  listToText(users.Classes))
    addRow(root, "Summons",  listToText(users.Summons))
addRow(root, "Summons",  listToText(users.Summons))
    addRow(root, "Monsters", listToText(users.Monsters))
addRow(root, "Monsters", listToText(users.Monsters))
    addRow(root, "Events",  listToText(users.Events))
addRow(root, "Events",  listToText(users.Events))


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


        addSectionHeader(root, "Requirements")
addSectionHeader(root, "Requirements")


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


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


    ------------------------------------------------------------------
------------------------------------------------------------------
    -- Type
-- Type
    ------------------------------------------------------------------
------------------------------------------------------------------
    local typeBlock = rec.Type or {}
local typeBlock = rec.Type or {}
    if next(typeBlock) ~= nil then
if next(typeBlock) ~= nil then
        addSectionHeader(root, "Type")
addSectionHeader(root, "Type")


        local dt = typeBlock["Damage Type"]
local dt = typeBlock["Damage Type"]
        if type(dt) == "table" and dt.Name then
if type(dt) == "table" and dt.Name then
            addRow(root, "Damage type", dt.Name)
addRow(root, "Damage type", dt.Name)
        end
end


        local et = typeBlock["Element Type"]
local et = typeBlock["Element Type"]
        if type(et) == "table" and et.Name then
if type(et) == "table" and et.Name then
            addRow(root, "Element", et.Name)
addRow(root, "Element", et.Name)
        end
end


        local tt = typeBlock["Target Type"]
local tt = typeBlock["Target Type"]
        if type(tt) == "table" and tt.Name then
if type(tt) == "table" and tt.Name then
            addRow(root, "Target", tt.Name)
addRow(root, "Target", tt.Name)
        end
end


        local ct = typeBlock["Cast Type"]
local ct = typeBlock["Cast Type"]
        if type(ct) == "table" and ct.Name then
if type(ct) == "table" and ct.Name then
            addRow(root, "Cast type", ct.Name)
addRow(root, "Cast type", ct.Name)
        end
end
    end
end


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


        if mech.Range ~= nil then
local rangeText = formatUnitValue(mech.Range)
            addRow(root, "Range", tostring(mech.Range))
addRow(root, "Range", rangeText)
        end


        local areaText = formatArea(mech.Area)
local areaText = formatArea(mech.Area)
        addRow(root, "Area", areaText)
addRow(root, "Area", areaText)


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


        local btText = formatTimingBlock(mech["Basic Timings"])
local btText = formatTimingBlock(mech["Basic Timings"])
        addRow(root, "Timing", btText)
addRow(root, "Timing", btText)


        local rcText = formatResourceCost(mech["Resource Cost"])
local rcText = formatResourceCost(mech["Resource Cost"])
        addRow(root, "Resource cost", rcText)
addRow(root, "Resource cost", rcText)


        local comboText = formatCombo(mech.Combo)
local comboText = formatCombo(mech.Combo)
        addRow(root, "Combo", comboText)
addRow(root, "Combo", comboText)


        local effText = formatMechanicEffects(mech.Effects)
local effText = formatMechanicEffects(mech.Effects)
        addRow(root, "Special mechanics", effText)
addRow(root, "Special mechanics", effText)
    end
end


    ------------------------------------------------------------------
------------------------------------------------------------------
    -- Damage & Healing
-- Damage & Healing
    ------------------------------------------------------------------
------------------------------------------------------------------
    local dmg = rec.Damage or {}
local dmg = rec.Damage or {}
    if next(dmg) ~= nil then
if next(dmg) ~= nil then
        addSectionHeader(root, "Damage and scaling")
addSectionHeader(root, "Damage and scaling")


        if dmg["Healing Present"] then
if dmg["Healing Present"] then
            addRow(root, "Healing", "Yes")
addRow(root, "Healing", "Yes")
        end
end


        local mainText = formatMainDamage(dmg["Main Damage"])
local mainText = formatMainDamage(dmg["Main Damage"])
        addRow(root, "Main damage", mainText)
addRow(root, "Main damage", mainText)


        local reflText = formatReflectDamage(dmg["Reflect Damage"])
local reflText = formatReflectDamage(dmg["Reflect Damage"])
        addRow(root, "Reflect damage", reflText)
addRow(root, "Reflect damage", reflText)


        local scaleText = formatScaling(dmg.Scaling)
local scaleText = formatScaling(dmg.Scaling)
        addRow(root, "Scaling", scaleText)
addRow(root, "Scaling", scaleText)
    end
end


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


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


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


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


    return tostring(root)
return tostring(root)
end
end


Line 705: Line 824:


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


    -- Prefer explicit param, then unnamed, then fall back to the current page name.
-- Prefer explicit param, then unnamed, then fall back to the current page name.
    local userName = args.user or args[1]
local userName = args.user or args[1]
    if not userName or userName == "" then
if not userName or userName == "" then
        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
if skillMatchesUser(rec, userName) then
            table.insert(matches, rec)
table.insert(matches, rec)
        end
end
    end
end


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


    local root = mw.html.create("div")
local root = mw.html.create("div")
    root:addClass("spiritvale-skill-list")
root:addClass("spiritvale-skill-list")


    for _, rec in ipairs(matches) do
for _, rec in ipairs(matches) do
        root:wikitext(buildInfobox(rec))
root:wikitext(buildInfobox(rec))
    end
end


    return tostring(root)
return tostring(root)
end
end


Line 748: Line 867:


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


    -- Allow three styles:
-- Allow three styles:
    --  {{Skill|Bash}}              -> args[1] = "Bash"  (Name)
--  {{Skill|Bash}}              -> args[1] = "Bash"  (External Name)
    --  {{Skill|name=Bash}}        -> args.name = "Bash"
--  {{Skill|name=Bash}}        -> args.name = "Bash"
    --  {{Skill|id=Bash_Internal}}  -> args.id = "Bash_Internal"
--  {{Skill|id=Bash_Internal}}  -> args.id = "Bash_Internal"
    local raw1 = args[1]
local raw1 = args[1]
    local name = args.name or raw1
local name = args.name or raw1
    local id  = args.id
local id  = args.id


    local rec
local rec


    -- 1) Prefer display Name
-- 1) Prefer External/Display Name
    if name and name ~= "" then
if name and name ~= "" then
        rec = findSkillByName(name)
rec = findSkillByName(name)
    end
end


    -- 2) Fallback: internal ID
-- 2) Fallback: internal ID
    if not rec and id and id ~= "" then
if not rec and id and id ~= "" then
        rec = getSkillById(id)
rec = getSkillById(id)
    end
end


    -- 3) If still nothing, decide if this is "list mode" or truly unknown.
-- 3) If still nothing, decide if this is "list mode" or truly unknown.
    if not rec then
if not rec then
        local pageTitle = mw.title.getCurrentTitle()
local pageTitle = mw.title.getCurrentTitle()
        local pageName  = pageTitle and pageTitle.text or ""
local pageName  = pageTitle and pageTitle.text or ""


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


        -- Case A: {{Skill}} with no parameters on a page → list for that page name.
-- Case A: {{Skill}} with no parameters on a page → list for that page name.
        if noExplicitArgs then
if noExplicitArgs then
            return p.listForUser(frame)
return p.listForUser(frame)
        end
end


        -- Case B: {{Skill|Acolyte}} on the "Acolyte" page and no id → treat as list.
-- Case B: {{Skill|Acolyte}} on the "Acolyte" page and no id → treat as list.
        if name and name ~= "" and name == pageName and (not id or id == "") then
if name and name ~= "" and name == pageName and (not id or id == "") then
            return p.listForUser(frame)
return p.listForUser(frame)
        end
end


        -- Otherwise, genuinely unknown skill.
-- Otherwise, genuinely unknown skill.
        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]]",
"<strong>Unknown skill:</strong> %s[[Category:Pages with unknown skill|%s]]",
            mw.text.nowiki(label),
mw.text.nowiki(label),
            label
label
        )
)
    end
end


    -- Normal single-skill behavior
return buildInfobox(rec)
    return buildInfobox(rec)
end
end


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