The Deadlock Wiki - User contributions [en]

Module:AbilityTable

2026-07-11T22:52:49Z

~2026-RegenSilencerGrey623: Extract list membership into public p.is_member() as the shared source of truth (exclusions + special rules); filter_abilities now delegates to it. Behavior-identical for tables (with help from vergir-bot LLM)

-- Renders sortable wikitables of abilities filtered by a named stat.

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

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 = {
["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,
},
["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,
},
}

-- ============================================================
-- 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

-- Merges auto-generated and human notes for compact mode.
-- Decapitalizes human note (skips T{N} prefixes like "T1 slow"),
-- joins with "; ", strips trailing period.
local function enrich_notes_compact(extra, human_note)
if human_note then
local first = human_note:sub(1,1)
if first:match("%u") and not human_note:sub(2,2):match("%d") then
human_note = first:lower() .. human_note:sub(2)
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

-- ============================================================
-- Membership
-- Shared source of truth for "is ability X a member of list Y".
-- Also consumed by Module:AbilityInteractions to decide which
-- interaction icons to show on ability cards.
-- ============================================================

-- 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 an ability record belong to list `stat`?
-- record an entry from Data:AbilityData.json
-- ability_num the ability's slot (1-4), used by special rules
function p.is_member(stat, record, ability_num)
local props = Lists.lists[stat]
if not props then return false end
local name = record["Name"]
if name and excluded_set(stat)[name] then return false end
if not special_ok(stat, record, ability_num) then return false end
return GameData.entity_matches(record, props)
end

-- ============================================================
-- Filtering
-- ============================================================

local function filter_abilities(stat, abilities, key_lookup)
local result = {}
for _, ability in ipairs(abilities) do
local info = ability["Key"] and key_lookup[ability["Key"]]
if info and p.is_member(stat, ability, info.abilityNum) then
table.insert(result, ability)
end
end
return result
end

-- ============================================================
-- Hero lookup
-- ============================================================

local _key_lookup = nil
local _name_to_key = nil

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

local hero_data = mw.loadJsonData("Data:HeroData.json")
local active_heroes = {}
for _, hero in pairs(hero_data) do
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 cards = mw.loadJsonData("Data:AbilityCards.json")
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)
if slot_num and type(ability) == "table" then
local info = { heroName = hero_name, abilityNum = slot_num }
if ability["Key"] then
_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
end

return _key_lookup, _name_to_key
end

-- ============================================================
-- Entry point
-- ============================================================

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

local internal_keys = Lists.lists[stat]
if not internal_keys then
return 'AbilityTable: unknown list "' .. stat .. '".'
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

local compact = mw.text.trim(frame.args["compact"] or "") ~= ""

local collapsed = mw.text.trim(frame.args["collapsed"] or ""):lower()

local key_lookup, _ = build_lookup()
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]

local abilities = GameData.get_entities(GameData.Dataset.ABILITIES, internal_keys)
local filtered = filter_abilities(stat, abilities, key_lookup)

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

table.sort(filtered, function(a, b)
local ia = key_lookup[a["Key"]]
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 lists_url = mw.uri.fullUrl("Module:AbilityTable/Lists")
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 '
.. '"' .. stat .. '". '
.. '[' .. tostring(lists_url) .. ' Edit contents]'
.. ' · '
.. '[' .. tostring(notes_url) .. ' Edit notes].'
.. '</div>'
)

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

local items = {}
for _, hero in ipairs(hero_order) do
local hero_cell = frame:expandTemplate{ title = "HeroIcon", args = { hero } }
local ability_parts = {}
for _, ability in ipairs(hero_abilities[hero]) do
local name = ability["Name"]
local ability_cell = frame:expandTemplate{ title = "AbilityIcon", args = { name } }

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
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
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

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 = {}
table.insert(out, disclaimer)
table.insert(out, '{| class="' .. table_class .. '"')

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)

for _, ability in ipairs(filtered) do
local info = key_lookup[ability["Key"]]

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

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

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

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

table.insert(out, "|}")
return table.concat(out, "\n")
end

return p

Module:GameData

2026-07-11T22:49:05Z

~2026-RegenSilencerGrey623: Add public entity_matches() and refactor get_entities to reuse it, so ability-list membership can share one matching implementation (with help from vergir-bot LLM)

-- Provides generic access to game data files

local p = {}

-- Dataset descriptors. Values are the data file paths passed to mw.loadJsonData.
-- Callers should use these constants rather than raw strings.
p.Dataset = {
ITEMS = "Data:ItemData.json",
ABILITIES = "Data:AbilityData.json",
HEROES = "Data:HeroData.json",
CONVARS = "Data:Convars.json",
}

-- Returns true if a record represents an active, usable entity.
-- Applies consistently across all datasets:
-- - IsDisabled must not be true
-- - Name must not be nil
-- - IsSelectable, if present, must not be false
local function is_active(record)
if record["IsDisabled"] == true then return false end
if record["Name"] == nil then return false end
if record["IsSelectable"] ~= nil and record["IsSelectable"] == false then return false end
return true
end

-- Recursively searches a record for a match against prop, which may be:
-- - a key name: matches if the key exists with a non-zero/non-empty value
-- - a plain value: matches if the string appears as a value anywhere in the record
-- Returns true if a match is found, false otherwise.
local function record_matches_prop(record, prop)
for k, v in pairs(record) do
-- Key match: property name exists with a meaningful value
if k == prop then
if type(v) == "table" then
if v["Value"] ~= nil then
v = v["Value"]
else
for _ in pairs(v) do return true end
return false
end
end
if v ~= nil and v ~= 0 and v ~= "" and v ~= "0" and v ~= "0m" then
return true
end
end
if type(v) == "table" and k ~= "DisabledStateMask" then
if record_matches_prop(v, prop) then return true end
elseif type(v) == "string" then
-- Value match: prop string appears as a value (e.g. Scale.Type = "melee")
if v == prop then return true end
end
end
return false
end

-- Returns true if a record matches at least one of the given properties,
-- using the same key-name-or-string-value semantics as get_entities.
-- Public so other modules (e.g. Module:AbilityTable membership) can reuse it.
function p.entity_matches(record, properties)
for _, prop in ipairs(properties) do
if record_matches_prop(record, prop) then
return true
end
end
return false
end

-- Returns all active entities from a dataset that match at least one of the
-- given properties. A property may be matched either as a key name (the
-- property exists with a non-zero value) or as a plain string value anywhere
-- in the record (e.g. "melee" matching Scale.Type = "melee").
-- @param dataset string one of the GameData.Dataset constants
-- @param properties table array of property strings
-- @return table array of matching entity records
function p.get_entities(dataset, properties)
local data = mw.loadJsonData(dataset)
local results = {}

for _, record in pairs(data) do
if is_active(record) and p.entity_matches(record, properties) then
table.insert(results, record)
end
end

return results
end

--------------------------------------------------------------------------------
-- Unified property lookup: get_prop
-- Uses ResourceLookup to route directly to the correct dataset.
-- Returns raw values for use in templates and expressions.
--------------------------------------------------------------------------------

-- Find an entity by display name or internal key.
-- Uses ResourceLookup type field to go directly to the right dataset.
-- Returns (entity_record, type_string) or (nil, nil).
local function find_entity(identifier)
local resource = mw.loadJsonData("Data:ResourceLookup.json")[identifier:lower()]
if resource then
local data
if resource.type == "ability" then
data = mw.loadJsonData(p.Dataset.ABILITIES)
elseif resource.type == "hero" then
data = mw.loadJsonData(p.Dataset.HEROES)
elseif resource.type == "item" then
data = mw.loadJsonData(p.Dataset.ITEMS)
end
if data and data[resource.key] then
return data[resource.key], resource.type
end
end

-- Fallback: try as direct internal key
local datasets = {
{ p.Dataset.ABILITIES, "ability" },
{ p.Dataset.HEROES, "hero" },
{ p.Dataset.ITEMS, "item" },
}
for _, ds in ipairs(datasets) do
local data = mw.loadJsonData(ds[1])
if data[identifier] then return data[identifier], ds[2] end
end

return nil, nil
end

-- Traverse a table using dot notation, unwrap tables with a .Value field.
-- Supports numeric indices for arrays (e.g. "Upgrades.1.WeaponDamageBonus").
local function resolve_prop(tbl, prop)
if not prop or prop == "" then return nil end
local element = tbl
for segment in string.gmatch(prop, "[^%.]+") do
if type(element) ~= "table" then return nil end
local next = element[segment]
if next == nil then
local num = tonumber(segment)
if num then next = element[num] end
end
element = next
if element == nil then return nil end
end
if type(element) == "table" then
return element.Value or ""
end
return element
end

-- Looks up a console variable in Data:Convars.json. A convar value is stored
-- either as a plain scalar (e.g. "adsp_alley_min": 122) or as a table holding
-- the value plus a description (e.g. { value = 75, description = "..." }), in
-- which case only the value is returned. The exact key is tried first, then a
-- lower-case form. Returns (value, found).
local function lookup_convar(key)
local data = mw.loadJsonData(p.Dataset.CONVARS)
local entry = data[key]
if entry == nil then
entry = data[mw.ustring.lower(key)]
end
if entry == nil then
return nil, false
end
if type(entry) == "table" then
return entry.value, true
end
return entry, true
end

-- {{#invoke:GameData|get_prop|...}}
-- Two modes:
-- Entity: {{#invoke:GameData|get_prop|ENTITY_NAME|PROPERTY}}
-- Finds entity via ResourceLookup, returns the raw value (no
-- formatting). Supports dot notation for nested properties
-- (e.g. "Scale.Value"); tables with a .Value field are unwrapped.
-- Convar: {{#invoke:GameData|get_prop|Convar|CONVAR_NAME}}
-- Looks up the convar in Data:Convars.json and returns its value,
-- unwrapping the { value, description } form when present.
function p.get_prop(frame)
local arg1 = frame.args[1]
local arg2 = frame.args[2]
if not arg1 then return "" end

-- Convar mode: first argument is the literal keyword "Convar".
if mw.ustring.lower(arg1) == "convar" then
if not arg2 or arg2 == "" then return "" end
local value, found = lookup_convar(arg2)
if not found then
return 'Convar not found: ' .. arg2 .. ''
end
if value == nil then return "" end
return value
end

-- Entity mode: search abilities, heroes, and items.
local name = arg1
local prop = arg2
if not prop then return "" end

local entity, etype = find_entity(name)
if not entity then
return 'Entity not found: ' .. name .. ''
end

local result = resolve_prop(entity, prop)
if result ~= nil then return result end

return 'Prop not found: ' .. name .. '/' .. prop .. ''
end

return p