The Deadlock Wiki - User contributions [en]

Module:Sandbox/Vergir

2026-09-07T00:11:17Z

~2026-EnduringDurationJump1108: Cleanup after audit (with help from vergir-bot LLM)

local p = {}
return p

User:Vergir/test1

2026-09-07T00:11:15Z

~2026-EnduringDurationJump1108: Cleanup after audit (with help from vergir-bot LLM)

Module:Infobox item

2026-09-07T00:05:58Z

~2026-EnduringDurationJump1108: append_label: prefer per-stat StatLinks target over generic attribute-type link (fixes e.g. Debuff Resist → Ability Duration) (with help from vergir-bot LLM)

local p = {}
local lang = require "Module:Lang"
local util_module = require "Module:Utilities"
local data = mw.loadJsonData("Data:ItemCards.json")
local stat_links = mw.loadJsonData("Data:StatLinks.json")
local ATTR_TYPE_ICON_MAP = require("Module:Icon/attr")

-- Local references for hot-path globals
local format = string.format
local concat = table.concat
local insert = table.insert
local ipairs = ipairs
local pairs = pairs
local tonumber = tonumber
local tostring = tostring
local type = type

-- Status Effect Icon Map
local STATUS_EFFECT_ICON_MAP = {
StatusEffectDisarmed = {img='Status_Disarm.png', link='Disarm', color='Red'},
StatusEffectEMP = {img='Status_Silence.png', link='Silence', color='Purple'},
StatusEffectInvisible= {img='Invisible.png', link='Invisible',color='Green'},
StatusEffectStun = {img='Status_Stun.png', link='Stun', color='NoColor'},
StatusEffectSlow = {img='Status_Movement_Slow.png', link='Slow', color='Purple'},
}

-- Pre-computed constants
local STATUS_FMT = "[[{{#invoke:Lang|get_string|Citadel_%s}}]]"
.. " [[{{#invoke:Lang|get_string|Citadel_StatusEffect}}]]"

-- Property keys to completely ignore during processing
local IGNORED_PROP_KEYS = {
BuildUpPerShot = true,
}

-- Label key remapping table (replaces if/elseif chain)
local LABEL_KEY_REMAP = {
DotDuration = "DOTDuration",
}

-- Item name override mapping (old name -> new name)
local ITEM_NAME_OVERRIDES = {
["debuff remover"] = "Dispel Magic",
["backstabber"] = "Stalker",
}

-- Suffix pairs for lang data existence checks
local LANG_SUFFIX_PAIRS = {
{ "_label", "_Label" },
{ "_prefix", "_Prefix" },
{ "_postfix", "_Postfix" },
{ "_postvalue_label", "_Postvalue_Label" },
}

--------------------------------------------------------------------------------
-- Caches
--------------------------------------------------------------------------------

local lang_cache = {}
local info_sections_cache = setmetatable({}, { __mode = "k" }) -- weak keys

local function cached_get_string(key)
local v = lang_cache[key]
if v ~= nil then return v or nil end -- false sentinel → nil
local result = lang.get_string(key)
lang_cache[key] = result or false
return result
end

local conditional_label -- lazily initialised

--------------------------------------------------------------------------------
-- Item name resolution
--------------------------------------------------------------------------------

local function resolve_item_name(name)
-- Check if there's an override for this name (case-insensitive)
local lowercase_name = name:lower()
local override = ITEM_NAME_OVERRIDES[lowercase_name]
if override then
return override
end

-- If no override, try to find the item in data and return its proper Name
-- First try direct key lookup
if data[name] and not data[name].IsDisabled then
return data[name].Name or name
end

-- Then try case-insensitive search by Name field
local lowercase_search = name:lower()
for _, v in pairs(data) do
if v.Name and v.Name:lower() == lowercase_search and not v.IsDisabled then
return v.Name
end
end

-- Fallback to original name
return name
end

--------------------------------------------------------------------------------
-- Utility helpers
--------------------------------------------------------------------------------

local function get_lang_pair(base_key, suffix1, suffix2)
local v1 = cached_get_string(base_key .. suffix1)
if v1 and v1 ~= "" then return v1 end
local v2 = cached_get_string(base_key .. suffix2)
if v2 and v2 ~= "" then return v2 end
return ""
end

--------------------------------------------------------------------------------
-- Data access helpers
--------------------------------------------------------------------------------

local function get_json_item(name)
-- Apply name override before lookup
local resolved_name = resolve_item_name(name)

local direct = data[resolved_name]
if direct and not direct.IsDisabled then return direct end

local fallback
for _, v in pairs(data) do
if v.Name == resolved_name then
if not v.IsDisabled then return v end
fallback = fallback or v
end
end
return fallback
end

local function get_info_sections(item)
local cached = info_sections_cache[item]
if cached then return cached end

local sections = {}
local i = 1
while item["Info" .. i] do
sections[i] = item["Info" .. i]
i = i + 1
end
info_sections_cache[item] = sections
return sections
end

local function find_property_obj(item, prop_key)
for _, section in ipairs(get_info_sections(item)) do
for _, obj in ipairs(section.Main or {}) do
if obj.Key == prop_key then return obj end
end
for _, obj in ipairs(section.Alt or {}) do
if obj.Key == prop_key then return obj end
end
end
local other = item.Other
return other and other[prop_key] or nil
end

local function is_property_in_lang_data(prop, loc_override)
local has_override = loc_override and loc_override ~= prop
for _, pair in ipairs(LANG_SUFFIX_PAIRS) do
if cached_get_string(prop .. pair[1]) or cached_get_string(prop .. pair[2]) then
return true
end
if has_override and (
cached_get_string(loc_override .. pair[1]) or
cached_get_string(loc_override .. pair[2])
) then
return true
end
end
return false
end

local function get_component_of_sorted(item_input)
-- Apply name override before processing
local resolved_input = resolve_item_name(item_input)

local target_key
if data[resolved_input] then
target_key = resolved_input
else
for k, v in pairs(data) do
if v.Name == resolved_input and not v.IsDisabled then
target_key = k
break
end
end
end
if not target_key then return {} end

local parents = {}
for key, item in pairs(data) do
if not item.IsDisabled and type(item.Components) == "table" then
for _, comp in ipairs(item.Components) do
if comp == target_key then
insert(parents, key)
break
end
end
end
end

table.sort(parents, function(a, b)
return (tonumber(data[a] and data[a].Tier) or 0)
< (tonumber(data[b] and data[b].Tier) or 0)
end)
return parents
end

--------------------------------------------------------------------------------
-- Shared formatting primitives
--------------------------------------------------------------------------------

local function resolve_label_key(prop_key, loc_override)
local base = (loc_override or prop_key):gsub("^#", "")
return LABEL_KEY_REMAP[base] or base
end

local function resolve_prefix(prefix, numeric_val)
if prefix == "{s:sign}" then
return numeric_val >= 0 and "+" or ""
end
return prefix
end

local function resolve_suffix(postfix, css_type)
if postfix == "HP/s" then return " " .. postfix end
return postfix
end

local function append_label(val_str, prop_key, label, attr_link, link_override, is_main)
if label == "" then return val_str end

-- Resolve link priority: Override > JSON Stat Link > Attribute Map Link
local link_target = link_override
if not link_target or link_target == "" then
link_target = stat_links[prop_key]
end
if not link_target or link_target == "" then
link_target = attr_link
end

-- Construct label with link if valid
local display_label = label
if link_target and link_target ~= "" then
if link_target == label then
display_label = "[[" .. label .. "]]"
else
display_label = "[[" .. link_target .. "|" .. label .. "]]"
end
end

-- Place label on a new line only for Main stats
if is_main then
return val_str .. "<br>" .. display_label
else
return val_str .. " " .. display_label
end
end

local function append_conditional(val_str, allow_conditional, usage_flags)
if not allow_conditional then return val_str end
if usage_flags ~= "ConditionallyApplied"
and usage_flags ~= "ConditionallyEnemyApplied" then
return val_str
end
if not conditional_label then
conditional_label = format(
'<span style="color:#C0C0C0">%s</span>',
lang.get_string("Citadel_Shop_ConditionalAttribute")
)
end
-- Place conditional text on a new line
return val_str .. "<br>" .. conditional_label
end

local function extract_numeric(value)
if value == nil or value == 0 or value == "" then return nil end
local n = tonumber(tostring(value):match("^-?%d+%.?%d*"))
return (n and n ~= 0) and n or nil
end

--------------------------------------------------------------------------------
-- Attribute Icon/Style detection helper
--------------------------------------------------------------------------------

local function resolve_attr_style(css_type)
if not css_type then return nil end
local attr = ATTR_TYPE_ICON_MAP[css_type]
if not attr then return nil end

local color = attr.color or "Grey" -- Fallback color
local img = attr.img or "GenericProperty.png"
local link = attr.link
local size = attr.size -- Optional

-- Construct icon using the defined color template: {{Icon/Color|img|size|link=link}}
local icon_str
if size and size ~= "" then
icon_str = format("{{Icon/%s|[[File:%s|%spx|link=%s]]}}", color, img, size, link or "")
else
icon_str = format("{{Icon/%s|[[File:%s|%spx|link=%s]]}}", color, img, 18, link or "")
end

return {
icon = icon_str,
link = link
}
end

--------------------------------------------------------------------------------
-- Status Effect Icon helper
--------------------------------------------------------------------------------

local function resolve_status_effect_icon(prop_key)
local effect_config = STATUS_EFFECT_ICON_MAP[prop_key]
if not effect_config then return nil end

local color = effect_config.color or "NoColor"
local img = effect_config.img or "GenericProperty.png"
local link = effect_config.link

-- Construct icon using the defined color template
local icon_str = format(
"{{Icon/%s|[[File:%s|18px|link=%s]]}}",
color, img, link or ""
)

return {
icon = icon_str,
link = link
}
end

--------------------------------------------------------------------------------
-- Core formatting: non-enhanced
--------------------------------------------------------------------------------

local function format_value(prop_key, value, css_type, loc_override,
skip_label, allow_conditional, usage_flags, scale_info,
disable_attr, is_main)
local numeric_val = extract_numeric(value)
if not numeric_val then return nil end

local label_key = resolve_label_key(prop_key, loc_override)
local label = skip_label and "" or get_lang_pair(label_key, "_label", "_Label")
local prefix = get_lang_pair(label_key, "_prefix", "_Prefix")
local postfix = get_lang_pair(label_key, "_postfix", "_Postfix")

if prefix == "" and postfix == "" and label == "" then return nil end

prefix = resolve_prefix(prefix, numeric_val)
local suffix = resolve_suffix(postfix, css_type)

-- Compose numeric + scaling first
local val_str = tostring(numeric_val)
if scale_info and scale_info.Value and scale_info.Value ~= 0 then
local scale_val = util_module.round_to_sig_fig(scale_info.Value, 2)
local tmpl = scale_info.Type == "power_increase" and "Boon" or "Ss"
val_str = val_str .. " " .. mw.getCurrentFrame():expandTemplate{
title = tmpl, args = { scale_val }
}
end

-- Then prepend prefix
if prefix ~= "" then val_str = prefix .. val_str end
-- Then append postfix
if suffix ~= "" and not val_str:find(suffix, 1, true) then
val_str = val_str .. suffix
end

-- Attribute styling (Icon via template) based on css_type
local attr_style
if not disable_attr then
attr_style = resolve_attr_style(css_type)
end

if attr_style and attr_style.icon then
val_str = attr_style.icon .. " " .. val_str
end

val_str = append_label(val_str, label_key, label,
attr_style and attr_style.link or nil,
nil, is_main) -- link_override not used here in base calls

return append_conditional(val_str, allow_conditional, usage_flags)
end

--------------------------------------------------------------------------------
-- Core formatting: enhanced
--------------------------------------------------------------------------------

local function format_value_enhanced(item_name, prop_key, value, css_type,
loc_override, skip_label,
allow_conditional, usage_flags,
disable_attr, is_main)
local numeric_val = extract_numeric(value)
if not numeric_val then return nil end

local label_key = resolve_label_key(prop_key, loc_override)

-- Enhanced requires at least one lang token to exist
local has_lang = false
for _, pair in ipairs(LANG_SUFFIX_PAIRS) do
if cached_get_string(label_key .. pair[1])
or cached_get_string(label_key .. pair[2]) then
has_lang = true
break
end
end
if not has_lang then return nil end

local label = skip_label and "" or get_lang_pair(label_key, "_label", "_Label")
local prefix = get_lang_pair(label_key, "_prefix", "_Prefix")
local postfix = get_lang_pair(label_key, "_postfix", "_Postfix")

if prefix == "" and postfix == "" and label == "" then return nil end

prefix = resolve_prefix(prefix, numeric_val)
local suffix = resolve_suffix(postfix, css_type)

-- Build Enhanced invoke
local extras = {}
if prefix ~= "" then insert(extras, "prefix=" .. prefix) end
if suffix ~= "" and suffix ~= "%" then insert(extras, "suffix=" .. suffix) end
insert(extras, "noicon=true")

local val_str = format(
"{{#invoke:Enhanced|render|%s|%s|%s}}",
item_name, prop_key, concat(extras, "|")
)

-- Append postfix if not already present
if postfix ~= "" and postfix ~= "%" and not val_str:find(postfix, 1, true) then
val_str = val_str .. (postfix == "HP/s" and (" " .. postfix) or postfix)
end

-- Attribute styling (Icon via template) based on css_type
local attr_style
if not disable_attr then
attr_style = resolve_attr_style(css_type)
end

if attr_style and attr_style.icon then
val_str = attr_style.icon .. " " .. val_str
end

val_str = append_label(val_str, label_key, label,
attr_style and attr_style.link or nil,
nil, is_main)

return append_conditional(val_str, allow_conditional, usage_flags)
end

--------------------------------------------------------------------------------
-- Status Effect formatting helper
--------------------------------------------------------------------------------

local function format_status_effect(prop_key)
local lang_str = format("[[{{#invoke:Lang|get_string|Citadel_%s}}]]", prop_key)
.. " [[{{#invoke:Lang|get_string|Citadel_StatusEffect}}]]"

-- Get icon for this status effect
local icon_style = resolve_status_effect_icon(prop_key)
if icon_style and icon_style.icon then
return icon_style.icon .. " " .. lang_str
end

return lang_str
end

--------------------------------------------------------------------------------
-- Tooltip builder helpers
--------------------------------------------------------------------------------

local function format_section_cooldown(section, item_name, enhanced)
local result = {}
local cd, cu = section.Cooldown, section.ChargeUp
if cd and cd ~= 0 then
result.cooldown = enhanced
and format_value_enhanced(item_name, "AbilityCooldown", cd, nil, nil, true, false, nil)
or format_value("AbilityCooldown", cd, nil, nil, true, false, nil, nil)
end
if cu and cu ~= 0 then
result.chargeup = enhanced
and format_value_enhanced(item_name, "AbilityChargeUpTime", cu, nil, nil, true, false, nil)
or format_value("AbilityChargeUpTime", cu, nil, nil, true, false, nil, nil)
end
return result
end

local function process_stat_list(lines, param_fmt, counter, start_index,
prop_list, seen, formatter)
local stat_index = start_index
for _, prop_obj in ipairs(prop_list or {}) do
local key = prop_obj.Key
if not seen[key] and not IGNORED_PROP_KEYS[key] and (
key:match("^StatusEffect")
or is_property_in_lang_data(key, prop_obj.LocTokenOverride)
) then
local val = formatter(prop_obj)
if val then
insert(lines, format(param_fmt, counter, stat_index, val))
stat_index = stat_index + 1
seen[key] = true
end
end
end
return stat_index
end

--------------------------------------------------------------------------------
-- Unified tooltip builder (handles both default and enhanced modes)
--------------------------------------------------------------------------------
local function build_tooltip_impl(frame, enhanced)
local item_name = frame.args[1]
if not item_name then return "Item name missing" end

-- Resolve the item name (apply override if exists)
local resolved_name = resolve_item_name(item_name)

local item = get_json_item(item_name)
if not item then return "Item not found" end

local ItemData = require("Module:ItemData")
local lines = { "{{Infobox item" }

if enhanced then
insert(lines, "| enhanced = true")
end
-- Use resolved name for item_name parameter
insert(lines, "| item_name = " .. resolved_name)

if item.StreetBrawl == true then
insert(lines, "| street_brawl = true")
end

-- Pass through nocat arg to the Infobox item template if provided
local nocat = frame.args.nocat
if nocat and nocat ~= "" then
insert(lines, "| nocat = " .. nocat)
end

local sections = get_info_sections(item)

------------------------------------------------------------------
-- Innate stats (Main and Alt merged into item_stat sequentially)
------------------------------------------------------------------
local innate_index = 1
for _, section in ipairs(sections) do
if section.Type == "Innate" then
for _, obj in ipairs(section.Main or {}) do
if not IGNORED_PROP_KEYS[obj.Key] and is_property_in_lang_data(obj.Key, obj.LocTokenOverride) then
local val
if enhanced then
val = format_value_enhanced(
resolved_name, obj.Key, obj.Value, obj.Type,
obj.LocTokenOverride, nil, false, obj.UsageFlags,
true -- disable_attr
)
else
val = format_value(
obj.Key, obj.Value, obj.Type, obj.LocTokenOverride,
false, false, obj.UsageFlags, obj.Scale,
true -- disable_attr
)
end
if val then
insert(lines, format("| item_stat%d = %s", innate_index, val))
innate_index = innate_index + 1
end
end
end
for _, obj in ipairs(section.Alt or {}) do
if not IGNORED_PROP_KEYS[obj.Key] and is_property_in_lang_data(obj.Key, obj.LocTokenOverride) then
local val
if enhanced then
val = format_value_enhanced(
resolved_name, obj.Key, obj.Value, obj.Type,
obj.LocTokenOverride, nil, false, obj.UsageFlags,
true -- disable_attr
)
else
val = format_value(
obj.Key, obj.Value, obj.Type, obj.LocTokenOverride,
false, false, obj.UsageFlags, obj.Scale,
true -- disable_attr
)
end
if val then
insert(lines, format("| item_stat%d = %s", innate_index, val))
innate_index = innate_index + 1
end
end
end
end
end

------------------------------------------------------------------
-- Build formatters once (closures capture resolved_name)
------------------------------------------------------------------
local main_formatter, alt_formatter

if enhanced then
main_formatter = function(obj)
if obj.Key:match("^StatusEffect") then
return format_status_effect(obj.Key)
end
return format_value_enhanced(
resolved_name, obj.Key, obj.Value, obj.Type,
obj.LocTokenOverride, false, true, obj.UsageFlags, nil, true
)
end
alt_formatter = function(obj)
if obj.Key:match("^StatusEffect") then
return format_status_effect(obj.Key)
end
return format_value_enhanced(
resolved_name, obj.Key, obj.Value, obj.Type,
obj.LocTokenOverride, nil, false, obj.UsageFlags,
true -- disable_attr
)
end
else
main_formatter = function(obj)
if obj.Key:match("^StatusEffect") then
return format_status_effect(obj.Key)
end
return format_value(
obj.Key, obj.Value, obj.Type, obj.LocTokenOverride,
false, true, obj.UsageFlags, obj.Scale, nil, true
)
end
alt_formatter = function(obj)
if obj.Key:match("^StatusEffect") then
return format_status_effect(obj.Key)
end
return format_value(
obj.Key, obj.Value, obj.Type, obj.LocTokenOverride,
false, false, obj.UsageFlags, obj.Scale,
true -- disable_attr
)
end
end

------------------------------------------------------------------
-- Passive & Active sections — Main and Alt output separately
------------------------------------------------------------------
local passive_counter, active_counter = 1, 1

for _, section in ipairs(sections) do
local stype = section.Type
if stype ~= "Innate" then
local is_active = (stype == "Active")
local prefix = is_active and "active" or "passive"
local counter = is_active and active_counter or passive_counter

-- Description
local loc = section.DescKey
if loc then
loc = loc:gsub("#", "")
if loc ~= "" then
insert(lines, format(
"| %s%d_description = {{#invoke:Lang|get_string|%s|item_name=%s}}",
prefix, counter, loc, resolved_name
))
end
end

-- Main stats → prefix{N}_main{M}
local main_fmt = "| " .. prefix .. "%d_main%d = %s"
local main_seen = {}
local main_index = 1
for _, prop_obj in ipairs(section.Main or {}) do
local key = prop_obj.Key
if not main_seen[key] and not IGNORED_PROP_KEYS[key] and (
key:match("^StatusEffect")
or is_property_in_lang_data(key, prop_obj.LocTokenOverride)
) then
local val = main_formatter(prop_obj)
if val then
insert(lines, format(main_fmt, counter, main_index, val))
main_index = main_index + 1
main_seen[key] = true
end
end
end

-- Alt stats → prefix{N}_alt{M}
local alt_fmt = "| " .. prefix .. "%d_alt%d = %s"
local alt_seen = {}
local alt_index = 1
for _, prop_obj in ipairs(section.Alt or {}) do
local key = prop_obj.Key
-- Skip keys already emitted as main stats
if not main_seen[key] and not alt_seen[key] and not IGNORED_PROP_KEYS[key] and (
key:match("^StatusEffect")
or is_property_in_lang_data(key, prop_obj.LocTokenOverride)
) then
local val = alt_formatter(prop_obj)
if val then
insert(lines, format(alt_fmt, counter, alt_index, val))
alt_index = alt_index + 1
alt_seen[key] = true
end
end
end

-- Cooldown / ChargeUp
local cd = format_section_cooldown(section, resolved_name, enhanced)
if cd.cooldown then
insert(lines, format("| %s%d_cooldown = %s", prefix, counter, cd.cooldown))
end
if cd.chargeup then
insert(lines, format("| %s%d_chargeup = %s", prefix, counter, cd.chargeup))
end

if is_active then
active_counter = active_counter + 1
else
passive_counter = passive_counter + 1
end
end
end

------------------------------------------------------------------
-- Components
------------------------------------------------------------------
for i = 1, 2 do
local comp = ItemData.get_component_name { args = { resolved_name, i } }
if comp and comp ~= "" then
insert(lines, format("| component%d_name = %s", i, comp))
end
end

------------------------------------------------------------------
-- Is Component Of (sorted by tier)
------------------------------------------------------------------
local parents = get_component_of_sorted(item_name)
for i, key in ipairs(parents) do
local d = data[key]
local parent_name = d and d.Name or ""
if parent_name ~= "" then
insert(lines, format("| iscomponentof%d_name = %s", i, parent_name))
end
end

------------------------------------------------------------------
-- Sounds (pass-through from frame args)
------------------------------------------------------------------
for key, value in pairs(frame.args) do
local index = tostring(key):match("^sound(%d+)$")
if index and value ~= "" then
insert(lines, format("| sound%s = %s", index, value))
end
end

insert(lines, "}}")
return concat(lines, "\n")
end

--------------------------------------------------------------------------------
-- Public interface
--------------------------------------------------------------------------------

-- Render only Default item infobox
function p.fill_tooltip(frame)
local output = build_tooltip_impl(frame, false)
local debug = tonumber(frame.args.debug) or 0
if debug == 1 or debug == 2 then return output end
return mw.getCurrentFrame():preprocess(output)
end

-- Render only Enhanced item infobox
function p.fill_tooltip_enhanced(frame)
return mw.getCurrentFrame():preprocess(build_tooltip_impl(frame, true))
end

-- Render both Default and Enhanced item infobox using tabber
function p.render(frame)
local output = concat({
"<tabber>",
lang.get_string("citadel_settings_camera_preset_default") .. "=",
build_tooltip_impl(frame, false),
"|-|",
lang.get_string("Citadel_ItemDraft_Enhanced") .. "=",
build_tooltip_impl(frame, true),
"</tabber>"
}, "\n")
return mw.getCurrentFrame():preprocess(output)
end

return p

Data:StatLinks.json

2026-09-07T00:04:22Z

~2026-EnduringDurationJump1108: SlowPercent/MaxSlowPercent → Movement Slow, TotalHealthRegen → Healing (with help from vergir-bot LLM)

{
"AbilityCastRange": "Ability Range",
"AbilityDuration": "Ability Duration",
"AbilityLifestealPercentHero": "Spirit Lifesteal (stat)",
"AbilityLifestealPercentHeroPassive": "Spirit Lifesteal",
"ActivatedFireRate": "Fire Rate",
"ActiveBonusFireRate": "Fire Rate",
"ActiveBonusLifesteal": "Bullet Lifesteal",
"ActiveBonusMoveSpeed": "Move Speed",
"ActiveMoveSpeedPenalty": "Move Speed",
"ActiveReloadPercent": "Ammo",
"AmbushBonusFireRate": "Fire Rate",
"AmbushBonusMeleeDamage": "Melee Damage",
"AmbushBonusTechPower": "Spirit Power",
"AmmoReloadPercent": "Ammo",
"BaseAttackDamagePercent": "Weapon Damage",
"BaseAttackDamagePercentAtMaxDuration": "Weapon Damage",
"BaseAttackDamagePercentBonus": "Weapon Damage",
"BonusAbilityCharges": "Charges",
"BonusAbilityDurationPercent": "Ability Duration",
"BonusAttackRangePercent": "Falloff Range",
"BonusBaseHealth": "Health",
"BonusBulletSpeedPercent": "Bullet Velocity",
"BonusClipSize": "Ammo",
"BonusClipSizePercent": "Ammo",
"BonusFireRate": "Fire Rate",
"BonusHealth": "Health",
"BonusHealthRegen": "Health Regen",
"BonusMeleeDamagePercent": "Melee Damage",
"BonusMoveSpeed": "Move Speed",
"BonusShotsDuration": "Status Effects",
"BonusSpirit": "Spirit Power",
"BonusSpiritForChargedAbilities": "Spirit Power",
"BonusSprintSpeed": "Sprint Speed",
"BuffBulletResist": "Bullet Resist",
"BuffDuration": "Status Effects",
"BuffMoveSpeedBonus": "Move Speed",
"BuffTechResist": "Spirit Resist",
"BulletArmorReduction": "Damage Resistance",
"BulletDamageReflectedPct": "Bullet Damage",
"BulletLifestealPercent": "Bullet Lifesteal (stat)",
"BulletResist": "Bullet Resist",
"BulletResistBelowThreshold": "Bullet Resist",
"BulletResistDuration": "Bullet Resist",
"BulletResistPerStack": "Bullet Resist",
"BulletResistReduction": "Bullet Resist",
"BulletsBonusMagicDamage": "Spirit Damage",
"CasterBuffDuration": "Status Effects",
"CloseRangeBonusWeaponPower": "Weapon Damage",
"CombatBarrier": "Damage Barrier",
"CooldownReduction": "Ability Cooldown",
"CooldownReductionOnChargedAbilities": "Ability Cooldown",
"CooldownReductionOnHitMin": "Ability Cooldown",
"CooldownReductionOnHitPct": "Ability Cooldown",
"CooldownReductionPerHit": "Ability Cooldown",
"CritDamagePercent": "Weapon Damage",
"DPS": "Spirit Damage",
"DamagePerChain": "Spirit Damage",
"DamagePulseAmount": "Spirit Damage",
"DamageToStack": "Stack",
"DazeDuration": "Status Effects",
"DebuffDuration": "Status Effects",
"EvasionWhileSliding": "Bullet Evasion",
"ExplosionDamage": "Spirit Damage",
"FervorFireRate": "Fire Rate",
"FervorMovespeed": "Move Speed",
"FervorStatusResistancePercent": "Debuff Resist",
"FervorTechResist": "Spirit Resist",
"FireRateBonus": "Fire Rate",
"FireRatePerKill": "Fire Rate",
"FireRateSlow": "Fire Rate",
"FireRateWhileSliding": "Fire Rate",
"FloatMoveSpeed": "Move Speed",
"FreezeDuration": "Status Effects",
"GroundDashReductionPercent": "Stamina",
"GuardianWardCombatBarrier": "Damage Barrier",
"HeadShotBonusDamage": "Headshot",
"HealAmpCastPercent": "Healing",
"HealAmpReceivePenaltyPercent": "Healing",
"HealFromHero": "Healing",
"HealFromNPC": "Healing",
"HealLifePercentOutOfCombat": "Health",
"HealOnKill": "Healing",
"HealOnSuccess": "Healing",
"HealOnVeil": "Healing",
"HealPerStack": "Healing",
"HealPercentAmount": "Healing",
"HealPercentPerHeadshot": "Healing",
"HealingPerCast": "Healing",
"HealthSteal": "Health",
"ImbueAbilityLifesteal": "Lifesteal",
"ImbuedCooldownReduction": "Ability Cooldown",
"ImbuedTechPower": "Spirit Power",
"ImpactDamage": "Spirit Damage",
"InvisMoveSpeedMod": "Sprint Speed",
"LifestrikeHeal": "Healing",
"LightMeleeAmmo": "Ammo",
"LongRangeBonusWeaponPower": "Weapon Damage",
"MagicIncreasePerStack": "Spirit Amp",
"MagicResistReduction": "Spirit Resist",
"MaxArmorStacks": "Bullet Resist",
"MaxHealthLossPercent": "Health",
"MaxSlowPercent": "Movement Slow",
"MaxStacks": "Stack",
"MeleeDistanceScale": "Melee Distance",
"MeleeResistPercent": "Melee Resist",
"MovementSpeedBonusDuration": "Move Speed",
"MovementSpeedSlow": "Movement Slow",
"NonHeroStackLimit": "Unit",
"OutOfCombatHealthRegen": "Health Regen",
"ParryCooldownReduction": "Parry",
"ProcAmmoConsumed": "Ammo",
"ProcBaseAttackDamagePercent": "Weapon Damage",
"ProcBaseAttackDamagePercentAltFire": "Weapon Damage",
"ProcBonusMagicDamage": "Spirit Damage",
"ProcBulletVelocity": "Bullet Velocity",
"RegenDuration": "Health Regen",
"Regeneration": "Health Regen",
"ReloadSpeedMultipler": "Reload Time",
"SlideScale": "Slide Distance",
"SlowDuration": "Movement Slow",
"SlowPercent": "Movement Slow",
"SlowResistancePercent": "Slow Resistance",
"SpiritDamage": "Spirit Damage",
"SpiritDamageReductionProc": "Damage Resistance",
"SpiritDamageReflectedPct": "Spirit Damage",
"SpiritPower": "Spirit Power",
"SpiritPowerInnate": "Spirit Power",
"StackingBonusHealth": "Health",
"StackingBonusSprintSpeed": "Sprint Speed",
"StackingGoldPerMinute": "Souls",
"StackingTechRangeMultiplier": "Ability Range",
"Stamina": "Stamina",
"StaminaCooldownReduction": "Stamina",
"StatusResistancePercent": "Debuff Resist",
"StunDuration": "Stun",
"TechArmorDamageReduction": "Spirit Resist",
"TechDamageReduction": "Damage Resistance",
"TechPower": "Spirit Power",
"TechPowerPercent": "Spirit Power",
"TechPowerReduction": "Spirit Power",
"TechRadiusMultiplier": "Ability Range",
"TechRangeMultiplier": "Ability Range",
"TechRangeMultiplierBuff": "Ability Range",
"TechResist": "Spirit Resist",
"TechResistBelowThreshold": "Spirit Resist",
"TotalHealthRegen": "Healing",
"VexBarrierCombatBarrier": "Damage Barrier",
"WeaponDamageBonusDuration": "Weapon Damage",
"WeaponDamagePerStack": "Weapon Damage",
"WeaponPowerPerStack": "Weapon Damage",
"WeaponPowerPerStackNonHero": "Unit",
"StatDesc_TechDamageAttribute": "Spirit Damage",
"StatDesc_WeaponPower": "Weapon Damage",
"StatDesc_MeleeDamage": "Melee Damage"
}

User:Vergir/test1

2026-09-06T23:47:43Z

~2026-EnduringDurationJump1108: Audit table v3 with formatted labels and change classification (with help from vergir-bot LLM)

Module:Sandbox/Vergir

2026-09-06T23:47:34Z

~2026-EnduringDurationJump1108: Audit script v3: formatted label values + classification column (with help from vergir-bot LLM)

-- Audit: for every item stat that goes through Infobox item's append_label
-- with attribute styling enabled (Passive/Active Main stats), compute the
-- label link target under the CURRENT priority (attr link > StatLinks)
-- and the PROPOSED priority (StatLinks > attr link), and classify the change.
local p = {}
local lang = require "Module:Lang"
local data = mw.loadJsonData("Data:ItemCards.json")
local stat_links = mw.loadJsonData("Data:StatLinks.json")
local ATTR = require("Module:Icon/attr")

local LABEL_KEY_REMAP = { DotDuration = "DOTDuration" }
local IGNORED = { BuildUpPerShot = true }

-- Keys whose StatLinks entry is worse than the current type link.
-- Proposed StatLinks fix noted alongside.
local STATLINKS_FIX = {
SlowPercent = "Movement Slow",
MaxSlowPercent = "Movement Slow",
}
local DEBATABLE = {
GroundDashReductionPercent = true,
}

local function get_pair(base, s1, s2)
local v = lang.get_string(base .. s1)
if v and v ~= "" then return v end
v = lang.get_string(base .. s2)
if v and v ~= "" then return v end
return ""
end

local function resolve_label_key(prop_key, loc_override)
local base = (loc_override or prop_key):gsub("^#", "")
return LABEL_KEY_REMAP[base] or base
end

local function norm(s)
if s == nil or s == "" then return nil end
return (tostring(s):gsub("_", " "))
end

-- Resolve a title through one redirect hop; returns final page name
local resolve_cache = {}
local function resolve(t)
if t == nil then return nil end
if resolve_cache[t] == nil then
local title = mw.title.new(t)
local r = t
if title and title.exists and title.isRedirect then
local tgt = title.redirectTarget
if tgt then r = tgt.prefixedText end
elseif not title or not title.exists then
r = t .. " (MISSING)"
end
resolve_cache[t] = r
end
return resolve_cache[t]
end

local function fmt_value(label_key, value, label)
local n = tonumber(tostring(value):match("^-?%d+%.?%d*"))
if not n then return label end
local prefix = get_pair(label_key, "_prefix", "_Prefix")
local postfix = get_pair(label_key, "_postfix", "_Postfix")
if prefix == "{s:sign}" then prefix = n >= 0 and "+" or "" end
local s = tostring(n)
if prefix ~= "" then s = prefix .. s end
if postfix ~= "" then s = s .. (postfix == "HP/s" and " " or "") .. postfix end
return s .. " " .. label
end

function p.audit(frame)
local names = {}
for key, item in pairs(data) do
if not item.IsDisabled then table.insert(names, key) end
end
table.sort(names, function(a, b)
return (data[a].Name or a) < (data[b].Name or b)
end)

local rows = {}
local counts = {}
local n_items, n_stats, n_same = 0, 0, 0
for _, key in ipairs(names) do
local item = data[key]
n_items = n_items + 1
local i = 1
while item["Info" .. i] do
local sec = item["Info" .. i]
if sec.Type ~= "Innate" then
local seen = {}
for _, obj in ipairs(sec.Main or {}) do
local pk = obj.Key
if not seen[pk] and not IGNORED[pk] and not pk:match("^StatusEffect") then
seen[pk] = true
local label_key = resolve_label_key(pk, obj.LocTokenOverride)
local label = get_pair(label_key, "_label", "_Label")
if label ~= "" then
n_stats = n_stats + 1
local attr = obj.Type and ATTR[obj.Type] or nil
local attr_link = norm(attr and attr.link)
local sl = norm(stat_links[label_key])
local cur = attr_link or sl
local new = sl or attr_link
if (cur or "") == (new or "") then
n_same = n_same + 1
else
local kind
if STATLINKS_FIX[label_key] then
kind = "Regression → fixed via StatLinks (" .. label_key .. " = " .. STATLINKS_FIX[label_key] .. ")"
elseif DEBATABLE[label_key] then
kind = "Debatable"
elseif resolve(cur) == resolve(new) then
kind = "NOP (redirect to same page)"
else
kind = "Fix"
end
counts[kind] = (counts[kind] or 0) + 1
table.insert(rows, string.format(
"|-\n| [[%s]] || %s || [[%s]] || [[%s]] || %s",
item.Name or key, fmt_value(label_key, obj.Value, label),
cur or "", new or "", kind))
end
end
end
end
end
i = i + 1
end
end

local out = {}
table.insert(out, string.format(
"Items scanned: %d. Passive/Active main stats with a label: %d. Unchanged: %d. Changed: %d.\n",
n_items, n_stats, n_same, #rows))
local ks = {}
for k in pairs(counts) do table.insert(ks, k) end
table.sort(ks)
for _, k in ipairs(ks) do table.insert(out, string.format("* %s: %d", k, counts[k])) end
table.insert(out, '{| class="wikitable sortable"\n! Item !! Label !! Current target !! Proposed target !! Type')
for _, r in ipairs(rows) do table.insert(out, r) end
table.insert(out, "|}")
return table.concat(out, "\n")
end

return p