@@ Line 1: / Line 1: @@
--- Provides generic access to game data files
+-- 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 = {}
--- Dataset descriptors. Values are the data file paths passed to mw.loadJsonData.
+-- ============================================================
--- Callers should use these constants rather than raw strings.
+-- TEST COPY of Module:AbilityTable with the proposed
-p.Dataset = {
+-- Module:AbilityTable/ComplexRenderers.RenderSpiritScaling inlined below,
-     ITEMS     = "Data:ItemData.json",
+-- so the whole change can be previewed from one sandbox module.
-     ABILITIES = "Data:AbilityData.json",
+-- ============================================================
-    HEROES    = "Data:HeroData.json",
-    CONVARS   = "Data:Convars.json",
+-- ============================================================
-}
+-- Spirit scaling helpers
+-- ============================================================
+-- Returns the Spirit scaling entry of a prop value, or nil. A prop's Scale is
+-- 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
+-- Collects the non-zero Spirit scalings of one record layer (the base record
+-- or one upgrade tier) as { key, value, multiply }, ordered the way the
+-- ability card lists its props; props the card does not list come last, in
+-- key order. `labels` is the view's cardprops map (see Module:AbilityTable).
+local function spirit_scalings(layer, labels)
+    local out = {}
+     for k, v in pairs(layer) do
+        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
--- Street Brawl ships a partial overlay of ability properties rather than a full
+-- Formats a scaling value to 3 significant figures, as the ability cards do.
--- dataset, so it is deliberately kept out of p.Dataset: its top-level keys are
+local function format_spirit(v)
--- sections ("ability-changes", "item-buckets"), not entity records, and it is
+    return string.format("%.3g", v)
--- not usable with get_entities. Only get_prop consults it.
+end
-local STREET_BRAWL = "Data:StreetBrawlData.json"
--- Returns true if a record represents an active, usable entity.
+-- Formats one Spirit scaling for the table cell through the compact {{Ss}}
--- Applies consistently across all datasets:
+-- form, the same way RenderBarrier does. The template is expanded via the
---   - IsDisabled must not be true
+-- frame the surrounding #invoke runs under, since module return values are
---   - Name must not be nil
+-- not re-expanded; the plain "×N" fallback covers a nil frame (module
---   - IsSelectable, if present, must not be false
+-- console).
+local function format_spirit_badge(v)
+    local text  = format_spirit(v)
+    local frame = mw.getCurrentFrame()
+    if frame then
+        return frame:expandTemplate{
+            title = "Ss",
+            args  = { text, compact = "1", show_value = "1" },
+        }
+    end
+    return "×" .. text
+end
--- Specifically for hero abilities, some of them are split into two entities, eg. Vexing Bolt has a sub-ability: Redirect Bolt.
+-- "A", "A and B", "A, B and C".
--- The secondary sub-abilities most often have nil name and get filtered out by this function
+local function join_names(names)
-local function is_active(record)
+     if #names <= 1 then return names[1] or "" end
-     if record["IsDisabled"] == true then return false end
+     return table.concat(names, ", ", 1, #names - 1) .. " and " .. names[#names]
-    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:
+-- Renders Spirit Power scaling.
---   - a key name: matches if the key exists with a non-zero/non-empty value
+-- Lists every prop that scales with Spirit at base, one per line as an {{Ss}}
---   - a plain value: matches if the string appears as a value anywhere in the record
+-- badge labelled with the prop's name from the ability card:
--- Returns true if a match is found, false otherwise.
+-- "x0.55 (Base Damage)". Two
-local function record_matches_prop(record, prop)
+-- props sharing a name are told apart by the card's Title
-     for k, v in pairs(record) do
+-- ("Damage: Cost of Stay"); props the card does not list show their raw key.
-         -- Key match: property name exists with a meaningful value
+-- Upgrades are reported in Notes per prop, with the running total: additive
-        if k == prop then
+-- ones as "adds +×0.5 ... (total ×1.05)", ones that unlock scaling on a prop
-             if type(v) == "table" then
+-- as "grants ×1.3 ...", and Multiply upgrades as "multiplies ... by 1.15",
-                 if v["Value"] ~= nil then
+-- which is how the ability-upgrade gadget applies them.
-                     v = v["Value"]
+function p.RenderSpiritScaling(ability, cardprops)
+    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
-                     for _ in pairs(v) do return true end
+                     table.insert(group.totals, "?")
-                    return false
                  end
-             end
+             elseif current then
-            if v ~= nil and v ~= 0 and v ~= "" and v ~= "0" and v ~= "0m" then
+                running[up.key] = current + up.value
-                return true
+                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
-         if type(v) == "table" and k ~= "DisabledStateMask" then
+         for _, m in ipairs(group_order) do
-            if record_matches_prop(v, prop) then return true end
+            local group = groups[m]
-        elseif type(v) == "string" then
+            table.insert(notes, "T" .. i .. " upgrade multiplies " .. join_names(group.labels)
-            -- Value match: prop string appears as a value (e.g. Scale.Type = "melee")
+                .. " scaling by " .. format_spirit(m)
-            if v == prop then return true end
+                .. " (total " .. table.concat(group.totals, ", ") .. ")")
          end
      end
-     return false
+    if #notes > 0 then cells["Notes"] = table.concat(notes, ". ") end
+     return cells
+end
+-- get_cells(ability, cardprops) -> { [column header] = cell text, Notes = ... }
+-- `cardprops` maps the ability's prop keys to their display labels; most
+-- renderers ignore it.
+local extra_columns = {
+    ["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
--- Returns true if a record matches at least one of the given properties,
+-- Merges auto-generated and human notes for compact mode.
--- using the same key-name-or-string-value semantics as get_entities.
+-- Decapitalizes human note (skips T{N} prefixes like "T1 slow"),
--- Public so other modules (e.g. Module:AbilityTable membership) can reuse it.
+-- joins with "; ", strips trailing period.
-function p.entity_matches(record, properties)
+local function enrich_notes_compact(extra, human_note)
-     for _, prop in ipairs(properties) do
+     if human_note then
-         if record_matches_prop(record, prop) then
+        local first = human_note:sub(1,1)
-             return true
+         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
-    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
+-- Ability views
--- property exists with a non-zero value) or as a plain string value anywhere
+--
--- in the record (e.g. "melee" matching Scale.Type = "melee").
+-- In-game Ability may containe 1 or more records in AbilityData.json
--- @param   dataset     string  one of the GameData.Dataset constants
+-- Example: Vexing Bolt is 2 records (Launch Bolt + Redirect Bolt).
--- @param   properties  table   array of property strings
--- @return              table   array of matching entity records
+-- "Ability View" is a main-record + any relevant sub-ability records.
-function p.get_entities(dataset, properties)
+-- Each view entry also carries "cardprops", the display labels of the
-    local data = mw.loadJsonData(dataset)
+-- ability's props taken from its card (see card_prop_labels). They are kept
-     local results = {}
+-- beside the record rather than inside it so that membership matching, which
+-- walks the whole record, never sees them.
+-- ============================================================
+-- Display labels for a card's props: prop key -> { name, title, order }, read
+-- from the Info sections of the card in AbilityCards.json. The flat
+-- AbilityData records carry no display names, and a key such as "Damage" is
+-- reused across abilities under different labels, so the map is built per
+-- card rather than wiki-wide. `order` is the position of the prop on the
+-- card, so renderers can list props the way the in-game card does.
+local function card_prop_labels(card)
+     local labels, n = {}, 0
-     for _, record in pairs(data) do
+     local function walk(node)
-        if is_active(record) and p.entity_matches(record, properties) then
+        if type(node) ~= "table" then return end
-             table.insert(results, record)
+        local key, name = node["Key"], node["Name"]
+        if type(key) == "string" and type(name) == "string" and not labels[key] then
+            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
+    for _, section in ipairs({ "Info1", "Info2", "Info3" }) do
+        walk(card[section])
+    end
+    local rest = {}
+    for k, v in pairs(card) do
+        if type(v) == "table" and k ~= "Upgrades"
+            and k ~= "Info1" and k ~= "Info2" and k ~= "Info3"
+        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(card[k]) end
-     return results
+    -- 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
+     return labels
 end
---------------------------------------------------------------------------------
+local _views = nil   -- card key -> { view = record, heroName = ..., abilityNum = ..., cardprops = ... }
--- Unified property lookup: get_prop
+local _order = nil   -- array of card keys, sorted by hero then slot
--- Uses ResourceLookup to route directly to the correct dataset.
--- Returns raw values for use in templates and expressions.
+local function build_views()
---------------------------------------------------------------------------------
+    if _views then return _views, _order end
+    _views, _order = {}, {}
+    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 ability_data = mw.loadJsonData(GameData.Dataset.ABILITIES)
+    local cards        = mw.loadJsonData("Data:AbilityCards.json")
--- Find an entity by display name or internal key.
+    local card_of = {}
--- Uses ResourceLookup type field to go directly to the right dataset.
+    for _, hero_entry in pairs(cards) do
--- Returns (entity_record, type_string, internal_key) or (nil, nil, nil).
+        if type(hero_entry) == "table" then
-local function find_entity(identifier)
+            local hero_name = hero_entry["Name"]
-    local resource = mw.loadJsonData("Data:ResourceLookup.json")[identifier:lower()]
+            if hero_name and active_heroes[hero_name] then
-    if resource then
+                for slot_str, ability in pairs(hero_entry) do
-        local data
+                    local slot_num = tonumber(slot_str)
-        if resource.type == "ability" then
+                    local key = type(ability) == "table" and ability["Key"] or nil
-            data = mw.loadJsonData(p.Dataset.ABILITIES)
+                    if slot_num and key and ability_data[key] then
-        elseif resource.type == "hero" then
+                        card_of[key] = { heroName = hero_name, abilityNum = slot_num, card = ability }
-            data = mw.loadJsonData(p.Dataset.HEROES)
+                    end
-        elseif resource.type == "item" then
+                end
-             data = mw.loadJsonData(p.Dataset.ITEMS)
+             end
          end
-         if data and data[resource.key] then
+    end
-             return data[resource.key], resource.type, resource.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
-     -- Fallback: try as direct internal key
+     for key, info in pairs(card_of) do
-    local datasets = {
+        local view = {}
-         { p.Dataset.ABILITIES, "ability" },
+         for k, v in pairs(ability_data[key]) do view[k] = v end
-         { p.Dataset.HEROES,    "hero" },
+        view["_subabilities"] = subs[key]
-        { p.Dataset.ITEMS,     "item" },
+         _views[key] = {
-    }
+            view       = view,
-    for _, ds in ipairs(datasets) do
+            heroName   = info.heroName,
-         local data = mw.loadJsonData(ds[1])
+            abilityNum = info.abilityNum,
-        if data[identifier] then return data[identifier], ds[2], identifier end
+            cardprops  = card_prop_labels(info.card),
+        }
+         table.insert(_order, key)
      end
-     return nil, nil, nil
+     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
--- Traverse a table using dot notation, unwrap tables with a .Value field.
+-- ============================================================
--- Supports numeric indices for arrays (e.g. "Upgrades.1.WeaponDamageBonus").
+-- Membership
-local function resolve_prop(tbl, prop)
+-- Pieces of code that help in telling  "is ability X a member of list Y".
-     if not prop or prop == "" then return nil end
+-- main function is: p.is_member()
-     local element = tbl
+-- ============================================================
-     for segment in string.gmatch(prop, "[^%.]+") do
-         if type(element) ~= "table" then return nil end
+-- Memoized name-exclusion set per list (from Lists.exclude_abilities).
-        local next = element[segment]
+local _excluded = {}
-        if next == nil then
+local function excluded_set(stat)
-            local num = tonumber(segment)
+     if _excluded[stat] then return _excluded[stat] end
-            if num then next = element[num] end
+     local set = {}
-        end
+     for _, name in ipairs(Lists.exclude_abilities[stat] or {}) do
-        element = next
+         set[name] = true
-        if element == nil then return nil end
      end
-     if type(element) == "table" then
+     _excluded[stat] = set
-         return element.Value or ""
+    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
-     return element
+    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
--- 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
+-- Entry point
--- 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).
+function p.render(frame)
-local function lookup_convar(key)
+    local stat = mw.text.trim(frame.args[1] or ""):lower()
-     local data = mw.loadJsonData(p.Dataset.CONVARS)
-    local entry = data[key]
+    local internal_keys = Lists.lists[stat]
-     if entry == nil then
+    if not internal_keys then
-         entry = data[mw.ustring.lower(key)]
+        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
-     if entry == nil then
-         return nil, false
+    local compact = mw.text.trim(frame.args["compact"] or "") ~= ""
+    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]
+    local filtered = {}
+    for _, key in ipairs(order) do
+        if p.is_member(stat, key) then
+            table.insert(filtered, key)
+         end
      end
-     if type(entry) == "table" then
-         return entry.value, true
+     if #filtered == 0 then
+        return "No abilities found for list: " .. stat
+    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 '
+        .. '<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])
+        end
+        local items = {}
+        for _, hero in ipairs(hero_order) do
+            local hero_cell = frame:expandTemplate{ title = "HeroIcon", args = { hero } }
+            local ability_parts = {}
+            for _, entry in ipairs(hero_abilities[hero]) do
+                local ability = entry.view
+                local name = ability["Name"]
+                local ability_cell = frame:expandTemplate{ title = "AbilityIcon", args = { name } }
+                local extra = get_cells(ability, entry.cardprops)
+                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
-    return entry, true
-end
--- {{#invoke:GameData|get_prop|...}}
+    local has_notes_header = false
--- Two modes:
+    local final_headers = {}
---   Entity:  {{#invoke:GameData|get_prop|ENTITY_NAME|PROPERTY|VARIANT}}
+    for _, h in ipairs(headers) do
---            Finds entity via ResourceLookup, returns the raw value (no
+        if h == "Notes" then
---            formatting). Supports dot notation for nested properties
+            has_notes_header = true
---            (e.g. "Scale.Value"); tables with a .Value field are unwrapped.
+        elseif not hide_set[h] then
---            The optional VARIANT selects a game mode variant. "Street Brawl"
+            table.insert(final_headers, h)
---            (case and spacing insensitive) returns the value changed for
+        end
---            Street Brawl, falling back to the base value when Street Brawl
+     end
---            does not change that property.
+     local needs_notes = (has_notes_header or stat_notes ~= nil) and not hide_set["Notes"]
---   Convar:  {{#invoke:GameData|get_prop|Convar|CONVAR_NAME}}
+     if needs_notes then table.insert(final_headers, "Notes") end
---            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]
-    local arg3 = frame.args[3]
-     if not arg1 then return "" end
-     -- Convar mode: first argument is the literal keyword "Convar".
+     local table_class = 'wikitable sortable ability-table'
-     if mw.ustring.lower(arg1) == "convar" then
+     if collapsed ~= "" then
-         if not arg2 or arg2 == "" then return "" end
+        table_class = table_class .. ' mw-collapsible'
-        local value, found = lookup_convar(arg2)
+         if collapsed == "yes" or collapsed == "true" or collapsed == "1" then
-        if not found then
+             table_class = table_class .. ' mw-collapsed'
-             return '<span style="color:red;">Convar not found: ' .. arg2 .. '</span>'
          end
-        if value == nil then return "" end
-        return value
      end
-    -- Entity mode: search abilities, heroes, and items.
+     local out = {}
-     local name = arg1
+     table.insert(out, disclaimer)
-     local prop = arg2
+     table.insert(out, '{| class="' .. table_class .. '"')
-     if not prop then return "" end
-     local entity, etype, ekey = find_entity(name)
+     local header_row = '! class="ability-table-col-hero" | Hero'
-    if not entity then
+                    .. ' !! class="ability-table-col-ability" | Ability'
-         return '<span style="color:red;">Entity not found: ' .. name .. '</span>'
+    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)
-     -- Street Brawl changes a handful of ability properties. The overlay lists
+        local hero_counts = {}
-     -- only what changed, so a miss here just means "unchanged" and the base
+     for _, key in ipairs(filtered) do
-     -- record answers instead. That includes the empty string resolve_prop
+        local hero = views[key].heroName
-     -- returns for a table with no Value field: the overlay records are partial,
+        hero_counts[hero] = (hero_counts[hero] or 0) + 1
-    -- so an overridden table often holds nothing but a nested Scale.
+     end
-    if arg3 and arg3 ~= "" then
-         local mode = mw.ustring.lower(mw.text.trim(arg3))
+     local hero_seen = {}
-         mode = mode:gsub("%s+", "")
-        if mode ~= "streetbrawl" then
+     for _, key in ipairs(filtered) do
-             return '<span style="color:red;">Unknown variant: ' .. arg3 .. '</span>'
+        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
+            hero_seen[hero] = true
+        else
+            row = '| class="ability-table-cell-ability" | ' .. ability_cell
          end
-         if etype == "ability" then
-            local changed = mw.loadJsonData(STREET_BRAWL)["ability-changes"][ekey]
+         for _, header in ipairs(final_headers) do
-             if changed then
+            local value = extra[header]
-                local value = resolve_prop(changed, prop)
+            local cls   = "ability-table-cell-" .. header:lower():gsub("%s+", "-")
-                if value ~= nil and value ~= "" then return value end
+             local content = value ~= nil and tostring(value) or "—"
-             end
+             row = row .. ' || class="' .. cls .. '" | ' .. content
          end
+        table.insert(out, "|-")
+        table.insert(out, row)
      end
-     local result = resolve_prop(entity, prop)
+     table.insert(out, "|}")
-     if result ~= nil then return result end
+     return table.concat(out, "\n")
+end
-     return '<span style="color:red;">Prop not found: ' .. name .. '/' .. prop .. '</span>'
+-- 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

Module:Sandbox/Vergir: Difference between revisionsGive feedback

Vergir (talk | contribs)