The Deadlock Wiki

Module:AbilityTable: Difference between revisions

Browse history interactively
← Older edit

Monster Domosed (talk | contribs)

2 user groups
4,572 edits
undo
Vergir (talk | contribs)
Contributors, Interface administrators
1,624 edits
Merge analyze_charges into charges_cells; move human notes to framework level with extensible table; Notes column auto-injected when notes exist (with help from vergir-bot LLM)
grouped repeated hero cells with rowspan
 
(97 intermediate revisions by 9 users not shown)
Line 1: Line 1:
-- Module:AbilityTables
-- Renders sortable wikitables of abilities filtered by a named stat.
-- Renders sortable wikitables of abilities filtered by a named stat.
-- Backing module for Template:AbilityTable.
 
--
local Lists    = require("Module:AbilityTable/Lists")
-- Usage on wiki pages: {{AbilityTable|charges}}
local Notes    = require("Module:AbilityTable/Notes")
--
local Renderers = require("Module:AbilityTable/ComplexRenderers")
-- ============================================================
local GameData  = require("Module:GameData")
-- ADDING A NEW STAT
-- ============================================================
-- 1. Add an entry to stat_to_props mapping the friendly name
--    (lowercase) to the internal AbilityData property keys that
--    determine whether an ability appears in the table.
--
-- 2. Optionally add a matching entry to extra_columns to show
--    additional data columns beyond Hero and Ability.
--    Copy the "charges" block as a template:
--      - headers:    ordered list of column header strings
--                    (do not include "Notes" — it is added automatically)
--      - get_cells:  function(ability) -> { ["Column Name"] = value }
--                    The ability is guaranteed to match the stat.
--                    Return nil or omit a key to show "—" in that cell.
--    If no extra_columns entry is added, only Hero and Ability
--    columns are shown (plus Notes if human notes exist).
--
-- 3. Optionally add entries to column_suffix to append a unit
--    string (e.g. "s", "%") after values in specific columns.
--
-- 4. Optionally add human-authored notes to human_notes:
--      human_notes["stat"]["Ability Name"] = "Note text."
--    Notes are appended as a Notes column automatically.
-- ============================================================


local p = {}
local p = {}
local GameData = require("Module:GameData")


-- Maps lowercase friendly stat names to internal AbilityData property keys.
local extra_columns = {
local stat_to_props = {
     ["barrier"] = {
     ["charges"] = { "AbilityCharges" },
        headers  = { "Barrier" },
}
        get_cells = Renderers.RenderBarrier,
 
     },
-- Maps column header names to their display unit suffix.
local column_suffix = {
     ["Time Between Charges"] = "s",
}
 
-- Human-authored notes, appended to the Notes column.
-- Keyed by stat name, then by ability display Name.
local human_notes = {
     ["charges"] = {
     ["charges"] = {
         ["Jar of Dead"] = "Charges by being near when anything dies.",
         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 = Renderers.RenderSpiritScaling,
    },
    ["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,
     },
     },
}
}


-- ============================================================
-- ============================================================
-- Shared helpers
-- Note enrichment
-- ============================================================
-- ============================================================


local function num_val(v)
-- Merges auto-generated and human notes for full-table mode.
     if type(v) == "number" then return v end
-- Capitalizes human note, joins with ". ", ensures trailing period.
     if type(v) == "table" then return v["Value"] end
local function enrich_notes_full(extra, human_note)
     return nil
     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


-- Searches Upgrades[] for a field and returns { tier = N, value = V } at its
-- Merges auto-generated and human notes for compact mode.
-- first appearance, or nil if the field is absent from all upgrade tiers.
-- Decapitalizes human note (skips T{N} prefixes like "T1 slow"),
local function find_in_upgrades(ability, field)
-- joins with "; ", strips trailing period.
     local upgrades = ability["Upgrades"]
local function enrich_notes_compact(extra, human_note)
    if type(upgrades) ~= "table" then return nil end
     if human_note then
    for i, tier in ipairs(upgrades) do
        local first = human_note:sub(1,1)
        if type(tier) == "table" and tier[field] ~= nil then
        if first:match("%u") and not human_note:sub(2,2):match("%d") then
             return { tier = i, value = num_val(tier[field]) }
             human_note = first:lower() .. human_note:sub(2)
         end
         end
        if human_note:sub(-1) == "." then human_note = human_note:sub(1, -2) end
        extra["Notes"] = extra["Notes"] and (extra["Notes"] .. "; " .. human_note) or human_note
     end
     end
    return nil
end
end


-- ============================================================
-- ============================================================
-- Per-stat cell renderers
-- Ability views
-- Each function receives a guaranteed-matching ability record
--
-- and returns { ["Column Name"] = value } for extra columns.
-- In-game Ability may containe 1 or more records in AbilityData.json
-- Human notes and the Notes column are handled by the framework.
-- Example: Vexing Bolt is 2 records (Launch Bolt + Redirect Bolt).
-- ============================================================
 
local function charges_cells(ability)
    local base_charges  = num_val(ability["AbilityCharges"])
    local base_cooldown = ability["AbilityCooldownBetweenCharge"]
    local has_base      = base_charges ~= nil and base_charges > 0
    local upgrade_info  = find_in_upgrades(ability, "AbilityCharges")
 
    local cooldown, upgrade_cooldown
    if has_base then
        if type(base_cooldown) == "number" and base_cooldown > 0 then
            cooldown = base_cooldown
        else
            local cd = find_in_upgrades(ability, "AbilityCooldownBetweenCharge")
            if cd and cd.value and cd.value > 0 then cooldown = cd.value end
        end
    else
        local cd = find_in_upgrades(ability, "AbilityCooldownBetweenCharge")
        if cd and cd.value and cd.value > 0 then upgrade_cooldown = cd.value end
    end
 
    local cells = {}
 
    if has_base then
        cells["Charges"] = tostring(base_charges)
        if cooldown then
            cells["Time Between Charges"] = tostring(cooldown)
        end
    end
 
    local note_parts = {}
    if upgrade_info then
        local n = upgrade_info.value or "?"
        local charge_str = n .. " charge" .. (n ~= 1 and "s" or "")
        if has_base then
            table.insert(note_parts, "+" .. charge_str .. " on T" .. upgrade_info.tier .. " upgrade.")
        else
            local cd_str = upgrade_cooldown and (upgrade_cooldown .. "s") or "unknown"
            table.insert(note_parts, "Becomes charged on T" .. upgrade_info.tier
                .. " upgrade with " .. charge_str
                .. " and " .. cd_str .. " time between charges.")
        end
    end
    if ability["AbilityChargesConditionally"] ~= nil then
        table.insert(note_parts, "Has a conditional charge.")
    end
    if #note_parts > 0 then
        cells["Notes"] = table.concat(note_parts, " ")
    end
 
    return cells
end
 
local extra_columns = {
    ["charges"] = {
        headers  = { "Charges", "Time Between Charges" },
        get_cells = charges_cells,
    },
}


-- ============================================================
-- "Ability View" is a main-record + any relevant sub-ability records.
-- Hero lookup (ability key -> { heroName, abilityNum })
-- ============================================================
-- ============================================================


local _hero_lookup = nil
local _views = nil   -- card key -> { view = record, heroName = ..., abilityNum = ... }
local _order = nil  -- array of card keys, sorted by hero then slot


local function build_hero_lookup()
local function build_views()
     if _hero_lookup then return _hero_lookup end
     if _views then return _views, _order end
     _hero_lookup = {}
     _views, _order = {}, {}


     local hero_data = mw.loadJsonData("Data:HeroData.json")
     local hero_data = mw.loadJsonData("Data:HeroData.json")
Line 162: Line 105:
     end
     end


     local cards = mw.loadJsonData("Data:AbilityCards.json")
    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
     for _, hero_entry in pairs(cards) do
         if type(hero_entry) == "table" then
         if type(hero_entry) == "table" then
Line 169: Line 115:
                 for slot_str, ability in pairs(hero_entry) do
                 for slot_str, ability in pairs(hero_entry) do
                     local slot_num = tonumber(slot_str)
                     local slot_num = tonumber(slot_str)
                     if slot_num and type(ability) == "table" and ability["Key"] then
                     local key = type(ability) == "table" and ability["Key"] or nil
                         _hero_lookup[ability["Key"]] = {
                    if slot_num and key and ability_data[key] then
                            heroName   = hero_name,
                         card_of[key] = { heroName = hero_name, abilityNum = slot_num }
                            abilityNum = slot_num,
                        }
                     end
                     end
                 end
                 end
Line 180: Line 124:
     end
     end


     return _hero_lookup
     -- Attach each non-card record to the longest card key it prefixes.
    local subs = {}
    for key, record in pairs(ability_data) do
        if not card_of[key] and record["IsDisabled"] ~= true then
            local parent = nil
            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
 
    for key, info in pairs(card_of) do
        local view = {}
        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 }
        table.insert(_order, key)
    end
 
    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
 
-- ============================================================
-- Membership
-- Pieces of code that help in telling  "is ability X a member of list Y".
-- main function is: p.is_member()
-- ============================================================
 
-- Memoized name-exclusion set per list (from Lists.exclude_abilities).
local _excluded = {}
local function excluded_set(stat)
    if _excluded[stat] then return _excluded[stat] end
    local set = {}
    for _, name in ipairs(Lists.exclude_abilities[stat] or {}) do
        set[name] = true
    end
    _excluded[stat] = set
    return set
end
 
-- Per-list rules that can't be expressed as prop lists or exclusions.
-- Returns true to keep the ability, false to drop it.
local function special_ok(stat, record, ability_num)
    if stat == "dispelmagic" and ability_num == 4 then return false end
    return true
end
 
-- Public: does ability `ability_key` belong to list `stat`?
function p.is_member(stat, ability_key, ability_num)
    local props = Lists.lists[stat]
    if not props then return false end
 
    local views = build_views()
    local entry = views[ability_key]
    local view  = entry and entry.view
 
    if not view then
        view = mw.loadJsonData(GameData.Dataset.ABILITIES)[ability_key]
        if not view then return false end
    end
 
    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


Line 187: Line 212:
-- ============================================================
-- ============================================================


function p.abilityPropTable(frame)
function p.render(frame)
     local stat = mw.text.trim(frame.args[1] or ""):lower()
     local stat = mw.text.trim(frame.args[1] or ""):lower()


     local internal_keys = stat_to_props[stat]
     local internal_keys = Lists.lists[stat]
     if not internal_keys then
     if not internal_keys then
         return '<span class="error">AbilityTable: unknown stat "' .. stat .. '".</span>'
         return '<span class="error">AbilityTable: unknown list "' .. stat .. '".</span>'
    end
 
    local hide_set = {}
    local hide_param = mw.text.trim(frame.args["hide"] or "")
    if hide_param ~= "" then
        for col in hide_param:gmatch("[^,]+") do hide_set[mw.text.trim(col)] = true end
     end
     end


     local lookup      = build_hero_lookup()
     local compact = mw.text.trim(frame.args["compact"] or "") ~= ""
    local spec        = extra_columns[stat]
    local headers    = spec and spec.headers or {}
    local get_cells  = spec and spec.get_cells or function() return {} end
    local stat_notes  = human_notes[stat]


     local abilities = GameData.get_entities(GameData.Dataset.ABILITIES, internal_keys)
     local collapsed = mw.text.trim(frame.args["collapsed"] or ""):lower()
 
    local views, order = build_views()
    local spec      = extra_columns[stat]
    local headers    = spec and spec.headers or {}
    local get_cells  = spec and spec.get_cells or function() return {} end
    local stat_notes = Notes[stat]


    -- Keep only abilities belonging to active, released heroes
     local filtered = {}
     local filtered = {}
     for _, ability in ipairs(abilities) do
     for _, key in ipairs(order) do
        local key = ability["Key"]
         if p.is_member(stat, key) then
         if key and lookup[key] then
             table.insert(filtered, key)
             table.insert(filtered, ability)
         end
         end
     end
     end


     if #filtered == 0 then
     if #filtered == 0 then
         return "No abilities found for stat: " .. stat
         return "No abilities found for list: " .. stat
     end
     end


     -- Sort by hero name, then ability slot number
     local lists_url = mw.uri.fullUrl("Module:AbilityTable/Lists")
     table.sort(filtered, function(a, b)
     local notes_url = mw.uri.fullUrl("Module:AbilityTable/Notes", { action = "edit" })
         local ia = lookup[a["Key"]]
    local disclaimer = frame:preprocess(
         local ib = lookup[b["Key"]]
         '<div class="ability-table-disclaimer">'
         if ia.heroName ~= ib.heroName then
        .. 'This is a dynamic list '
             return ia.heroName < ib.heroName
         .. '<span class="ability-table-list-name">"' .. stat .. '"</span>. '
        .. '[' .. tostring(lists_url) .. ' Edit contents]'
        .. ' · '
        .. '[' .. tostring(notes_url) .. ' Edit notes].'
         .. '</div>'
    )
 
    if compact then
        local hero_order    = {}
        local hero_abilities = {}
        for _, key in ipairs(filtered) do
            local hero = views[key].heroName
            if not hero_abilities[hero] then
                table.insert(hero_order, hero)
                hero_abilities[hero] = {}
             end
            table.insert(hero_abilities[hero], views[key].view)
         end
         end
        return ia.abilityNum < ib.abilityNum
    end)


    -- Determine whether a Notes column is needed:
        local items = {}
    -- either the stat renderer produces notes, or human notes exist for this stat.
        for _, hero in ipairs(hero_order) do
    local needs_notes = stat_notes ~= nil
            local hero_cell = frame:expandTemplate{ title = "HeroIcon", args = { hero } }
    if not needs_notes then
            local ability_parts = {}
        for _, ability in ipairs(filtered) do
            for _, ability in ipairs(hero_abilities[hero]) do
            local extra = get_cells(ability)
                local name = ability["Name"]
            if extra["Notes"] then
                local ability_cell = frame:expandTemplate{ title = "AbilityIcon", args = { name } }
                 needs_notes = true
 
                 break
                local extra = get_cells(ability)
                enrich_notes_compact(extra, stat_notes and stat_notes[name])
 
                local note = extra["Notes"]
                if note then
                    table.insert(ability_parts, ability_cell .. " (" .. note .. ")")
                 else
                    table.insert(ability_parts, ability_cell)
                 end
             end
             end
            table.insert(items, "<li>" .. hero_cell .. ": " .. table.concat(ability_parts, ", ") .. "</li>")
         end
         end
        return disclaimer .. "<ul>" .. table.concat(items) .. "</ul>"
     end
     end


     -- Build final header list: declared headers + Notes if needed
     local has_notes_header = false
     local final_headers = {}
     local final_headers = {}
     for _, h in ipairs(headers) do table.insert(final_headers, h) end
     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
    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
     if needs_notes then table.insert(final_headers, "Notes") end


     -- Render wikitable
     local table_class = 'wikitable sortable ability-table'
    if collapsed ~= "" then
        table_class = table_class .. ' mw-collapsible'
        if collapsed == "yes" or collapsed == "true" or collapsed == "1" then
            table_class = table_class .. ' mw-collapsed'
        end
    end
 
     local out = {}
     local out = {}
     local header_row = "! Hero !! Ability"
    table.insert(out, disclaimer)
     if #final_headers > 0 then
    table.insert(out, '{| class="' .. table_class .. '"')
         header_row = header_row .. " !! " .. table.concat(final_headers, " !! ")
 
     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
    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
     end


     table.insert(out, '{| class="wikitable sortable"')
     local hero_seen = {}
    table.insert(out, header_row)


     for _, ability in ipairs(filtered) do
     for _, key in ipairs(filtered) do
         local info = lookup[ability["Key"]]
         local entry  = views[key]
        local ability = entry.view
        local hero    = entry.heroName


        local hero_cell = frame:expandTemplate{
            title = "HeroIcon",
            args  = { info.heroName }
        }
         local ability_cell = frame:expandTemplate{
         local ability_cell = frame:expandTemplate{
             title = "AbilityIcon",
             title = "AbilityIcon",
             args = { ability["Name"] }
             args = { ability["Name"] }
         }
         }


         local cells  = { hero_cell, ability_cell }
         local extra = get_cells(ability)
         local extra = get_cells(ability)
         enrich_notes_full(extra, stat_notes and stat_notes[ability["Name"]])


         -- Append human note to any renderer-generated note
         local row
         if stat_notes and stat_notes[ability["Name"]] then
 
             local human = stat_notes[ability["Name"]]
         if not hero_seen[hero] then
            extra["Notes"] = extra["Notes"] and (extra["Notes"] .. " " .. human) or human
             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
 
            hero_seen[hero] = true
        else
            row = '| class="ability-table-cell-ability" | ' .. ability_cell
         end
         end


         for _, header in ipairs(final_headers) do
         for _, header in ipairs(final_headers) do
             local value = extra[header]
             local value = extra[header]
             if value ~= nil then
             local cls  = "ability-table-cell-" .. header:lower():gsub("%s+", "-")
                local suffix = column_suffix[header] or ""
             local content = value ~= nil and tostring(value) or "—"
                table.insert(cells, value .. suffix)
             row = row .. ' || class="' .. cls .. '" | ' .. content
             else
                table.insert(cells, "—")
             end
         end
         end


         table.insert(out, "|-")
         table.insert(out, "|-")
         table.insert(out, "| " .. table.concat(cells, " || "))
         table.insert(out, row)
     end
     end


Retrieved from "https://deadlock.wiki/Module:AbilityTable"