|
|
| Line 1: |
Line 1: |
| local p = {};
| |
| local heroes_data = mw.loadJsonData("Data:HeroData.json")
| |
| local attributes_data = mw.loadJsonData("Data:AttributeData.json")
| |
| local attribute_orders = mw.loadJsonData("Data:StatInfoboxOrder.json")
| |
| local util_module = require('Module:Utilities')
| |
| local lang_module = require('Module:Lang')
| |
| local dictionary_module = require('Module:Dictionary')
| |
| local attribute_module = require('Module:AttributeData')
| |
|
| |
|
| -- returns the table of a specific item, used by external modules
| |
| function p.get_json_item(name)
| |
| for i,v in pairs(heroes_data) do
| |
| if (v["Name"] == name) then
| |
| return v
| |
| end
| |
| end
| |
| return nil
| |
| end
| |
|
| |
| -- Returns an array of item tables that have the same properties
| |
| -- @function get_similar_items
| |
| -- @param {string}
| |
| -- @return {array of tables}
| |
| local function get_similar_items(property)
| |
| local similarItems = {}
| |
| for _, v in pairs(heroes_data) do
| |
| if (v[property] ~= nil) then
| |
| table.insert(similarItems, v)
| |
| end
| |
| end
| |
| return similarItems
| |
| end
| |
|
| |
| -- returns the key of the specified hero's english name
| |
| 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
| |
|
| |
| hero_name_input = hero_name_input:lower() -- For case-independent search
| |
|
| |
| -- Go through all the characters and look for a name match.
| |
| for hero_key, hero_data in pairs(heroes_data) do
| |
| if hero_data["Name"] then
| |
| 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
| |
|
| |
| return "Hero not found." -- If nothing is found
| |
| end
| |
|
| |
| --{{#invoke:HeroData|get_hero_var|HERO_NAME|STAT_NAME|sig_figs_or_localize}}--
| |
| --sig_figs optional for rounding floats
| |
| 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
| |
|
| |
| return var_value
| |
| end
| |
|
| |
| --{{#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
| |
|
| |
| 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_str = frame.args[3]
| |
| local number_int = tonumber(number_str)
| |
| local localize = frame.args[4]
| |
|
| |
| local hero = heroes_data[hero_name]
| |
| if(hero == nil) then hero = p.get_json_item(hero_name) end
| |
| if(hero == nil) then return "Hero Not Found" end
| |
|
| |
| -- Check top-level first, then Weapon, then AltFire
| |
| local list = hero[var]
| |
| if list == nil and hero.Weapon then
| |
| list = hero.Weapon[var]
| |
| end
| |
| if list == nil and hero.Weapon and hero.Weapon.AltFire then
| |
| list = hero.Weapon.AltFire[var]
| |
| end
| |
|
| |
| if (list == nil) then return "" end
| |
| local element = list[number_int]
| |
| if (element == nil) then return "" end
| |
|
| |
| if localize=="true" then
| |
| element = lang_module.get_string(element)
| |
| end
| |
|
| |
| return element
| |
| end
| |
|
| |
| p.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"]) 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
| |
|
| |
|
| |
| --If the hero scales with the stat, it returns {{Ss|value}} or {{Ls|value}}, else blank string
| |
| --{{#invoke:HeroData|get_hero_scalar|HERO_NAME|SCALING_TYPE|STAT_NAME|sig_figs_or_localize}}--
| |
| p.get_hero_scalar = function(frame)
| |
| 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 "" end
| |
|
| |
| local scaling_value = scaling_data[hero_stat_key]
| |
| if scaling_value == nil then return "" end
| |
|
| |
| --round
| |
| if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
| |
| 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)
| |
|
| |
| return scaling_str
| |
| 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 = 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
| |
|
| |
| -- 1. Check Base Value
| |
| -- We allow 0 if it's explicitly set, but usually we filter 0 for hiding.
| |
| -- However, for resists, 0 usually means "hide", so we check ~= 0.
| |
| local val = hero_data[stat_key]
| |
| if (val ~= nil and val ~= 0) then return "true" end
| |
|
| |
| -- 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
| |
|
| |
| -- 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
| |
|
| |
| return nil
| |
| 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 {{Ls|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" end
| |
|
| |
| local template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
| |
|
| |
| return template_call:gsub("\n", ""):gsub("\r", "")
| |
| end
| |
|
| |
| -- Retrieve scaling value and type of a hero's given stat, if it has scaling, else return 0
| |
| function p.get_hero_scaling_data(hero_data, hero_stat_key)
| |
| local scaling_type_full
| |
| local scaling_data
| |
| local scaling_value
| |
| local scaling_types = {"Spirit", "Level"}
| |
| local scaling_data_returned = {}
| |
|
| |
| for index, scaling_type in ipairs(scaling_types) do
| |
| scaling_type_full = scaling_type .. "Scaling"
| |
| scaling_data = hero_data[scaling_type_full]
| |
|
| |
| --If the scaling data exists
| |
| if (scaling_data ~= nil) then
| |
| scaling_value = scaling_data[hero_stat_key]
| |
|
| |
| --If the stat scales
| |
| if (scaling_value ~= nil) then
| |
| scaling_data_returned[scaling_value] = scaling_type
| |
| end
| |
| end
| |
| end
| |
|
| |
| return scaling_data_returned
| |
| end
| |
|
| |
| local function get_nested_stat_value(hero_data, stat_key)
| |
| -- Check top-level, then Weapon, then AltFire
| |
| if hero_data[stat_key] ~= nil then
| |
| return hero_data[stat_key]
| |
| elseif hero_data.Weapon and hero_data.Weapon[stat_key] ~= nil then
| |
| return hero_data.Weapon[stat_key]
| |
| elseif hero_data.Weapon and hero_data.Weapon.AltFire and hero_data.Weapon.AltFire[stat_key] ~= nil then
| |
| return hero_data.Weapon.AltFire[stat_key]
| |
| end
| |
| return 0
| |
| end
| |
|
| |
| --writes the massive hero comparison table for a specific PI and SP
| |
| -- scaling icons are shown only if PI and SP are both 0 or both not provided
| |
| --{{#invoke:HeroData|write_hero_comparison_table|POWER_INCREASES|SPIRIT_POWER|MAX_POWER|MAX_SPIRIT}}
| |
| p.write_hero_comparison_table = function(frame)
| |
| -- process inputs (convert to numbers)
| |
| local power_increases = tonumber(frame.args[1]) or 0
| |
| local spirit_power = tonumber(frame.args[2]) or 0
| |
| local max_power = tonumber(frame.args[3]) or 25
| |
| local max_spirit = tonumber(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"
| |
| }
| |
| }
| |
|
| |
| -- 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)
| |
|
| |
| -- Iterate heroes
| |
| for _, hero_entry in ipairs(sorted_heroes) do
| |
| local hero_key = hero_entry.key
| |
| local hero_data = hero_entry.data
| |
|
| |
| row_str = ""
| |
|
| |
| -- Retrieve hero's localized name
| |
| hero_name = localize(hero_key, hero_key)
| |
|
| |
| -- Retrieve hero's english name, used for hero icon
| |
| hero_name_en = hero_data["Name"]
| |
|
| |
| -- Expand hero icon
| |
| template_title = "Template:HeroIcon"
| |
| template_args[1] = hero_name_en
| |
| template_args[2] = hero_name
| |
| hero_icon = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
| |
|
| |
| -- First column in each row is hero name (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
| |
|
| |
| 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, true)
| |
| 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
| |
| stat_value = stat_value + (power_increases * scaling_val)
| |
| 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 = (hero_data["LevelScaling"] and hero_data["LevelScaling"]["TechPower"]) or 0
| |
|
| |
| -- 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
| |
|
| |
| -- Keep numeric value in its own span, scaling HTML as sibling
| |
| local cell_inner = string.format(
| |
| '<span class="stat-num">%s</span><span class="stat-scaling">%s</span>',
| |
| stat_value,
| |
| scaling_strs
| |
| )
| |
|
| |
| -- At the point where you build data_attrs for DPS/SustainedDPS cells
| |
| local hit_once = "false"
| |
| if (attr_key == 'DPS' or attr_key == 'SustainedDPS') and hero_data.Weapon and hero_data.Weapon.HitOnceAcrossAllBullets then
| |
| hit_once = "true"
| |
| end
| |
|
| |
| local data_attrs = string.format(
| |
| 'data-stat-name="%s" data-base="%s" data-spirit-scale="%s" data-level-scale="%s" data-innate-spirit-scale="%s" data-sort-value="%s" data-hit-once="%s"',
| |
| attr_key,
| |
| tostring(type(base_value) == "number" and util_module.round_to_sig_fig(base_value, 3) or base_value),
| |
| tonumber(spirit_scale) or 0,
| |
| (attr_key == "TechPower") and "0" or (tonumber(level_scale) or 0),
| |
| innate_spirit_scale or 0,
| |
| stat_value,
| |
| hit_once
| |
| )
| |
|
| |
| -- Add it to the row
| |
| row_str = row_str .. string.format('<td style="white-space: nowrap;" %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>"
| |
|
| |
| -- Wrap table in container with data attributes for JS
| |
| local table_str = string.format(
| |
| '<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
| |
| )
| |
|
| |
| return table_str
| |
| end
| |
|
| |
| function localize(key, fallback)
| |
| local result = lang_module.get_string(key)
| |
| if (result == "") or (result == nil) then
| |
| result = util_module.add_space_before_cap(fallback) .. mw.getCurrentFrame():expandTemplate{title="MissingValveTranslationTooltip"}
| |
| end
| |
| return result
| |
| end
| |
|
| |
| -- Mapping from hero name to internal tag name
| |
| local TAG_NAME_MAP = {
| |
| ["Abrams"] = "Abrams",
| |
| ["Bebop"] = "Bebop",
| |
| ["Billy"] = "Punkgoat",
| |
| ["Calico"] = "Nano",
| |
| ["The Doorman"] = "Doorman",
| |
| ["Drifter"] = "Drifter",
| |
| ["Dynamo"] = "Dynamo",
| |
| ["Apollo"] = "Fencer",
| |
| ["Graves"] = "Necro",
| |
| ["Grey Talon"] = "Orion",
| |
| ["Haze"] = "Haze",
| |
| ["Holliday"] = "Astro",
| |
| ["Infernus"] = "Inferno",
| |
| ["Ivy"] = "Tengu",
| |
| ["Kelvin"] = "Kelvin",
| |
| ["Lady Geist"] = "Geist",
| |
| ["Lash"] = "Lash",
| |
| ["McGinnis"] = "Engineer",
| |
| ["Mina"] = "VampireBat",
| |
| ["Mirage"] = "Mirage",
| |
| ["Mo & Krill"] = "Digger",
| |
| ["Paige"] = "Bookworm",
| |
| ["Paradox"] = "Chrono",
| |
| ["Celeste"] = "Unicorn",
| |
| ["Pocket"] = "Synth",
| |
| ["Rem"] = "Familiar",
| |
| ["Seven"] = "Gigawatt",
| |
| ["Shiv"] = "Shiv",
| |
| ["Silver"] = "Werewolf",
| |
| ["Silver (Transformed)"] = "Werewolf",
| |
| ["Sinclair"] = "Magician",
| |
| ["Venator"] = "Priest",
| |
| ["Victor"] = "Frank",
| |
| ["Vindicta"] = "Vindicta",
| |
| ["Viscous"] = "Viscous",
| |
| ["Vyper"] = "Viper",
| |
| ["Warden"] = "Warden",
| |
| ["Wraith"] = "Wraith",
| |
| ["Yamato"] = "Yamato",
| |
| }
| |
|
| |
| -- Function to call hero tags based on name
| |
| p.get_hero_tag = function (frame)
| |
| local name = frame.args[1]
| |
| local number = tonumber(frame.args[2])
| |
|
| |
| -- Validate input
| |
| if not name then
| |
| return "Error: Missing name input."
| |
| end
| |
|
| |
| if number ~= 1 and number ~= 2 and number ~= 3 then
| |
| return string.format("Error: Invalid number '%s'. Must be 1, 2, or 3.", tostring(frame.args[2]))
| |
| end
| |
|
| |
| local tagname = TAG_NAME_MAP[name]
| |
| if not tagname then
| |
| return string.format("Error: Unknown name '%s'.", name)
| |
| end
| |
|
| |
| -- Build localization key
| |
| local key = string.format("Citadel_%s_HeroTag_%d", tagname, number)
| |
|
| |
| -- Call Lang.get_string
| |
| local result = lang_module.get_string(key)
| |
|
| |
| return result or ("[Missing string for key: " .. key .. "]")
| |
| end
| |
|
| |
| -- Outputs a wikitable of heroes grouped by GroundDashDuration using {{HeroIcon|hero_name}}
| |
| -- {{#invoke:HeroData|write_ground_dash_buckets}}
| |
| p.write_ground_dash_buckets = function(frame)
| |
| local buckets = {
| |
| [0.62] = {},
| |
| [0.68] = {},
| |
| [0.70] = {},
| |
| }
| |
|
| |
| local get_dash = function(hero)
| |
| return hero.GroundDashDuration
| |
| or (hero.Weapon and hero.Weapon.GroundDashDuration)
| |
| or (hero.Weapon and hero.Weapon.AltFire and hero.Weapon.AltFire.GroundDashDuration)
| |
| end
| |
|
| |
| -- Collect heroes
| |
| for hero_key, hero_data in pairs(heroes_data) do
| |
| if not hero_data.InDevelopment and not hero_data.IsDisabled then
| |
| local dash = get_dash(hero_data)
| |
| if dash and buckets[dash] then
| |
| table.insert(buckets[dash], hero_data.Name or hero_key)
| |
| end
| |
| end
| |
| end
| |
|
| |
| -- Sort alphabetically
| |
| for _, list in pairs(buckets) do
| |
| table.sort(list)
| |
| end
| |
|
| |
| -- Determine max rows dynamically
| |
| local max_rows = 0
| |
| for _, list in pairs(buckets) do
| |
| if #list > max_rows then max_rows = #list end
| |
| end
| |
|
| |
| local output = {"{| class='wikitable'", "! Bucket 1 !! Bucket 2 !! Bucket 3"}
| |
| local current_frame = frame or mw.getCurrentFrame()
| |
|
| |
| for i = 1, max_rows do
| |
| local row = {}
| |
| for _, bucket in ipairs({0.62, 0.68, 0.70}) do
| |
| local hero_name = buckets[bucket][i]
| |
| table.insert(row, hero_name and current_frame:expandTemplate{title = "HeroIcon", args = {hero_name}} or "")
| |
| end
| |
| table.insert(output, "|-\n| " .. table.concat(row, " || "))
| |
| end
| |
|
| |
| table.insert(output, "|}")
| |
| return table.concat(output, "\n")
| |
| end
| |
|
| |
| return p
| |
