The Deadlock Wiki

Module:AbilityTable/ComplexRenderers: 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
rename val_stat_cells to render_upgradable_stat, simplify RenderHealReduce to use it, fix Lists.props to Lists.lists (with help from vergir-bot LLM)
add scalingspirit
 
(18 intermediate revisions by 3 users not shown)
Line 1: Line 1:
-- Complex cell renderers for AbilityTable.
-- Complex cell renderers for AbilityTable.
local Lists   = require("Module:AbilityTable/Lists")
local Lists = require("Module:AbilityTable/Lists")
local GameData = require("Module:GameData")


-- ============================================================
-- ============================================================
Line 48: Line 47:
end
end


-- Returns true if prop exists with a non-zero value anywhere in the record
-- Sums the non-zero values of `fields` within a single record layer (the base
-- excluding the Upgrades key.
-- ability record, or one upgrade tier). Returns nil when none are present.
local function is_base_property(record, prop)
local function sum_fields(layer, fields)
     for k, v in pairs(record) do
    local total = nil
         if k == "Upgrades" then
     for _, field in ipairs(fields) do
            -- skip
        local v = unwrap_value(layer[field])
         elseif k == prop then
         if v and v ~= 0 then total = (total or 0) + math.abs(v) end
             if type(v) == "table" then v = v["Value"] end
    end
            if v ~= nil and v ~= 0 and v ~= "" and v ~= "0" and v ~= "0m" then
    return total
                return true
end
 
-- Sums the barrier value and Spirit scaling contributed by a single record
-- layer (the base ability record, or one upgrade tier). Returns nil when the
-- layer grants no barrier at all; a tier that only raises the scaling still
-- counts, so "+0 value, +1.0 scaling" upgrades are not lost.
local function sum_barrier(layer, fields)
    local value, scale, found = 0, 0, false
    for _, field in ipairs(fields) do
         local entry = layer[field]
        if entry ~= nil then
            local v = unwrap_value(entry) or 0
            local s = 0
             if type(entry) == "table" and type(entry["Scale"]) == "table" then
                s = entry["Scale"]["Value"] or 0
             end
             end
        elseif type(v) == "table" then
            if v ~= 0 or s ~= 0 then found = true end
            if is_base_property(v, prop) then return true end
            value = value + v
        elseif type(v) == "string" then
             scale = scale + s
             if v == prop then return true end
         end
         end
     end
     end
     return false
     if not found then return nil end
    return value, scale
end
end


-- ============================================================
-- Pads a whole-number scaling out to one decimal, so a running total of 2
-- Debuff short names (used by RenderDebuff)
-- reads "2.0" next to its "1.5" neighbours instead of "2". Values that already
-- ============================================================
-- carry decimals are left alone, which keeps precision on things like 0.75.
local function format_scale(scale)
    local text = tostring(scale)
    if not text:find(".", 1, true) then text = text .. ".0" end
    return text
end


local debuff_short_name = {
-- Formats one barrier step. Spirit scaling goes through the compact {{Ss}}
    ["StunDuration"]              = "stun",
-- form, expanded via the frame the surrounding #invoke is already running
    ["SleepDuration"]              = "sleep",
-- under: module return values are not re-expanded, so a literal "{{Ss|0.8}}"
    ["SilenceDuration"]            = "silence",
-- would reach the page as text. The plain fallback covers a nil frame
    ["SilenceDebuff"]              = "silence",
-- (module console).
    ["PetrifyDuration"]            = "petrify",
local function format_barrier(value, scale)
    ["HexDuration"]                = "hex",
     local out = tostring(value)
     ["ImmobilizeDuration"]        = "immobilize",
     if scale and scale ~= 0 then
     ["LiftDuration"]              = "lift",
        local scale_text = format_scale(scale)
    ["HoldInPlaceDuration"]        = "immobilize",
        local frame = mw.getCurrentFrame()
    ["RestrictionDuration"]        = "immobilize",
        if frame then
    ["SlowPercent"]                = "slow",
            out = out .. " " .. frame:expandTemplate{
    ["EnemySlowPct"]              = "slow",
                title = "Ss",
    ["MoveSlowPercent"]            = "slow",
                args  = { scale_text, compact = "1", show_value = "1" },
    ["GroundDashReductionPercent"] = "dash slow",
            }
    ["SlowDuration"]              = "slow",
        else
    ["MaxSlowDuration"]            = "slow",
            out = out .. " ×" .. scale_text
    ["BulletDamageAmpDuration"]    = "bullet amp",
        end
    ["BulletResistReduction"]      = "bullet resist reduction",
     end
    ["TimeSlowDuration"]          = "time slow",
     return out
    ["LateCheckoutStun"]          = "stun",
end
     ["BurnDuration"]              = "burn",
     ["BleedDuration"]              = "bleed",
    ["VenomDuration"]              = "venom",
    ["TossDuration"]              = "knockback",
}


-- ============================================================
-- ============================================================
Line 103: Line 116:
-- additively through upgrades. Shows value in a named column
-- additively through upgrades. Shows value in a named column
-- and generates upgrade notes with running totals.
-- and generates upgrade notes with running totals.
-- Note: auto-generated notes omit trailing periods; the main
-- module's ensure_period handles that.
-- ============================================================
-- ============================================================


Line 136: Line 151:
                         table.insert(notes, "T" .. i .. " upgrade increases "
                         table.insert(notes, "T" .. i .. " upgrade increases "
                             .. col_name:lower() .. " by " .. delta .. suffix
                             .. col_name:lower() .. " by " .. delta .. suffix
                             .. " (total " .. total .. suffix .. ").")
                             .. " (total " .. total .. suffix .. ")")
                         running = total
                         running = total
                     end
                     end
Line 154: Line 169:
local p = {}
local p = {}


-- Charges: shows base charges, time between charges, and upgrade notes.
-- Renders the barrier an ability grants, with its Spirit Power scaling.
-- Both the value and the scaling accumulate across upgrades, so every step
-- after the first shows the running total: "100 x0.8 → 180 x1.5 (T2)".
-- A tier that only improves the scaling still gets its own segment.
function p.RenderBarrier(ability)
    local fields  = Lists.lists["barrier"]
    local segments = {}
 
    local value, scale = sum_barrier(ability, fields)
    if value then
        table.insert(segments, format_barrier(value, scale))
    else
        value, scale = 0, 0
    end
 
    local upgrades = ability["Upgrades"]
    if type(upgrades) == "table" then
        for i, tier in ipairs(upgrades) do
            if type(tier) == "table" then
                local delta_value, delta_scale = sum_barrier(tier, fields)
                if delta_value then
                    value, scale = value + delta_value, scale + delta_scale
                    table.insert(segments,
                        format_barrier(value, scale) .. " (T" .. i .. ")")
                end
            end
        end
    end
 
    if #segments == 0 then return {} end
    return { ["Barrier"] = table.concat(segments, " → ") }
end
 
-- Renders charge count and time between charges.
-- Special case for abilities that gain charges only through upgrades.
function p.RenderCharges(ability)
function p.RenderCharges(ability)
     local base_charges  = unwrap_value(ability["AbilityCharges"])
     local base_charges  = unwrap_value(ability["AbilityCharges"])
     local base_cooldown = ability["AbilityCooldownBetweenCharge"]
     local base_cooldown = unwrap_value(ability["AbilityCooldownBetweenCharge"])
     local has_base      = base_charges ~= nil and base_charges > 0
     local has_base      = base_charges ~= nil and base_charges > 0
     local upgrade_info  = find_in_upgrades(ability, "AbilityCharges")
     local upgrade_info  = find_in_upgrades(ability, "AbilityCharges")
Line 188: Line 237:
         local charge_str = n .. " charge" .. (n ~= 1 and "s" or "")
         local charge_str = n .. " charge" .. (n ~= 1 and "s" or "")
         if has_base then
         if has_base then
             table.insert(note_parts, "+" .. charge_str .. " on T" .. upgrade_info.tier .. " upgrade.")
             table.insert(note_parts, "+" .. charge_str .. " on T" .. upgrade_info.tier .. " upgrade")
         else
         else
             local cd_str = upgrade_cooldown and (upgrade_cooldown .. "s") or "unknown"
             local cd_str = upgrade_cooldown and (upgrade_cooldown .. "s") or "unknown"
             table.insert(note_parts, "Becomes charged on T" .. upgrade_info.tier
             table.insert(note_parts, "Becomes charged on T" .. upgrade_info.tier
                 .. " upgrade with " .. charge_str
                 .. " upgrade with " .. charge_str
                 .. " and " .. cd_str .. " time between charges.")
                 .. " and " .. cd_str .. " time between charges")
         end
         end
     end
     end
     if ability["AbilityChargesConditionally"] ~= nil then
     if ability["AbilityChargesConditionally"] ~= nil then
         table.insert(note_parts, "Has a conditional charge.")
         table.insert(note_parts, "Has a conditional charge")
     end
     end
     if #note_parts > 0 then
     if #note_parts > 0 then
Line 206: Line 255:
end
end


-- Melee: shows light melee scaling and upgrade notes.
-- Renders base damage and melee scaling.
-- Special case for upgrades that switch from Light to Heavy Melee scaling.
function p.RenderMelee(ability)
function p.RenderMelee(ability)
     local function find_base_melee_scale(ability)
     local melee_types = {}
        for _, v in pairs(ability) do
    for _, t in ipairs(Lists.lists["melee"]) do melee_types[t] = true end
            if type(v) == "table" then
 
                local scale = v["Scale"]
    -- Find the base property with active melee/heavy_melee scaling (Scale.Value > 0)
                if type(scale) == "table"
    local base_prop, base_damage, base_scale, base_type
                    and scale["Type"] == "melee"
    for k, v in pairs(ability) do
                    and type(scale["Value"]) == "number"
        if k ~= "Upgrades" and type(v) == "table" then
                    and scale["Value"] > 0
            local scale = v["Scale"]
                 then
            if type(scale) == "table" and melee_types[scale["Type"]]
                    return scale["Value"]
              and type(scale["Value"]) == "number" and scale["Value"] > 0 then
                 end
                 base_prop = k
                base_damage = v["Value"] or 0
                base_scale = scale["Value"]
                 base_type = scale["Type"]
                break
             end
             end
         end
         end
        return nil
     end
     end


     local cells = {}
     local cells = {}
     local base_scale = find_base_melee_scale(ability)
     cells["Base Damage"] = tostring(base_damage or 0)
     if base_scale then cells["Light Melee Scaling"] = "×" .. base_scale end
     if base_scale then
        cells["Light Melee Scaling"] = "×" .. base_scale
    end


     local upgrades = ability["Upgrades"]
     local upgrades = ability["Upgrades"]
     if type(upgrades) ~= "table" then return cells end
     if type(upgrades) ~= "table" then return cells end
     local notes = {}
     local notes = {}
    local running_damage = base_damage or 0
    local running_scale = base_scale or 0
    local running_type = base_type
     for i, tier in ipairs(upgrades) do
     for i, tier in ipairs(upgrades) do
         if type(tier) == "table" then
         if type(tier) == "table" then
             for _, v in pairs(tier) do
            local damage_delta = 0
            local new_scale = nil
            local new_type = nil
 
             for k, v in pairs(tier) do
                 if type(v) == "table" then
                 if type(v) == "table" then
                     local scale = v["Scale"]
                     local scale = v["Scale"]
                     if type(scale) == "table" and type(scale["Value"]) == "number" then
                     if type(scale) == "table" and melee_types[scale["Type"]] then
                         local stype = scale["Type"]
                         damage_delta = damage_delta + (v["Value"] or 0)
                         local delta = scale["Value"]
                         if scale["Value"] > 0 then
                        if stype == "heavy_melee" and delta > 0 then
                             new_scale = scale["Value"]
                             table.insert(notes, "T" .. i .. " upgrade changes scaling to ×"
                             new_type = scale["Type"]
                                .. delta .. " of Heavy Melee damage.")
                        elseif stype == "melee" and delta ~= 0 and base_scale then
                             local final = math.floor((base_scale + delta) * 1000 + 0.5) / 1000
                            table.insert(notes, "T" .. i .. " upgrade adds ×"
                                .. delta .. " scaling (total ×" .. final .. ").")
                         end
                         end
                     end
                     end
                 end
                 end
            end
            local flat_delta = 0
            if base_prop and type(tier[base_prop]) == "number" then
                flat_delta = tier[base_prop]
            end
            local tier_parts = {}
            if new_type and new_type ~= running_type then
                running_damage = running_damage + damage_delta
                running_scale = new_scale
                running_type = new_type
                local type_label = new_type == "heavy_melee" and "'''Heavy Melee'''" or "Light Melee"
                local parts = {}
                if running_damage > 0 then
                    table.insert(parts, running_damage .. " base damage")
                end
                table.insert(parts, "×" .. new_scale .. " " .. type_label .. " scaling")
                table.insert(tier_parts, "on T" .. i .. " becomes " .. table.concat(parts, " with "))
            elseif new_scale then
                running_damage = running_damage + damage_delta
                running_scale = running_scale + new_scale
                local parts = {}
                if damage_delta ~= 0 then
                    table.insert(parts, "+" .. damage_delta .. " base damage")
                end
                table.insert(parts, "+×" .. new_scale .. " scaling (total ×" .. running_scale .. ")")
                table.insert(tier_parts, "on T" .. i .. " gets " .. table.concat(parts, ", "))
            end
            if flat_delta ~= 0 and not new_scale then
                running_damage = running_damage + flat_delta
                table.insert(tier_parts, "on T" .. i .. " gets +" .. flat_delta .. " base damage (total " .. running_damage .. ")")
            end
            if #tier_parts > 0 then
                table.insert(notes, table.concat(tier_parts, ", "))
             end
             end
         end
         end
     end
     end
     if #notes > 0 then cells["Notes"] = table.concat(notes, " ") end
 
     if #notes > 0 then cells["Notes"] = table.concat(notes, ". ") end
     return cells
     return cells
end
end


-- HealReduce: shows heal reduction percentage and upgrade notes.
-- Renders base damage and heavy melee scaling.
function p.RenderHealReduce(ability)
-- Notes when heavy melee is only available via upgrade.
     -- DisableHealing is always 100%, handle it separately
function p.RenderHeavyMelee(ability)
     local v = unwrap_value(ability["DisableHealing"])
     -- Find base heavy_melee property
    if v and v ~= 0 then
    local base_damage, base_scale
        return { ["Heal Reduction"] = "100%" }
     for k, v in pairs(ability) do
        if k ~= "Upgrades" and type(v) == "table" then
            local scale = v["Scale"]
            if type(scale) == "table" and scale["Type"] == "heavy_melee"
              and type(scale["Value"]) == "number" then
                base_damage = v["Value"] or 0
                base_scale = scale["Value"]
                break
            end
        end
     end
     end
     local upgrade = find_in_upgrades(ability, "DisableHealing")
 
     if upgrade then
     local cells = {}
         return { ["Heal Reduction"] = "100% (T" .. upgrade.tier .. ")" }
 
    -- Active at base
     if base_scale and base_scale > 0 then
         cells["Base Damage"] = tostring(base_damage)
        cells["Heavy Melee Scaling"] = "×" .. base_scale
        return cells
     end
     end


     -- Everything else goes through the generic renderer
     -- Not at base — find in upgrades
     local filtered = {}
     local upgrades = ability["Upgrades"]
     for _, prop in ipairs(Lists.lists["healreduce"]) do
    if type(upgrades) ~= "table" then return cells end
        if prop ~= "DisableHealing" then table.insert(filtered, prop) end
 
     for i, tier in ipairs(upgrades) do
        if type(tier) == "table" then
            for k, v in pairs(tier) do
                if type(v) == "table" then
                    local scale = v["Scale"]
                    if type(scale) == "table" and scale["Type"] == "heavy_melee"
                      and type(scale["Value"]) == "number" and scale["Value"] > 0 then
                        cells["Base Damage"] = tostring(v["Value"] or 0)
                        cells["Heavy Melee Scaling"] = "×" .. scale["Value"]
                        cells["Notes"] = "Only becomes Heavy Melee on '''T" .. i .. "''' upgrade"
                        return cells
                    end
                end
            end
        end
     end
     end
     return render_upgradable_stat(ability, "Heal Reduction", filtered, "%")
 
     return cells
end
end


-- Debuff: shared by debuffresist and dispelmagic.
-- Renders Spirit Power scaling.
-- Outputs upgrade-tier notes for debuffs added only in upgrades (not at base).
-- Shows the Scale.Value for abilities whose Scale.Type is "spirit".
function p.RenderDebuff(ability, stat)
function p.RenderSpiritScaling(ability)
    local stat_props = Lists.lists[stat]
    local base_scale = nil
    local base_prop = nil
 
    -- Find base Spirit scaling
    for k, v in pairs(ability) do
        if k ~= "Upgrades" and type(v) == "table" then
            local scale = v["Scale"]
            if type(scale) == "table"
              and scale["Type"] == "spirit"
              and type(scale["Value"]) == "number"
              and scale["Value"] ~= 0 then
                base_scale = scale["Value"]
                base_prop = k
                break
            end
        end
    end
 
     local cells = {}
     local cells = {}


     -- If any prop exists in base, this is a base-level debuff — no note needed.
     if base_scale then
    for _, prop in ipairs(stat_props) do
        cells["Spirit Scaling"] = "×" .. base_scale
        if is_base_property(ability, prop) then
            return cells
        end
     end
     end


Line 292: Line 434:
     if type(upgrades) ~= "table" then return cells end
     if type(upgrades) ~= "table" then return cells end


     local tier_debuffs = {}
     local notes = {}
    local seen_names  = {}


     for i, tier in ipairs(upgrades) do
     for i, tier in ipairs(upgrades) do
         if type(tier) == "table" then
         if type(tier) == "table" then
             local names_this_tier = {}
             local upgrade_scale = nil
            local seen_this_tier  = {}
 
             for _, prop in ipairs(stat_props) do
             for k, v in pairs(tier) do
                 local v = tier[prop]
                 if type(v) == "table" then
                if v ~= nil then
                    local scale = v["Scale"]
                    if type(v) == "table" then v = v["Value"] end
                     if type(scale) == "table"
                     if v ~= nil and v ~= 0 and v ~= "" and v ~= "0" and v ~= "0m" then
                      and scale["Type"] == "spirit"
                        local short = debuff_short_name[prop] or "debuff"
                      and type(scale["Value"]) == "number"
                        if not seen_this_tier[short] then
                      and scale["Value"] ~= 0 then
                            seen_this_tier[short] = true
                        upgrade_scale = scale["Value"]
                            if not seen_names[short] then
                         break
                                seen_names[short] = true
                                table.insert(names_this_tier, short)
                            end
                         end
                     end
                     end
                 end
                 end
             end
             end
             if #names_this_tier > 0 then
 
                 tier_debuffs[i] = names_this_tier
             if upgrade_scale then
                 table.insert(notes,
                    "on T" .. i .. " gets +×" .. upgrade_scale .. " Spirit scaling")
             end
             end
         end
         end
     end
     end


     local tier_indices = {}
     if #notes > 0 then
    for i in pairs(tier_debuffs) do table.insert(tier_indices, i) end
        cells["Notes"] = table.concat(notes, ". ")
     table.sort(tier_indices)
    end
 
     return cells
end


     local parts = {}
-- Renders heal reduction percentage.
     for _, i in ipairs(tier_indices) do
-- Special case for DisableHealing, shown as 100%.
         table.insert(parts, "T" .. i .. " " .. table.concat(tier_debuffs[i], " + "))
function p.RenderHealReduce(ability)
    -- DisableHealing is always 100%, handle it separately
     local v = unwrap_value(ability["DisableHealing"])
    if v and v ~= 0 then
        return { ["Heal Reduction"] = "100%" }
     end
    local upgrade = find_in_upgrades(ability, "DisableHealing")
    if upgrade then
         return { ["Heal Reduction"] = "100% (T" .. upgrade.tier .. ")" }
     end
     end


     if #parts > 0 then cells["Notes"] = table.concat(parts, ", ") end
     -- Everything else goes through the generic renderer
     return cells
    local filtered = {}
    for _, prop in ipairs(Lists.lists["healreduce"]) do
        if prop ~= "DisableHealing" then table.insert(filtered, prop) end
    end
     return render_upgradable_stat(ability, "Heal Reduction", filtered, "%")
end
end


-- MoveSlow: shows move slow percentage and caster slow note if present.
-- Renders move slow percentage.
-- Appends a note if the ability also self-slows the caster.
function p.RenderMoveSlow(ability)
function p.RenderMoveSlow(ability)
     local cells = render_upgradable_stat(ability, "Move Slow", Lists.lists["moveslow"], "%")
     local cells = render_upgradable_stat(ability, "Move Slow", Lists.lists["moveslow"], "%")
Line 340: Line 495:
     local channel_slow = unwrap_value(ability["ChannelSlowPercent"])
     local channel_slow = unwrap_value(ability["ChannelSlowPercent"])
     if channel_slow and channel_slow ~= 0 then
     if channel_slow and channel_slow ~= 0 then
         local note = "Also slows the caster for " .. math.abs(channel_slow) .. "%."
         local note = "Also slows the caster for " .. math.abs(channel_slow) .. "%"
         cells["Notes"] = cells["Notes"] and (cells["Notes"] .. "; " .. note) or note
         cells["Notes"] = cells["Notes"] and (cells["Notes"] .. "; " .. note) or note
     end
     end
Line 347: Line 502:
end
end


-- DashSlow: shows dash slow percentage, auto-detects caster self-slow.
-- Renders dash slow percentage.
-- Special case for GroundDashReductionPercent coexisting with another dashslow
-- prop, which means it's a caster self-slow and is noted separately.
function p.RenderDashSlow(ability)
function p.RenderDashSlow(ability)
     local stat_props = Lists.lists["dashslow"]
     local stat_props = Lists.lists["dashslow"]
Line 394: Line 551:


     if caster_dash_slow then
     if caster_dash_slow then
         local note = "Gives " .. caster_dash_slow .. "% dash slow for the caster."
         local note = "Gives " .. caster_dash_slow .. "% dash slow for the caster"
         cells["Notes"] = cells["Notes"] and (cells["Notes"] .. "; " .. note) or note
         cells["Notes"] = cells["Notes"] and (cells["Notes"] .. "; " .. note) or note
     end
     end


     return cells
     return cells
end
-- Renders the amount of Debuff Resist an ability grants.
-- Upgrades stack additively onto the base value, so every step after the first
-- shows the running total: "20% (T3)" when granted only by an upgrade,
-- "10% → 25% (T2)" when a base value is later increased. Chains for any number
-- of steps. No ability currently has both a base and an upgrade value.
function p.RenderExtraDebuffResist(ability)
    local fields  = Lists.lists["extradebuffresist"]
    local segments = {}
    local running = sum_fields(ability, fields)
    if running then
        table.insert(segments, running .. "%")
    end
    local upgrades = ability["Upgrades"]
    if type(upgrades) == "table" then
        for i, tier in ipairs(upgrades) do
            if type(tier) == "table" then
                local delta = sum_fields(tier, fields)
                if delta then
                    running = (running or 0) + delta
                    table.insert(segments, running .. "% (T" .. i .. ")")
                end
            end
        end
    end
    if #segments == 0 then return {} end
    return { ["Debuff Resist"] = table.concat(segments, " → ") }
end
end


return p
return p
Retrieved from "https://deadlock.wiki/Module:AbilityTable/ComplexRenderers"