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
refactor abilitytable to use submodules
grouped repeated hero cells with rowspan
 
(17 intermediate revisions by 5 users not shown)
Line 7: Line 7:


local p = {}
local p = {}
-- ============================================================
-- Extra columns: maps stat names to their column headers and
-- cell renderer functions from ComplexRenderers.
-- Stats not listed here get a plain Hero + Ability + Notes table.
-- ============================================================


local extra_columns = {
local extra_columns = {
    ["barrier"] = {
        headers  = { "Barrier" },
        get_cells = Renderers.RenderBarrier,
    },
     ["charges"] = {
     ["charges"] = {
         headers  = { "Charges", "Time Between Charges", "Notes" },
         headers  = { "Charges", "Time Between Charges", "Notes" },
Line 20: Line 18:
     },
     },
     ["melee"] = {
     ["melee"] = {
         headers  = { "Light Melee Scaling", "Notes" },
         headers  = { "Base Damage", "Light Melee Scaling", "Notes" },
         get_cells = Renderers.RenderMelee,
         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"] = {
     ["healreduce"] = {
         headers  = { "Heal Reduction", "Notes" },
         headers  = { "Heal Reduction", "Notes" },
         get_cells = Renderers.RenderHealReduce,
         get_cells = Renderers.RenderHealReduce,
    },
    ["debuffresist"] = {
        headers  = { "Notes" },
        get_cells = function(ability) return Renderers.RenderDebuff(ability, "debuffresist") end,
    },
    ["dispelmagic"] = {
        headers  = { "Notes" },
        get_cells = function(ability) return Renderers.RenderDebuff(ability, "dispelmagic") end,
     },
     },
     ["moveslow"] = {
     ["moveslow"] = {
Line 42: Line 40:
         headers  = { "Dash Slow", "Notes" },
         headers  = { "Dash Slow", "Notes" },
         get_cells = Renderers.RenderDashSlow,
         get_cells = Renderers.RenderDashSlow,
    },
    ["extradebuffresist"] = {
        headers  = { "Debuff Resist" },
        get_cells = Renderers.RenderExtraDebuffResist,
     },
     },
}
}


-- ============================================================
-- ============================================================
-- Human-note formatters
-- Note enrichment
-- ============================================================
-- ============================================================


-- Capitalises the first letter of a human note before merging (full-table mode).
-- Merges auto-generated and human notes for full-table mode.
local function human_note_full(note)
-- Capitalizes human note, joins with ". ", ensures trailing period.
     if not note or note == "" then return note end
local function enrich_notes_full(extra, human_note)
    return note:sub(1,1):upper() .. note:sub(2)
     if human_note then
end
        human_note = human_note:sub(1,1):upper() .. human_note:sub(2)
 
        extra["Notes"] = extra["Notes"] and (extra["Notes"] .. ". " .. human_note) or human_note
-- Ensures the final merged Notes string ends with "." (full-table mode).
     end
local function ensure_period(s)
     if extra["Notes"] and extra["Notes"]:sub(-1) ~= "." then
    if not s or s == "" then return s end
         extra["Notes"] = extra["Notes"] .. "."
    if s:sub(-1) ~= "." then s = s .. "." end
    return s
end
 
-- Compact mode: decapitalise first letter unless it looks like a tier prefix
-- (e.g. "T1", "T2"). Also strips any trailing ".".
local function human_note_compact(note)
     if not note or note == "" then return note end
    local first = note:sub(1,1)
     if first:match("%u") and not note:sub(2,2):match("%d") then
         note = first:lower() .. note:sub(2)
     end
     end
    if note:sub(-1) == "." then note = note:sub(1, -2) end
    return note
end
end


-- ============================================================
-- Merges auto-generated and human notes for compact mode.
-- Filtering
-- Decapitalizes human note (skips T{N} prefixes like "T1 slow"),
-- ============================================================
-- joins with "; ", strips trailing period.
 
local function enrich_notes_compact(extra, human_note)
local function filter_abilities(stat, abilities, key_lookup)
     if human_note then
     local excluded = {}
        local first = human_note:sub(1,1)
    if Lists.exclude_abilities[stat] then
        if first:match("%u") and not human_note:sub(2,2):match("%d") then
        for _, name in ipairs(Lists.exclude_abilities[stat]) do
             human_note = first:lower() .. human_note:sub(2)
             excluded[name] = true
         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
    local result = {}
    for _, ability in ipairs(abilities) do
        local key  = ability["Key"]
        local info = key and key_lookup[key]
        if info and not excluded[ability["Name"]] then
            local skip = false
            if stat == "dispelmagic" and info.abilityNum == 4 then
                skip = true
            end
            if not skip then
                table.insert(result, ability)
            end
        end
    end
    return result
end
end


-- ============================================================
-- ============================================================
-- Hero lookup
-- Ability views
--
-- In-game Ability may containe 1 or more records in AbilityData.json
-- Example: Vexing Bolt is 2 records (Launch Bolt + Redirect Bolt).
 
-- "Ability View" is a main-record + any relevant sub-ability records.
-- ============================================================
-- ============================================================


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


local function build_lookup()
local function build_views()
     if _key_lookup then return _key_lookup, _name_to_key end
     if _views then return _views, _order end
     _key_lookup  = {}
     _views, _order = {}, {}
    _name_to_key = {}


     local hero_data = mw.loadJsonData("Data:HeroData.json")
     local hero_data = mw.loadJsonData("Data:HeroData.json")
Line 127: 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 134: 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" then
                     local key = type(ability) == "table" and ability["Key"] or nil
                        local info = { heroName = hero_name, abilityNum = slot_num }
                    if slot_num and key and ability_data[key] then
                        if ability["Key"] then
                        card_of[key] = { heroName = hero_name, abilityNum = slot_num }
                            _key_lookup[ability["Key"]] = info
                        end
                        if ability["Name"] and ability["Key"] then
                            _name_to_key[ability["Name"]] = ability["Key"]
                        end
                     end
                     end
                 end
                 end
Line 148: Line 124:
     end
     end


     return _key_lookup, _name_to_key
    -- 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 171: Line 228:
     local compact = mw.text.trim(frame.args["compact"] or "") ~= ""
     local compact = mw.text.trim(frame.args["compact"] or "") ~= ""


     local key_lookup, _ = build_lookup()
     local collapsed = mw.text.trim(frame.args["collapsed"] or ""):lower()
 
    local views, order = build_views()
     local spec      = extra_columns[stat]
     local spec      = extra_columns[stat]
     local headers    = spec and spec.headers or {}
     local headers    = spec and spec.headers or {}
Line 177: Line 236:
     local stat_notes = Notes[stat]
     local stat_notes = Notes[stat]


     local abilities = GameData.get_entities(GameData.Dataset.ABILITIES, internal_keys)
     local filtered = {}
    local filtered = filter_abilities(stat, abilities, key_lookup)
    for _, key in ipairs(order) do
        if p.is_member(stat, key) then
            table.insert(filtered, key)
        end
    end


     if #filtered == 0 then
     if #filtered == 0 then
Line 184: Line 247:
     end
     end


     table.sort(filtered, function(a, b)
     local lists_url = mw.uri.fullUrl("Module:AbilityTable/Lists")
        local ia = key_lookup[a["Key"]]
     local notes_url = mw.uri.fullUrl("Module:AbilityTable/Notes", { action = "edit" })
        local ib = key_lookup[b["Key"]]
        if not ia and not ib then return (a["Name"] or "") < (b["Name"] or "") end
        if not ia then return false end
        if not ib then return true end
        if ia.heroName ~= ib.heroName then return ia.heroName < ib.heroName end
        return ia.abilityNum < ib.abilityNum
    end)
 
     local edit_url = mw.uri.fullUrl("Module:AbilityTable", { action = "edit" })
     local disclaimer = frame:preprocess(
     local disclaimer = frame:preprocess(
         '<div class="ability-table-disclaimer">'
         '<div class="ability-table-disclaimer">'
         .. "This is an automatic list. "
         .. 'This is a dynamic list '
         .. "[" .. tostring(edit_url) .. " Click here]"
        .. '<span class="ability-table-list-name">"' .. stat .. '"</span>. '
         .. " to add notes or correct the contents."
         .. '[' .. tostring(lists_url) .. ' Edit contents]'
         .. "</div>"
        .. ' · '
         .. '[' .. tostring(notes_url) .. ' Edit notes].'
         .. '</div>'
     )
     )


Line 206: Line 262:
         local hero_order    = {}
         local hero_order    = {}
         local hero_abilities = {}
         local hero_abilities = {}
         for _, ability in ipairs(filtered) do
         for _, key in ipairs(filtered) do
             local info = key_lookup[ability["Key"]]
             local hero = views[key].heroName
            local hero = info and info.heroName or "—"
             if not hero_abilities[hero] then
             if not hero_abilities[hero] then
                 table.insert(hero_order, hero)
                 table.insert(hero_order, hero)
                 hero_abilities[hero] = {}
                 hero_abilities[hero] = {}
             end
             end
             table.insert(hero_abilities[hero], ability)
             table.insert(hero_abilities[hero], views[key].view)
         end
         end


Line 225: Line 280:


                 local extra = get_cells(ability)
                 local extra = get_cells(ability)
                 if stat_notes and stat_notes[name] then
                 enrich_notes_compact(extra, stat_notes and stat_notes[name])
                    local human = human_note_compact(stat_notes[name])
                    extra["Notes"] = extra["Notes"] and (extra["Notes"] .. "; " .. human) or human
                end


                 local note = extra["Notes"]
                 local note = extra["Notes"]
Line 254: Line 306:
     local needs_notes = (has_notes_header or stat_notes ~= nil) and not hide_set["Notes"]
     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
    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 = {}
     table.insert(out, disclaimer)
     table.insert(out, disclaimer)
     table.insert(out, '{| class="wikitable sortable ability-table"')
     table.insert(out, '{| class="' .. table_class .. '"')


     local header_row = '! class="ability-table-col-hero" | Hero'
     local header_row = '! class="ability-table-col-hero" | Hero'
Line 267: Line 327:
     table.insert(out, header_row)
     table.insert(out, header_row)


     for _, ability in ipairs(filtered) do
        local hero_counts = {}
         local info = key_lookup[ability["Key"]]
     for _, key in ipairs(filtered) do
         local hero = views[key].heroName
        hero_counts[hero] = (hero_counts[hero] or 0) + 1
    end
 
    local hero_seen = {}


         local hero_cell
    for _, key in ipairs(filtered) do
         if info then
         local entry  = views[key]
            hero_cell = frame:expandTemplate{ title = "HeroIcon", args = { info.heroName } }
         local ability = entry.view
         else
         local hero    = entry.heroName
            hero_cell = "—"
 
        end
         local ability_cell = frame:expandTemplate{
         local ability_cell = frame:expandTemplate{ title = "AbilityIcon", args = { ability["Name"] } }
            title = "AbilityIcon",
            args = { ability["Name"] }
        }


         local extra = get_cells(ability)
         local extra = get_cells(ability)
        enrich_notes_full(extra, stat_notes and stat_notes[ability["Name"]])


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


        local row = '| class="ability-table-cell-hero" | '    .. hero_cell
                .. ' || class="ability-table-cell-ability" | ' .. ability_cell
         for _, header in ipairs(final_headers) do
         for _, header in ipairs(final_headers) do
             local value = extra[header]
             local value = extra[header]
Retrieved from "https://deadlock.wiki/Module:AbilityTable"