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(name)
-- =========================================================================
for i,v in pairs(heroes_data) do
if (v["Name"] == name) then
return i
end
end
return nil
end


local function calculate_dps(stats, dps_type)
    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)
--{{#invoke:HeroData|get_hero_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
    local burst_count = stats.BulletsPerBurst or 1
--sig_figs optional for rounding floats
    local cycle_time = 1 / rps
p.get_hero_var = function(frame)
    local total_cycle_time = cycle_time * burst_count
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] --check if hero key is passed instead
if(hero == nil) then hero = p.get_json_item(hero_name) end --check if hero name is passed
if(hero == nil) then return "Hero Not Found" end --both invalid, error
local var_value = hero[hero_stat_key]
if(var_value == nil) then return 0 end
--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
--localize
if (sig_figs_or_localize == "true") then
return lang_module.get_string(var_value)
end


    if total_cycle_time == 0 then return 0 end
return var_value
end


    local base_damage = stats.BulletDamage or 0
--{{#invoke:HeroData|get_list_elem|HERO_NAME|VAR|NUMBER|LOCALIZE}}
    if dps_type == 'burst' then
p.get_list_elem = function(frame)
        return base_damage * bullets_per_shot * burst_count / total_cycle_time
local hero_name = frame.args[1]
    end
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] --check if hero key is passed instead
if(hero == nil) then hero = p.get_json_item(hero_name) end --check if hero name is passed
if(hero == nil) then return "Hero Not Found" end --both invalid, error
if (hero == nil) then return "Hero " .. hero_name .. " not found" end
local list = hero[var]
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


    local clip_size = stats.ClipSize or 0
p.get_ability_key = function(frame)
    if clip_size <= 0 then
local hero_key = frame.args[1]
        return base_damage * bullets_per_shot * burst_count / total_cycle_time
local bound_slot_number = frame.args[2]
    end
local hero_data = heroes_data[hero_key]
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 reload_time
p.write_role_playstyle_quote = function(frame)
    if stats.ReloadSingle then
local hero_key = frame.args[1]
        reload_time = (stats.ReloadTime or 0) * clip_size
local hero_data = heroes_data[hero_key]
    else
if (hero_data == nil) then return hero_key.." not found" end
        reload_time = stats.ReloadTime or 0
local role_key = hero_data["Role"]
    end
local role_localized = lang_module.get_string(role_key, nil, 'en')
    reload_time = reload_time + (stats.ReloadDelay or 0)
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 time_to_empty_clip = (clip_size / burst_count) * total_cycle_time
p.write_default_items = function(frame)
    local damage_from_clip = base_damage * bullets_per_shot * clip_size
local hero_key = frame.args[1] --unlocalized
    local total_time = time_to_empty_clip + reload_time
if (hero_key == nil) then return "No hero key provided" end
    if total_time == 0 then return 0 end
local str = ""
    return damage_from_clip / total_time
local hero = heroes_data[hero_key]
if (hero == nil) then return "Hero not found, must be unlocalized" end
local template_title = 'PageRef'
for i, item_key in ipairs(hero["RecommendedItems"]) do
template_args = {}
template_args[1] = lang_module.get_string(item_key, 'en')
template_args['alt_name'] = localize(item_key, item_key)
local expanded_template = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
str = str .. "* " .. expanded_template .. "\n"
end
return str
end
end


-- Compute how much DPS changes when all relevant component scalings are applied.
--If the hero scales with the stat, it returns {{Ss|value}} or {{Ls|value}}, else blank string
-- Used for alt-fire rows where explicit DPS/SustainedDPS scaling keys are missing.
--{{#invoke:HeroData|get_hero_scalar|HERO_NAME|SCALING_TYPE|STAT_NAME|sig_figs_or_localize}}--
local function compute_dps_scaling(hero_data, base_stats, dps_type, scaling_type)
p.get_hero_scalar = function(frame)
    local scaling_source = hero_data[scaling_type .. "Scaling"] or {}
local hero_key = frame.args[1]
local scaling_type = frame.args[2]
local hero_stat_key = frame.args[3]
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 scaling_type .. "Scaling data not found for hero" .. hero_key end
local scaling_value = scaling_data[hero_stat_key]
if scaling_value == nil then return scaling_type .. "Scaling data does not have key " .. hero_stat_key .. " for hero " .. hero_key end


    local component_scalings = {}
--round
    local possible_keys = {
if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
        "BulletDamage", "RoundsPerSecond", "ClipSize", "ReloadTime",
scaling_value = util_module.round_to_sig_fig(scaling_value, sig_figs_or_localize)
        "ReloadDelay", "BulletsPerShot", "BulletsPerBurst"
if (scaling_value == nil) then return "get_hero_scalar() error with rounding" end
    }
end
    for _, key in ipairs(possible_keys) do
        local alt_key = key .. "AltFire"
--localize
        if scaling_source[alt_key] then
if (sig_figs_or_localize == "true") then
            component_scalings[key] = scaling_source[alt_key]
return lang_module.get_string(scaling_value)
        end
end
    end
local scaling_str = p.write_scalar_str(scaling_value, scaling_type)
if (scaling_str ~= "") then scaling_str = " " .. scaling_str end
return scaling_str
end


    -- ClipSize is shared between fire modes; fall back to primary scaling
-- Retrieve scaling string of a hero's given stat, if it has scaling, else return blank
    if base_stats.ClipSize and not component_scalings.ClipSize then
-- Scaling string meaning the expanded template {{Ss|scalar}} or {{Ls|scalar}}
        local primary_clip_scale = scaling_source["ClipSize"]
function p.write_scalar_str(scaling_value, scaling_type)
        if primary_clip_scale then
local scaling_abbrevs = {Spirit = "Ss", Level = "PI"}
            component_scalings.ClipSize = primary_clip_scale
        end
-- Return blank if it doesnt scale
    end
if (scaling_value == 0) then return "" end
 
    if next(component_scalings) == nil then
-- Round it
        return 0
scaling_value = util_module.round_to_sig_fig(scaling_value, 3)
    end
--The hero has a scaling value with this stat
local template_title = "Template:" .. scaling_abbrevs[scaling_type] --scaling type's abbreviation
local template_args = {}
template_args["1"] = scaling_value --store in 1st arg for {{{1}}} to grab it from {{SS}} or {{LS}} template
local template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
return template_call
end


    local base_dps = calculate_dps(base_stats, dps_type)
-- Retrieve scaling value and type of a hero's given stat, if it has scaling, else return 0
    local scaled_stats = {}
function p.get_hero_scaling_data(hero_data, hero_stat_key)
    for k, v in pairs(base_stats) do scaled_stats[k] = v end
local scaling_type_full
    for comp_key, scale_val in pairs(component_scalings) do
local scaling_data
        if scaled_stats[comp_key] ~= nil then
local scaling_value
            scaled_stats[comp_key] = scaled_stats[comp_key] + scale_val
local scaling_types = {"Spirit", "Level"}
        end
local scaling_data_returned = {}
    end
    local scaled_dps = calculate_dps(scaled_stats, dps_type)
for index, scaling_type in ipairs(scaling_types) do
    return scaled_dps - base_dps
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
end


-- =========================================================================
--HERO_NAME in english
-- Main module function
--{{#invoke:HeroData|write_infobox|HERO_NAME}}--
-- =========================================================================
p.write_infobox = function(frame)
 
-- Get hero data
p.write_hero_comparison_table = function(frame)
     hero_key = frame.args[1]
     local power_increases = tonumber(frame.args[1]) or 0
     hero_data = heroes_data[hero_key]
    local spirit_power    = tonumber(frame.args[2]) or 0
     if(hero_data == nil) then return "Hero " .. hero_key .. " Not Found" end
     local max_power      = tonumber(frame.args[3]) or 25
   
     local max_spirit      = tonumber(frame.args[4]) or 500
     local infobox_attributes = {
 
         Weapon = {'DPS','ClipSize','RoundsPerSecond','ReloadTime'},
    local display_scaling_icons = (power_increases == 0 and spirit_power == 0)
         Vitality = {'MaxHealth','BulletResist','TechResist','MaxMoveSpeed'}
 
    local body_str = ""
 
     local stats_to_include = {
         Weapon = {
            "DPS", "SustainedDPS", "BulletDamage", "RoundsPerSecond", "FireRate",
            "ClipSize", "ReloadTime", "ReloadDelay", "ReloadSingle", "BulletsPerShot", "BulletsPerBurst",
            "BurstInterShotInterval", "LightMeleeDamage", "HeavyMeleeDamage",
            "BulletSpeed", "FalloffStartRange", "FalloffEndRange",
            "CritDamageBonusPercent", "BulletRadius", "RoundsPerSecondAtMaxSpin", "SpinAcceleration", "SpinDeceleration"
        },
         Vitality = {
            "MaxHealth", "BaseHealthRegen", "BulletResist", "TechResist", "MeleeResist",
            "CritDamageReceivedPercent", "DebuffResist", "BulletLifesteal", "MaxMoveSpeed",
            "SprintSpeed", "StaminaCooldown", "Stamina", "GroundDashSpeed", "GravityChange"
        },
        Spirit = { "TechPower" }
     }
     }
   
    -- 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
stat_value = 0 --default to 0 if not present
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


    -- 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
--{{#invoke:HeroData|write_stat_infoboxes|HERO_KEY}}
    local function buildStatCell(hero_data, hero_key, attr_key, is_alt_fire, category)
--Creates {{Infobox_stat}}'s' for the 3 categories Weapon, Vitality, Spirit
        -- Conversion factors for stats that need unit changes (e.g. metres → centimetres)
p.write_stat_infoboxes = function(frame)
        local unit_conversion = {
local hero_key = frame.args[1]
            BulletRadius = 100 -- metres to centimetres
if(hero_key == nil) then return "Hero parameter missing" end
        }
        local conv_factor = unit_conversion[attr_key] or 1
-- 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 = {CritDamageReceivedScale = 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
stat_value = 0 --default to 0 if not present
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 base_value
--writes the massive hero comparison table for a specific PI and SP
        if is_alt_fire then
-- scaling icons are shown only if PI and SP are both 0 or both not provided
            if attr_key == "ClipSize" or attr_key == "ReloadTime" then
--{{#invoke:HeroData|write_hero_comparison_table|POWER_INCREASES|SPIRIT_POWER|sticky-header-bg=#333|sticky-cell-bg=#202020}}
                base_value = get_nested_stat_value(hero_data, attr_key)
p.write_hero_comparison_table = function(frame)
            elseif hero_data.Weapon and hero_data.Weapon.AltFire
local args = frame:getParent().args
                and hero_data.Weapon.AltFire[attr_key] ~= nil then
-- process inputs
                base_value = hero_data.Weapon.AltFire[attr_key]
local power_increases = args[1]
            else
if (power_increases == nil or power_increases == '') then power_increases = 0 end
                base_value = get_nested_stat_value(hero_data, attr_key)
local spirit_power = args[2]
            end
if (spirit_power == nil or spirit_power == '') then spirit_power = 0 end
        else
            base_value = get_nested_stat_value(hero_data, attr_key)
-- Allow overriding sticky background colors, trim whitespace for robustness
        end
local sticky_header_bg_arg = args['sticky-header-bg']
if sticky_header_bg_arg then
sticky_header_bg_arg = mw.text.trim(sticky_header_bg_arg)
end
local sticky_cell_bg_arg = args['sticky-cell-bg']
if sticky_cell_bg_arg then
sticky_cell_bg_arg = mw.text.trim(sticky_cell_bg_arg)
end
local sticky_header_bg = (sticky_header_bg_arg and sticky_header_bg_arg ~= '') and sticky_header_bg_arg or '#333333'
local sticky_cell_bg = (sticky_cell_bg_arg and sticky_cell_bg_arg ~= '') and sticky_cell_bg_arg or '#202122'
-- Show scaling icons if power/increases/spirit power are 0/not specified
local display_scaling_icons = false
if (power_increases == 0 and spirit_power == 0) then
display_scaling_icons = true
end
-- 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", "RoundsPerSecondAtMaxSpin", "SpinAcceleration", "SpinDeceleration"
},
Vitality = {
"MaxHealth", "BaseHealthRegen", "BulletResist", "TechResist", "CritDamageReceivedScale", "MaxMoveSpeed", "SprintSpeed", "StaminaCooldown", "Stamina"
}
}


        -- Apply unit conversion to the base value
-- Use mw.html builder to construct the table safely
        if type(base_value) == "number" then
local table = mw.html.create('table')
            base_value = base_value * conv_factor
:addClass('wikitable sortable')
        end
:cssText('table-layout: auto; width: 100%;')
-- Build Header
local thead = table:tag('thead')
local header_row = thead:tag('tr')
-- Top-left corner cell
header_row:tag('th')
:cssText('position: sticky; top: 0; left: 0; z-index: 2; background-color: ' .. sticky_header_bg .. ';')
:wikitext('Hero')
local category_data = attribute_module.get_category_data()
local postfix_key_map = {
["ReloadDelay"] = "StatDesc_ReloadTime_postfix", ["BulletsPerShot"] = "", ["BulletsPerBurst"] = "", ["BurstInterShotInterval"] = "StatDesc_ReloadTime_postfix", ["ReloadSingle"] = "", ["BonusAttackRange"] = "StatDesc_WeaponRangeFalloffMax_postfix", ["SustainedDPS"] = "DPS_postfix", ["RoundsPerSecondAtMaxSpin"] = "", ["SpinAcceleration"] = "BonusFireRate_postfix", ["SpinDeceleration"] = "BonusFireRate_postfix"
}
for _, category in ipairs(attribute_orders["category_order"]) do
local category_attrs = attributes_data[category]
local category_rgb = category_data[category]["rgb"]
if (stats_to_include[category] ~= nil) then
for _, attr_key in ipairs(stats_to_include[category]) do
local attr_data = category_attrs[attr_key]
local attr_localized, postfix
if (attr_data ~= nil) then
attr_localized = lang_module.get_string(attr_data["label"])
if (attr_localized == nil or attr_localized == "") then attr_localized = util_module.add_space_before_cap(attr_key) end
postfix = lang_module.get_string(attr_data["postfix"])
if (postfix == nil or postfix == "") then postfix = "" else postfix = " (" .. postfix .. ")" end
else
attr_localized = dictionary_module.translate(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 ~= "" then postfix = " (" .. postfix .. ")" end
end
header_row:tag('th')
:cssText('position: sticky; top: 0; z-index: 1; background-color: rgb(' .. category_rgb .. ');')
:wikitext(attr_localized .. postfix)
end
end
end


        local stat_value = base_value
-- Build Body
local tbody = table:tag('tbody')
for hero_key, hero_data in pairs(heroes_data) do
local in_development = hero_data["InDevelopment"]
if (not in_development) then
local is_disabled = hero_data["IsDisabled"]
if (not is_disabled) then
local body_row = tbody:tag('tr')
-- Hero Icon cell
local hero_name = localize(hero_key, hero_key)
local hero_name_en = hero_data["Name"]
local hero_icon_args = { [1] = hero_name_en, [2] = hero_name }
local hero_icon = frame:expandTemplate{ title = "Template:HeroIcon", args = hero_icon_args }
body_row:tag('td')
:cssText('position: sticky; left: 0; z-index: 1; background-color: ' .. sticky_cell_bg .. ';')
:wikitext(hero_icon)
-- Stat cells
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
local stat_value = hero_data[attr_key]
if (stat_value == nil) then stat_value = 0 end
local scaling_data = p.get_hero_scaling_data(hero_data, attr_key)
local scaling_strs = ""
if (scaling_data ~= nil) then
for scaling_val, scaling_type in pairs(scaling_data) do
local scaling_str = p.write_scalar_str(scaling_val, scaling_type)
if (scaling_str ~= "") then scaling_str = " " .. scaling_str end
if (scaling_str ~= nil) then scaling_strs = scaling_strs .. scaling_str end
if (scaling_type == "Spirit") then
stat_value = stat_value + (spirit_power * scaling_val)
elseif (scaling_type == "Level") then
if attr_key == 'TechResist' or attr_key == 'BulletResist' then
stat_value = (stat_value/100 + 1 - (1-scaling_val/100)^power_increases)*100
else
stat_value = stat_value + (power_increases * scaling_val)
end
end
end
end
if (not display_scaling_icons) then scaling_strs = "" end
if (type(stat_value)) == 'boolean' then
stat_value = tostring(stat_value)
else
stat_value = util_module.round_to_sig_fig(stat_value, 3)
end
body_row:tag('td'):wikitext(stat_value .. scaling_strs)
end
end
end
end
end
end


        -- Scaling lookup
-- Final wrapper div
        local scaling_data
local div = mw.html.create('div')
        if is_alt_fire then
:cssText('overflow-x: auto; width: 100%;')
            if attr_key == "ClipSize" or attr_key == "ReloadTime" then
:node(table)
                scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key)
            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 = ""
return tostring(div)
        local spirit_scale = 0
end
        local level_scale  = 0
        local spirit_val = 0
        local level_val  = 0
        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
function localize(key, fallback)
            local function append_scaling(val, stype)
local result = lang_module.get_string(key)
                if val ~= 0 then
if (result == "") or (result == nil) then
                    local scaling_str = hero_data_module.write_scalar_str(val, stype, true)
result = util_module.add_space_before_cap(fallback) .. mw.getCurrentFrame():expandTemplate{title="MissingValveTranslationTooltip"}
                    if scaling_str ~= "" then
end
                        scaling_strs = scaling_strs .. " " .. scaling_str
return result
                    end
end
                end
            end
            append_scaling(spirit_val, "Spirit")
            append_scaling(level_val, "Level")
 
            if type(stat_value) == "number" then
                stat_value = stat_value + (spirit_power * spirit_val)
                stat_value = stat_value + (power_increases * level_val)
            end
 
            spirit_scale = spirit_val
            level_scale  = level_val
        end
 
        if attr_key == "TechPower" and spirit_scale == 0 then
            spirit_scale = 1.0
            if type(stat_value) == "number" then
                stat_value = stat_value + (spirit_power * spirit_scale)
            end
        end
 
        local innate_spirit_scale =
            (hero_data["LevelScaling"] and hero_data["LevelScaling"]["TechPower"]) or 0
 
        if not display_scaling_icons then scaling_strs = "" 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(
            '<span class="stat-num">%s</span><span class="stat-scaling">%s</span>',
            stat_value,
            scaling_strs
        )


        local weapon_table = hero_data.Weapon
-- Mapping from hero name to internal tag name
        if is_alt_fire and weapon_table and weapon_table.AltFire then
local TAG_NAME_MAP = {
            weapon_table = weapon_table.AltFire
["Abrams"] = "Abrams",
        end
["Bebop"] = "Bebop",
        local hit_once = "false"
["Billy"] = "Punkgoat",
        if (attr_key == "DPS" or attr_key == "SustainedDPS")
["Calico"] = "Nano",
            and weapon_table
["The Doorman"] = "Doorman",
            and weapon_table.HitOnceAcrossAllBullets
["Drifter"] = "Drifter",
        then
["Dynamo"] = "Dynamo",
            hit_once = "true"
["Grey Talon"] = "Orion",
        end
["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",
    ["Pocket"] = "Synth",
    ["Seven"] = "Gigawatt",
    ["Shiv"] = "Shiv",
    ["Sinclair"] = "Magician",
    ["Victor"] = "Frank",
    ["Vindicta"] = "Vindicta",
    ["Viscous"] = "Viscous",
    ["Vyper"] = "Viper",
    ["Warden"] = "Warden",
    ["Wraith"] = "Wraith",
    ["Yamato"] = "Yamato",
}


        local data_attrs = string.format(
-- Function to call hero tags based on name
            '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"',
p.get_hero_tag = function (frame)
            attr_key,
    local name = frame.args[1]
            tostring(type(base_value) == "number" and util_module.round_to_sig_fig(base_value, 3) or base_value),
    local number = tonumber(frame.args[2])
            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)
    -- Validate input
    if not name then
         return "Error: Missing name input."
     end
     end


     -- Generate a hero's primary stat row
     if number ~= 1 and number ~= 2 and number ~= 3 then
    local function generatePrimaryRow(hero_data, hero_key, has_alt)
         return string.format("Error: Invalid number '%s'. Must be 1, 2, or 3.", tostring(frame.args[2]))
        local row_str = ""
        local hero_name_local = localize(hero_key, hero_key)
        local hero_name_en = hero_data["Name"]
        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
        if has_alt then
            hero_cell_content = '[[#alt-fire-' .. hero_key .. '|+]] ' .. hero_cell_content
        end
        local sort_name = (hero_data["Name"] or hero_key):gsub("^The ", "")
        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
            if stats_to_include[category] ~= nil then
                for _, attr_key in ipairs(stats_to_include[category]) do
                    row_str = row_str .. buildStatCell(hero_data, hero_key, attr_key, false, category)
                end
            end
        end
        return "<tr>" .. row_str .. "</tr>"
     end
     end


     -- Generate an expandable alt-fire sub-row (weapon stats only)
     local tagname = TAG_NAME_MAP[name]
    local function generateAltFireSubRow(hero_data, hero_key)
    if not tagname then
        local row_str = ""
         return string.format("Error: Unknown name '%s'.", name)
        local hero_name_local = localize(hero_key, hero_key)
        local hero_name_en = hero_data["Name"]
        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
        return '<tr class="alt-fire-sub" data-parent="' .. hero_key .. '">' .. row_str .. '</tr>'
     end
     end


     -- Build all body rows
     -- Build localization key
     for _, hero_entry in ipairs(sorted_heroes) do
     local key = string.format("Citadel_%s_HeroTag_%d", tagname, number)
        local hero_key  = hero_entry.key
        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.
     -- Call Lang.get_string
     -- Used to set column widths in the header.
     local result = lang_module.get_string(key)
    local stats_with_any_scaling  = {}
    local stats_with_both_scaling = {}
    for _, hero_entry in ipairs(sorted_heroes) do
        local hero_data = hero_entry.data
        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
                    -- Primary scaling
                    local scaling_data = hero_data_module.get_hero_scaling_data(hero_data, attr_key)
                    if scaling_data ~= nil and next(scaling_data) ~= nil then
                        stats_with_any_scaling[attr_key] = true
                        local has_spirit, has_level = false, false
                        for _, scaling_type in pairs(scaling_data) do
                            if scaling_type == "Spirit" then has_spirit = true
                            elseif scaling_type == "Level" then has_level = true 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)
                    if hero_data.Weapon
                        and hero_data.Weapon.AltFire
                        and hero_data.Weapon.AltFire[attr_key] ~= nil
                    then
                        if attr_key ~= "ClipSize" then
                            local alt_scaling = hero_data_module.get_hero_scaling_data(hero_data, attr_key .. "AltFire")
                            if alt_scaling and next(alt_scaling) ~= nil then
                                stats_with_any_scaling[attr_key] = true
                                local has_spirit_alt, has_level_alt = false, false
                                for _, stype in pairs(alt_scaling) do
                                    if stype == "Spirit" then has_spirit_alt = true
                                    elseif stype == "Level" then has_level_alt = true end
                                end
                                if has_spirit_alt and has_level_alt then stats_with_both_scaling[attr_key] = true end
                            else
                                if attr_key == "DPS" or attr_key == "SustainedDPS" then
                                    local alt_stats = hero_data.Weapon.AltFire
                                    local dps_type = attr_key == "DPS" and 'burst' or 'sustained'
                                    local lv = compute_dps_scaling(hero_data, alt_stats, dps_type, "Level")
                                    local sp = compute_dps_scaling(hero_data, alt_stats, dps_type, "Spirit")
                                    lv = util_module.round_to_sig_fig(lv, 5)
                                    sp = util_module.round_to_sig_fig(sp, 5)
                                    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
    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>'
    local category_data = attribute_module.get_category_data()
    local postfix_key_map = {
        ["ReloadDelay"] = "StatDesc_ReloadTime_postfix",
        ["BulletsPerShot"] = "",
        ["BulletsPerBurst"] = "",
        ["BurstInterShotInterval"] = "StatDesc_ReloadTime_postfix",
        ["ReloadSingle"] = "",
        ["BonusAttackRange"] = "StatDesc_WeaponRangeFalloffMax_postfix",
        ["SustainedDPS"] = "DPS_postfix",
        ["RoundsPerSecondAtMaxSpin"] = "",
        ["CritDamageBonusPercent"]  = "StatDesc_CritDamageBonusScale_postfix",
["CritDamageReceivedPercent"] = "StatDesc_CritDamageReceivedScale_postfix",
        ["BulletLifesteal"] = "BulletLifestealPercentHero_postfix",
        ["GroundDashSpeed"] = "DashSpeed_postfix"
    }
    for _, category in ipairs(attribute_orders["category_order"]) do
        local category_attrs = attributes_data[category]
        local category_rgb  = category_data[category]["rgb"]
        if stats_to_include[category] ~= nil then
            for _, attr_key in ipairs(stats_to_include[category]) do
                local attr_data = category_attrs[attr_key]
               
                -- Fallback: if the stat is missing from this category, check all other categories
                if attr_data == nil then
                    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"])
                    if attr_localized == nil or attr_localized == "" then
                        attr_localized = util_module.add_space_before_cap(attr_key)
                    end
                    postfix = lang_module.get_string(attr_data["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)
                    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 ~= "" then postfix = " (" .. postfix .. ")" 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
                    th_style = th_style .. ' min-width: 130px;'
                elseif stats_with_any_scaling[attr_key] then
                    th_style = th_style .. ' min-width: 75px;'
                end
                headers_str = headers_str .. '<th style="' .. th_style .. '">' .. attr_localized .. postfix .. "</th>"
            end
        end
    end
    headers_str = "<tr>" .. headers_str .. "</tr>"


     return string.format(
     return result or ("[Missing string for key: " .. key .. "]")
        '<div id="hero-comparison-container" data-max-power="%s" data-max-spirit="%s">' ..
        '<div style="overflow: auto; max-height: 70vh; width: 100%%;">' ..
        '<table class="wikitable sortable" style="table-layout: auto; width: 100%%;" id="hero-comparison-table">%s%s</table>' ..
        '</div></div>',
        max_power, max_spirit, headers_str, body_str
    )
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"