The Deadlock Wiki

Module:HeroData: Difference between revisions

Browse history interactively
← Older edit

Vergir (talk | contribs)

2 user groups
1,640 edits
undo
Sur (talk | contribs)
Moderators
2,147 edits
m call_lang removed
Vergir (talk | contribs)
Contributors, Interface administrators
1,640 edits
m replace Ls => PI in the comments to match code
 
(152 intermediate revisions by 7 users not shown)
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 util_module = require('Module:Utilities')
local util_module = require('Module:Utilities')
local lang_module = require('Module:Lang')
local lang_module = require('Module:Lang')
local attribute_module = require('Module:AttributeData')
 
--------------------------------------------------------------------------------
-- Internal helpers
--------------------------------------------------------------------------------
 
-- Localized string for a key, falling back to a readable version of `fallback`
-- plus a "missing translation" tooltip.
local function localize(key, fallback)
local result = lang_module.get_string(key)
if (result == "") or (result == nil) then
result = util_module.add_space_before_cap(fallback) .. mw.getCurrentFrame():expandTemplate{title="MissingValveTranslationTooltip"}
end
return result
end
 
-- Raw scaling value of a stat under LevelScaling / SpiritScaling, or nil when
-- the hero has no scaling of that type for that stat.
local function raw_scaling(hero_data, scaling_type, stat)
local scaling = hero_data and hero_data[scaling_type .. "Scaling"]
if (scaling == nil or stat == nil) then return nil end
return scaling[stat]
end
 
-- Mapping from hero name to internal tag name
local TAG_NAME_MAP = {
["Abrams"] = "Abrams",
["Bebop"] = "Bebop",
["Billy"] = "Punkgoat",
["Calico"] = "Nano",
["The Doorman"] = "Doorman",
["Drifter"] = "Drifter",
["Dynamo"] = "Dynamo",
["Apollo"] = "Fencer",
["Graves"] = "Necro",
["Grey Talon"] = "Orion",
["Haze"] = "Haze",
["Holliday"] = "Astro",
["Infernus"] = "Inferno",
["Ivy"] = "Tengu",
["Kelvin"] = "Kelvin",
["Lady Geist"] = "Geist",
["Lash"] = "Lash",
["McGinnis"] = "Engineer",
["Mina"] = "VampireBat",
["Mirage"] = "Mirage",
["Mo & Krill"] = "Digger",
["Paige"] = "Bookworm",
["Paradox"] = "Chrono",
["Celeste"] = "Unicorn",
["Pocket"] = "Synth",
["Rem"] = "Familiar",
["Seven"] = "Gigawatt",
["Shiv"] = "Shiv",
["Silver"] = "Werewolf",
["Silver (Transformed)"] = "Werewolf",
["Sinclair"] = "Magician",
["Venator"] = "Priest",
["Victor"] = "Frank",
["Vindicta"] = "Vindicta",
["Viscous"] = "Viscous",
["Vyper"] = "Viper",
["Warden"] = "Warden",
["Wraith"] = "Wraith",
["Yamato"] = "Yamato",
}
 
--------------------------------------------------------------------------------
-- Data access, for use by other modules
--------------------------------------------------------------------------------


-- returns the table of a specific item, used by external modules
-- returns the table of a specific item, used by external modules
Line 16: Line 83:
end
end


-- Hero table for a hero_* key or an exact English name, or nil.
local function hero_by_key_or_name(input)
local hero = heroes_data[input]
if (hero == nil) then hero = p.get_json_item(input) end
return hero
end


--{{#invoke:HeroData|get_hero_stat|HERO_NAME|STAT_NAME}}--
-- Value of a stat, checking the hero's top level, then Weapon, then AltFire.
p.get_hero_stat = function(frame)
-- Returns nil when the hero has no such stat.
local hero_name = frame.args[1]
function p.get_stat(hero_data, stat)
local hero_stat_key = frame.args[2]
if (hero_data == nil or stat == nil) then return nil end
local value = hero_data[stat]
local hero = p.get_json_item(hero_name)
if (value == nil and hero_data.Weapon) then
if(hero == nil) then return "Hero Not Found" end
value = hero_data.Weapon[stat]
end
local var_value = hero[hero_stat_key]
if (value == nil and hero_data.Weapon and hero_data.Weapon.AltFire) then
if(var_value == nil) then return 0 end
value = hero_data.Weapon.AltFire[stat]
end
return value
end


return var_value
-- Ordered list of a hero's scalings for a stat, Level first then Spirit:
--  { { type = "Level", value = 1.5 }, { type = "Spirit", value = 0.04 } }
-- Absent scalings are omitted, so an empty list means "no scaling". Zero
-- scalings are omitted too unless include_zero is set, which only the
-- deprecated get_hero_scaling_data below needs.
function p.get_scalings(hero_data, stat, include_zero)
local scalings = {}
for _, scaling_type in ipairs({"Level", "Spirit"}) do
local value = raw_scaling(hero_data, scaling_type, stat)
if (value ~= nil and (include_zero or value ~= 0)) then
table.insert(scalings, { type = scaling_type, value = value })
end
end
return scalings
end
end


-- DEPRECATED, kept for [[Module:HeroComparisonTable]]. Use p.get_scalings.
-- Keyed by scaling value, so it silently drops an entry when Level and Spirit
-- scale by the same amount, and it keeps zero scalings.
function p.get_hero_scaling_data(hero_data, hero_stat_key)
local scaling_data_returned = {}
-- Walked backwards so Level is written last and wins a value collision,
-- matching the original Spirit-then-Level assignment order.
local scalings = p.get_scalings(hero_data, hero_stat_key, true)
for i = #scalings, 1, -1 do
scaling_data_returned[scalings[i].value] = scalings[i].type
end
return scaling_data_returned
end


--If the hero scales with the stat, it returns {{Ss|value}} or {{Ls|value}}, else blank string
-- Whether a hero has a stat at all: a non-zero base value, or any scaling.
--{{#invoke:HeroData|get_hero_scalar_str_invoke|HERO_NAME|STAT_NAME}}--
function p.has_stat(hero_data, stat)
p.get_hero_scalar_str_invoke = function(frame)
local base = p.get_stat(hero_data, stat)
local hero_name = frame.args[1]
if (base ~= nil and base ~= 0) then return true end
local hero_stat_key = frame.args[2]
return #p.get_scalings(hero_data, stat) > 0
local hero_data = p.get_json_item(hero_name)
if(hero_data == nil) then return "Hero Not Found" end
return p.get_hero_scalar_str(hero_data, hero_stat_key) --surely theres a better way
end
end


function p.get_hero_scalar_str(hero, hero_stat_key)
-- Resolves a hero_* key or an English hero name to a hero_* key.
local scaling_type_full
-- Returns nil when the input matches no hero. Name matching is case-insensitive.
local scaling_data
function p.find_hero_key(input)
local scaling_value
if (input == nil or input == '') then return nil end
local scaling_types = {"Spirit", "Level"}
if (heroes_data[input] ~= nil) then return input end
local scaling_abbrevs = {"Ss", "Ls"}
local wanted = mw.ustring.lower(input)
for hero_key, hero_data in pairs(heroes_data) do
for index, scaling_type in ipairs(scaling_types) do
if (hero_data["Name"] and mw.ustring.lower(hero_data["Name"]) == wanted) then
scaling_type_full = scaling_type .. "Scaling"
return hero_key
scaling_data = hero[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_value = util_module.round_to_sig_fig(scaling_value, 3)
--The hero has a scaling value with this stat
local template_title = "Template:" .. scaling_abbrevs[index] --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
end
end
end
end
return nil
-- Otherwise return empty string
end
return ""
 
-- A hero's Nth roster tag (1-3) by English name, or '' when there is no such tag.
function p.hero_tag(hero_en, index)
local tagname = hero_en and TAG_NAME_MAP[hero_en]
if (tagname == nil) then return '' end
if (index ~= 1 and index ~= 2 and index ~= 3) then return '' end
return lang_module.get_string(string.format("Citadel_%s_HeroTag_%d", tagname, index)) or ''
end
 
--------------------------------------------------------------------------------
-- Wikitext entry points
--------------------------------------------------------------------------------
 
-- returns the key of the specified hero's english name
function p.get_hero_key(frame)
local hero_name_input = frame.args[1]
if not hero_name_input then
return "Error: Hero name not specified."
end
return p.find_hero_key(hero_name_input) or "Hero not found."
end
 
--{{#invoke:HeroData|resolve_key|HERO_KEY_OR_NAME}}--
-- The matching hero_* key, or '' when the input matches no hero.
function p.resolve_key(frame)
return p.find_hero_key(frame.args[1]) or ''
end
end


--HERO_NAME in english
--{{#invoke:HeroData|get_hero_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
--{{#invoke:HeroData|write_infobox|HERO_NAME}}--
--sig_figs optional for rounding floats
p.write_infobox = function(frame)
p.get_hero_var = function(frame)
-- Get hero data
     local hero_name = frame.args[1]
     hero_name = frame.args[1]
     local hero_stat_key = frame.args[2]
     hero_data = p.get_json_item(hero_name)
     local sig_figs_or_localize = frame.args[3]
     if(hero_data == nil) then return "Hero Not Found" end
      
      
    -- Attributes to include in the infobox call
     local hero = hero_by_key_or_name(hero_name)
     local infobox_attributes = {
    if(hero == nil) then return "Hero Not Found" end
    Weapon = {"DPS", "ClipSize", "RoundsPerSecond", "ReloadTime"},
    Vitality = {"MaxHealth", "BulletResist", "SpiritResist", "MoveSpeed"}
    }
      
      
    -- Declarations and initializations
     local var_value = p.get_stat(hero, hero_stat_key)
     local category_data = attribute_module.get_category_data()
     if(var_value == nil) then return 0 end
     local stats
    local stat_data
    local stat_value
    local stat_text
    local label
    local postfix
      
      
     local templateArgs = {}
     --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
      
      
     -- Iterate attribute categories
     --localize
     for _, category in ipairs(infobox_attributes) do
     if (sig_figs_or_localize == "true") then
stats = attributes_data[category]
        return lang_module.get_string(var_value)
if (stats ~= nil) then -- Ensure the category is in the hero data
    end
 
-- Iterate attributes to be called by infobox
    return var_value
for _, stat_name in ipairs(infobox_attributes[category]) do
end
stat_data = stats[stat_name]
 
--{{#invoke:HeroData|get_alt_fire_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
-- gets the stat's value
p.get_alt_fire_var = function(frame)
stat_value = hero_data[stat_name]
    local hero_name = frame.args[1]
if (stat_value == nil) then
    local stat_key = frame.args[2]
stat_value = 0 --default to 0 if not present
    local sig_figs_or_localize = frame.args[3]
end
   
    local hero = hero_by_key_or_name(hero_name)
--Round value to 3 significant figures
    if(hero == nil) then return "Hero Not Found" end
stat_value = util_module.round_to_sig_fig(stat_value, 3)
-- get label and postfix
label = lang_module.get_string(stat_data["label"])
postfix = stat_data["postfix"]
if (postfix == nil) then  
postfix = ""
else
postfix = lang_module.call_lang(postfix)
end
end
else
return "Error: Category not in attributes data"
end
end
      
      
     for stat_name, stat_value in pairs(hero_data) do
     if not (hero.Weapon and hero.Weapon.AltFire) then
         if (type(stat_value) ~= "table") then  -- skips complex nested tables
         return "No Alt Fire"
            templateArgs[stat_name] = stat_value
        end
     end
     end
      
      
    -- Use expandTemplate to evaluate the Infobox_hero template
     local var_value = hero.Weapon.AltFire[stat_key]
     local templateTitle = mw.title.new("Template:Infobox_hero")
    if(var_value == nil) then return 0 end
     local expandedTemplate = mw.getCurrentFrame():expandTemplate{ title = templateTitle, args = templateArgs }
   
    --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
      
      
     return expandedTemplate
     --localize
    if (sig_figs_or_localize == "true") then
        return lang_module.get_string(var_value)
    end
 
    return var_value
end
 
--{{#invoke:HeroData|get_list_elem|HERO_NAME|VAR|NUMBER|LOCALIZE}}
p.get_list_elem = function(frame)
local hero_name = frame.args[1]
local var = frame.args[2]
local number_int = tonumber(frame.args[3])
local localize_arg = frame.args[4]
local hero = hero_by_key_or_name(hero_name)
if(hero == nil) then return "Hero Not Found" end
local list = p.get_stat(hero, var)
if (list == nil) then return "" end
local element = list[number_int]
if (element == nil) then return "" end
if localize_arg=="true" then
element = lang_module.get_string(element)
end
return element
end
end


p.get_ability_key = function(frame)
local hero_key = frame.args[1]
local bound_slot_number = frame.args[2]
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


p.write_role_playstyle_quote = function(frame)
local hero_key = frame.args[1]
local hero_data = heroes_data[hero_key]
if (hero_data == nil) then return hero_key.." not found" end
local role_key = hero_data["Role"]
local role_localized = lang_module.get_string(role_key, nil, 'en')
local playstyle_key = hero_data["Playstyle"]
local playstyle_localized = lang_module.get_string(playstyle_key, nil, 'en')
local str = "<b>" .. role_localized .. '</b><br>' .. playstyle_localized
local template_args = {}
template_args[1] = ""
template_args[2] = str
return frame:expandTemplate{title = 'Quotation', args = template_args}
end
p.write_default_items = function(frame)
local hero_key = frame.args[1] --unlocalized
if (hero_key == nil) then return "No hero key provided" end
local str = ""
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"] or {}) do
local 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


--{{#invoke:HeroData|write_stat_boxes|HERO_NAME}}
--If the hero scales with the stat, it returns {{Ss|value}} or {{PI|value}}, else blank string
--Creates {{StatBox}}'s' for the 3 categories Weapon, Vitality, Spirit
--{{#invoke:HeroData|get_hero_scalar|HERO_NAME|SCALING_TYPE|STAT_NAME|sig_figs_or_localize}}--
p.write_stat_boxes = function(frame)
p.get_hero_scalar = function(frame)
local hero_name = frame.args[1]
local hero_key = frame.args[1]
if(hero_name == nil) then return "Hero parameter missing" end
local scaling_type = frame.args[2]
local hero_stat_key = frame.args[3]
local sig_figs_or_localize = frame.args[4]
local no_template = frame.args["no_template"]
local hero_data = hero_by_key_or_name(hero_key)
if(hero_data == nil) then return "Hero not found." end
-- Use expandTemplate to evaluate the Infobox_hero template
local scaling_value = raw_scaling(hero_data, scaling_type, hero_stat_key)
    local template_title = mw.title.new("Template:StatBox") --name of the template
if scaling_value == nil then return "" end
    local template_calls = "" --all template calls concatenated
 
    local template_call --current template call
--round
local template_args = {} --current template arguments
if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
local cell_values --current cell values
scaling_value = util_module.round_to_sig_fig(scaling_value, sig_figs_or_localize)
local cell_value --current cell value
if (scaling_value == nil) then return "get_hero_scalar() error with rounding" end
local label --current stat's label
end
local postfix --current stat's postfix
local stat_value --current stat's numerical value in the hero data
local hero_data = p.get_json_item(hero_name)
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 = {BulletLifesteal = true, CritDamageReceivedScale = true}
if (hero_data == nil) then return "Hero Not Found in AttrData" end
local category_data = attribute_module.get_category_data()
for _, category in ipairs(attributes_data["_category_order"]) do
--localize
stats = attributes_data[category]
if (sig_figs_or_localize == "true") then
local category_values = category_data[category]
return lang_module.get_string(scaling_value)
template_args["box_name"] = category_values.unlocalized_name
end
template_args["box_rgb"] = category_values.rgb
template_args["num_cols"] = 2
cell_values = ""
-- Determine cell values
for _, stat_name in ipairs(stats["_attribute_order"]) do
stat_data = stats[stat_name]
-- 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 = util_module.call_lang(stat_data["label"])
postfix = stat_data["postfix"]
if (postfix == nil) then  
postfix = ""
else
postfix = util_module.call_lang(postfix)
end
-- Check if icon file exists, and if not, don't use any image
image_file_name = 'File:AttributeIcon' .. stat_name .. '.png'
image_file_name = util_module.get_image_file(image_file_name)
-- 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
-- Add the scaling str if it scales
local scalar_str = p.get_hero_scalar_str(hero_data, stat_name)
-- 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_name .. " " .. stat_value  .. postfix .. " " .. label .. " " .. scalar_str .. "," .. 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
if no_template == "true" then
template_calls = template_calls .. "\n" .. template_call
return scaling_value
end
end
-- Add a few newlines below the template calls to give space for the hover box
return p.write_scalar_str(scaling_value, scaling_type)
template_calls = template_calls .. "\n\n"
end
 
-- Check if a hero has a stat (Base, Boons, or Spirit Scaling)
-- Returns "true" if found, nil if not (for #if templates)
p.hero_has_stat = function(frame)
local hero_key = frame.args[1]
local stat_key = frame.args[2]
if (hero_key == nil) then return nil end
local hero_data = hero_by_key_or_name(hero_key)
if (hero_data == nil) then return nil end
return template_calls
if p.has_stat(hero_data, stat_key) then return "true" end
return nil
end
end


-- Function to call hero tags based on name
p.get_hero_tag = function (frame)
local name = frame.args[1]
local number = tonumber(frame.args[2])
-- Validate input
if not name then
return "Error: Missing name input."
end
if number ~= 1 and number ~= 2 and number ~= 3 then
return string.format("Error: Invalid number '%s'. Must be 1, 2, or 3.", tostring(frame.args[2]))
end
if TAG_NAME_MAP[name] == nil then
return string.format("Error: Unknown name '%s'.", name)
end


return p.hero_tag(name, number)
end


--{{#invoke:HeroData|has_tags|HERO_ENGLISH_NAME}}--
-- 'true' when the hero has roster tags, '' otherwise.
function p.has_tags(frame)
if p.hero_tag(frame.args[1], 1) ~= '' then return 'true' end
return ''
end
-- Retrieve scaling string of a hero's given stat, if it has scaling, else return blank
-- Scaling string meaning the expanded template {{Ss|scalar}} or {{PI|scalar}}
function p.write_scalar_str(scaling_value, scaling_type, compact)
local scaling_abbrevs = {Spirit = "Ss", Level = "PI"}
-- Return blank if it doesnt scale
if (scaling_value == 0) then return "" end
-- Round it
scaling_value = util_module.round_to_sig_fig(scaling_value, 3)
--The hero has a scaling value with this stat
local template_title = "Template:" .. scaling_abbrevs[scaling_type]
local template_args = {}
template_args["1"] = scaling_value
if compact then
template_args["compact"] = "yes"
template_args["show_value"] = "yes"
end
local template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
local result = template_call:gsub("\n", ""):gsub("\r", "")
   
return result
end


-- Outputs a wikitable of heroes grouped by GroundDashDuration using {{HeroIcon|hero_name}}
-- {{#invoke:HeroData|write_ground_dash_buckets}}
p.write_ground_dash_buckets = function(frame)
    local buckets = {
        [0.62] = {},
        [0.68] = {},
        [0.72] = {},
    }


    -- Collect heroes
    for hero_key, hero_data in pairs(heroes_data) do
        if not hero_data.InDevelopment and not hero_data.IsDisabled then
            local dash = p.get_stat(hero_data, "GroundDashDuration")
            if dash and buckets[dash] then
                table.insert(buckets[dash], hero_data.Name or hero_key)
            end
        end
    end
    -- Sort alphabetically
    for _, list in pairs(buckets) do
        table.sort(list)
    end
    -- Determine max rows dynamically
    local max_rows = 0
    for _, list in pairs(buckets) do
        if #list > max_rows then max_rows = #list end
    end
    local output = {"{| class='wikitable mw-collapsible'",
    "|+Hero Dash Buckets", "! Bucket 1 !! Bucket 2 !! Bucket 3"}
    local current_frame = frame or mw.getCurrentFrame()
    for i = 1, max_rows do
        local row = {}
        for _, bucket in ipairs({0.62, 0.68, 0.72}) do
            local hero_name = buckets[bucket][i]
            table.insert(row, hero_name and current_frame:expandTemplate{title = "HeroIcon", args = {hero_name}} or "")
        end
        table.insert(output, "|-\n| " .. table.concat(row, " || "))
    end
    table.insert(output, "|}")
    return table.concat(output, "\n")
end


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