The Deadlock Wiki

Module:Sandbox/Vergir: Difference between revisions

Browse history interactively
← Older edit

Vergir (talk | contribs)

2 user groups
1,643 edits
undo
Vergir (talk | contribs)
Contributors, Interface administrators
1,643 edits
Testing reworked HeroData: module body (with help from vergir-bot LLM)
Vergir (talk | contribs)
Contributors, Interface administrators
1,643 edits
Use {{Ss}} badge in the Spirit Scaling cell; add plain-text dump for review (with help from vergir-bot LLM)
 
(18 intermediate revisions by 2 users not shown)
Line 1: Line 1:
local p = {};
-- Renders sortable wikitables of abilities filtered by a named stat.
local heroes_data = mw.loadJsonData("Data:HeroData.json")
local util_module = require('Module:Utilities')
local lang_module = require('Module:Lang')


--------------------------------------------------------------------------------
local Lists    = require("Module:AbilityTable/Lists")
-- Internal helpers
local Notes    = require("Module:AbilityTable/Notes")
--------------------------------------------------------------------------------
local Renderers = require("Module:AbilityTable/ComplexRenderers")
local GameData  = require("Module:GameData")


-- Localized string for a key, falling back to a readable version of `fallback`
local p = {}
-- plus a "missing translation" tooltip.
local function localize(key, fallback)
local result = lang_module.get_string(key)
if (result == "") or (result == nil) then
result = util_module.add_space_before_cap(fallback) .. mw.getCurrentFrame():expandTemplate{title="MissingValveTranslationTooltip"}
end
return result
end


-- Raw scaling value of a stat under LevelScaling / SpiritScaling, or nil when
-- ============================================================
-- the hero has no scaling of that type for that stat.
-- TEST COPY of Module:AbilityTable with the proposed
local function raw_scaling(hero_data, scaling_type, stat)
-- Module:AbilityTable/ComplexRenderers.RenderSpiritScaling inlined below,
local scaling = hero_data and hero_data[scaling_type .. "Scaling"]
-- so the whole change can be previewed from one sandbox module.
if (scaling == nil or stat == nil) then return nil end
-- ============================================================
return scaling[stat]
end


-- Mapping from hero name to internal tag name
-- ============================================================
local TAG_NAME_MAP = {
-- Spirit scaling helpers
["Abrams"] = "Abrams",
-- ============================================================
["Bebop"] = "Bebop",
["Billy"] = "Punkgoat",
["Calico"] = "Nano",
["The Doorman"] = "Doorman",
["Drifter"] = "Drifter",
["Dynamo"] = "Dynamo",
["Apollo"] = "Fencer",
["Graves"] = "Necro",
["Grey Talon"] = "Orion",
["Haze"] = "Haze",
["Holliday"] = "Astro",
["Infernus"] = "Inferno",
["Ivy"] = "Tengu",
["Kelvin"] = "Kelvin",
["Lady Geist"] = "Geist",
["Lash"] = "Lash",
["McGinnis"] = "Engineer",
["Mina"] = "VampireBat",
["Mirage"] = "Mirage",
["Mo & Krill"] = "Digger",
["Paige"] = "Bookworm",
["Paradox"] = "Chrono",
["Celeste"] = "Unicorn",
["Pocket"] = "Synth",
["Rem"] = "Familiar",
["Seven"] = "Gigawatt",
["Shiv"] = "Shiv",
["Silver"] = "Werewolf",
["Silver (Transformed)"] = "Werewolf",
["Sinclair"] = "Magician",
["Venator"] = "Priest",
["Victor"] = "Frank",
["Vindicta"] = "Vindicta",
["Viscous"] = "Viscous",
["Vyper"] = "Viper",
["Warden"] = "Warden",
["Wraith"] = "Wraith",
["Yamato"] = "Yamato",
}


--------------------------------------------------------------------------------
-- Returns the Spirit scaling entry of a prop value, or nil. A prop's Scale is
-- Data access, for use by other modules
-- either a single { Value, Type } table or an array of them (a duration that
--------------------------------------------------------------------------------
-- scales with both Spirit and ability duration, for example).
local function spirit_scale(v)
    if type(v) ~= "table" then return nil end
    local scale = v["Scale"]
    if type(scale) ~= "table" then return nil end
    if scale[1] == nil then
        if scale["Type"] == "spirit" then return scale end
        return nil
    end
    for _, entry in ipairs(scale) do
        if type(entry) == "table" and entry["Type"] == "spirit" then return entry end
    end
    return nil
end


-- returns the table of a specific item, used by external modules
-- Collects the non-zero Spirit scalings of one record layer (the base record
function p.get_json_item(name)
-- or one upgrade tier) as { key, value, multiply }, ordered the way the
for i,v in pairs(heroes_data) do
-- ability card lists its props; props the card does not list come last, in
if (v["Name"] == name) then
-- key order. `labels` is the view's cardprops map (see Module:AbilityTable).
return v
local function spirit_scalings(layer, labels)
end
    local out = {}
end
    for k, v in pairs(layer) do
return nil
        if k ~= "Upgrades" and tostring(k):sub(1, 1) ~= "_" then
            local s = spirit_scale(v)
            if s and type(s["Value"]) == "number" and s["Value"] ~= 0 then
                table.insert(out, {
                    key      = k,
                    value    = s["Value"],
                    multiply = s["Multiply"] == true,
                })
            end
        end
    end
    table.sort(out, function(a, b)
        local oa = labels[a.key] and labels[a.key].order or math.huge
        local ob = labels[b.key] and labels[b.key].order or math.huge
        if oa ~= ob then return oa < ob end
        return a.key < b.key
    end)
    return out
end
end


-- Hero table for a hero_* key or an exact English name, or nil.
-- Formats a scaling value to 3 significant figures, as the ability cards do.
local function hero_by_key_or_name(input)
local function format_spirit(v)
local hero = heroes_data[input]
    return string.format("%.3g", v)
if (hero == nil) then hero = p.get_json_item(input) end
return hero
end
end


-- Value of a stat, checking the hero's top level, then Weapon, then AltFire.
-- Formats one Spirit scaling for the table cell through the compact {{Ss}}
-- Returns nil when the hero has no such stat.
-- form, the same way RenderBarrier does. The template is expanded via the
function p.get_stat(hero_data, stat)
-- frame the surrounding #invoke runs under, since module return values are
if (hero_data == nil or stat == nil) then return nil end
-- not re-expanded; the plain "×N" fallback covers a nil frame (module
local value = hero_data[stat]
-- console).
if (value == nil and hero_data.Weapon) then
local function format_spirit_badge(v)
value = hero_data.Weapon[stat]
    local text  = format_spirit(v)
end
    local frame = mw.getCurrentFrame()
if (value == nil and hero_data.Weapon and hero_data.Weapon.AltFire) then
    if frame then
value = hero_data.Weapon.AltFire[stat]
        return frame:expandTemplate{
end
            title = "Ss",
return value
            args  = { text, compact = "1", show_value = "1" },
        }
    end
    return "×" .. text
end
end


-- Ordered list of a hero's scalings for a stat, Level first then Spirit:
-- "A", "A and B", "A, B and C".
--  { { type = "Level", value = 1.5 }, { type = "Spirit", value = 0.04 } }
local function join_names(names)
-- Absent and zero scalings are omitted, so an empty list means "no scaling".
    if #names <= 1 then return names[1] or "" end
function p.get_scalings(hero_data, stat)
    return table.concat(names, ", ", 1, #names - 1) .. " and " .. names[#names]
local scalings = {}
for _, scaling_type in ipairs({"Level", "Spirit"}) do
local value = raw_scaling(hero_data, scaling_type, stat)
if (value ~= nil and value ~= 0) then
table.insert(scalings, { type = scaling_type, value = value })
end
end
return scalings
end
end


-- DEPRECATED, kept for [[Module:HeroComparisonTable]]. Use p.get_scalings.
-- Renders Spirit Power scaling.
-- Keyed by scaling value, so it silently drops an entry when Level and Spirit
-- Lists every prop that scales with Spirit at base, one per line as an {{Ss}}
-- scale by the same amount, and it keeps zero scalings.
-- badge labelled with the prop's name from the ability card:
function p.get_hero_scaling_data(hero_data, hero_stat_key)
-- "x0.55 (Base Damage)". Two
local scaling_data_returned = {}
-- props sharing a name are told apart by the card's Title
for _, scaling_type in ipairs({"Spirit", "Level"}) do
-- ("Damage: Cost of Stay"); props the card does not list show their raw key.
local scaling_value = raw_scaling(hero_data, scaling_type, hero_stat_key)
-- Upgrades are reported in Notes per prop, with the running total: additive
if (scaling_value ~= nil) then
-- ones as "adds +×0.5 ... (total ×1.05)", ones that unlock scaling on a prop
scaling_data_returned[scaling_value] = scaling_type
-- as "grants ×1.3 ...", and Multiply upgrades as "multiplies ... by 1.15",
end
-- which is how the ability-upgrade gadget applies them.
end
function p.RenderSpiritScaling(ability, cardprops)
return scaling_data_returned
    local labels = cardprops or {}
 
    local base  = spirit_scalings(ability, labels)
    local tiers = {}  -- { tier = i, list = ... } in tier order
    local upgrades = ability["Upgrades"]
    if type(upgrades) == "table" then
        -- ipairs rather than #: mw.loadJsonData tables have no length.
        for i, tier in ipairs(upgrades) do
            if type(tier) == "table" then
                table.insert(tiers, { tier = i, list = spirit_scalings(tier, labels) })
            end
        end
    end
 
    -- Names used by more than one scaling prop of this ability get their Title
    -- appended so the rows can be told apart.
    local keys_by_name = {}
    local function note_keys(list)
        for _, prop in ipairs(list) do
            local info = labels[prop.key]
            if info then
                keys_by_name[info.name] = keys_by_name[info.name] or {}
                keys_by_name[info.name][prop.key] = true
            end
        end
    end
    note_keys(base)
    for _, t in ipairs(tiers) do note_keys(t.list) end
 
    local function label_of(key)
        local info = labels[key]
        if not info then return key end
        local n = 0
        for _ in pairs(keys_by_name[info.name] or {}) do n = n + 1 end
        if n > 1 and info.title then return info.name .. ": " .. info.title end
        return info.name
    end
 
    local cells  = {}
    local running = {}  -- prop key -> current total scaling
 
    if #base > 0 then
        local lines = {}
        for _, prop in ipairs(base) do
            table.insert(lines, format_spirit_badge(prop.value) .. " (" .. label_of(prop.key) .. ")")
            running[prop.key] = prop.value
        end
        cells["Spirit Scaling"] = table.concat(lines, "<br>")
    end
 
    local notes = {}
    for _, t in ipairs(tiers) do
        local i, list = t.tier, t.list
        local groups, group_order = {}, {}   -- Multiply upgrades, grouped by multiplier
        for _, up in ipairs(list) do
            local label  = label_of(up.key)
            local current = running[up.key]
            if up.multiply then
                local group = groups[up.value]
                if not group then
                    group = { labels = {}, totals = {} }
                    groups[up.value] = group
                    table.insert(group_order, up.value)
                end
                table.insert(group.labels, label)
                if current then
                    running[up.key] = current * up.value
                    table.insert(group.totals, "×" .. format_spirit(running[up.key]))
                else
                    table.insert(group.totals, "?")
                end
            elseif current then
                running[up.key] = current + up.value
                table.insert(notes, "T" .. i .. " upgrade adds +×" .. format_spirit(up.value)
                    .. " " .. label .. " scaling (total ×" .. format_spirit(running[up.key]) .. ")")
            else
                running[up.key] = up.value
                table.insert(notes, "T" .. i .. " upgrade grants ×" .. format_spirit(up.value)
                    .. " " .. label .. " scaling")
            end
        end
        for _, m in ipairs(group_order) do
            local group = groups[m]
            table.insert(notes, "T" .. i .. " upgrade multiplies " .. join_names(group.labels)
                .. " scaling by " .. format_spirit(m)
                .. " (total " .. table.concat(group.totals, ", ") .. ")")
        end
    end
 
    if #notes > 0 then cells["Notes"] = table.concat(notes, ". ") end
    return cells
end
end


-- Whether a hero has a stat at all: a non-zero base value, or any scaling.
-- get_cells(ability, cardprops) -> { [column header] = cell text, Notes = ... }
function p.has_stat(hero_data, stat)
-- `cardprops` maps the ability's prop keys to their display labels; most
local base = p.get_stat(hero_data, stat)
-- renderers ignore it.
if (base ~= nil and base ~= 0) then return true end
local extra_columns = {
return #p.get_scalings(hero_data, stat) > 0
    ["barrier"] = {
        headers  = { "Barrier" },
        get_cells = Renderers.RenderBarrier,
    },
    ["bossdmgscale"] = {
        headers  = { "Damage to Objectives" },
        get_cells = Renderers.RenderBossDamageScale,
    },
    ["charges"] = {
        headers  = { "Charges", "Time Between Charges", "Notes" },
        get_cells = Renderers.RenderCharges,
    },
    ["melee"] = {
        headers  = { "Base Damage", "Light Melee Scaling", "Notes" },
        get_cells = Renderers.RenderMelee,
    },
    ["heavymelee"] = {
        headers  = { "Base Damage", "Heavy Melee Scaling", "Notes" },
        get_cells = Renderers.RenderHeavyMelee,
    },
    ["scalingspirit"] = {
        headers  = { "Spirit Scaling", "Notes" },
        get_cells = p.RenderSpiritScaling,  -- TEST: inlined copy above
    },
    ["healreduce"] = {
        headers  = { "Heal Reduction", "Notes" },
        get_cells = Renderers.RenderHealReduce,
    },
    ["moveslow"] = {
        headers  = { "Move Slow", "Notes" },
        get_cells = Renderers.RenderMoveSlow,
    },
    ["dashslow"] = {
        headers  = { "Dash Slow", "Notes" },
        get_cells = Renderers.RenderDashSlow,
    },
    ["extradebuffresist"] = {
        headers  = { "Debuff Resist" },
        get_cells = Renderers.RenderExtraDebuffResist,
    },
}
 
-- ============================================================
-- Note enrichment
-- ============================================================
 
-- Merges auto-generated and human notes for full-table mode.
-- Capitalizes human note, joins with ". ", ensures trailing period.
local function enrich_notes_full(extra, human_note)
    if human_note then
        human_note = human_note:sub(1,1):upper() .. human_note:sub(2)
        extra["Notes"] = extra["Notes"] and (extra["Notes"] .. ". " .. human_note) or human_note
    end
    if extra["Notes"] and extra["Notes"]:sub(-1) ~= "." then
        extra["Notes"] = extra["Notes"] .. "."
    end
end
end


-- Resolves a hero_* key or an English hero name to a hero_* key.
-- Merges auto-generated and human notes for compact mode.
-- Returns nil when the input matches no hero. Name matching is case-insensitive.
-- Decapitalizes human note (skips T{N} prefixes like "T1 slow"),
function p.find_hero_key(input)
-- joins with "; ", strips trailing period.
if (input == nil or input == '') then return nil end
local function enrich_notes_compact(extra, human_note)
if (heroes_data[input] ~= nil) then return input end
    if human_note then
local wanted = mw.ustring.lower(input)
        local first = human_note:sub(1,1)
for hero_key, hero_data in pairs(heroes_data) do
        if first:match("%u") and not human_note:sub(2,2):match("%d") then
if (hero_data["Name"] and mw.ustring.lower(hero_data["Name"]) == wanted) then
            human_note = first:lower() .. human_note:sub(2)
return hero_key
        end
end
        if human_note:sub(-1) == "." then human_note = human_note:sub(1, -2) end
end
        extra["Notes"] = extra["Notes"] and (extra["Notes"] .. "; " .. human_note) or human_note
return nil
    end
end
end


-- A hero's Nth roster tag (1-3) by English name, or '' when there is no such tag.
-- ============================================================
function p.hero_tag(hero_en, index)
-- Ability views
local tagname = hero_en and TAG_NAME_MAP[hero_en]
--
if (tagname == nil) then return '' end
-- In-game Ability may containe 1 or more records in AbilityData.json
if (index ~= 1 and index ~= 2 and index ~= 3) then return '' end
-- Example: Vexing Bolt is 2 records (Launch Bolt + Redirect Bolt).
return lang_module.get_string(string.format("Citadel_%s_HeroTag_%d", tagname, index)) or ''
end


--------------------------------------------------------------------------------
-- "Ability View" is a main-record + any relevant sub-ability records.
-- Wikitext entry points
-- Each view entry also carries "cardprops", the display labels of the
--------------------------------------------------------------------------------
-- ability's props taken from its card (see card_prop_labels). They are kept
-- beside the record rather than inside it so that membership matching, which
-- walks the whole record, never sees them.
-- ============================================================


-- returns the key of the specified hero's english name
-- Display labels for a card's props: prop key -> { name, title, order }, read
function p.get_hero_key(frame)
-- from the Info sections of the card in AbilityCards.json. The flat
local hero_name_input = frame.args[1]
-- AbilityData records carry no display names, and a key such as "Damage" is
if not hero_name_input then
-- reused across abilities under different labels, so the map is built per
return "Error: Hero name not specified."
-- card rather than wiki-wide. `order` is the position of the prop on the
end
-- card, so renderers can list props the way the in-game card does.
return p.find_hero_key(hero_name_input) or "Hero not found."
local function card_prop_labels(card)
end
    local labels, n = {}, 0


--{{#invoke:HeroData|resolve_key|HERO_KEY_OR_NAME}}--
    local function walk(node)
-- The matching hero_* key, or '' when the input matches no hero.
        if type(node) ~= "table" then return end
function p.resolve_key(frame)
        local key, name = node["Key"], node["Name"]
return p.find_hero_key(frame.args[1]) or ''
        if type(key) == "string" and type(name) == "string" and not labels[key] then
end
            n = n + 1
            local title = node["Title"]
            if type(title) == "string" then
                title = title:gsub(":%s*$", "")
            else
                title = nil
            end
            labels[key] = { name = name, title = title, order = n }
        end
        if node[1] ~= nil then
            for _, child in ipairs(node) do walk(child) end
        else
            -- Sections such as Range or Move key each prop by its name:
            -- { AttackDashRange = { Name = "...", Value = ... } }.
            local keyed = {}
            for k, v in pairs(node) do
                if type(k) == "string" and type(v) == "table" and v["Key"] == nil
                    and type(v["Name"]) == "string" and not labels[k]
                then
                    table.insert(keyed, k)
                end
            end
            table.sort(keyed)
            for _, k in ipairs(keyed) do
                n = n + 1
                labels[k] = { name = node[k]["Name"], order = n }
            end
            -- Main props before Alt props, then anything else in key order.
            if node["Main"] ~= nil then walk(node["Main"]) end
            if node["Alt"]  ~= nil then walk(node["Alt"])  end
            local rest = {}
            for k, v in pairs(node) do
                if k ~= "Main" and k ~= "Alt" and k ~= "Upgrades" and type(v) == "table" then
                    table.insert(rest, k)
                end
            end
            table.sort(rest, function(a, b) return tostring(a) < tostring(b) end)
            for _, k in ipairs(rest) do walk(node[k]) end
        end
    end


--{{#invoke:HeroData|get_hero_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
    for _, section in ipairs({ "Info1", "Info2", "Info3" }) do
--sig_figs optional for rounding floats
        walk(card[section])
p.get_hero_var = function(frame)
     end
    local hero_name = frame.args[1]
     local rest = {}
     local hero_stat_key = frame.args[2]
     for k, v in pairs(card) do
     local sig_figs_or_localize = frame.args[3]
        if type(v) == "table" and k ~= "Upgrades"
      
            and k ~= "Info1" and k ~= "Info2" and k ~= "Info3"
    local hero = hero_by_key_or_name(hero_name)
        then
    if(hero == nil) then return "Hero Not Found" end
            table.insert(rest, k)
   
         end
    local var_value = p.get_stat(hero, hero_stat_key)
    if(var_value == nil) then return 0 end
   
    --round
    if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
        var_value = util_module.round_to_sig_fig(var_value, sig_figs_or_localize)
         if (var_value == nil) then return "get_hero_var() error with rounding" end
     end
     end
      
     table.sort(rest, function(a, b) return tostring(a) < tostring(b) end)
     --localize
    for _, k in ipairs(rest) do walk(card[k]) end
     if (sig_figs_or_localize == "true") then
 
         return lang_module.get_string(var_value)
     -- Header attributes are stored on the card without a Name.
     local header_attrs = {
        { "AbilityCastRange",            "Cast Range" },
        { "Radius",                      "Radius" },
        { "AbilityDuration",            "Duration" },
        { "AbilityChannelTime",          "Channel Time" },
        { "AbilityCooldown",            "Cooldown" },
        { "AbilityCharges",              "Charges" },
        { "AbilityCooldownBetweenCharge", "Charge Cooldown" },
    }
    for _, attr in ipairs(header_attrs) do
        if not labels[attr[1]] then
            n = n + 1
            labels[attr[1]] = { name = attr[2], order = n }
         end
     end
     end


     return var_value
     return labels
end
end


--{{#invoke:HeroData|get_alt_fire_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
local _views = nil  -- card key -> { view = record, heroName = ..., abilityNum = ..., cardprops = ... }
p.get_alt_fire_var = function(frame)
local _order = nil  -- array of card keys, sorted by hero then slot
     local hero_name = frame.args[1]
 
     local stat_key = frame.args[2]
local function build_views()
     local sig_figs_or_localize = frame.args[3]
     if _views then return _views, _order end
      
    _views, _order = {}, {}
    local hero = hero_by_key_or_name(hero_name)
 
    if(hero == nil) then return "Hero Not Found" end
     local hero_data = mw.loadJsonData("Data:HeroData.json")
      
     local active_heroes = {}
     if not (hero.Weapon and hero.Weapon.AltFire) then
     for _, hero in pairs(hero_data) do
        return "No Alt Fire"
        if type(hero) == "table"
            and hero["IsDisabled"] == false
            and type(hero["Name"]) == "string"
            and (hero["IsSelectable"] == nil or hero["IsSelectable"] ~= false)
        then
            active_heroes[hero["Name"]] = true
        end
     end
 
     local ability_data = mw.loadJsonData(GameData.Dataset.ABILITIES)
    local cards        = mw.loadJsonData("Data:AbilityCards.json")
 
    local card_of = {}
    for _, hero_entry in pairs(cards) do
        if type(hero_entry) == "table" then
            local hero_name = hero_entry["Name"]
            if hero_name and active_heroes[hero_name] then
                for slot_str, ability in pairs(hero_entry) do
                    local slot_num = tonumber(slot_str)
                    local key = type(ability) == "table" and ability["Key"] or nil
                    if slot_num and key and ability_data[key] then
                        card_of[key] = { heroName = hero_name, abilityNum = slot_num, card = ability }
                    end
                end
            end
        end
     end
     end
      
 
     local var_value = hero.Weapon.AltFire[stat_key]
     -- Attach each non-card record to the longest card key it prefixes.
     if(var_value == nil) then return 0 end
     local subs = {}
   
     for key, record in pairs(ability_data) do
    --round
        if not card_of[key] and record["IsDisabled"] ~= true then
    if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
            local parent = nil
        var_value = util_module.round_to_sig_fig(var_value, sig_figs_or_localize)
            for card_key in pairs(card_of) do
                if key:sub(1, #card_key + 1) == card_key .. "_"
                    and (parent == nil or #card_key > #parent)
                then
                    parent = card_key
                end
            end
            if parent then
                subs[parent] = subs[parent] or {}
                table.insert(subs[parent], record)
            end
        end
     end
     end
      
 
    --localize
     for key, info in pairs(card_of) do
    if (sig_figs_or_localize == "true") then
        local view = {}
         return lang_module.get_string(var_value)
        for k, v in pairs(ability_data[key]) do view[k] = v end
        view["_subabilities"] = subs[key]
        _views[key] = {
            view      = view,
            heroName  = info.heroName,
            abilityNum = info.abilityNum,
            cardprops  = card_prop_labels(info.card),
        }
         table.insert(_order, key)
     end
     end


     return var_value
     table.sort(_order, function(a, b)
        local ia, ib = _views[a], _views[b]
        if ia.heroName ~= ib.heroName then return ia.heroName < ib.heroName end
        return ia.abilityNum < ib.abilityNum
    end)
 
    return _views, _order
end
end


--{{#invoke:HeroData|get_list_elem|HERO_NAME|VAR|NUMBER|LOCALIZE}}
-- ============================================================
p.get_list_elem = function(frame)
-- Membership
local hero_name = frame.args[1]
-- Pieces of code that help in telling  "is ability X a member of list Y".
local var = frame.args[2]
-- main function is: p.is_member()
local number_int = tonumber(frame.args[3])
-- ============================================================
local localize_arg = frame.args[4]
 
-- Memoized name-exclusion set per list (from Lists.exclude_abilities).
local hero = hero_by_key_or_name(hero_name)
local _excluded = {}
if(hero == nil) then return "Hero Not Found" end
local function excluded_set(stat)
    if _excluded[stat] then return _excluded[stat] end
local list = p.get_stat(hero, var)
    local set = {}
if (list == nil) then return "" end
    for _, name in ipairs(Lists.exclude_abilities[stat] or {}) do
local element = list[number_int]
        set[name] = true
if (element == nil) then return "" end
    end
    _excluded[stat] = set
if localize_arg=="true" then
    return set
element = lang_module.get_string(element)
end
return element
end
end


p.get_ability_key = function(frame)
-- Per-list rules that can't be expressed as prop lists or exclusions.
local hero_key = frame.args[1]
-- Returns true to keep the ability, false to drop it.
local bound_slot_number = frame.args[2]
local function special_ok(stat, record, ability_num)
local hero_data = heroes_data[hero_key]
    if stat == "dispelmagic" and ability_num == 4 then return false end
if (hero_data == nil) then return "Hero key "..hero_key.. " not found" end
    return true
local bound_abilities_data = hero_data["BoundAbilities"]
if (bound_abilities_data == nil) then return "Hero key " .. hero_key.. " has no BoundAbilities" end
return bound_abilities_data[tonumber(bound_slot_number)]["Key"]
end
end


p.write_role_playstyle_quote = function(frame)
-- Public: does ability `ability_key` belong to list `stat`?
local hero_key = frame.args[1]
function p.is_member(stat, ability_key, ability_num)
local hero_data = heroes_data[hero_key]
    local props = Lists.lists[stat]
if (hero_data == nil) then return hero_key.." not found" end
    if not props then return false end
local role_key = hero_data["Role"]
 
local role_localized = lang_module.get_string(role_key, nil, 'en')
    local views = build_views()
local playstyle_key = hero_data["Playstyle"]
    local entry = views[ability_key]
local playstyle_localized = lang_module.get_string(playstyle_key, nil, 'en')
    local view  = entry and entry.view
 
local str = "<b>" .. role_localized .. '</b><br>' .. playstyle_localized
    if not view then
local template_args = {}
        view = mw.loadJsonData(GameData.Dataset.ABILITIES)[ability_key]
template_args[1] = ""
        if not view then return false end
template_args[2] = str
    end
return frame:expandTemplate{title = 'Quotation', args = template_args}
 
    local name = view["Name"]
    if name and excluded_set(stat)[name] then return false end
 
    ability_num = ability_num or (entry and entry.abilityNum)
    if not special_ok(stat, view, ability_num) then return false end
 
    return GameData.entity_matches(view, props)
end
end


p.write_default_items = function(frame)
-- ============================================================
local hero_key = frame.args[1] --unlocalized
-- Entry point
if (hero_key == nil) then return "No hero key provided" end
-- ============================================================
local str = ""
 
local hero = heroes_data[hero_key]
function p.render(frame)
if (hero == nil) then return "Hero not found, must be unlocalized" end
    local stat = mw.text.trim(frame.args[1] or ""):lower()
local template_title = 'PageRef'
for i, item_key in ipairs(hero["RecommendedItems"] or {}) do
local template_args = {}
template_args[1] = lang_module.get_string(item_key, 'en')
template_args['alt_name'] = localize(item_key, item_key)
local expanded_template = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
str = str .. "* " .. expanded_template .. "\n"
end
return str
end


--If the hero scales with the stat, it returns {{Ss|value}} or {{Ls|value}}, else blank string
    local internal_keys = Lists.lists[stat]
--{{#invoke:HeroData|get_hero_scalar|HERO_NAME|SCALING_TYPE|STAT_NAME|sig_figs_or_localize}}--
    if not internal_keys then
p.get_hero_scalar = function(frame)
        return '<span class="error">AbilityTable: unknown list "' .. stat .. '".</span>'
local hero_key = frame.args[1]
    end
local scaling_type = frame.args[2]
local hero_stat_key = frame.args[3]
local sig_figs_or_localize = frame.args[4]
local no_template = frame.args["no_template"]
local hero_data = hero_by_key_or_name(hero_key)
if(hero_data == nil) then return "Hero not found." end
local scaling_value = raw_scaling(hero_data, scaling_type, hero_stat_key)
if scaling_value == nil then return "" end


--round
    local hide_set = {}
if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
    local hide_param = mw.text.trim(frame.args["hide"] or "")
scaling_value = util_module.round_to_sig_fig(scaling_value, sig_figs_or_localize)
    if hide_param ~= "" then
if (scaling_value == nil) then return "get_hero_scalar() error with rounding" end
        for col in hide_param:gmatch("[^,]+") do hide_set[mw.text.trim(col)] = true end
end
    end
--localize
if (sig_figs_or_localize == "true") then
return lang_module.get_string(scaling_value)
end
if no_template == "true" then
return scaling_value
end
return p.write_scalar_str(scaling_value, scaling_type)
end


-- Check if a hero has a stat (Base, Boons, or Spirit Scaling)
    local compact = mw.text.trim(frame.args["compact"] or "") ~= ""
-- Returns "true" if found, nil if not (for #if templates)
p.hero_has_stat = function(frame)
local hero_key = frame.args[1]
local stat_key = frame.args[2]
if (hero_key == nil) then return nil end
local hero_data = hero_by_key_or_name(hero_key)
if (hero_data == nil) then return nil end
if p.has_stat(hero_data, stat_key) then return "true" end
return nil
end


-- Function to call hero tags based on name
    local collapsed = mw.text.trim(frame.args["collapsed"] or ""):lower()
p.get_hero_tag = function (frame)
local name = frame.args[1]
local number = tonumber(frame.args[2])


-- Validate input
    local views, order = build_views()
if not name then
    local spec      = extra_columns[stat]
return "Error: Missing name input."
    local headers    = spec and spec.headers or {}
end
    local get_cells  = spec and spec.get_cells or function() return {} end
    local stat_notes = Notes[stat]


if number ~= 1 and number ~= 2 and number ~= 3 then
    local filtered = {}
return string.format("Error: Invalid number '%s'. Must be 1, 2, or 3.", tostring(frame.args[2]))
    for _, key in ipairs(order) do
end
        if p.is_member(stat, key) then
            table.insert(filtered, key)
        end
    end


if TAG_NAME_MAP[name] == nil then
    if #filtered == 0 then
return string.format("Error: Unknown name '%s'.", name)
        return "No abilities found for list: " .. stat
end
    end


return p.hero_tag(name, number)
    local lists_url = mw.uri.fullUrl("Module:AbilityTable/Lists")
end
    local notes_url = mw.uri.fullUrl("Module:AbilityTable/Notes", { action = "edit" })
    local disclaimer = frame:preprocess(
        '<div class="ability-table-disclaimer">'
        .. 'This is a dynamic list '
        .. '<span class="ability-table-list-name">"' .. stat .. '"</span>. '
        .. '[' .. tostring(lists_url) .. ' Edit contents]'
        .. ' · '
        .. '[' .. tostring(notes_url) .. ' Edit notes].'
        .. '</div>'
    )


--{{#invoke:HeroData|has_tags|HERO_ENGLISH_NAME}}--
    if compact then
-- 'true' when the hero has roster tags, '' otherwise.
        local hero_order    = {}
function p.has_tags(frame)
        local hero_abilities = {}
if p.hero_tag(frame.args[1], 1) ~= '' then return 'true' end
        for _, key in ipairs(filtered) do
return ''
            local hero = views[key].heroName
end
            if not hero_abilities[hero] then
                table.insert(hero_order, hero)
                hero_abilities[hero] = {}
            end
            table.insert(hero_abilities[hero], views[key])
        end


-- Retrieve scaling string of a hero's given stat, if it has scaling, else return blank
        local items = {}
-- Scaling string meaning the expanded template {{Ss|scalar}} or {{Ls|scalar}}
        for _, hero in ipairs(hero_order) do
function p.write_scalar_str(scaling_value, scaling_type, compact)
            local hero_cell = frame:expandTemplate{ title = "HeroIcon", args = { hero } }
local scaling_abbrevs = {Spirit = "Ss", Level = "PI"}
            local ability_parts = {}
            for _, entry in ipairs(hero_abilities[hero]) do
-- Return blank if it doesnt scale
                local ability = entry.view
if (scaling_value == 0) then return "" end
                local name = ability["Name"]
                local ability_cell = frame:expandTemplate{ title = "AbilityIcon", args = { name } }
-- Round it
scaling_value = util_module.round_to_sig_fig(scaling_value, 3)
--The hero has a scaling value with this stat
local template_title = "Template:" .. scaling_abbrevs[scaling_type]
local template_args = {}
template_args["1"] = scaling_value
if compact then
template_args["compact"] = "yes"
template_args["show_value"] = "yes"
end
local template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
   
return template_call:gsub("\n", ""):gsub("\r", "")
end


-- Outputs a wikitable of heroes grouped by GroundDashDuration using {{HeroIcon|hero_name}}
                local extra = get_cells(ability, entry.cardprops)
-- {{#invoke:HeroData|write_ground_dash_buckets}}
                enrich_notes_compact(extra, stat_notes and stat_notes[name])
p.write_ground_dash_buckets = function(frame)
    local buckets = {
        [0.62] = {},
        [0.68] = {},
        [0.72] = {},
    }


    -- Collect heroes
                local note = extra["Notes"]
    for hero_key, hero_data in pairs(heroes_data) do
                if note then
        if not hero_data.InDevelopment and not hero_data.IsDisabled then
                    table.insert(ability_parts, ability_cell .. " (" .. note .. ")")
            local dash = p.get_stat(hero_data, "GroundDashDuration")
                else
            if dash and buckets[dash] then
                    table.insert(ability_parts, ability_cell)
                table.insert(buckets[dash], hero_data.Name or hero_key)
                end
             end
             end
            table.insert(items, "<li>" .. hero_cell .. ": " .. table.concat(ability_parts, ", ") .. "</li>")
        end
        return disclaimer .. "<ul>" .. table.concat(items) .. "</ul>"
    end
    local has_notes_header = false
    local final_headers = {}
    for _, h in ipairs(headers) do
        if h == "Notes" then
            has_notes_header = true
        elseif not hide_set[h] then
            table.insert(final_headers, h)
         end
         end
     end
     end
    local needs_notes = (has_notes_header or stat_notes ~= nil) and not hide_set["Notes"]
    if needs_notes then table.insert(final_headers, "Notes") end


     -- Sort alphabetically
     local table_class = 'wikitable sortable ability-table'
     for _, list in pairs(buckets) do
     if collapsed ~= "" then
         table.sort(list)
         table_class = table_class .. ' mw-collapsible'
        if collapsed == "yes" or collapsed == "true" or collapsed == "1" then
            table_class = table_class .. ' mw-collapsed'
        end
     end
     end


     -- Determine max rows dynamically
     local out = {}
    local max_rows = 0
    table.insert(out, disclaimer)
     for _, list in pairs(buckets) do
    table.insert(out, '{| class="' .. table_class .. '"')
         if #list > max_rows then max_rows = #list end
 
    local header_row = '! class="ability-table-col-hero" | Hero'
                    .. ' !! class="ability-table-col-ability" | Ability'
     for _, h in ipairs(final_headers) do
         header_row = header_row .. ' !! class="ability-table-col-'
            .. h:lower():gsub("%s+", "-") .. '" | ' .. h
     end
     end
    table.insert(out, header_row)
        local hero_counts = {}
    for _, key in ipairs(filtered) do
        local hero = views[key].heroName
        hero_counts[hero] = (hero_counts[hero] or 0) + 1
    end
    local hero_seen = {}
    for _, key in ipairs(filtered) do
        local entry  = views[key]
        local ability = entry.view
        local hero    = entry.heroName
        local ability_cell = frame:expandTemplate{
            title = "AbilityIcon",
            args = { ability["Name"] }
        }
        local extra = get_cells(ability, entry.cardprops)
        enrich_notes_full(extra, stat_notes and stat_notes[ability["Name"]])
        local row
        if not hero_seen[hero] then
            local hero_cell = frame:expandTemplate{
                title = "HeroIcon",
                args = { hero }
            }
            if hero_counts[hero] > 1 then
                row = '| rowspan="' .. hero_counts[hero] .. '" class="ability-table-cell-hero" | '
                    .. hero_cell
                    .. ' || class="ability-table-cell-ability" | ' .. ability_cell
            else
                row = '| class="ability-table-cell-hero" | '
                    .. hero_cell
                    .. ' || class="ability-table-cell-ability" | ' .. ability_cell
            end


    local output = {"{| class='wikitable mw-collapsible'",
            hero_seen[hero] = true
    "|+Hero Dash Buckets", "! Bucket 1 !! Bucket 2 !! Bucket 3"}
        else
    local current_frame = frame or mw.getCurrentFrame()
            row = '| class="ability-table-cell-ability" | ' .. ability_cell
        end


    for i = 1, max_rows do
         for _, header in ipairs(final_headers) do
        local row = {}
             local value = extra[header]
         for _, bucket in ipairs({0.62, 0.68, 0.72}) do
             local cls  = "ability-table-cell-" .. header:lower():gsub("%s+", "-")
             local hero_name = buckets[bucket][i]
            local content = value ~= nil and tostring(value) or "—"
             table.insert(row, hero_name and current_frame:expandTemplate{title = "HeroIcon", args = {hero_name}} or "")
            row = row .. ' || class="' .. cls .. '" | ' .. content
         end
         end
         table.insert(output, "|-\n| " .. table.concat(row, " || "))
 
         table.insert(out, "|-")
        table.insert(out, row)
     end
     end


     table.insert(output, "|}")
     table.insert(out, "|}")
     return table.concat(output, "\n")
     return table.concat(out, "\n")
end
end
-- TEST ONLY: plain-text dump of a list for review, one line per ability.
function p.dump(frame)
    local stat = mw.text.trim(frame.args[1] or ""):lower()
    local views, order = build_views()
    local spec = extra_columns[stat]
    local get_cells = spec and spec.get_cells or function() return {} end
    local out = {}
    for _, key in ipairs(order) do
        if p.is_member(stat, key) then
            local entry = views[key]
            local extra = get_cells(entry.view, entry.cardprops)
            local cell = extra["Spirit Scaling"] or "—"
            cell = mw.text.killMarkers(cell):gsub("<br>", " / "):gsub("<[^>]+>", "")
            table.insert(out, entry.heroName .. " | " .. entry.view["Name"] .. " | " .. cell .. " | " .. (extra["Notes"] or "—"))
        end
    end
    return "<pre>" .. mw.text.nowiki(table.concat(out, "\n")) .. "</pre>"
end
return p
Retrieved from "https://deadlock.wiki/Module:Sandbox/Vergir"