|
|
| Line 1: |
Line 1: |
| local p = {}; | | -- TEMPORARY test module. |
| | -- {{#invoke:Sandbox/Vergir|test}} |
| | local p = {} |
| local heroes_data = mw.loadJsonData("Data:HeroData.json") | | local heroes_data = mw.loadJsonData("Data:HeroData.json") |
| local util_module = require('Module:Utilities') | | local old_module = require('Module:HeroData') |
| local lang_module = require('Module:Lang')
| |
| | |
| --------------------------------------------------------------------------------
| |
| -- 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 function raw_scaling(hero_data, scaling_type, stat) |
| local scaling = hero_data and hero_data[scaling_type .. "Scaling"] | | local scaling = hero_data and hero_data[scaling_type .. "Scaling"] |
| Line 26: |
Line 11: |
| end | | end |
|
| |
|
| -- Mapping from hero name to internal tag name
| | function p.get_scalings(hero_data, stat, include_zero) |
| 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
| |
| 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
| |
| | |
| -- 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
| |
| | |
| -- Value of a stat, checking the hero's top level, then Weapon, then AltFire.
| |
| -- Returns nil when the hero has no such stat.
| |
| function p.get_stat(hero_data, stat)
| |
| if (hero_data == nil or stat == nil) then return nil end
| |
| local value = hero_data[stat]
| |
| if (value == nil and hero_data.Weapon) then
| |
| value = hero_data.Weapon[stat]
| |
| end
| |
| if (value == nil and hero_data.Weapon and hero_data.Weapon.AltFire) then
| |
| value = hero_data.Weapon.AltFire[stat]
| |
| end
| |
| return value
| |
| end
| |
| | |
| -- 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 and zero scalings are omitted, so an empty list means "no scaling".
| |
| function p.get_scalings(hero_data, stat)
| |
| local scalings = {} | | local scalings = {} |
| for _, scaling_type in ipairs({"Level", "Spirit"}) do | | for _, scaling_type in ipairs({"Level", "Spirit"}) do |
| local value = raw_scaling(hero_data, scaling_type, stat) | | local value = raw_scaling(hero_data, scaling_type, stat) |
| if (value ~= nil and value ~= 0) then | | if (value ~= nil and (include_zero or value ~= 0)) then |
| table.insert(scalings, { type = scaling_type, value = value }) | | table.insert(scalings, { type = scaling_type, value = value }) |
| end | | end |
| Line 118: |
Line 22: |
| 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) | | function p.get_hero_scaling_data(hero_data, hero_stat_key) |
| local scaling_data_returned = {} | | local scaling_data_returned = {} |
| for _, scaling_type in ipairs({"Spirit", "Level"}) do | | -- Walked backwards so Level is written last and wins a value collision, |
| local scaling_value = raw_scaling(hero_data, scaling_type, hero_stat_key)
| | -- matching the original Spirit-then-Level assignment order. |
| if (scaling_value ~= nil) then
| | local scalings = p.get_scalings(hero_data, hero_stat_key, true) |
| scaling_data_returned[scaling_value] = scaling_type
| | for i = #scalings, 1, -1 do |
| end
| | scaling_data_returned[scalings[i].value] = scalings[i].type |
| end | | end |
| return scaling_data_returned | | return scaling_data_returned |
| end | | end |
|
| |
|
| -- Whether a hero has a stat at all: a non-zero base value, or any scaling.
| | local function repr(v) |
| function p.has_stat(hero_data, stat)
| |
| local base = p.get_stat(hero_data, stat)
| |
| if (base ~= nil and base ~= 0) then return true end
| |
| return #p.get_scalings(hero_data, stat) > 0
| |
| end
| |
| | |
| -- Resolves a hero_* key or an English hero name to a hero_* key.
| |
| -- Returns nil when the input matches no hero. Name matching is case-insensitive.
| |
| function p.find_hero_key(input)
| |
| if (input == nil or input == '') then return nil end
| |
| if (heroes_data[input] ~= nil) then return input end
| |
| local wanted = mw.ustring.lower(input)
| |
| for hero_key, hero_data in pairs(heroes_data) do
| |
| if (hero_data["Name"] and mw.ustring.lower(hero_data["Name"]) == wanted) then
| |
| return hero_key
| |
| end
| |
| end
| |
| return nil
| |
| end
| |
| | |
| -- 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
| |
| | |
| --{{#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 = hero_by_key_or_name(hero_name)
| |
| if(hero == nil) then return "Hero Not Found" end
| |
|
| |
| local var_value = p.get_stat(hero, hero_stat_key)
| |
| if(var_value == nil) then return 0 end
| |
|
| |
| --round
| |
| if (sig_figs_or_localize ~= nil and tonumber(sig_figs_or_localize) ~= nil) then
| |
| var_value = util_module.round_to_sig_fig(var_value, sig_figs_or_localize)
| |
| if (var_value == nil) then return "get_hero_var() error with rounding" end
| |
| end
| |
|
| |
| --localize
| |
| if (sig_figs_or_localize == "true") then
| |
| return lang_module.get_string(var_value)
| |
| end
| |
| | |
| 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 = hero_by_key_or_name(hero_name)
| |
| 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_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
| |
| | |
| 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
| |
| | |
| --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 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
| |
|
| |
| local scaling_value = raw_scaling(hero_data, scaling_type, 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
| |
|
| |
| if no_template == "true" then
| |
| return scaling_value
| |
| end
| |
|
| |
| return p.write_scalar_str(scaling_value, scaling_type)
| |
| 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
| |
|
| |
| if p.has_stat(hero_data, stat_key) then return "true" end
| |
| return nil
| |
| 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 {{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"
| |
| template_args["show_value"] = "yes"
| |
| end
| |
|
| |
| local template_call = mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
| |
|
| |
| return template_call:gsub("\n", ""):gsub("\r", "")
| |
| 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
| |
| --------------------------------------------------------------------------------
| |
| -- TEMPORARY parity harness - NOT part of the live module.
| |
| -- {{#invoke:Sandbox/Vergir|test|SUITE}} where SUITE is one of:
| |
| -- stats | list | scalars | scalings | has_stat | keys | tags
| |
| --------------------------------------------------------------------------------
| |
| | |
| local old_module = require('Module:HeroData')
| |
| | |
| local function repr(v, depth) | |
| depth = depth or 0
| |
| if type(v) ~= 'table' then return tostring(v) end | | if type(v) ~= 'table' then return tostring(v) end |
| if depth > 3 then return '<deep>' end
| |
| local entries = {} | | local entries = {} |
| for k, val in pairs(v) do | | for k, val in pairs(v) do |
| table.insert(entries, { k = tostring(k), v = val }) | | table.insert(entries, tostring(k) .. '=' .. tostring(val)) |
| end | | end |
| table.sort(entries, function(a, b) return a.k < b.k end) | | table.sort(entries) |
| local parts = {}
| | return '{' .. table.concat(entries, ',') .. '}' |
| for _, e in ipairs(entries) do
| |
| table.insert(parts, e.k .. '=' .. repr(e.v, depth + 1))
| |
| end
| |
| return '{' .. table.concat(parts, ',') .. '}' | |
| end | | end |
|
| |
|
| -- Calls fn(...) and returns a normalised string, so that a raised error on one
| | function p.test(frame) |
| -- side compares equal to the same error on the other (line numbers stripped).
| | local hero_keys, stat_keys, seen = {}, {}, {} |
| local function attempt(fn, ...) | | for hero_key in pairs(heroes_data) do table.insert(hero_keys, hero_key) end |
| local ok, result = pcall(fn, ...)
| | table.sort(hero_keys) |
| if ok then return repr(result) end
| |
| return 'ERR:' .. tostring(result):gsub("^.-:%d+: ", "")
| |
| end
| |
| | |
| local function sorted_hero_keys()
| |
| local list = {}
| |
| for hero_key in pairs(heroes_data) do table.insert(list, hero_key) end | |
| table.sort(list) | |
| return list
| |
| end
| |
| | |
| -- Every key appearing anywhere in the hero data, so sweeps are exhaustive.
| |
| local function all_stat_keys()
| |
| local seen = {}
| |
| for _, hero in pairs(heroes_data) do | | for _, hero in pairs(heroes_data) do |
| local sources = { | | local sources = { |
| Line 503: |
Line 61: |
| end | | end |
| end | | end |
| local list = {}
| | for stat in pairs(seen) do table.insert(stat_keys, stat) end |
| for stat in pairs(seen) do table.insert(list, stat) end | | table.sort(stat_keys) |
| table.sort(list) | |
| return list
| |
| end
| |
| | |
| local MAX_ROWS = 50
| |
| | |
| local function report(title, checked, mismatches)
| |
| local out = {
| |
| "'''" .. title .. "'''",
| |
| '',
| |
| 'Comparisons: ' .. checked,
| |
| 'Mismatches: ' .. #mismatches,
| |
| '',
| |
| }
| |
| if #mismatches == 0 then
| |
| table.insert(out, ':<span style="color:#13f278">No differences.</span>')
| |
| return table.concat(out, '\n')
| |
| end
| |
| table.insert(out, '{| class="wikitable"')
| |
| table.insert(out, '! Case !! old !! new')
| |
| for i, row in ipairs(mismatches) do
| |
| if i > MAX_ROWS then
| |
| table.insert(out, '|-\n| colspan="3" | ... and ' .. (#mismatches - MAX_ROWS) .. ' more')
| |
| break
| |
| end
| |
| table.insert(out, '|-\n| <code>' .. row[1] .. '</code> || <code>' ..
| |
| mw.text.nowiki(row[2]) .. '</code> || <code>' .. mw.text.nowiki(row[3]) .. '</code>')
| |
| end
| |
| table.insert(out, '|}')
| |
| return table.concat(out, '\n')
| |
| end
| |
| | |
| local suites = {}
| |
| | |
| -- p.get_stat, via get_hero_var
| |
| suites.stats = function()
| |
| local checked, mismatches = 0, {}
| |
| local stat_keys = all_stat_keys()
| |
| for _, hero_key in ipairs(sorted_hero_keys()) do
| |
| for _, stat in ipairs(stat_keys) do
| |
| local frame = { args = { hero_key, stat } }
| |
| local a = attempt(old_module.get_hero_var, frame)
| |
| local b = attempt(p.get_hero_var, frame)
| |
| checked = checked + 1
| |
| if a ~= b then
| |
| table.insert(mismatches, { hero_key .. ' / ' .. stat, a, b })
| |
| end
| |
| end
| |
| end
| |
| return report('get_hero_var (p.get_stat)', checked, mismatches)
| |
| end
| |
|
| |
|
| -- p.get_stat, via get_list_elem
| |
| suites.list = function()
| |
| local checked, mismatches = 0, {} | | local checked, mismatches = 0, {} |
| local stat_keys = all_stat_keys() | | local zero_cases, collision_cases = 0, 0 |
| for _, hero_key in ipairs(sorted_hero_keys()) do
| |
| for _, stat in ipairs(stat_keys) do
| |
| for index = 1, 2 do
| |
| local frame = { args = { hero_key, stat, tostring(index) } }
| |
| local a = attempt(old_module.get_list_elem, frame)
| |
| local b = attempt(p.get_list_elem, frame)
| |
| checked = checked + 1
| |
| if a ~= b then
| |
| table.insert(mismatches, { hero_key .. ' / ' .. stat .. ' [' .. index .. ']', a, b })
| |
| end
| |
| end
| |
| end
| |
| end
| |
| return report('get_list_elem (p.get_stat)', checked, mismatches)
| |
| end
| |
|
| |
|
| -- raw_scaling, via get_hero_scalar (both template and no_template modes)
| | for _, hero_key in ipairs(hero_keys) do |
| suites.scalars = function()
| |
| local checked, mismatches = 0, {}
| |
| local stat_keys = all_stat_keys()
| |
| for _, hero_key in ipairs(sorted_hero_keys()) do
| |
| for _, stat in ipairs(stat_keys) do
| |
| for _, scaling_type in ipairs({ 'Level', 'Spirit' }) do
| |
| for _, no_template in ipairs({ 'true', '' }) do
| |
| local frame = { args = { hero_key, scaling_type, stat, no_template = no_template } }
| |
| local a = attempt(old_module.get_hero_scalar, frame)
| |
| local b = attempt(p.get_hero_scalar, frame)
| |
| checked = checked + 1
| |
| if a ~= b then
| |
| table.insert(mismatches, {
| |
| hero_key .. ' / ' .. scaling_type .. ' / ' .. stat ..
| |
| (no_template == 'true' and ' (raw)' or ''), a, b })
| |
| end
| |
| end
| |
| end
| |
| end
| |
| end
| |
| return report('get_hero_scalar (raw_scaling)', checked, mismatches)
| |
| end
| |
| | |
| -- The deprecated shim must stay byte-identical for Module:HeroComparisonTable
| |
| suites.scalings = function()
| |
| local checked, mismatches = 0, {}
| |
| local stat_keys = all_stat_keys()
| |
| for _, hero_key in ipairs(sorted_hero_keys()) do | |
| local hero_data = heroes_data[hero_key] | | local hero_data = heroes_data[hero_key] |
| for _, stat in ipairs(stat_keys) do | | for _, stat in ipairs(stat_keys) do |
| local a = attempt(old_module.get_hero_scaling_data, hero_data, stat) | | local a = repr(old_module.get_hero_scaling_data(hero_data, stat)) |
| local b = attempt(p.get_hero_scaling_data, hero_data, stat) | | local b = repr(p.get_hero_scaling_data(hero_data, stat)) |
| checked = checked + 1 | | checked = checked + 1 |
| if a ~= b then | | if a ~= b then |
| table.insert(mismatches, { hero_key .. ' / ' .. stat, a, b }) | | table.insert(mismatches, hero_key .. ' / ' .. stat .. ': ' .. a .. ' vs ' .. b) |
| end | | end |
| end
| | -- Coverage: does the data actually exercise the tricky paths? |
| end
| | local with_zero = p.get_scalings(hero_data, stat, true) |
| return report('get_hero_scaling_data (deprecated shim)', checked, mismatches)
| | local without_zero = p.get_scalings(hero_data, stat) |
| end
| | if #with_zero ~= #without_zero then zero_cases = zero_cases + 1 end |
| | | if #with_zero == 2 and with_zero[1].value == with_zero[2].value then |
| -- EXPECTED to differ: new version is Weapon/AltFire aware | | collision_cases = collision_cases + 1 |
| suites.has_stat = function()
| |
| local checked, mismatches = 0, {}
| |
| local stat_keys = all_stat_keys()
| |
| for _, hero_key in ipairs(sorted_hero_keys()) do
| |
| for _, stat in ipairs(stat_keys) do
| |
| local frame = { args = { hero_key, stat } }
| |
| local a = attempt(old_module.hero_has_stat, frame)
| |
| local b = attempt(p.hero_has_stat, frame) | |
| checked = checked + 1 | |
| if a ~= b then | |
| table.insert(mismatches, { hero_key .. ' / ' .. stat, a, b }) | |
| end | | end |
| end | | end |
| end | | end |
| return report('hero_has_stat (EXPECTED to widen)', checked, mismatches)
| |
| end
| |
|
| |
|
| -- EXPECTED to differ: new version also accepts a hero_* key
| | local out = { |
| suites.keys = function()
| | 'Comparisons: ' .. checked, |
| local checked, mismatches = 0, {}
| | 'Mismatches: ' .. #mismatches, |
| local inputs = {} | | 'Cases with a zero scaling (shim must keep them): ' .. zero_cases, |
| for _, hero_key in ipairs(sorted_hero_keys()) do | | 'Cases where Level and Spirit share a value (collision order): ' .. collision_cases, |
| table.insert(inputs, hero_key) | | '', |
| local name = heroes_data[hero_key]['Name']
| | } |
| if name then
| | for i, m in ipairs(mismatches) do |
| table.insert(inputs, name)
| | if i > 30 then table.insert(out, '... and ' .. (#mismatches - 30) .. ' more') break end |
| table.insert(inputs, mw.ustring.upper(name))
| | table.insert(out, '* <code>' .. m .. '</code>') |
| table.insert(inputs, mw.ustring.lower(name))
| |
| end
| |
| end | | end |
| for _, extra in ipairs({ '', ' ', 'Not A Hero', 'hero_nope' }) do | | if #mismatches == 0 then table.insert(out, 'No differences.') end |
| table.insert(inputs, extra)
| | return table.concat(out, '\n') |
| end
| |
| for _, input in ipairs(inputs) do
| |
| local frame = { args = { input } }
| |
| local a = attempt(old_module.get_hero_key, frame)
| |
| local b = attempt(p.get_hero_key, frame)
| |
| checked = checked + 1
| |
| if a ~= b then
| |
| table.insert(mismatches, { input, a, b })
| |
| end
| |
| end
| |
| return report('get_hero_key (EXPECTED to widen)', checked, mismatches)
| |
| end
| |
| | |
| -- get_hero_tag must be unchanged; the has_tags predicate may narrow
| |
| suites.tags = function()
| |
| local checked, mismatches = 0, {}
| |
| local names = {}
| |
| for _, hero_key in ipairs(sorted_hero_keys()) do
| |
| local name = heroes_data[hero_key]['Name']
| |
| if name then table.insert(names, name) end
| |
| end
| |
| for _, extra in ipairs({ 'Not A Hero', '' }) do table.insert(names, extra) end
| |
| | |
| for _, name in ipairs(names) do
| |
| for _, index in ipairs({ '0', '1', '2', '3', '4', 'x' }) do
| |
| local frame = { args = { name, index } }
| |
| local a = attempt(old_module.get_hero_tag, frame)
| |
| local b = attempt(p.get_hero_tag, frame)
| |
| checked = checked + 1
| |
| if a ~= b then
| |
| table.insert(mismatches, { name .. ' [' .. index .. ']', a, b })
| |
| end
| |
| end
| |
| -- Predicate: old Infobox_hero.hero_has_tags vs new p.has_tags
| |
| local old_tag = old_module.get_hero_tag({ args = { name, '1' } })
| |
| local old_pred = tostring(string.find(old_tag, 'Error:') == nil)
| |
| local new_pred = tostring(p.has_tags({ args = { name } }) == 'true')
| |
| checked = checked + 1
| |
| if old_pred ~= new_pred then
| |
| table.insert(mismatches, { 'PREDICATE ' .. name, old_pred, new_pred })
| |
| end
| |
| end
| |
| return report('get_hero_tag + has_tags predicate', checked, mismatches)
| |
| end
| |
| | |
| function p.test(frame)
| |
| local suite = frame.args[1]
| |
| if suite == nil or suites[suite] == nil then | |
| local names = {}
| |
| for name in pairs(suites) do table.insert(names, name) end
| |
| table.sort(names)
| |
| return 'Pick a suite: ' .. table.concat(names, ', ')
| |
| end
| |
| return suites[suite]()
| |
| end | | end |
|
| |
|
| return p | | return p |
