@@ Line 1: / Line 1: @@
 local p = {};
+local lang = require "Module:Lang"
+local util_module = require "Module:Utilities"
 local data = mw.loadJsonData("Data:ItemData.json")
--- returns the table of a specific item
+-- A list of item properties that should have a '%' sign appended to their base value.
-function get_json_item(name)
+local percentage_properties = {
-	for i,v in pairs(data) do
+	AbilityLifestealPercentHero = true,
+	AbilityLifestealPercentHeroPassive = true,
+	ActivatedFireRate = true,
+	ActiveBonusFireRate = true,
+	ActiveBonusLifesteal = true,
+	ActiveReloadPercent = true,
+	AirBonusDamageGiven = true,
+	AirBonusDamageTaken = true,
+	AirControlPercent = true,
+	AirMoveIncreasePercent = true,
+	AllyPercentage = true,
+	AmbushBonusFireRate = true,
+	AmbushBonusMeleeDamage = true,
+	AmmoReloadPercent = true,
+	BaseAttackDamagePercent = true,
+	BaseAttackDamagePercentAtMaxDuration = true,
+	BaseAttackDamagePercentBonus = true,
+	BonusAbilityDurationPercent = true,
+	BonusAttackRangePercent = true,
+	BonusBaseHealth = true,
+	BonusBulletSpeedPercent = true,
+	BonusClipSizePercent = true,
+	BonusDamagePercent = true,
+	BonusFireRate = true,
+	BonusHeavyMeleeDamage = true,
+	BonusMeleeDamagePercent = true,
+	BonusSoulsPct = true,
+	BonusZoomPercent = true,
+	BuffBulletResist = true,
+	BuffMeleeDamageBoost = true,
+	BuffTechResist = true,
+	BulletArmorReduction = true,
+	BulletDamageReflectedPct = true,
+	BulletLifestealPercent = true,
+	BulletProcDeflectionPercent = true,
+	BulletResist = true,
+	BulletResistBelowThreshold = true,
+	BulletResistPerStack = true,
+	BulletResistReduction = true,
+	CloseRangeBonusWeaponPower = true,
+	CooldownBetweenChargeReduction = true,
+	CooldownReduction = true,
+	CooldownReductionOnChargedAbilities = true,
+	CooldownReductionOnHitPct = true,
+	CooldownReductionPctOnNonHeroes = true,
+	CritDamagePercent = true,
+	CurrentHealthDamage = true,
+	DamagePctVsNonHeroes = true,
+	DeathImmunityDamageReduction = true,
+	DeflectionPercent = true,
+	DotHealthPercent = true,
+	FervorTechResist = true,
+	FervorFireRate = true,
+	FireRatePerKill = true,
+	FireRateBonus = true,
+	FireRateSlow = true,
+	FireRateWhileSliding = true,
+	GravityScale = true,
+	GroundDashReductionPercent = true,
+	HealAmpCastPercent = true,
+	HealAmpReceivePenaltyPercent = true,
+	HealAmpRegenPenaltyPercent = true,
+	HealAmpRegenPercent = true,
+	HealLifePercentOutOfCombat = true,
+	HealPercentAmount = true,
+	HealPercentPerHeadshot = true,
+	HealthPctDamage = true,
+	ItemCooldownReduction = true,
+	ImbueAbilityLifesteal = true,
+	ImbuedCooldownReduction = true,
+	LifestealHealPercent = true,
+	LightMeleeAmmo = true,
+	LongRangeBonusWeaponPower = true,
+	MagicIncreasePerStack = true,
+	MagicResistReduction = true,
+	MaxArmorStacks = true,
+	MaxHealthDamage = true,
+	MaxHealthLossPercent = true,
+	MaxHealthPercentAsDPS = true,
+	MaxHPDamage = true,
+	MaxSlowPercent = true,
+	MeleeDistanceScale = true,
+	MeleeResistPercent = true,
+	ModelScaleGrowthTooltip = true,
+	MoveWhileShootingSpeedPenaltyReductionPercent = true,
+	MoveWhileZoomedSpeedPenaltyReductionPercent = true,
+	MovementSpeedSlow = true,
+	NonHeroHealPct = true,
+	NonHeroReductionPercent = true,
+	NonPlayerBonusWeaponPower = true,
+	NonPlayerBulletResist = true,
+	OutgoingDamagePenaltyPercent = true,
+	ParrySuccessHealPercentage = true,
+	PercentDamage = true,
+	ProcBaseAttackDamagePercent = true,
+	ProcBaseAttackDamagePercentAltFire = true,
+	ProcChance = true,
+	ReduceFootstepSound = true,
+	ReloadSpeedMultipler = true,
+	ResistStealAmount = true,
+	RespawnTime = true,
+	RicochetDamagePercent = true,
+	SelfModifier = true,
+	SlideScale = true,
+	SlowPercent = true,
+	SlowResistancePercent = true,
+	SpiritDamageReductionProc = true,
+	SpiritDamageReflectedPct = true,
+	StackingTechRangeMultiplier = true,
+	StackingTechRadiusMultiplier = true,
+	StaminaCooldownReduction = true,
+	StatusResistancePercent = true,
+	TechArmorDamageReduction = true,
+	TechDamagePercent = true,
+	TechDamageReduction = true,
+	TechPowerPercent = true,
+	TechRadiusMultiplier = true,
+	TechRadiusMultiplierBuff = true,
+	TechRangeMultiplier = true,
+	TechRangeMultiplierBuff = true,
+	TechResist = true,
+	TechResistBelowThreshold = true,
+	WeaponDamagePerStack = true,
+	WeaponPowerPerStack = true,
+}
+-- Mappings from placeholder tokens (used in descriptions) to the actual
+-- flat property keys in Data:ItemData.json
+local PROPERTY_KEY_OVERRIDES = {
+    ["ArcaneSurgeWindow"] = "AbilityDuration",
+    -- Add any other mismatches here as they appear
+}
+local function strip_suffix(value)
+	if type(value) == "number" then
+		return tostring(value)
+	end
+	if type(value) ~= "string" then
+		return tostring(value)
+	end
+	return value:match("[-%d%.]+") or value
+end
+---------------------------------------- Utility functions
+-- Returns the table of a specific item.
+-- Prioritizes active (non-disabled) items if multiple entries share the same name.
+-- @function   get_json_item
+-- @param      {string}
+-- @return     {table}
+local function get_json_item(name)
+	-- First, try to find an active item. This handles cases where a disabled item
+	-- with the same name exists in the data (e.g., old versions).
+	for _, v in pairs(data) do
+		if (v["Name"] == name and (v["IsDisabled"] == false or v["IsDisabled"] == nil)) then
+			return v -- Return the active item immediately
+		end
+	end
+	-- If no active item was found, fall back to finding any item with the name.
+	-- This preserves functionality for items that are intentionally disabled.
+	for _, v in pairs(data) do
 		if (v["Name"] == name) then
 			return v
 		end
 	end
-	return nil
+	return nil -- Return nil if no item was found at all
+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(data) do
+		if (v[property] ~= nil) then
+			table.insert(similarItems, v)
+		end
+	end
+	return similarItems
+end
+-- Adds commas delimiter to the thousands place
+local function Format(amount)
+	local contentLanguage = mw.language.getContentLanguage()
+    local formatted = amount
+    if(type(formatted) ~= "number") then return "<span style=\"color:red;\">Cannot format non-number value.</span>" end
+    return contentLanguage:formatNum(tonumber(formatted))
+end
+--- Get cost of an item
+-- @function   get_cost
+-- @param      {string}
+-- @return     {number}
+local function get_cost(item_name)
+	local item = get_json_item(item_name)
+	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
+	return tonumber(item["Cost"])
+end
+--- Get type/slot/category of an item
+-- @function   get_type
+-- @param      {string} item_name
+-- @param      {boolean} raw (optional)
+-- @return     {string}
+local function get_type(item_name, raw)
+	local item = get_json_item(item_name)
+	if not item then
+		return "<span style=\"color:red;\">Item Not Found.</span>"
+	end
+	local slot = item["Slot"]
+	if not slot then return nil end
+	local key_map = {
+		Weapon = 'CitadelCategoryWeapon',
+		Armor = 'CitadelCategoryArmor',
+		Tech = 'CitadelCategoryTech'
+	}
+	local key = key_map[slot]
+	if not key then return nil end
+	if raw then
+		return lang.get_string(key, "en")
+	else
+		return lang.get_string(key)
+	end
 end
---{{#invoke:ItemData|get_cost|ITEM_NAME}}--
+---------------------------------------- Invocable functions
+--- {{#invoke:ItemData|get_cost|ITEM_NAME}} access point
 p.get_cost = function(frame)
 	local item_name = frame.args[1]
-	local item = get_json_item(item_name)
+	return Format(get_cost(item_name))
-	if(item == nil) then return "Item Not Found" end
+end
-	local cost = 0
-	local cur_item = item
-	repeat
-		cost = cost + cur_item["Cost"]
-		if(cur_item["Components"] == nil) then
-			break
-		end
-		cur_item = data[cur_item["Components"][1]]
-	until cur_item == nil
-	return cost
+-- Module access point
+function p._get_cost(a)
+	a = tostring(a) or '0'
+	return get_cost(a)
 end
---{{#invoke:ItemData|get_type|ITEM_NAME}}--
+-- {{#invoke:ItemData|get_type|ITEM_NAME}} access point
 p.get_type = function(frame)
 	local item_name = frame.args[1]
-	local item = get_json_item(item_name)
+	-- Accept 'raw' as string "true" (case sensitive)
-	if(item == nil) then return "Item Not Found" end
+	local raw = frame.args['raw'] == 'true'
+	return get_type(item_name, raw)
-	if (item["Slot"] == "Weapon") then
+end
-		return "Weapon"
-	elseif (item["Slot"] == "Armor") then
+-- Module access point
-		return "Vitality"
+function p._get_type(a)
-	elseif (item["Slot"] == "Tech") then
+	a = tostring(a) or ""
-		return "Spirit"
+	return get_type(a)
-	else
-		return nil
-	end
 end
@@ Line 52: / Line 272: @@
 	local item_name = frame.args[1]
 	local item = get_json_item(item_name)
-	if(item == nil) then return "Item Not Found" end
+	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
 	if (item["Activation"] == "Passive") then
-		return	nil
+		return	false
 	else
 		return true
@@ Line 64: / Line 284: @@
 --check Data:ItemData.json for properties
 p.get_prop = function(frame)
-	local item_name = frame.args[1]
+    local item_name = frame.args[1]
-	local property = frame.args[2]
+    local property = frame.args[2]
-	local item = get_json_item(item_name)
+    local raw = frame.args.raw == 'true'
-	if(item == nil) then return "Item Not Found" end
+    local item = get_json_item(item_name)
+    if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
-	return item[property]
+    -- Look up property directly; if missing, try the override table
+    local prop_value = item[property]
+    if prop_value == nil and PROPERTY_KEY_OVERRIDES[property] then
+        prop_value = item[ PROPERTY_KEY_OVERRIDES[property] ]
+    end
+    if (prop_value == nil) then return nil end
+	local display_value
+	local scaling_str = "" -- Default to an empty string for non-scaled values
+	-- Determine the base value and scaling string (if any)
+	if(type(prop_value) == "table") then
+		if prop_value["Value"] ~= nil and prop_value["Scale"] ~= nil and prop_value["Scale"]["Value"] ~= nil and prop_value["Scale"]["Type"] ~= nil then
+			-- This is a structured attribute with scaling data
+			display_value = raw and strip_suffix(prop_value["Value"]) or tostring(prop_value["Value"])
+			if not raw then
+				local scale_val = tonumber(prop_value["Scale"]["Value"])
+				if scale_val ~= 0 then
+					local scale_type = prop_value["Scale"]["Type"]
+					local rounded_scale_val = util_module.round_to_sig_fig(scale_val, 2)
+					local template_title
+					if scale_type == "power_increase" then
+						template_title = "Template:Boon"
+					else
+						template_title = "Template:Ss"
+					end
+					local template_args = { [1] = rounded_scale_val }
+					-- Add a space before the scaling template for proper separation
+					scaling_str = " " .. mw.getCurrentFrame():expandTemplate{ title = template_title, args = template_args }
+				end
+			end
+		else
+			-- This is a simple list (e.g., TargetTypes), handle and return it directly
+			local tableValues = {}
+			for _, v in pairs(prop_value) do
+				table.insert(tableValues, raw and strip_suffix(v) or tostring(v))
+			end
+			return table.concat(tableValues, ", ")
+		end
+	else
+		-- This is a simple, non-table property
+		display_value = raw and strip_suffix(prop_value) or tostring(prop_value)
+	end
+	if raw then
+		return display_value
+	end
+	-- Assemble the final string, adding the '%' sign if necessary
+	if percentage_properties[property] == true then
+		return display_value .. "%" .. scaling_str
+	else
+		return display_value .. scaling_str
+	end
 end
 p.get_component_name = function(frame)
 	local item_name = frame.args[1]
+	local slot_arg = frame.args[2]
 	local item = get_json_item(item_name)
-	if(item == nil) then return "Item Not Found" end
+	if(item == nil) then return "<span style=\"color:red;\">Item Not Found.</span>" end
 	local components = item['Components']
@@ Line 81: / Line 360: @@
 	if(components == nil) then return nil end
-	local component_key = components[1]
+	local slot = tonumber(slot_arg) or 1
+	local component_key = components[slot]
+	if (component_key == nil) then return nil end
 	local component = data[component_key]
-	if (component == nil) then return nil end
+	local component = data[component_key]
+	if (component == nil or component["IsDisabled"] == true) then return nil end
 	return component['Name']
+end
+-- {{Items count}} access point
+function p.get_headcount(frame)
+	local item_type = frame.args[1]
+	local iter = 0
+	local tbl = get_similar_items("IsDisabled")
+	for _, v in ipairs(tbl) do
+		if item_type == "Standard" then
+			-- return only regular items
+		    if (v["IsDisabled"] == false and v["Slot"] ~= nil and v["StreetBrawl"] == false and v["Name"] ~= nil) then
+			iter = iter + 1
+		   end
+		elseif item_type == "Street Brawl" then
+			-- return only street brawl items
+        	if (v["IsDisabled"] == false and v["Slot"] ~= nil and v["StreetBrawl"] == true and v["Name"] ~= nil) then
+			iter = iter + 1
+		   end
+	   end
+	end
+	return iter
+end
+-- Gets the codename (the key in the JSON data) for a given item's display name.
+-- Prioritizes active items to handle cases where disabled duplicates exist.
+p.get_codename = function(frame)
+	local name = frame.args[1]
+	-- First, try to find an active item.
+	for k, v in pairs(data) do
+		if (v["Name"] == name and (v["IsDisabled"] == false or v["IsDisabled"] == nil)) then
+			return k -- Return the codename of the active item
+		end
+	end
+	-- If no active item was found, fall back to finding any item with the name.
+	for k, v in pairs(data) do
+		if (v["Name"] == name) then
+			return k
+		end
+	end
+	return nil -- Return nil if no item was found at all
+end
+-- {{#invoke:ItemData|get_property_upgrade|ITEM_NAME|PROPERTY}} --
+p.get_property_upgrade = function(frame)
+	local item_name = frame.args[1]
+	local property = frame.args[2]
+	local raw = frame.args.raw == 'true'
+	local item = get_json_item(item_name)
+	if item == nil then
+		return "<span style=\"color:red;\">Item Not Found.</span>"
+	end
+	local upgrades = item["PropertyUpgrades"]
+	if upgrades == nil then return nil end
+	local value = upgrades[property]
+	if value == nil then return nil end
+	local result = raw and strip_suffix(value) or tostring(value)
+	if raw then
+		return result
+	end
+	-- Append % if this property is percentage-based
+	if percentage_properties[property] == true then
+		return result .. "%"
+	else
+		return result
+	end
+end
+-- Helping function for [[Module:Enhanced]]
+function p.get_prop_meta(item_name, property)
+	local item = get_json_item(item_name)
+	if not item then return nil end
+	local raw = item[property]
+	if raw == nil then return nil end
+	local meta = {
+		unit = nil,     -- "%", "m", "s" or nil
+		scale = nil     -- { type = "Ss"/"Boon", value = number } or nil
+	}
+	if percentage_properties[property] then
+		meta.unit = "%"
+	end
+	if type(raw) == "table"
+		and raw.Scale
+		and raw.Scale.Value
+		and raw.Scale.Type
+	then
+		local scale_val = tonumber(raw.Scale.Value)
+		if scale_val and scale_val ~= 0 then
+			meta.scale = {
+				type = raw.Scale.Type == "power_increase" and "Boon" or "Ss",
+				value = util_module.round_to_sig_fig(scale_val, 2)
+			}
+		end
+	end
+	return meta
+end
+-- Builds Into functions
+-- Helper: accepts item key or display name, returns the key used in data table
+local function get_codename_from_input(input)
+	if data[input] then return input end
+	for k, v in pairs(data) do
+		if v["Name"] == input and (v["IsDisabled"] == false or v["IsDisabled"] == nil) then
+			return k
+		end
+	end
+	for k, v in pairs(data) do
+		if v["Name"] == input then return k end
+	end
+	return nil
+end
+-- Core logic: returns table of keys that have this item in their Components
+local function get_component_of(item_input)
+	local target_key = get_codename_from_input(item_input)
+	if not target_key then return {} end
+	local parents = {}
+	for key, item in pairs(data) do
+		if item.IsDisabled ~= true and item.Components and type(item.Components) == "table" then
+			for _, comp in ipairs(item.Components) do
+				if comp == target_key then
+					table.insert(parents, key)
+					break
+				end
+			end
+		end
+	end
+	table.sort(parents)
+	return parents
+end
+-- Template: {{#invoke:ItemData|get_builds_into_count|ITEM_NAME}}
+p.get_builds_into_count = function(frame)
+	local item = frame.args[1]
+	return #get_component_of(item)
+end
+-- Template: {{#invoke:ItemData|get_builds_into_name|ITEM_NAME|INDEX}}
+p.get_builds_into_name = function(frame)
+	local item = frame.args[1]
+	local idx = tonumber(frame.args[2]) or 1
+	local parents = get_component_of(item)
+	local key = parents[idx]
+	return key and data[key] and data[key]["Name"] or ""
+end
+-- Template: {{#invoke:ItemData|get_builds_into|ITEM_NAME}}
+-- Returns fully rendered ItemIcon templates
+p.get_builds_into = function(frame)
+	local item = frame.args[1]
+	local parents = get_component_of(item)
+	if #parents == 0 then return "" end
+	local and_word = frame:preprocess("{{#invoke:Dictionary|translate|And}}")
+	and_word = mw.ustring.lower(and_word)
+	local parts = {}
+	for _, key in ipairs(parents) do
+		local name = data[key] and data[key]["Name"] or key
+		local icon = mw.getCurrentFrame():expandTemplate{ title = "ItemIcon", args = { name } }
+		table.insert(parts, icon)
+	end
+	if #parts == 1 then return parts[1] end
+	if #parts == 2 then
+		return parts[1] .. " " .. and_word .. " " .. parts[2]
+	end
+	local last = table.remove(parts)
+	return table.concat(parts, ", ") .. ", " .. and_word .. " " .. last
 end
 return p

Module:ItemData: Difference between revisionsGive feedback

LVL (talk | contribs)