Editing Module:Sandbox/LVL

Jump to navigation Jump to search
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
   
    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
     end


     local clip_size = stats.ClipSize or 0
    return var_value
     if clip_size <= 0 then
end
         return base_damage * bullets_per_shot * burst_count / total_cycle_time
 
--{{#invoke:HeroData|get_alt_fire_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
p.get_alt_fire_var = function(frame)
    local hero_name = frame.args[1]
    local 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
   
    if not (hero.Weapon and hero.Weapon.AltFire) then
        return "No Alt Fire"
    end
   
     local var_value = hero.Weapon.AltFire[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)
    end
   
    --localize
    if (sig_figs_or_localize == "true") then
         return lang_module.get_string(var_value)
     end
     end


     local reload_time
     return var_value
    if stats.ReloadSingle then
end
        reload_time = (stats.ReloadTime or 0) * clip_size
 
    else
--{{#invoke:HeroData|get_list_elem|HERO_NAME|VAR|NUMBER|LOCALIZE}}
        reload_time = stats.ReloadTime or 0
p.get_list_elem = function(frame)
    end
local hero_name = frame.args[1]
    reload_time = reload_time + (stats.ReloadDelay or 0)
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


    local time_to_empty_clip = (clip_size / burst_count) * total_cycle_time
p.get_ability_key = function(frame)
    local damage_from_clip = base_damage * bullets_per_shot * clip_size
local hero_key = frame.args[1]
    local total_time = time_to_empty_clip + reload_time
local bound_slot_number = frame.args[2]
    if total_time == 0 then return 0 end
local hero_data = heroes_data[hero_key]
    return damage_from_clip / total_time
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
end


-- Compute how much DPS changes when all relevant component scalings are applied.
p.write_role_playstyle_quote = function(frame)
-- Used for alt-fire rows where explicit DPS/SustainedDPS scaling keys are missing.
local hero_key = frame.args[1]
local function compute_dps_scaling(hero_data, base_stats, dps_type, scaling_type)
local hero_data = heroes_data[hero_key]
    local scaling_source = hero_data[scaling_type .. "Scaling"] or {}
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 component_scalings = {}
p.write_default_items = function(frame)
    local possible_keys = {
local hero_key = frame.args[1] --unlocalized
        "BulletDamage", "RoundsPerSecond", "ClipSize", "ReloadTime",
if (hero_key == nil) then return "No hero key provided" end
        "ReloadDelay", "BulletsPerShot", "BulletsPerBurst"
local str = ""
    }
local hero = heroes_data[hero_key]
    for _, key in ipairs(possible_keys) do
if (hero == nil) then return "Hero not found, must be unlocalized" end
        local alt_key = key .. "AltFire"
local template_title = 'PageRef'
        if scaling_source[alt_key] then
for i, item_key in ipairs(hero["RecommendedItems"]) do
            component_scalings[key] = scaling_source[alt_key]
template_args = {}
        end
template_args[1] = lang_module.get_string(item_key, 'en')
    end
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


    -- ClipSize is shared between fire modes; fall back to primary scaling
--If the hero scales with the stat, it returns {{Ss|value}} or {{Ls|value}}, else blank string
    if base_stats.ClipSize and not component_scalings.ClipSize then
--{{#invoke:HeroData|get_hero_scalar|HERO_NAME|SCALING_TYPE|STAT_NAME|sig_figs_or_localize}}--
        local primary_clip_scale = scaling_source["ClipSize"]
p.get_hero_scalar = function(frame)
        if primary_clip_scale then
local hero_key = frame.args[1]
            component_scalings.ClipSize = primary_clip_scale
local scaling_type = frame.args[2]
        end
local hero_stat_key = frame.args[3]
    end
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


    if next(component_scalings) == nil then
--round
        return 0
if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
    end
scaling_value = util_module.round_to_sig_fig(scaling_value, sig_figs_or_localize)
if (scaling_value == nil) then return "get_hero_scalar() error with rounding" end
end
--localize
if (sig_figs_or_localize == "true") then
return lang_module.get_string(scaling_value)
end
local scaling_str = p.write_scalar_str(scaling_value, scaling_type)


    local base_dps = calculate_dps(base_stats, dps_type)
return scaling_str
    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


-- =========================================================================
-- Check if a hero has a stat (Base, Boons, or Spirit Scaling)
-- Main module function
-- 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]
 
    if (hero_key == nil) then return nil end
   
    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 nil end


p.write_hero_comparison_table = function(frame)
    -- 1. Check Base Value
     local power_increases = tonumber(frame.args[1]) or 0
     -- We allow 0 if it's explicitly set, but usually we filter 0 for hiding.  
     local spirit_power    = tonumber(frame.args[2]) or 0
     -- However, for resists, 0 usually means "hide", so we check ~= 0.
     local max_power      = tonumber(frame.args[3]) or 25
     local val = hero_data[stat_key]
     local max_spirit      = tonumber(frame.args[4]) or 500
     if (val ~= nil and val ~= 0) then return "true" end


     local display_scaling_icons = (power_increases == 0 and spirit_power == 0)
     -- 2. Check Level Scaling (Boons)
    if (hero_data["LevelScaling"] ~= nil and hero_data["LevelScaling"][stat_key] ~= nil and hero_data["LevelScaling"][stat_key] ~= 0) then
        return "true"
    end


     local body_str = ""
     -- 3. Check Spirit Scaling
    if (hero_data["SpiritScaling"] ~= nil and hero_data["SpiritScaling"][stat_key] ~= nil and hero_data["SpiritScaling"][stat_key] ~= 0) then
        return "true"  
    end


     local stats_to_include = {
     return nil
        Weapon = {
end
            "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" }
    }


    -- Collect and sort heroes alphabetically, excluding disabled/in-development
-- Retrieve scaling string of a hero's given stat, if it has scaling, else return blank
    local sorted_heroes = {}
-- Scaling string meaning the expanded template {{Ss|scalar}} or {{Ls|scalar}}
    for hero_key, hero_data in pairs(heroes_data) do
function p.write_scalar_str(scaling_value, scaling_type)
        if not hero_data["InDevelopment"] and not hero_data["IsDisabled"] then
local scaling_abbrevs = {Spirit = "Ss", Level = "PI"}
            table.insert(sorted_heroes, {key = hero_key, data = hero_data})
        end
-- Return blank if it doesnt scale
    end
if (scaling_value == 0) then return "" end
     table.sort(sorted_heroes, function(a, b)
        local function get_sort_name(name)
-- Round it
            return (name:gsub("^The ", ""))
scaling_value = util_module.round_to_sig_fig(scaling_value, 3)
        end
        return get_sort_name(a.data["Name"] or a.key) < get_sort_name(b.data["Name"] or b.key)
--The hero has a scaling value with this stat
    end)
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


    -- Build a single stat cell (<td>) with data attributes for JS recalculation
-- Retrieve scaling value and type of a hero's given stat, if it has scaling, else return 0
    local function buildStatCell(hero_data, hero_key, attr_key, is_alt_fire, category)
function p.get_hero_scaling_data(hero_data, hero_stat_key)
        -- Conversion factors for stats that need unit changes (e.g. metres → centimetres)
local scaling_type_full
        local unit_conversion = {
local scaling_data
            BulletRadius = 100  -- metres to centimetres
local scaling_value
        }
local scaling_types = {"Spirit", "Level"}
        local conv_factor = unit_conversion[attr_key] or 1
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


        local base_value
local function get_nested_stat_value(hero_data, stat_key)
        if is_alt_fire then
    -- Check top-level, then Weapon, then AltFire
            if attr_key == "ClipSize" or attr_key == "ReloadTime" then
    if hero_data[stat_key] ~= nil then
                base_value = get_nested_stat_value(hero_data, attr_key)
        return hero_data[stat_key]
            elseif hero_data.Weapon and hero_data.Weapon.AltFire
    elseif hero_data.Weapon and hero_data.Weapon[stat_key] ~= nil then
                and hero_data.Weapon.AltFire[attr_key] ~= nil then
        return hero_data.Weapon[stat_key]
                base_value = hero_data.Weapon.AltFire[attr_key]
    elseif hero_data.Weapon and hero_data.Weapon.AltFire and hero_data.Weapon.AltFire[stat_key] ~= nil then
            else
        return hero_data.Weapon.AltFire[stat_key]
                base_value = get_nested_stat_value(hero_data, attr_key)
    end
            end
    return 0
        else
end
            base_value = get_nested_stat_value(hero_data, attr_key)
        end


        -- Apply unit conversion to the base value
--writes the massive hero comparison table for a specific PI and SP
        if type(base_value) == "number" then
-- scaling icons are shown only if PI and SP are both 0 or both not provided
             base_value = base_value * conv_factor
--{{#invoke:HeroData|write_hero_comparison_table|POWER_INCREASES|SPIRIT_POWER|MAX_POWER|MAX_SPIRIT}}
        end
p.write_hero_comparison_table = function(frame)
-- process inputs
local power_increases = frame.args[1]
if (power_increases == nil) then power_increases = 0 end
local spirit_power = frame.args[2]
if (spirit_power == nil) then spirit_power = 0 end
local max_power = frame.args[3] or 25
local max_spirit = frame.args[4] or 500
-- 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
-- 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"
}
}


        local stat_value = base_value
-- Collect and sort heroes alphabetically by name
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)
return (a.data["Name"] or a.key) < (b.data["Name"] or b.key)
end)


        -- Scaling lookup
-- Iterate heroes
        local scaling_data
for _, hero_entry in ipairs(sorted_heroes) do
        if is_alt_fire then
local hero_key = hero_entry.key
            if attr_key == "ClipSize" or attr_key == "ReloadTime" then
local hero_data = hero_entry.data
                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 = ""
row_str = ""
        local spirit_scale = 0
        local level_scale = 0
-- Retrieve hero's localized name
        local spirit_val = 0
hero_name = localize(hero_key, hero_key)
        local level_val  = 0
        if scaling_data ~= nil then
-- Retrieve hero's english name, used for hero icon
            for scaling_val, scaling_type in pairs(scaling_data) do
hero_name_en = hero_data["Name"]
                if scaling_type == "Spirit" then
                    spirit_val = scaling_val * conv_factor  -- apply unit conversion
-- Expand hero icon
                elseif scaling_type == "Level" then
template_title = "Template:HeroIcon"
                    level_val = scaling_val * conv_factor  -- apply unit conversion
template_args[1] = hero_name_en
                end
template_args[2] = hero_name
            end
hero_icon = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
-- First column in each row is hero name (sticky)
row_str = row_str .. '<td style="position: sticky; left: 0; z-index: 10; background-color: #202122; isolation: isolate;">' .. hero_icon .. "</td>"
-- Consecutive columns are then stats
-- Iterate categories
for _, category in ipairs(attribute_orders["category_order"]) do
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
--Retrieve the stats value from hero data
local base_value = get_nested_stat_value(hero_data, attr_key)
local stat_value = base_value
-- Retrieve scaling val and str if it scales
local scaling_data = p.get_hero_scaling_data(hero_data, attr_key)
local scaling_strs = ""
local spirit_scale = 0
local level_scale = 0
local is_resist = (attr_key == 'TechResist' or attr_key == 'BulletResist')
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
       
        -- Track scaling values for data attributes
        if (scaling_type == "Spirit") then
            spirit_scale = scaling_val
            stat_value = stat_value + (spirit_power * scaling_val)
        elseif (scaling_type == "Level") then
            level_scale = scaling_val
            if is_resist then
                -- each PI for resists is multiplicative
                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
-- TechPower gains 1:1 with user-input Spirit Power (only if not already defined)
if attr_key == 'TechPower' and spirit_scale == 0 then
    spirit_scale = 1.0
    stat_value = stat_value + (spirit_power * spirit_scale)
end
-- Calculate innate TechPower scaling for this hero
local innate_spirit_scale = 1.1 -- Default for most heroes
if hero_data["LevelScaling"] and hero_data["LevelScaling"]["TechPower"] then
    innate_spirit_scale = hero_data["LevelScaling"]["TechPower"]
elseif hero_data["Spirit"] and hero_data["Spirit"]["LevelScaling"] then
    innate_spirit_scale = hero_data["Spirit"]["LevelScaling"]
end
-- Hide scaling icons if not at base values
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
-- Build tooltip content showing scaling info
local tooltip_lines = {}
local has_scaling = false
if type(base_value) == "number" then
    table.insert(tooltip_lines, string.format("Base: %s", util_module.round_to_sig_fig(base_value, 3)))
end
if attr_key == 'TechPower' then
    -- TechPower is unique: it represents Spirit Power itself.
    -- We only show its base and how much it grows per boon.
    local tp_boon_scale = (level_scale > 0) and level_scale or innate_spirit_scale
    if tp_boon_scale and tp_boon_scale > 0 then
        table.insert(tooltip_lines, string.format("Level: +%s per boon", tp_boon_scale))
        has_scaling = true
    end
else
    -- Standard stat tooltip logic
    if level_scale and level_scale > 0 then
        table.insert(tooltip_lines, string.format("Level: +%s per boon", level_scale))
        has_scaling = true
    end
    if spirit_scale and spirit_scale > 0 then
        table.insert(tooltip_lines, string.format("Spirit: +%s per Spirit", spirit_scale))
        has_scaling = true
    end
end
local tooltip_text = table.concat(tooltip_lines, "<br>")
-- Build data attributes for JavaScript manipulation (ONLY ONCE)
local data_attrs = string.format(
    'data-base="%s" data-spirit-scale="%s" data-level-scale="%s" data-innate-spirit-scale="%s"%s',
    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,
    is_resist and ' data-is-resist="true"' or ''
)
-- Build cell with tooltip wrapper ONLY if there is scaling
local cell_inner
if has_scaling then
    cell_inner = string.format(
        '<span class="tooltip-container">' ..
        '<span class="tooltip-trigger" tabindex="0"><span class="stat-num">%s</span></span>' ..
        '<span class="tooltip-content" role="tooltip">%s</span>' ..
        '</span>',
        stat_value,
        tooltip_text
    )
else
    cell_inner = string.format('<span class="stat-num">%s</span>', stat_value)
end
-- Add it to the row with data attributes and span wrapper
row_str = row_str .. string.format(
    '<td %s>%s</td>',
    data_attrs,
    cell_inner
)
end
end
end
-- Add row to the body
row_str = "<tr>" .. row_str .. "</tr>"
body_str = body_str .. row_str
end
-- First header is Hero (sticky)
local headers_str = '<th style="position: sticky; left: 0; top: 0; z-index: 12; background-color: #27292d; isolation: isolate;">Hero</th>'
local header_style = ""
local category_data = attribute_module.get_category_data()
local postfix
-- Used for keys that are not localized by Valve
local postfix_key_map = {
["ReloadDelay"] = "StatDesc_ReloadTime_postfix",
["BulletsPerShot"] = "",
["BulletsPerBurst"] = "",
["BurstInterShotInterval"] = "StatDesc_ReloadTime_postfix",
["ReloadSingle"] = "",
["BonusAttackRange"] = "StatDesc_WeaponRangeFalloffMax_postfix",
["SustainedDPS"] = "DPS_postfix",
["RoundsPerSecondAtMaxSpin"] = "",
["CritDamageBonusScale"] = "StatDesc_CritDamageBonusScale_postfix",
["BonusCritDamagePercent"] = "BonusCritDamagePercent_postfix",
["BulletLifesteal"] = "BulletLifestealPercentHero_postfix",
["GroundDashSpeed"] = "DashSpeed_postfix"
}
-- Iterate stats again for displaying headers with their respective color
for _, category in ipairs(attribute_orders["category_order"]) do
category_attrs = attributes_data[category]
category_rgb = category_data[category]["rgb"]
-- Iterate attributes within the category
if (stats_to_include[category] ~= nil) then
for _, attr_key in ipairs(stats_to_include[category]) do
attr_data = category_attrs[attr_key]
if (attr_data ~= nil) then
-- Localize, fallback to attr_key with proper spaces
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
-- Get postfix
postfix = lang_module.get_string(attr_data["postfix"])
if (postfix == nil or postfix == "") then
postfix = ""
else
postfix = " (" .. postfix .. ")"
end
else -- If not in attributes data, use dictionary translate and postfix
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_style = ' style="position: sticky; top: 0; z-index: 3; background-color: rgb(' .. category_rgb .. ');"'
headers_str = headers_str .. "<th" .. header_style .. ">" .. attr_localized .. postfix .. "</th>"
end
end
end
headers_str = "<tr>" .. headers_str .. "</tr>"


            -- Output Spirit icon before Level icon
-- Wrap table in container with data attributes for JS
            local function append_scaling(val, stype)
local table_str = string.format(
                if val ~= 0 then
'<div id="hero-comparison-container" data-max-power="%s" data-max-spirit="%s">' ..
                    local scaling_str = hero_data_module.write_scalar_str(val, stype, true)
'<div style="overflow: auto; max-height: 70vh; width: 100%%;">' ..
                    if scaling_str ~= "" then
'<table class="wikitable sortable" style="table-layout: auto; width: 100%%;" id="hero-comparison-table">%s%s</table>' ..
                        scaling_strs = scaling_strs .. " " .. scaling_str
'</div></div>',
                    end
max_power,
                end
max_spirit,
            end
headers_str,
            append_scaling(spirit_val, "Spirit")
body_str
            append_scaling(level_val, "Level")
)
return table_str
end


            if type(stat_value) == "number" then
function localize(key, fallback)
                stat_value = stat_value + (spirit_power * spirit_val)
local result = lang_module.get_string(key)
                stat_value = stat_value + (power_increases * level_val)
if (result == "") or (result == nil) then
            end
result = util_module.add_space_before_cap(fallback) .. mw.getCurrentFrame():expandTemplate{title="MissingValveTranslationTooltip"}
end
return result
end


            spirit_scale = spirit_val
-- Mapping from hero name to internal tag name
            level_scale  = level_val
local TAG_NAME_MAP = {
        end
["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",
}


        if attr_key == "TechPower" and spirit_scale == 0 then
-- Function to call hero tags based on name
            spirit_scale = 1.0
p.get_hero_tag = function (frame)
            if type(stat_value) == "number" then
    local name = frame.args[1]
                stat_value = stat_value + (spirit_power * spirit_scale)
    local number = tonumber(frame.args[2])
            end
        end


         local innate_spirit_scale =
    -- Validate input
            (hero_data["LevelScaling"] and hero_data["LevelScaling"]["TechPower"]) or 0
    if not name then
         return "Error: Missing name input."
    end


        if not display_scaling_icons then scaling_strs = "" 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


        if type(stat_value) == "boolean" then
    local tagname = TAG_NAME_MAP[name]
            stat_value = tostring(stat_value)
    if not tagname then
         else
         return string.format("Error: Unknown name '%s'.", name)
            stat_value = util_module.round_to_sig_fig(stat_value, 5)
    end
        end


        local cell_inner = string.format(
    -- Build localization key
            '<span class="stat-num">%s</span><span class="stat-scaling">%s</span>',
    local key = string.format("Citadel_%s_HeroTag_%d", tagname, number)
            stat_value,
            scaling_strs
        )


        local weapon_table = hero_data.Weapon
    -- Call Lang.get_string
        if is_alt_fire and weapon_table and weapon_table.AltFire then
    local result = lang_module.get_string(key)
            weapon_table = weapon_table.AltFire
        end
        local hit_once = "false"
        if (attr_key == "DPS" or attr_key == "SustainedDPS")
            and weapon_table
            and weapon_table.HitOnceAcrossAllBullets
        then
            hit_once = "true"
        end


        local data_attrs = string.format(
    return result or ("[Missing string for key: " .. key .. "]")
            '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"',
end
            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)
-- Outputs a wikitable of heroes grouped by GroundDashDuration using {{HeroIcon|hero_name}}
     end
-- {{#invoke:HeroData|write_ground_dash_buckets}}
p.write_ground_dash_buckets = function(frame)
    local buckets = {
         [0.62] = {},
        [0.68] = {},
        [0.70] = {},
     }


    -- Generate a hero's primary stat row
     local get_dash = function(hero)
     local function generatePrimaryRow(hero_data, hero_key, has_alt)
         return hero.GroundDashDuration
         local row_str = ""
             or (hero.Weapon and hero.Weapon.GroundDashDuration)
        local hero_name_local = localize(hero_key, hero_key)
             or (hero.Weapon and hero.Weapon.AltFire and hero.Weapon.AltFire.GroundDashDuration)
        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)
     -- Collect heroes
     local function generateAltFireSubRow(hero_data, hero_key)
     for hero_key, hero_data in pairs(heroes_data) do
        local row_str = ""
         if not hero_data.InDevelopment and not hero_data.IsDisabled then
        local hero_name_local = localize(hero_key, hero_key)
            local dash = get_dash(hero_data)
        local hero_name_en = hero_data["Name"]
             if dash and buckets[dash] then
        local template_args = {[1] = hero_name_en, l1 = hero_name_local}
                 table.insert(buckets[dash], hero_data.Name or hero_key)
        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
         end
        return '<tr class="alt-fire-sub" data-parent="' .. hero_key .. '">' .. row_str .. '</tr>'
     end
     end


     -- Build all body rows
     -- Sort alphabetically
     for _, hero_entry in ipairs(sorted_heroes) do
     for _, list in pairs(buckets) do
         local hero_key  = hero_entry.key
         table.sort(list)
        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
     end


     -- Pre-pass: determine which stats have any scaling, and which have both types.
     -- Determine max rows dynamically
    -- Used to set column widths in the header.
     local max_rows = 0
     local stats_with_any_scaling  = {}
     for _, list in pairs(buckets) do
    local stats_with_both_scaling = {}
         if #list > max_rows then max_rows = #list end
     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
     end


    -- Build table header row
     local output = {"{| class='wikitable'", "! Bucket 1 !! Bucket 2 !! Bucket 3"}
     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 current_frame = frame or mw.getCurrentFrame()
    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
    for i = 1, max_rows do
                if attr_data ~= nil then
        local row = {}
                    attr_localized = lang_module.get_string(attr_data["label"])
        for _, bucket in ipairs({0.62, 0.68, 0.70}) do
                    if attr_localized == nil or attr_localized == "" then
            local hero_name = buckets[bucket][i]
                        attr_localized = util_module.add_space_before_cap(attr_key)
            table.insert(row, hero_name and current_frame:expandTemplate{title = "HeroIcon", args = {hero_name}} or "")
                    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
        table.insert(output, "|-\n| " .. table.concat(row, " || "))
     end
     end
    headers_str = "<tr>" .. headers_str .. "</tr>"


     return string.format(
     table.insert(output, "|}")
        '<div id="hero-comparison-container" data-max-power="%s" data-max-spirit="%s">' ..
    return table.concat(output, "\n")
        '<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"