more-descriptions/data-final-fixes.lua

local function seconds(x)
	return {"time-symbol-seconds", tostring(x)}
end

local function build_new_description(main_description, new_descriptions)
	local new_localised_description = {
		"",
		main_description,
	}
	for i, k in pairs(new_descriptions)
	do
		if i ~= 1
		then
			table.insert(new_localised_description, "\n")
		end
		table.insert(new_localised_description, k)
	end
	return new_localised_description
end

local item_categories =
{
	"item",
	"item-with-entity-data",
	"rail-planner",
	"capsule",
	"repair-tool",
	"blueprint",
	"deconstruction-item",
	"upgrade-item",
	"blueprint-book",
	"copy-paste-tool",
	"module",
	"tool",
	"gun",
	"ammo",
	"space-platform-starter-pack",
	"armor",
	"spidertron-remote",
}

local entity_categories =
{
	"container",
	"storage-tank",
	"transport-belt",
	"underground-belt",
	"splitter",
	"loader",
	"inserter",
	"electric-pole",
	"pipe",
	"pipe-to-ground",
	"pump",
	"straight-rail",
	"half-diagonal-rail",
	"curved-rail-a",
	"curved-rail-b",
	"elevated-straight-rail",
	"elevated-half-diagonal-rail",
	"elevated-curved-rail-a",
	"elevated-curved-rail-b",
	"legacy-straight-rail",
	"legacy-curved-rail",
	"rail-ramp",
	"rail-support",
	"train-stop",
	"rail-signal",
	"rail-chain-signal",
	"locomotive",
	"cargo-wagon",
	"fluid-wagon",
	"artillery-wagon",
	"car",
	"spider-vehicle",
	"logistic-robot",
	"construction-robot",
	"logistic-container",
	"roboport",
	"lamp",
	"arithmetic-combinator",
	"decider-combinator",
	"selector-combinator",
	"constant-combinator",
	"power-switch",
	"programmable-speaker",
	"display-panel",
	"boiler",
	"generator",
	"fusion-reactor",
	"fusion-generator",
	"mining-drill",
	"offshore-pump",
	"furnace",
	"assembling-machine",
	"agricultural-tower",
	"lab",
	"lightning-attractor",
	"reactor",
	"beacon",
	"rocket-silo",
	"cargo-landing-pad",
	"space-platform-hub",
	"cargo-bay",
	"asteroid-collector",
	"thruster",
	"wall",
	"gate",
	"radar",
	"land-mine",
	"ammo-turret",
	"electric-turret",
	"fluid-turret",
	"artillery-turret",
	"plant",
	"simple-entity-with-force",
	"simple-entity-with-owner",
	"electric-energy-interface",
	"linked-container",
	"proxy-container",
	"heat-interface",
	"heat-pipe",
	"lane-splitter",
	"linked-belt",
	"valve",
	"infinity-cargo-wagon",
	"infinity-container",
	"infinity-pipe",
	"burner-generator",
	"resource",
	"cargo-pod",
	"temporary-container",
	"asteroid",
	"combat-robot",
	"unit",
	"turret",
	"unit-spawner",
	"spider-unit",
	"segmented-unit",
	"cliff",
	"character",
	"fish",
	"tree",
	"simple-entity",
	"lightning",
	"corpse",
	"rail-remnants",
	"explosion",
	"particle-source",
	"fire",
	"sticker",
	"stream",
	"artillery-flare",
	"artillery-projectile",
	"projectile",
	"segment",
	"spider-leg",
	"beam",
	"character-corpse",
	"speech-bubble",
	"smoke-with-trigger",
	"entity-ghost",
	"arrow",
	"highlight-box",
	"item-entity",
	"item-request-proxy",
	"loader-1x1",
	"rocket-silo-rocket",
	"rocket-silo-rocket-shadow",
	"tile-ghost",
	"market",
	"capture-robot",
	"solar-panel",
}

local function find_entity(name)
	for _, entity_category in pairs(entity_categories)
	do
		if data.raw[entity_category] and data.raw[entity_category][name]
		then
			return data.raw[entity_category][name]
		end
	end
	return nil
end

local ammo_categories = {}

for _, ammo in pairs(data.raw.ammo)
do
	if not ammo_categories[ammo.ammo_category]
	then
		ammo_categories[ammo.ammo_category] = ""
	end
	if #ammo_categories[ammo.ammo_category] < 120
	then
		ammo_categories[ammo.ammo_category] = ammo_categories[ammo.ammo_category].."[item="..ammo.name.."]"
	elseif string.sub(ammo_categories[ammo.ammo_category], -3, -1) ~= "..."
	then
		ammo_categories[ammo.ammo_category] = ammo_categories[ammo.ammo_category] .. "..."
	end
end

for _, item_type in pairs(item_categories)
do
	for _, item in pairs(data.raw[item_type] or {})
	do
        local new_descriptions = {}
		local recycling_recipe = data.raw.recipe[item.name.."-recycling"]

		local add_description = function(x)
			table.insert(new_descriptions, x)
		end

		local add_ammo_from_attack_parameters = function(attack_parameters)
			if attack_parameters.ammo_category and ammo_categories[attack_parameters.ammo_category]
			then
				add_description{"more-descriptions-mod.gun-accepts-ammo", ammo_categories[attack_parameters.ammo_category]}
			end
			for _, category in pairs(attack_parameters.ammo_categories or {})
			do
				if ammo_categories[category]
				then
					add_description{"more-descriptions-mod.gun-accepts-ammo", ammo_categories[category]}
				end
			end
		end

		if recycling_recipe ~= nil
		then
			local recycling_results = {""}
			for _, result in pairs(recycling_recipe.results)
			do
				table.insert(recycling_results, "[img="..result.type.."."..result.name.."]")
			end
            add_description{
                "more-descriptions-mod.recycling",
                seconds(recycling_recipe.energy_required),
				recycling_results
            }
		end

		if mods["promethium-quality"]
		then
			local refining_recipe = data.raw.recipe[item.name.."-refining"]
			if refining_recipe ~= nil
			then
				add_description{
					"more-descriptions-mod.refining-cost",
					tostring(refining_recipe.energy_required),
				}
			elseif recycling_recipe ~= nil
			then
				add_description{"more-descriptions-mod.cannot-be-refined"}
			end
		end

		if item.type == "ammo" and (item.reload_time or 0) > 0
		then
			add_description{
				"more-descriptions-mod.reload-time",
				seconds(tostring(item.reload_time / 60.0)),
			}
		end

		if item.type == "active-defense-equipment" and item.automatic
		then
			add_description{"more-descriptions-mod.fires-automatically"}
		end

		if item.type == "armor" and item.provides_flight
		then
			add_description{"more-descriptions-mod.armor-provides-flight"}
		end

		if item.type == "gun"
		then
			add_ammo_from_attack_parameters(item.attack_parameters)
		end

		local entity = item.place_result and find_entity(item.place_result) or nil
		if entity ~= nil
		then
			if entity.collision_box
			then
				local cb = entity.collision_box
				local width = math.ceil(cb[2][1] - cb[1][1])
				local height = math.ceil(cb[2][2] - cb[1][2])
				add_description{
					"more-descriptions-mod.size",
					tostring(width),
					tostring(height),
				}
			end

			if entity.drops_full_belt_stacks
			then
				add_description{"more-descriptions-mod.drops-full-belt-stacks"}
			end

			if entity.heat_buffer and entity.heat_buffer.specific_heat
			then
				add_description{
					"more-descriptions-mod.specific-heat",
					entity.heat_buffer.specific_heat,
				}
			elseif entity.energy_source
				and entity.energy_source.type == "heat"
				and entity.energy_source.specific_heat
			then
				add_description{
					"more-descriptions-mod.specific-heat",
					entity.energy_source.specific_heat,
				}
			end

			if entity.is_military_target
			then
				add_description{"more-descriptions-mod.is-military-target"}
			end

			if entity.type == "agricultural-tower"
			then
				local cb = entity.collision_box
				local W = math.ceil(cb[2][1] - cb[1][1])
				local w = (entity.growth_grid_tile_size or 3)
				-- width of the "buffer" area around the agricultural tower
				local z = (2 * w * math.ceil((W - w) / 2 / w)) + w
				-- num of growth cells extending from the edges of the tower
				local r = math.floor(entity.radius) -- why is it double..?
				add_description{"more-descriptions-mod.agricultural-tower-num-inputs",
					tostring(entity.input_inventory_size)
				}
				add_description{"more-descriptions-mod.agricultural-tower-growth-cell-size",
					tostring(w)
				}
				add_description{"more-descriptions-mod.agricultural-tower-growth-cell-count",
					tostring(4 * r * (r + (z / w)))
				}
				add_description{"more-descriptions-mod.agricultural-tower-total-size",
					tostring(z + 2 * r * w)
				}
			elseif entity.type == "ammo-turret"
			then
				if entity.energy_per_shot ~= nil
				then
					add_description{"more-descriptions-mod.energy-per-shot-fired",
						entity.energy_per_shot}
				end
				add_ammo_from_attack_parameters(entity.attack_parameters)
			elseif entity.type == "beacon"
			then
				add_description{"more-descriptions-mod.beacon-supply-area-distance",
					tostring(entity.supply_area_distance)
				}
			elseif entity.type == "car"
			then
				local immunities = ""
				if (entity.immune_to_tree_impacts or false)
				then
					immunities = immunities.."[entity=tree-01]"
				end
				if (entity.immune_to_rock_impacts or false)
				then
					immunities = immunities.."[entity=big-rock]"
				end
				if (entity.immune_to_cliff_impacts or true)
				then
					immunities = immunities.."[entity=cliff]"
				end
				if immunities ~= ""
				then
					add_description{"more-descriptions-mod.car-immune-to-impacts", immunities}
				end
			elseif entity.type == "constant-combinator"
			then
				-- used by pushbutton mod
				if (entity.pulse_duration or 0) > 60
				then
					add_description{"more-descriptions-mod.constant-combinator-pulse-duration",
						seconds(entity.pulse_duration / 60.0)}
				elseif (entity.pulse_duration or 0) > 0
				then
					add_description{"more-descriptions-mod.constant-combinator-pulse-duration",
						{"more-descriptions-mod.ticks", tostring(entity.pulse_duration)}}
				end
			elseif (entity.type == "container" or entity.type == "logistic-container")
			then
				if entity.inventory_type == "with_filters_and_bar"
				then
					add_description{"more-descriptions-mod.container-filters"}
				end
			elseif entity.type == "cargo-wagon"
			then
				-- all cargo wagons support filters
				add_description{"more-descriptions-mod.container-filters"}
			elseif entity.type == "display-panel"
			then
				add_description{"more-descriptions-mod.display-panel-max-text-width",
					tostring(entity.max_text_width or 400)}
			elseif entity.type == "logistic-robot" or entity.type == "construction-robot"
			then
				if entity.speed_multiplier_when_out_of_energy > 0
				then
					add_description{"more-descriptions-mod.robot-speed-multiplier-when-out-of-energy",
						tostring(entity.speed_multiplier_when_out_of_energy * 100)}
				else
					add_description{"more-descriptions-mod.robot-crashes-when-out-of-energy"}
				end
			elseif entity.type == "inserter"
			then
				if entity.wait_for_full_hand
				then
					add_description{"more-descriptions-mod.inserter-wait-for-full-hand",
					tostring(entity.filter_count)}
				end
			elseif entity.type == "land-mine"
			then
				add_description{"more-descriptions-mod.land-mine-timeout",
				seconds((entity.timeout or 120) / 60.0)}
			elseif entity.type == "radar"
			then
				if entity.connects_to_other_radars ~= false
				then
					add_description{"more-descriptions-mod.radar-connection"}
				end
			end
			if entity.filter_count
			then
				add_description{"more-descriptions-mod.filter-count",
					tostring(entity.filter_count)}
			end
			for _, flag in pairs(entity.flags or {})
			do
				if flag == "no-automated-item-insertion"
				then
					table.insert(new_descriptions, {"more-descriptions-mod.no-automated-item-insertion"})
				end
			end
		end

		if #new_descriptions > 0
		then
			local main_description = item.localised_description
                and {"", item.localised_description, "\n"}
                or {
                    "?",
                    {"", {"entity-description."..item.name}, "\n"},
                    {"", {"item-description."..item.name}, "\n"},
                    ""
            }
			item.localised_description = build_new_description(main_description, new_descriptions)
		end
	end
end

for _, recipe in pairs(data.raw.recipe)
do
	local new_descriptions = {}

	if recipe.allow_productivity
	then
		table.insert(new_descriptions, {"more-descriptions-mod.allows-productivity"})
	end

	if #new_descriptions > 0
	then
		local main_description = recipe.localised_description
			and {"", recipe.localised_description, "\n"}
			or {
				"?",
				{"", {"recipe-description."..recipe.name}, "\n"},
				""
		}
		recipe.localised_description = build_new_description(main_description, new_descriptions)
	end
end

-- Stuff mostly specific for entities that you don't place with items (like biters)
for _, entity_category in pairs(entity_categories)
do
	for _, entity in pairs(data.raw[entity_category] or {})
	do
		local new_descriptions = {}

		if entity.minable
		then
			table.insert(new_descriptions, {"more-descriptions-mod.mining-time",
				seconds(entity.minable.mining_time)})
		end

		for _, flag in pairs(entity.flags or {})
		do
			if flag == "breaths-air"
			then
				table.insert(new_descriptions, {"more-descriptions-mod.breathes-air"})
			end
		end

		if entity.type == "unit-spawner"
		then
			if (entity.time_to_capture or 0) > 0
			then
				table.insert(new_descriptions, {"more-descriptions-mod.unit-spawner-time-to-capture",
					seconds(entity.time_to_capture / 60.0)})
			end
		end

		if #new_descriptions > 0
		then
			local main_description = entity.localised_description
				and {"", entity.localised_description, "\n"}
				or {
					"?",
					{"", {"entity-description."..entity.name}, "\n"},
					""
			}
			entity.localised_description = build_new_description(main_description, new_descriptions)
		end
	end
end

for _, space_location in pairs(data.raw["space-location"])
do
	local new_descriptions = {}

	if (space_location.fly_condition or false)
	then
		table.insert(new_descriptions, {"more-descriptions-mod.space-location-fly-condition"})
	end

	if space_location.auto_save_on_first_trip == false -- (nil=true)
	then
		table.insert(new_descriptions, {"more-descriptions-mod.space-location-no-autosave"})
	end

	if #new_descriptions > 0
	then
		local main_description = space_location.localised_description
			and {"", space_location.localised_description, "\n"}
			or {
				"?",
				{"", {"space-location-description."..space_location.name}, "\n"},
				""
		}
		space_location.localised_description = build_new_description(main_description, new_descriptions)
	end
end