The Deadlock Wiki

Editing Module:Sandbox/LVL

Warning: You are not logged in. Once you make an edit, a temporary account will be created for you. Learn more. Log in or create an account to continue receiving notifications after this account expires, and to access other features.
The edit can be undone. Please check the comparison below to verify that this is what you want to do, and then publish the changes below to finish undoing the edit.
Latest revision Your text
Line 1: Line 1:
local p = {}
local p = {};
 
local heroes_data = mw.loadJsonData("Data:HeroData.json")
local heroes_data       = mw.loadJsonData("Data:HeroData.json")
local attributes_data = mw.loadJsonData("Data:AttributeData.json")
local attributes_data   = mw.loadJsonData("Data:AttributeData.json")
local attribute_orders = mw.loadJsonData("Data:StatInfoboxOrder.json")
local attribute_orders = mw.loadJsonData("Data:StatInfoboxOrder.json")
local util_module = require('Module:Utilities')
local util_module       = require('Module:Utilities')
local lang_module = require('Module:Lang')
local lang_module       = require('Module:Lang')
local dictionary_module = require('Module:Dictionary')
local dictionary_module = require('Module:Dictionary')
local attribute_module = require('Module:AttributeData')
local attribute_module = require('Module:AttributeData')
local hero_data_module  = require('Module:HeroData')


local function get_nested_stat_value(hero_data, stat_key)
-- returns the table of a specific item, used by external modules
    if hero_data[stat_key] ~= nil then
function p.get_json_item(name)
        return hero_data[stat_key]
for i,v in pairs(heroes_data) do
    elseif hero_data.Weapon and hero_data.Weapon[stat_key] ~= nil then
if (v["Name"] == name) then
        return hero_data.Weapon[stat_key]
return v
    elseif hero_data.Weapon and hero_data.Weapon.AltFire and hero_data.Weapon.AltFire[stat_key] ~= nil then
end
        return hero_data.Weapon.AltFire[stat_key]
end
    end
return nil
    return 0
end
end


local function localize(key, fallback)
-- Returns an array of item tables that have the same properties
    local result = lang_module.get_string(key)
-- @function  get_similar_items
    if result == "" or result == nil then
-- @param      {string}
        result = util_module.add_space_before_cap(fallback) ..
-- @return    {array of tables}
                mw.getCurrentFrame():expandTemplate{title = "MissingValveTranslationTooltip"}
local function get_similar_items(property)
    end
local similarItems = {}
    return result
for _, v in pairs(heroes_data) do
if (v[property] ~= nil) then
table.insert(similarItems, v)
end
end
return similarItems
end
end


-- =========================================================================
-- returns the key of the specified hero's english name
-- DPS calculation helpers
function p.get_hero_key(frame)
-- =========================================================================
    local hero_name_input = frame.args[1] -- Get the hero name from the template argument
    if not hero_name_input then
        return "Error: Hero name not specified."
    end


local function calculate_dps(stats, dps_type)
    hero_name_input = hero_name_input:lower() -- For case-independent search
    local rps = stats.RoundsPerSecond or 0
    if rps == 0 then return 0 end


     local bullets_per_shot = (stats.HitOnceAcrossAllBullets and 1) or (stats.BulletsPerShot or 1)
     -- Go through all the characters and look for a name match.
    local burst_count = stats.BulletsPerBurst or 1
    for hero_key, hero_data in pairs(heroes_data) do
    local cycle_time = 1 / rps
        if hero_data["Name"] then
     local total_cycle_time = cycle_time * burst_count
            local current_hero_name = hero_data["Name"]:lower()
            if current_hero_name == hero_name_input then
                return hero_key -- Return the key if the name matches
            end
        end
     end


     if total_cycle_time == 0 then return 0 end
     return "Hero not found." -- If nothing is found
end


     local base_damage = stats.BulletDamage or 0
--{{#invoke:HeroData|get_hero_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
     if dps_type == 'burst' then
--sig_figs optional for rounding floats
         return base_damage * bullets_per_shot * burst_count / total_cycle_time
p.get_hero_var = function(frame)
    local hero_name = frame.args[1]
    local hero_stat_key = frame.args[2]
    local sig_figs_or_localize = frame.args[3]
   
    local hero = heroes_data[hero_name]
    if(hero == nil) then hero = p.get_json_item(hero_name) end
    if(hero == nil) then return "Hero Not Found" end
   
    -- Check top-level first, then Weapon, then AltFire
     local var_value = hero[hero_stat_key]
    if var_value == nil and hero.Weapon then
        var_value = hero.Weapon[hero_stat_key]
    end
     if var_value == nil and hero.Weapon and hero.Weapon.AltFire then
         var_value = hero.Weapon.AltFire[hero_stat_key]
     end
     end
 
   
     local clip_size = stats.ClipSize or 0
     if(var_value == nil) then return 0 end
     if clip_size <= 0 then
   
         return base_damage * bullets_per_shot * burst_count / total_cycle_time
    --round
     if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
         var_value = util_module.round_to_sig_fig(var_value, sig_figs_or_localize)
        if (var_value == nil) then return "get_hero_var() error with rounding" end
     end
     end
 
   
     local reload_time
     --localize
     if stats.ReloadSingle then
     if (sig_figs_or_localize == "true") then
         reload_time = (stats.ReloadTime or 0) * clip_size
         return lang_module.get_string(var_value)
    else
        reload_time = stats.ReloadTime or 0
     end
     end
    reload_time = reload_time + (stats.ReloadDelay or 0)


     local time_to_empty_clip = (clip_size / burst_count) * total_cycle_time
     return var_value
    local damage_from_clip = base_damage * bullets_per_shot * clip_size
    local total_time = time_to_empty_clip + reload_time
    if total_time == 0 then return 0 end
    return damage_from_clip / total_time
end
end


-- Compute how much DPS changes when all relevant component scalings are applied.
--{{#invoke:HeroData|get_alt_fire_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
-- Used for alt-fire rows where explicit DPS/SustainedDPS scaling keys are missing.
p.get_alt_fire_var = function(frame)
local function compute_dps_scaling(hero_data, base_stats, dps_type, scaling_type)
     local hero_name = frame.args[1]
     local scaling_source = hero_data[scaling_type .. "Scaling"] or {}
    local stat_key = frame.args[2]
 
    local sig_figs_or_localize = frame.args[3]
     local component_scalings = {}
   
     local possible_keys = {
     local hero = heroes_data[hero_name]
        "BulletDamage", "RoundsPerSecond", "ClipSize", "ReloadTime",
     if(hero == nil) then hero = p.get_json_item(hero_name) end
        "ReloadDelay", "BulletsPerShot", "BulletsPerBurst"
    if(hero == nil) then return "Hero Not Found" end
     }
      
     for _, key in ipairs(possible_keys) do
     if not (hero.Weapon and hero.Weapon.AltFire) then
        local alt_key = key .. "AltFire"
         return "No Alt Fire"
        if scaling_source[alt_key] then
            component_scalings[key] = scaling_source[alt_key]
         end
     end
     end
 
      
     -- ClipSize is shared between fire modes; fall back to primary scaling
     local var_value = hero.Weapon.AltFire[stat_key]
     if base_stats.ClipSize and not component_scalings.ClipSize then
    if(var_value == nil) then return 0 end
        local primary_clip_scale = scaling_source["ClipSize"]
   
        if primary_clip_scale then
    --round
            component_scalings.ClipSize = primary_clip_scale
    if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
         end
         var_value = util_module.round_to_sig_fig(var_value, sig_figs_or_localize)
     end
     end
 
   
     if next(component_scalings) == nil then
    --localize
         return 0
     if (sig_figs_or_localize == "true") then
         return lang_module.get_string(var_value)
     end
     end


    local base_dps = calculate_dps(base_stats, dps_type)
     return var_value
    local scaled_stats = {}
    for k, v in pairs(base_stats) do scaled_stats[k] = v end
    for comp_key, scale_val in pairs(component_scalings) do
        if scaled_stats[comp_key] ~= nil then
            scaled_stats[comp_key] = scaled_stats[comp_key] + scale_val
        end
    end
    local scaled_dps = calculate_dps(scaled_stats, dps_type)
     return scaled_dps - base_dps
end
end


-- =========================================================================
--{{#invoke:HeroData|get_list_elem|HERO_NAME|VAR|NUMBER|LOCALIZE}}
-- Main module function
p.get_list_elem = function(frame)
-- =========================================================================
local hero_name = frame.args[1]
local var = frame.args[2]
local number_str = frame.args[3]
local number_int = tonumber(number_str)
local localize = frame.args[4]
local hero = heroes_data[hero_name]
if(hero == nil) then hero = p.get_json_item(hero_name) end
if(hero == nil) then return "Hero Not Found" end
-- Check top-level first, then Weapon, then AltFire
local list = hero[var]
if list == nil and hero.Weapon then
    list = hero.Weapon[var]
end
if list == nil and hero.Weapon and hero.Weapon.AltFire then
    list = hero.Weapon.AltFire[var]
end
if (list == nil) then return "" end
local element = list[number_int]
if (element == nil) then return "" end
if localize=="true" then
element = lang_module.get_string(element)
end
return element
end


p.write_hero_comparison_table = function(frame)
p.get_ability_key = function(frame)
    local power_increases = tonumber(frame.args[1]) or 0
local hero_key = frame.args[1]
    local spirit_power    = tonumber(frame.args[2]) or 0
local bound_slot_number = frame.args[2]
    local max_power      = tonumber(frame.args[3]) or 25
local hero_data = heroes_data[hero_key]
    local max_spirit      = tonumber(frame.args[4]) or 500
if (hero_data == nil) then return "Hero key "..hero_key.. " not found" end
local bound_abilities_data = hero_data["BoundAbilities"]
if (bound_abilities_data == nil) then return "Hero key " .. hero_key.. " has no BoundAbilities" end
return bound_abilities_data[tonumber(bound_slot_number)]["Key"]
end


    local display_scaling_icons = (power_increases == 0 and spirit_power == 0)
p.write_role_playstyle_quote = function(frame)
local hero_key = frame.args[1]
local hero_data = heroes_data[hero_key]
if (hero_data == nil) then return hero_key.." not found" end
local role_key = hero_data["Role"]
local role_localized = lang_module.get_string(role_key, nil, 'en')
local playstyle_key = hero_data["Playstyle"]
local playstyle_localized = lang_module.get_string(playstyle_key, nil, 'en')
local str = "<b>" .. role_localized .. '</b><br>' .. playstyle_localized
local template_args = {}
template_args[1] = ""
template_args[2] = str
return frame:expandTemplate{title = 'Quotation', args = template_args}
end


    local body_str = ""
p.write_default_items = function(frame)
 
local hero_key = frame.args[1] --unlocalized
    local stats_to_include = {
if (hero_key == nil) then return "No hero key provided" end
        Weapon = {
local str = ""
            "DPS", "SustainedDPS", "BulletDamage", "RoundsPerSecond", "FireRate",
local hero = heroes_data[hero_key]
            "ClipSize", "ReloadTime", "ReloadDelay", "ReloadSingle", "BulletsPerShot", "BulletsPerBurst",
if (hero == nil) then return "Hero not found, must be unlocalized" end
            "BurstInterShotInterval", "LightMeleeDamage", "HeavyMeleeDamage",
local template_title = 'PageRef'
            "BulletSpeed", "FalloffStartRange", "FalloffEndRange",
for i, item_key in ipairs(hero["RecommendedItems"]) do
            "CritDamageBonusPercent", "BulletRadius", "RoundsPerSecondAtMaxSpin", "SpinAcceleration", "SpinDeceleration"
template_args = {}
        },
template_args[1] = lang_module.get_string(item_key, 'en')
        Vitality = {
template_args['alt_name'] = localize(item_key, item_key)
            "MaxHealth", "BaseHealthRegen", "BulletResist", "TechResist", "MeleeResist",
local expanded_template = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
            "CritDamageReceivedPercent", "DebuffResist", "BulletLifesteal", "MaxMoveSpeed",
str = str .. "* " .. expanded_template .. "\n"
            "SprintSpeed", "StaminaCooldown", "Stamina", "GroundDashSpeed", "GravityChange"
end
        },
return str
        Spirit = { "TechPower" }
end
    }
 
    -- Collect and sort heroes alphabetically, excluding disabled/in-development
    local sorted_heroes = {}
    for hero_key, hero_data in pairs(heroes_data) do
        if not hero_data["InDevelopment"] and not hero_data["IsDisabled"] then
            table.insert(sorted_heroes, {key = hero_key, data = hero_data})
        end
    end
    table.sort(sorted_heroes, function(a, b)
        local function get_sort_name(name)
            return (name:gsub("^The ", ""))
        end
        return get_sort_name(a.data["Name"] or a.key) < get_sort_name(b.data["Name"] or b.key)
    end)


    -- Build a single stat cell (<td>) with data attributes for JS recalculation
--If the hero scales with the stat, it returns {{Ss|value}} or {{Ls|value}}, else blank string
    local function buildStatCell(hero_data, hero_key, attr_key, is_alt_fire, category)
--{{#invoke:HeroData|get_hero_scalar|HERO_NAME|SCALING_TYPE|STAT_NAME|sig_figs_or_localize}}--
        -- Conversion factors for stats that need unit changes (e.g. metres → centimetres)
p.get_hero_scalar = function(frame)
        local unit_conversion = {
local hero_key = frame.args[1]
            BulletRadius = 100  -- metres to centimetres
local scaling_type = frame.args[2]
        }
local hero_stat_key = frame.args[3]
        local conv_factor = unit_conversion[attr_key] or 1
local sig_figs_or_localize = frame.args[4]
local hero_data = heroes_data[hero_key]
if(hero_data == nil) then hero_data = p.get_json_item(hero_key) end
if(hero_data == nil) then return "Hero not found." end
local scaling_data = hero_data[scaling_type .. "Scaling"]
if scaling_data == nil then return "" end
local scaling_value = scaling_data[hero_stat_key]
if scaling_value == nil then return "" end


        local base_value
--round
        if is_alt_fire then
if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
            if attr_key == "ClipSize" or attr_key == "ReloadTime" then
scaling_value = util_module.round_to_sig_fig(scaling_value, sig_figs_or_localize)
                base_value = get_nested_stat_value(hero_data, attr_key)
if (scaling_value == nil) then return "get_hero_scalar() error with rounding" end
            elseif hero_data.Weapon and hero_data.Weapon.AltFire
end
                and hero_data.Weapon.AltFire[attr_key] ~= nil then
                base_value = hero_data.Weapon.AltFire[attr_key]
--localize
            else
if (sig_figs_or_localize == "true") then
                base_value = get_nested_stat_value(hero_data, attr_key)
return lang_module.get_string(scaling_value)
            end
end
        else
            base_value = get_nested_stat_value(hero_data, attr_key)
local scaling_str = p.write_scalar_str(scaling_value, scaling_type)
        end


        -- Apply unit conversion to the base value
return scaling_str
        if type(base_value) == "number" then
end
            base_value = base_value * conv_factor
        end


        local stat_value = base_value
-- Check if a hero has a stat (Base, Boons, or Spirit Scaling)
-- Returns "true" if found, nil if not (for #if templates)
p.hero_has_stat = function(frame)
    local hero_key = frame.args[1]
    local stat_key = frame.args[2]


        -- Scaling lookup
    if (hero_key == nil) then return nil end
        local scaling_data
   
        if is_alt_fire then
    local hero_data = heroes_data[hero_key]
            if attr_key == "ClipSize" or attr_key == "ReloadTime" then
    if (hero_data == nil) then hero_data = p.get_json_item(hero_key) end
                scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key)
    if (hero_data == nil) then return nil end
            elseif (attr_key == "DPS" or attr_key == "SustainedDPS")
                and hero_data.Weapon and hero_data.Weapon.AltFire then
                -- Alt-fire DPS/SustainedDPS: use explicit key if present, otherwise compute from components
                local direct_scaling = hero_data_module.get_hero_scaling_data(hero_data, attr_key .. "AltFire")
                if direct_scaling and next(direct_scaling) ~= nil then
                    scaling_data = direct_scaling
                else
                    local alt_stats = hero_data.Weapon.AltFire
                    local dps_type = attr_key == "DPS" and 'burst' or 'sustained'
                    local level_scale = compute_dps_scaling(hero_data, alt_stats, dps_type, "Level")
                    local spirit_scale = compute_dps_scaling(hero_data, alt_stats, dps_type, "Spirit")
                    level_scale = util_module.round_to_sig_fig(level_scale, 5)
                    spirit_scale = util_module.round_to_sig_fig(spirit_scale, 5)
                    scaling_data = {}
                    if level_scale ~= 0 then scaling_data[level_scale] = "Level" end
                    if spirit_scale ~= 0 then scaling_data[spirit_scale] = "Spirit" end
                    if next(scaling_data) == nil then scaling_data = nil end
                end
            elseif hero_data.Weapon and hero_data.Weapon.AltFire
                and hero_data.Weapon.AltFire[attr_key] ~= nil then
                scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key .. "AltFire")
            else
                scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key)
            end
        else
            scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key)
        end


        local scaling_strs = ""
    -- 1. Check Base Value
        local spirit_scale = 0
    -- We allow 0 if it's explicitly set, but usually we filter 0 for hiding.
        local level_scale  = 0
    -- However, for resists, 0 usually means "hide", so we check ~= 0.
        local spirit_val = 0
    local val = hero_data[stat_key]
        local level_val  = 0
    if (val ~= nil and val ~= 0) then return "true" end
        if scaling_data ~= nil then
            for scaling_val, scaling_type in pairs(scaling_data) do
                if scaling_type == "Spirit" then
                    spirit_val = scaling_val * conv_factor  -- apply unit conversion
                elseif scaling_type == "Level" then
                    level_val = scaling_val * conv_factor  -- apply unit conversion
                end
            end


            -- Output Spirit icon before Level icon
    -- 2. Check Level Scaling (Boons)
            local function append_scaling(val, stype)
    if (hero_data["LevelScaling"] ~= nil and hero_data["LevelScaling"][stat_key] ~= nil and hero_data["LevelScaling"][stat_key] ~= 0) then  
                if val ~= 0 then
        return "true"  
                    local scaling_str = hero_data_module.write_scalar_str(val, stype, true)
    end
                    if scaling_str ~= "" then
                        scaling_strs = scaling_strs .. " " .. scaling_str
                    end
                end
            end
            append_scaling(spirit_val, "Spirit")
            append_scaling(level_val, "Level")


            if type(stat_value) == "number" then
    -- 3. Check Spirit Scaling
                stat_value = stat_value + (spirit_power * spirit_val)
    if (hero_data["SpiritScaling"] ~= nil and hero_data["SpiritScaling"][stat_key] ~= nil and hero_data["SpiritScaling"][stat_key] ~= 0) then
                stat_value = stat_value + (power_increases * level_val)
        return "true"
            end
    end


            spirit_scale = spirit_val
    return nil
            level_scale  = level_val
end
        end


        if attr_key == "TechPower" and spirit_scale == 0 then
-- Retrieve scaling string of a hero's given stat, if it has scaling, else return blank
            spirit_scale = 1.0
-- Scaling string meaning the expanded template {{Ss|scalar}} or {{Ls|scalar}}
            if type(stat_value) == "number" then
function p.write_scalar_str(scaling_value, scaling_type)
                stat_value = stat_value + (spirit_power * spirit_scale)
local scaling_abbrevs = {Spirit = "Ss", Level = "PI"}
            end
        end
-- Return blank if it doesnt scale
if (scaling_value == 0) then return "" end
-- Round it
scaling_value = util_module.round_to_sig_fig(scaling_value, 3)
--The hero has a scaling value with this stat
local template_title = "Template:" .. scaling_abbrevs[scaling_type]
local template_args = {}
template_args["1"] = scaling_value
local template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
   
return template_call:gsub("\n", ""):gsub("\r", "")
end


        local innate_spirit_scale =
-- Retrieve scaling value and type of a hero's given stat, if it has scaling, else return 0
            (hero_data["LevelScaling"] and hero_data["LevelScaling"]["TechPower"]) or 0
function p.get_hero_scaling_data(hero_data, hero_stat_key)
local scaling_type_full
local scaling_data
local scaling_value
local scaling_types = {"Spirit", "Level"}
local scaling_data_returned = {}
for index, scaling_type in ipairs(scaling_types) do
scaling_type_full = scaling_type .. "Scaling"
scaling_data = hero_data[scaling_type_full]
--If the scaling data exists
if (scaling_data ~= nil) then
scaling_value = scaling_data[hero_stat_key]
--If the stat scales
if (scaling_value ~= nil) then
scaling_data_returned[scaling_value] = scaling_type
end
end
end
return scaling_data_returned
end


         if not display_scaling_icons then scaling_strs = "" end
--HERO_NAME in english
--{{#invoke:HeroData|write_infobox|HERO_NAME}}--
p.write_infobox = function(frame)
-- Get hero data
    hero_key = frame.args[1]
    hero_data = heroes_data[hero_key]
    if(hero_data == nil) then return "Hero " .. hero_key .. " Not Found" end
   
    local infobox_attributes = {
         Weapon = {'DPS','ClipSize','RoundsPerSecond','ReloadTime'},
        Vitality = {'MaxHealth','BulletResist','TechResist','MaxMoveSpeed'}
    }
   
    -- Declarations and initializations
    local category_data = attribute_module.get_category_data()
    local stats
    local stat_data
    local stat_value
    local stat_text
    local label
    local postfix
    local should_display
    local image_file_name
    local image_file
    local icon_and_value_str
    local template_args = {}
    local stat_values = {Weapon = "", Vitality = ""}
   
    -- Add the main parameters
    template_args["name_english"] = lang_module.get_string(hero_key, 'en')
    template_args["name_localized"] = localize(hero_key, hero_key)
   
    -- Iterate attribute categories
    for category, stats in pairs(infobox_attributes) do
-- Iterate stats
for _, stat_name in ipairs(stats) do
-- Confirm its in attribute data and retrieve it
attribute_data = attributes_data[category]
if (attribute_data == nil) then return "Category " .. category .. " in infobox_attributes is not in Data:AttributeData" end
stat_data = attribute_data[stat_name]
if (stat_data == nil) then return "Attribute " .. stat_name .. " in infobox_attributes is not in Data:AttributeData" end
-- gets the stat's value
stat_value = hero_data[stat_name]
if (stat_value == nil) then
    -- Check nested weapon stats
    if hero_data.Weapon and hero_data.Weapon[stat_name] ~= nil then
        stat_value = hero_data.Weapon[stat_name]
    elseif hero_data.Weapon and hero_data.Weapon.AltFire and hero_data.Weapon.AltFire[stat_name] ~= nil then
        stat_value = hero_data.Weapon.AltFire[stat_name]
    else
        stat_value = 0 --default to 0 if not present
    end
end
--Round value to 3 significant figures
stat_value = util_module.round_to_sig_fig(stat_value, 3)
-- get label and postfix
label = localize(stat_data["label"], stat_name)
postfix = stat_data["postfix"]
if (postfix == nil) then
postfix = ""
else
-- light grey for postfixes
postfix = lang_module.get_string(postfix)
if (postfix == nil) then
postfix = ""
end
postfix = '<span style="color: #666666;">' .. postfix .. "</span>"
end
-- if a language is missing the postfix, use no postfix
-- Check if icon file exists, and if not, don't use any image
image_file_name = 'File:AttributeIcon' .. stat_name .. '.png'
image_file = util_module.get_image_file(image_file_name, 15, stat_name)
-- Create the template'd icon
local icon_color = attribute_module.get_attr_icon_color(stat_name)
icon_template_title = mw.title.new("Template:Icon/" .. icon_color)
icon_template_args = {}
icon_template_args[1] = image_file
icon_template_args[2] = stat_value .. postfix
icon_and_value_str = mw.getCurrentFrame():expandTemplate{ title = icon_template_title, args = icon_template_args }
label =  ',<span style="color: #999999; background-color: #2F2F2F; display: inline-flex; width: 100%; height: 100%; justify-content: center; align-items: center;">' .. label .. '</span>'
-- First add localized stat name for left column
stat_values[category] = stat_values[category] .. label
-- Then add icon and stat value for right column
stat_values[category] = stat_values[category] .. ',' .. icon_and_value_str
end
-- Add the stat values in the category to i.e weapon_values and vitality_values parameters
template_args[string.lower(category) .. "_values"] = stat_values[category]
end
   
    -- Use expandTemplate to evaluate the Infobox_hero template
    local template_title = mw.title.new("User:Sur")
    local expanded_template = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
   
    return expanded_template
end


        if type(stat_value) == "boolean" then
            stat_value = tostring(stat_value)
        else
            stat_value = util_module.round_to_sig_fig(stat_value, 5)
        end


        local cell_inner = string.format(
--{{#invoke:HeroData|write_stat_infoboxes|HERO_KEY}}
            '<span class="stat-num">%s</span><span class="stat-scaling">%s</span>',
--Creates {{Infobox_stat}}'s' for the 3 categories Weapon, Vitality, Spirit
            stat_value,
p.write_stat_infoboxes = function(frame)
            scaling_strs
local hero_key = frame.args[1]
        )
if(hero_key == nil) then return "Hero parameter missing" end
-- Use expandTemplate to evaluate the Infobox_hero template
    local template_title = mw.title.new("Template:Infobox_stat") --name of the template
    local template_calls = '<div style="display: flex; flex-direction: column;">' --all template calls concatenated
    local template_call --current template call
local template_args = {} --current template arguments
local cell_values --current cell values
local cell_value --current cell value
local label --current stat's label
local postfix --current stat's postfix
local stat_value --current stat's numerical value in the hero data
local hero_data = heroes_data[hero_key]
local stats --stats of the current category
local image_file_name --name of the image_file to check
local image_file --mw returned image file
local extra_blank_cell --add a blank cell after certain stats
local stats_to_add_blank_after = {CritDamageReceivedPercent = true}
if (hero_data == nil) then return "Hero Not Found" end
local category_data = attribute_module.get_category_data()
local should_display
for _, category in ipairs(attribute_orders["category_order"]) do
if (category ~= "Spirit") then --hide Spirit section for now
stats = attributes_data[category]
local category_values = category_data[category]
template_args["box_name"] = category_values.unlocalized_name
template_args["box_rgb"] = category_values.rgb
template_args["num_cols"] = 2
cell_values = ""
-- Determine cell values
for _, stat_name in ipairs(attribute_orders[category]["attribute_order"]) do
local stat_data = stats[stat_name]
if stat_data == nil then return "Stat " .. stat_name .. " from StatInfoboxOrder has no data in AttributeData" end
-- gets the stat's value if it has that stat, default to 0 if not
stat_value = hero_data[stat_name]
if (stat_value == nil) then
    -- Check nested weapon stats
    if hero_data.Weapon and hero_data.Weapon[stat_name] ~= nil then
        stat_value = hero_data.Weapon[stat_name]
    elseif hero_data.Weapon and hero_data.Weapon.AltFire and hero_data.Weapon.AltFire[stat_name] ~= nil then
        stat_value = hero_data.Weapon.AltFire[stat_name]
    else
        stat_value = 0 --default to 0 if not present
    end
end
--Round value to 3 significant figures
stat_value = util_module.round_to_sig_fig(stat_value, 3)
-- get label and postfix
label = localize(stat_data["label"], stat_name)
postfix = stat_data["postfix"]
if (postfix == nil) then
postfix = ""
else
-- light grey for postfixes
postfix = '<span style="color: #666666;">' .. lang_module.get_string(postfix) .. "</span>"
end
-- if a language is missing the postfix, use no postfix
if (postfix == nil) then
postfix = ""
end
-- Check if icon file exists, and if not, don't use any image
image_file_name = 'File:AttributeIcon' .. stat_name .. '.png'
-- 15px and link to stat name (page name might not match perfectly yet)
image_file = util_module.get_image_file(image_file_name, 15, stat_name)
-- Create the template'd icon
local icon_color = attribute_module.get_attr_icon_color(stat_name)
if (icon_color == "Brown") then
image_file = '<span style="position: relative; bottom: 2px; filter: invert(42%) sepia(10%) saturate(2912%) hue-rotate(351deg) brightness(90%) contrast(87%);">' .. image_file .. '</span>'
end
-- use white instead of grey if grey is returned
-- Add an empty cell following some stats to align them correctly as seen in game
if (stats_to_add_blank_after[stat_name]) then
extra_blank_cell = " ," --prefixed space is needed
else
extra_blank_cell = ""
end
-- slightly lighter color for stat name
label = '<span style="color: #3d3d3d;">' .. label .. '</span>'
-- Add the scaling str if it scales
local scaling_data = p.get_hero_scaling_data(hero_data, stat_name)
local scaling_strs = ""
if (scaling_data ~= nil) then
for scaling_value, scaling_type in pairs(scaling_data) do
local scaling_str = p.write_scalar_str(scaling_value, scaling_type)
if (scaling_str ~= "") then scaling_str = " " .. scaling_str end
scaling_strs = scaling_strs .. scaling_str
end
end
-- Set cell value as "Icon StatvaluePostfix Statname Scaling,"
-- If icon file already exists, set it to #REDIRECT to the duplicate file page
cell_value = image_file .. " " .. stat_value .. postfix .. " " .. label  .. scaling_strs .. "," .. extra_blank_cell
cell_values = cell_values .. cell_value --add value to values list
end
template_args["cell_values"] = cell_values
-- Write current call
template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
-- Add call to the set of calls
template_calls = template_calls .. "\n" .. template_call
end
end
return template_calls .. "</div>"
end


        local weapon_table = hero_data.Weapon
local function get_nested_stat_value(hero_data, stat_key)
        if is_alt_fire and weapon_table and weapon_table.AltFire then
    -- Check top-level, then Weapon, then AltFire
            weapon_table = weapon_table.AltFire
    if hero_data[stat_key] ~= nil then
        end
         return hero_data[stat_key]
        local hit_once = "false"
    elseif hero_data.Weapon and hero_data.Weapon[stat_key] ~= nil then
         if (attr_key == "DPS" or attr_key == "SustainedDPS")
         return hero_data.Weapon[stat_key]
            and weapon_table
    elseif hero_data.Weapon and hero_data.Weapon.AltFire and hero_data.Weapon.AltFire[stat_key] ~= nil then
            and weapon_table.HitOnceAcrossAllBullets
         return hero_data.Weapon.AltFire[stat_key]
        then
            hit_once = "true"
         end
 
        local data_attrs = string.format(
            'data-stat-name="%s" data-base="%s" data-spirit-scale="%s" data-level-scale="%s" data-innate-spirit-scale="%s" data-sort-value="%s" data-hit-once="%s"',
            attr_key,
            tostring(type(base_value) == "number" and util_module.round_to_sig_fig(base_value, 3) or base_value),
            tonumber(spirit_scale) or 0,
            (attr_key == "TechPower") and "0" or (tonumber(level_scale) or 0),
            innate_spirit_scale or 0,
            stat_value,
            hit_once
        )
 
         return string.format('<td style="white-space: nowrap;" %s>%s</td>', data_attrs, cell_inner)
     end
     end
    return 0
end


    -- Generate a hero's primary stat row
--writes the massive hero comparison table for a specific PI and SP
    local function generatePrimaryRow(hero_data, hero_key, has_alt)
-- scaling icons are shown only if PI and SP are both 0 or both not provided
        local row_str = ""
--{{#invoke:HeroData|write_hero_comparison_table|POWER_INCREASES|SPIRIT_POWER|DATA_ATTRS}}
        local hero_name_local = localize(hero_key, hero_key)
--  DATA_ATTRS: pass "true" to output base values with data-base/data-spirit-scale/data-level-scale
        local hero_name_en = hero_data["Name"]
--              attributes on each <td> for client-side JavaScript recalculation
        local template_args = {[1] = hero_name_en, l1 = hero_name_local}
p.write_hero_comparison_table = function(frame)
        local hero_icon = mw.getCurrentFrame():expandTemplate{ title = "Template:HeroIcon", args = template_args }
    -- process inputs
        local hero_cell_content = hero_icon
    local power_increases = frame.args[1]
        if has_alt then
    if (power_increases == nil) then power_increases = 0 end
            hero_cell_content = '[[#alt-fire-' .. hero_key .. '|+]] ' .. hero_cell_content
    local spirit_power = frame.args[2]
        end
    if (spirit_power == nil) then spirit_power = 0 end
        local sort_name = (hero_data["Name"] or hero_key):gsub("^The ", "")
    local data_attrs = frame.args[3] -- "true" to embed data attributes for JS scaling
        row_str = row_str .. '<td style="position: sticky; left: 0; z-index: 10; background-color: var(--background-color-base-2); isolation: isolate; overflow: hidden; min-width: 150px;" data-sort-value="' .. sort_name .. '">' .. hero_cell_content .. '</td>'
   
        for _, category in ipairs(attribute_orders["category_order"]) do
    -- Show scaling icons if power/increases/spirit power are 0/not specified
            if stats_to_include[category] ~= nil then
    local display_scaling_icons = false
                for _, attr_key in ipairs(stats_to_include[category]) do
    if (power_increases == 0 and spirit_power == 0) then
                    row_str = row_str .. buildStatCell(hero_data, hero_key, attr_key, false, category)
         display_scaling_icons = true
                end
            end
         end
        return "<tr>" .. row_str .. "</tr>"
     end
     end
   
    -- Initializations and declarations
    local row_str = ""
    local body_str = ""
    local template_title = ""
    local template_args = {}
    local hero_icon
   
    -- Add hero comp stats to
    local stats_to_include = {
        Weapon = {
            "DPS",
            "SustainedDPS",
            "BulletDamage",
            "RoundsPerSecond",
            "FireRate",
            "ClipSize",
            "ReloadTime",
            "ReloadDelay",
            "BulletsPerShot",
            "BulletsPerBurst",
            "BurstInterShotInterval",
            "LightMeleeDamage",
            "HeavyMeleeDamage",
            "ReloadSingle",
            "BulletSpeed",
            "BulletGravityScale",
            "FalloffStartRange",
            "FalloffEndRange",
            "BonusAttackRange",
            "CritDamageBonusPercent",
            "RoundsPerSecondAtMaxSpin",
            "SpinAcceleration",
            "SpinDeceleration"
        },
        Vitality = {
            "MaxHealth",
            "BaseHealthRegen",
            "BulletResist",
            "TechResist",
            "MeleeResist",
            "BulletLifesteal",
            "CritDamageReceivedPercent",
            "MaxMoveSpeed",
            "SprintSpeed",
            "StaminaCooldown",
            "Stamina",
            "GroundDashSpeed"
        },
        Spirit = {
            "TechPower"
        }
    }


     -- Generate an expandable alt-fire sub-row (weapon stats only)
     -- Collect and sort heroes alphabetically by name
     local function generateAltFireSubRow(hero_data, hero_key)
     local sorted_heroes = {}
        local row_str = ""
    for hero_key, hero_data in pairs(heroes_data) do
        local hero_name_local = localize(hero_key, hero_key)
         if not hero_data["InDevelopment"] and not hero_data["IsDisabled"] then
        local hero_name_en = hero_data["Name"]
             table.insert(sorted_heroes, {key = hero_key, data = hero_data})
        local template_args = {[1] = hero_name_en, l1 = hero_name_local}
        local hero_icon = mw.getCurrentFrame():expandTemplate{ title = "Template:HeroIcon", args = template_args }
         local hero_cell_content = hero_icon .. ' <small style="color:#aaa;">(Alt‑fire)</small>'
        local sort_name = (hero_data["Name"] or hero_key):gsub("^The ", "")
        row_str = row_str .. '<td style="position: sticky; left: 0; z-index: 9; background-color: #202122; isolation: isolate; overflow: hidden; min-width: 150px;" data-sort-value="' .. sort_name .. '">' .. hero_cell_content .. '</td>'
        for _, category in ipairs(attribute_orders["category_order"]) do
             if stats_to_include[category] ~= nil then
                for _, attr_key in ipairs(stats_to_include[category]) do
                    if category == "Weapon" then
                        row_str = row_str .. buildStatCell(hero_data, hero_key, attr_key, true, category)
                    else
                        row_str = row_str .. '<td></td>'
                    end
                end
            end
         end
         end
        return '<tr class="alt-fire-sub" data-parent="' .. hero_key .. '">' .. row_str .. '</tr>'
     end
     end
    table.sort(sorted_heroes, function(a, b)
        return (a.data["Name"] or a.key) < (b.data["Name"] or b.key)
    end)


     -- Build all body rows
     -- Iterate heroes
     for _, hero_entry in ipairs(sorted_heroes) do
     for _, hero_entry in ipairs(sorted_heroes) do
         local hero_key = hero_entry.key
         local hero_key = hero_entry.key
         local hero_data = hero_entry.data
         local hero_data = hero_entry.data
        local has_alt = hero_data.Weapon and hero_data.Weapon.AltFire and true or false
        body_str = body_str .. generatePrimaryRow(hero_data, hero_key, has_alt)
        if has_alt then
            body_str = body_str .. generateAltFireSubRow(hero_data, hero_key)
        end
    end


    -- Pre-pass: determine which stats have any scaling, and which have both types.
        row_str = ""
    -- Used to set column widths in the header.
       
    local stats_with_any_scaling  = {}
        -- Retrieve hero's localized name
    local stats_with_both_scaling = {}
        hero_name = localize(hero_key, hero_key)
    for _, hero_entry in ipairs(sorted_heroes) do
       
         local hero_data = hero_entry.data
        -- Retrieve hero's english name, used for hero icon
        hero_name_en = hero_data["Name"]
       
        -- Expand hero icon
        template_title = "Template:HeroIcon"
        template_args[1] = hero_name_en
        template_args[2] = hero_name
        hero_icon = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
       
        -- First column in each row is hero name
         row_str = row_str .. "<td>" .. hero_icon .. "</td>"
       
        -- Consecutive columns are then stats
        -- Iterate categories
         for _, category in ipairs(attribute_orders["category_order"]) do
         for _, category in ipairs(attribute_orders["category_order"]) do
             if stats_to_include[category] ~= nil then
            category_attrs = attributes_data[category]
           
            -- Iterate attributes within the category
             if (stats_to_include[category] ~= nil) then
               
                 for _, attr_key in ipairs(stats_to_include[category]) do
                 for _, attr_key in ipairs(stats_to_include[category]) do
                     -- Primary scaling
                   
                     local scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key)
                     -- Retrieve the raw base value (unscaled)
                     if scaling_data ~= nil and next(scaling_data) ~= nil then
                    local base_value = get_nested_stat_value(hero_data, attr_key)
                         stats_with_any_scaling[attr_key] = true
                   
                         local has_spirit, has_level = false, false
                    -- Retrieve scaling coefficients (always, needed for both modes)
                         for _, scaling_type in pairs(scaling_data) do
                     local scaling_data = p.get_hero_scaling_data(hero_data, attr_key)
                            if scaling_type == "Spirit" then has_spirit = true
                   
                            elseif scaling_type == "Level" then has_level = true end
                    -- Extract individual scale values
                    local spirit_scale = 0
                    local level_scale = 0
                     if (scaling_data ~= nil) then
                        for sv, stype in pairs(scaling_data) do
                            if (stype == "Spirit") then spirit_scale = sv end
                            if (stype == "Level") then level_scale = sv end
                         end
                end
 
                    if (data_attrs == "true") then
                        -- DATA ATTR MODE: output base value, embed scaling coefficients for JS
                         local display_value = base_value
                        if (type(display_value) == 'boolean') then
                            display_value = tostring(display_value)
                        else
                            display_value = util_module.round_to_sig_fig(display_value, 3)
                        end
 
                        -- Always show scaling icons in data attr mode
                        local scaling_strs = ""
                         if (scaling_data ~= nil) then
                            for scaling_value, scaling_type in pairs(scaling_data) do
                                local scaling_str = p.write_scalar_str(scaling_value, scaling_type)
                                if (scaling_str ~= "") then scaling_str = " " .. scaling_str end
                                if (scaling_str ~= nil) then
                                    scaling_strs = scaling_strs .. scaling_str
                                end
                            end
                         end
                         end
                        if has_spirit and has_level then stats_with_both_scaling[attr_key] = true end
                    end


                    -- Alt-fire scaling (only for stats present in the AltFire table)
                        -- Build data attribute string
                    if hero_data.Weapon
                        local data_str = 'data-base="' .. base_value .. '"'
                        and hero_data.Weapon.AltFire
                            .. ' data-spirit-scale="' .. spirit_scale .. '"'
                        and hero_data.Weapon.AltFire[attr_key] ~= nil
                            .. ' data-level-scale="' .. level_scale .. '"'
                    then
                            .. ' data-spirit="' .. spirit_power .. '"'
                         if attr_key ~= "ClipSize" then
                            .. ' data-level="' .. power_increases .. '"'
                             local alt_scaling = hero_data_module.get_hero_scaling_data(hero_data, attr_key .. "AltFire")
 
                            if alt_scaling and next(alt_scaling) ~= nil then
                        -- Mark resist cells so JS knows to use multiplicative formula
                                stats_with_any_scaling[attr_key] = true
                         if attr_key == 'TechResist' or attr_key == 'BulletResist' then
                                local has_spirit_alt, has_level_alt = false, false
                            data_str = data_str .. ' data-resist="1"'
                                for _, stype in pairs(alt_scaling) do
                        end
                                    if stype == "Spirit" then has_spirit_alt = true
 
                                    elseif stype == "Level" then has_level_alt = true end
                        row_str = row_str .. '<td ' .. data_str .. '>'
                             .. display_value .. scaling_strs .. "</td>"
 
                    else
                        -- ORIGINAL MODE: compute scaled values (existing behavior)
                        local stat_value = base_value
                        local scaling_strs = ""
                        if (scaling_data ~= nil) then
                            for scaling_value, scaling_type in pairs(scaling_data) do
                                local scaling_str = p.write_scalar_str(scaling_value, scaling_type)
                                if (scaling_str ~= "") then scaling_str = " " .. scaling_str end
                                if (scaling_str ~= nil) then
                                    scaling_strs = scaling_strs .. scaling_str
                                 end
                                 end
                                 if has_spirit_alt and has_level_alt then stats_with_both_scaling[attr_key] = true end
                                 -- Scale the stat value
                            else
                                 if (scaling_type == "Spirit") then
                                 if attr_key == "DPS" or attr_key == "SustainedDPS" then
                                    stat_value = stat_value + (spirit_power * scaling_value)
                                     local alt_stats = hero_data.Weapon.AltFire
                                elseif (scaling_type == "Level") then
                                    local dps_type = attr_key == "DPS" and 'burst' or 'sustained'
                                     if attr_key == 'TechResist' or attr_key == 'BulletResist' then
                                    local lv = compute_dps_scaling(hero_data, alt_stats, dps_type, "Level")
                                        -- each PI for resists is multiplicative
                                    local sp = compute_dps_scaling(hero_data, alt_stats, dps_type, "Spirit")
                                        stat_value = (stat_value/100 + 1 - (1-scaling_value/100)^power_increases)*100
                                    lv = util_module.round_to_sig_fig(lv, 5)
                                     else
                                    sp = util_module.round_to_sig_fig(sp, 5)
                                         stat_value = stat_value + (power_increases * scaling_value)
                                     if lv ~= 0 or sp ~= 0 then
                                         stats_with_any_scaling[attr_key] = true
                                        if lv ~= 0 and sp ~= 0 then
                                            stats_with_both_scaling[attr_key] = true
                                        end
                                     end
                                     end
                                 end
                                 end
                             end
                             end
                         end
                         end
                        if (not display_scaling_icons) then scaling_strs = "" end
                       
                        -- Convert from boolean to string, or round it
                        if (type(stat_value)) == 'boolean' then
                            stat_value = tostring(stat_value)
                        else
                            stat_value = util_module.round_to_sig_fig(stat_value, 3)
                        end
                       
                        -- Add it to the row
                        row_str = row_str .. "<td>" .. stat_value .. scaling_strs .. "</td>"
                     end
                     end
                 end
                 end
             end
             end
         end
         end
       
        -- Add row to the body
        row_str = "<tr>" .. row_str .. "</tr>"
        body_str = body_str .. row_str
     end
     end
 
   
     -- Build table header row
   
     local headers_str = '<th style="position: sticky; left: 0; top: -1px; z-index: 12; background-color: var(--background-color-base-5); isolation: isolate; min-width: 150px;">Hero</th>'
     -- First header is Hero
     local headers_str = "<th>" .. "Hero" .. "</th>"
    local header_style = ""
     local category_data = attribute_module.get_category_data()
     local category_data = attribute_module.get_category_data()
    local postfix
    -- Used for keys that are not localized by Valve
     local postfix_key_map = {
     local postfix_key_map = {
         ["ReloadDelay"] = "StatDesc_ReloadTime_postfix",
         ["ReloadDelay"] = "StatDesc_ReloadTime_postfix",
Line 431: Line 778:
         ["SustainedDPS"] = "DPS_postfix",
         ["SustainedDPS"] = "DPS_postfix",
         ["RoundsPerSecondAtMaxSpin"] = "",
         ["RoundsPerSecondAtMaxSpin"] = "",
         ["CritDamageBonusPercent"]   = "StatDesc_CritDamageBonusScale_postfix",
         ["CritDamageBonusScale"] = "StatDesc_CritDamageBonusScale_postfix",
["CritDamageReceivedPercent"] = "StatDesc_CritDamageReceivedScale_postfix",
        ["BonusCritDamagePercent"] = "BonusCritDamagePercent_postfix",
         ["BulletLifesteal"] = "BulletLifestealPercentHero_postfix",
         ["BulletLifesteal"] = "BulletLifestealPercentHero_postfix",
         ["GroundDashSpeed"] = "DashSpeed_postfix"
         ["GroundDashSpeed"] = "DashSpeed_postfix"
     }
        }
      
    -- Iterate stats again for displaying headers with their respective color
     for _, category in ipairs(attribute_orders["category_order"]) do
     for _, category in ipairs(attribute_orders["category_order"]) do
         local category_attrs = attributes_data[category]
         category_attrs = attributes_data[category]
         local category_rgb   = category_data[category]["rgb"]
         category_rgb = category_data[category]["rgb"]
         if stats_to_include[category] ~= nil then
       
        -- Iterate attributes within the category
         if (stats_to_include[category] ~= nil) then  
             for _, attr_key in ipairs(stats_to_include[category]) do
             for _, attr_key in ipairs(stats_to_include[category]) do
                 local attr_data = category_attrs[attr_key]
                 attr_data = category_attrs[attr_key]
                  
                  
                -- Fallback: if the stat is missing from this category, check all other categories
                 if (attr_data ~= nil) then
                 if attr_data == nil then
                     -- Localize, fallback to attr_key with proper spaces
                     for _, fallback_cat_data in pairs(attributes_data) do
                        if fallback_cat_data[attr_key] ~= nil then
                            attr_data = fallback_cat_data[attr_key]
                            break
                        end
                    end
                end
 
                local attr_localized, postfix
                if attr_data ~= nil then
                     attr_localized = lang_module.get_string(attr_data["label"])
                     attr_localized = lang_module.get_string(attr_data["label"])
                     if attr_localized == nil or attr_localized == "" then
                     if (attr_localized == nil or attr_localized == "") then attr_localized = util_module.add_space_before_cap(attr_key) end
                        attr_localized = util_module.add_space_before_cap(attr_key)
               
                    -- Get postfix
                    postfix = lang_module.get_string(attr_data["postfix"])
                    if (postfix == nil or postfix == "") then
                        postfix = ""
                    else
                        postfix = " (" .. postfix .. ")"
                     end
                     end
                    postfix = lang_module.get_string(attr_data["postfix"])
                else -- If not in attributes data, use dictionary translate and postfix
                    if postfix == nil or postfix == "" then postfix = ""
                    else postfix = " (" .. postfix .. ")" end
                    if attr_key == "BulletRadius" then postfix = " (cm)" end
                else
                     attr_localized = dictionary_module.translate(attr_key)
                     attr_localized = dictionary_module.translate(attr_key)
                     postfix = lang_module.get_string(postfix_key_map[attr_key])
                     postfix = lang_module.get_string(postfix_key_map[attr_key])
                     if postfix == nil then return "attr_key " .. attr_key .. " must be added to postfix_key_map" end
                     if postfix == nil then  
                     if postfix ~= "" then postfix = " (" .. postfix .. ")" end
                        return "attr_key " .. attr_key .. " must be added to postfix_key_map"  
                    end
                     if postfix ~= "" then
                        postfix = " (" .. postfix .. ")"
                    end
                 end
                 end
                 local th_style = 'position: sticky; top: -1px; z-index: 3; background-color: rgb(' .. category_rgb .. ');'
                  
                 if stats_with_both_scaling[attr_key] then
                header_style = ' style="background-color: ' .. "rgb(" .. category_rgb .. ') ;"'
                    th_style = th_style .. ' min-width: 130px;'
                  
                elseif stats_with_any_scaling[attr_key] then
                 headers_str = headers_str .. "<th" .. header_style .. ">" .. attr_localized .. postfix .. "</th>"
                    th_style = th_style .. ' min-width: 75px;'
                end
                 headers_str = headers_str .. '<th style="' .. th_style .. '">' .. attr_localized .. postfix .. "</th>"
             end
             end
         end
         end
Line 481: Line 825:
     headers_str = "<tr>" .. headers_str .. "</tr>"
     headers_str = "<tr>" .. headers_str .. "</tr>"


     return string.format(
     local table_str = '<table id="hero-comparison-table" class="wikitable sortable" style="table-layout: auto; width: 100%;">'
        '<div id="hero-comparison-container" data-max-power="%s" data-max-spirit="%s">' ..
        .. headers_str .. body_str .. "</table>"
        '<div style="overflow: auto; max-height: 70vh; width: 100%%;">' ..
    local output_str = '<div style="overflow-x: auto; width: 100%;">' .. table_str .. '</div>'
        '<table class="wikitable sortable" style="table-layout: auto; width: 100%%;" id="hero-comparison-table">%s%s</table>' ..
    return output_str
         '</div></div>',
end
         max_power, max_spirit, headers_str, body_str
 
     )
function localize(key, fallback)
local result = lang_module.get_string(key)
if (result == "") or (result == nil) then
result = util_module.add_space_before_cap(fallback) .. mw.getCurrentFrame():expandTemplate{title="MissingValveTranslationTooltip"}
end
return result
end
 
-- Mapping from hero name to internal tag name
local TAG_NAME_MAP = {
["Abrams"] = "Abrams",
["Bebop"] = "Bebop",
["Billy"] = "Punkgoat",
["Calico"] = "Nano",
["The Doorman"] = "Doorman",
["Drifter"] = "Drifter",
["Dynamo"] = "Dynamo",
["Apollo"] = "Fencer",
["Graves"] = "Necro",
["Grey Talon"] = "Orion",
["Haze"] = "Haze",
    ["Holliday"] = "Astro",
    ["Infernus"] = "Inferno",
    ["Ivy"] = "Tengu",
    ["Kelvin"] = "Kelvin",
    ["Lady Geist"] = "Geist",
    ["Lash"] = "Lash",
    ["McGinnis"] = "Engineer",
    ["Mina"] = "VampireBat",
    ["Mirage"] = "Mirage",
    ["Mo & Krill"] = "Digger",
    ["Paige"] = "Bookworm",
    ["Paradox"] = "Chrono",
    ["Celeste"] = "Unicorn",
    ["Pocket"] = "Synth",
    ["Rem"] = "Familiar",
    ["Seven"] = "Gigawatt",
    ["Shiv"] = "Shiv",
    ["Silver"] = "Werewolf",
    ["Silver (Transformed)"] = "Werewolf",
    ["Sinclair"] = "Magician",
    ["Venator"] = "Priest",
    ["Victor"] = "Frank",
    ["Vindicta"] = "Vindicta",
    ["Viscous"] = "Viscous",
    ["Vyper"] = "Viper",
    ["Warden"] = "Warden",
    ["Wraith"] = "Wraith",
    ["Yamato"] = "Yamato",
}
 
-- Function to call hero tags based on name
p.get_hero_tag = function (frame)
    local name = frame.args[1]
    local number = tonumber(frame.args[2])
 
    -- Validate input
    if not name then
        return "Error: Missing name input."
    end
 
    if number ~= 1 and number ~= 2 and number ~= 3 then
        return string.format("Error: Invalid number '%s'. Must be 1, 2, or 3.", tostring(frame.args[2]))
    end
 
    local tagname = TAG_NAME_MAP[name]
    if not tagname then
        return string.format("Error: Unknown name '%s'.", name)
    end
 
    -- Build localization key
    local key = string.format("Citadel_%s_HeroTag_%d", tagname, number)
 
    -- Call Lang.get_string
    local result = lang_module.get_string(key)
 
    return result or ("[Missing string for key: " .. key .. "]")
end
 
-- Outputs a wikitable of heroes grouped by GroundDashDuration using {{HeroIcon|hero_name}}
-- {{#invoke:HeroData|write_ground_dash_buckets}}
p.write_ground_dash_buckets = function(frame)
    local buckets = {
        [0.62] = {},
        [0.68] = {},
        [0.70] = {},
    }
 
    local get_dash = function(hero)
        return hero.GroundDashDuration
            or (hero.Weapon and hero.Weapon.GroundDashDuration)
            or (hero.Weapon and hero.Weapon.AltFire and hero.Weapon.AltFire.GroundDashDuration)
    end
 
    -- Collect heroes
    for hero_key, hero_data in pairs(heroes_data) do
        if not hero_data.InDevelopment and not hero_data.IsDisabled then
            local dash = get_dash(hero_data)
            if dash and buckets[dash] then
                table.insert(buckets[dash], hero_data.Name or hero_key)
            end
        end
    end
 
    -- Sort alphabetically
    for _, list in pairs(buckets) do
        table.sort(list)
    end
 
    -- Determine max rows dynamically
    local max_rows = 0
    for _, list in pairs(buckets) do
         if #list > max_rows then max_rows = #list end
    end
 
    local output = {"{| class='wikitable'", "! Bucket 1 !! Bucket 2 !! Bucket 3"}
    local current_frame = frame or mw.getCurrentFrame()
 
    for i = 1, max_rows do
        local row = {}
         for _, bucket in ipairs({0.62, 0.68, 0.70}) do
            local hero_name = buckets[bucket][i]
            table.insert(row, hero_name and current_frame:expandTemplate{title = "HeroIcon", args = {hero_name}} or "")
        end
        table.insert(output, "|-\n| " .. table.concat(row, " || "))
    end
 
    table.insert(output, "|}")
     return table.concat(output, "\n")
end
end


return p
return p
Please note that all contributions to The Deadlock Wiki are considered to be released under the Creative Commons Attribution-NonCommercial-ShareAlike (see Deadlock:Copyrights for details). If you do not want your writing to be edited mercilessly and redistributed at will, then do not submit it here.
You are also promising us that you wrote this yourself, or copied it from a public domain or similar free resource. Do not submit copyrighted work without permission!
Cancel Editing help (opens in new window)
Preview page with this template

Page included on this page:

Retrieved from "https://deadlock.wiki/Module:Sandbox/LVL"