211 lines
8.0 KiB
Lua
211 lines
8.0 KiB
Lua
local table = require("__flib__.table")
|
|
|
|
local util = require("scripts.util")
|
|
|
|
local item_proc = {}
|
|
|
|
function item_proc.build(database, metadata)
|
|
local modules = {}
|
|
local place_as_equipment_results = {}
|
|
local place_results = {}
|
|
local rocket_launch_payloads = {}
|
|
|
|
for name, prototype in pairs(global.prototypes.item) do
|
|
-- Group
|
|
local group = prototype.group
|
|
local group_data = database.group[group.name]
|
|
group_data.items[#group_data.items + 1] = { class = "item", name = name }
|
|
-- Rocket launch products
|
|
local launch_products = {}
|
|
for i, product in ipairs(prototype.rocket_launch_products or {}) do
|
|
-- Add to products table w/ amount string
|
|
local amount_ident = util.build_amount_ident(product)
|
|
launch_products[i] = {
|
|
class = product.type,
|
|
name = product.name,
|
|
amount_ident = amount_ident,
|
|
}
|
|
-- Add to payloads table
|
|
local product_payloads = rocket_launch_payloads[product.name]
|
|
local ident = { class = "item", name = name }
|
|
if product_payloads then
|
|
product_payloads[#product_payloads + 1] = ident
|
|
else
|
|
rocket_launch_payloads[product.name] = { ident }
|
|
end
|
|
end
|
|
local default_categories =
|
|
util.unique_string_array(#launch_products > 0 and table.shallow_copy(metadata.rocket_silo_categories) or {})
|
|
|
|
local place_as_equipment_result = prototype.place_as_equipment_result
|
|
if place_as_equipment_result then
|
|
place_as_equipment_result = { class = "equipment", name = place_as_equipment_result.name }
|
|
place_as_equipment_results[name] = place_as_equipment_result
|
|
end
|
|
|
|
local place_result = prototype.place_result
|
|
if place_result and database.entity[place_result.name] then
|
|
place_result = { class = "entity", name = place_result.name }
|
|
place_results[name] = place_result
|
|
else
|
|
place_result = nil
|
|
end
|
|
|
|
local burnt_result = prototype.burnt_result
|
|
if burnt_result then
|
|
burnt_result = { class = "item", name = burnt_result.name }
|
|
end
|
|
|
|
local equipment_categories = util.unique_obj_array()
|
|
local equipment = util.unique_obj_array()
|
|
local equipment_grid = prototype.equipment_grid
|
|
if equipment_grid then
|
|
for _, equipment_category in pairs(equipment_grid.equipment_categories) do
|
|
table.insert(equipment_categories, { class = "equipment_category", name = equipment_category })
|
|
local category_data = database.equipment_category[equipment_category]
|
|
if category_data then
|
|
for _, equipment_ident in pairs(category_data.equipment) do
|
|
table.insert(equipment, equipment_ident)
|
|
local equipment_data = database.equipment[equipment_ident.name]
|
|
if equipment_data then
|
|
equipment_data.placed_in[#equipment_data.placed_in + 1] = { class = "item", name = name }
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local fuel_value = prototype.fuel_value
|
|
local has_fuel_value = prototype.fuel_value > 0
|
|
local fuel_acceleration_multiplier = prototype.fuel_acceleration_multiplier
|
|
local fuel_emissions_multiplier = prototype.fuel_emissions_multiplier
|
|
local fuel_top_speed_multiplier = prototype.fuel_top_speed_multiplier
|
|
|
|
local module_effects = {}
|
|
if prototype.type == "module" then
|
|
-- Add to internal list of modules
|
|
modules[name] = table.invert(prototype.limitations)
|
|
-- Process effects
|
|
for effect_name, effect in pairs(prototype.module_effects or {}) do
|
|
module_effects[#module_effects + 1] = {
|
|
type = "plain",
|
|
label = effect_name .. "_bonus",
|
|
value = effect.bonus,
|
|
formatter = "percent",
|
|
}
|
|
end
|
|
-- Process which beacons this module is compatible with
|
|
for beacon_name in pairs(global.prototypes.beacon) do
|
|
local beacon_data = database.entity[beacon_name]
|
|
local allowed_effects = metadata.beacon_allowed_effects[beacon_name]
|
|
local compatible = true
|
|
if allowed_effects then
|
|
for effect_name in pairs(prototype.module_effects or {}) do
|
|
if not allowed_effects[effect_name] then
|
|
compatible = false
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if compatible then
|
|
beacon_data.accepted_modules[#beacon_data.accepted_modules + 1] = { class = "item", name = name }
|
|
end
|
|
end
|
|
-- Process which crafters this module is compatible with
|
|
for crafter_name in pairs(global.prototypes.crafter) do
|
|
local crafter_data = database.entity[crafter_name]
|
|
local allowed_effects = metadata.allowed_effects[crafter_name]
|
|
local compatible = true
|
|
if allowed_effects then
|
|
for effect_name in pairs(prototype.module_effects or {}) do
|
|
if not allowed_effects[effect_name] then
|
|
compatible = false
|
|
break
|
|
end
|
|
end
|
|
end
|
|
if compatible then
|
|
crafter_data.accepted_modules[#crafter_data.accepted_modules + 1] = { class = "item", name = name }
|
|
end
|
|
end
|
|
end
|
|
|
|
local fuel_category = util.convert_to_ident("fuel_category", prototype.fuel_category)
|
|
if fuel_category then
|
|
local items = database.fuel_category[fuel_category.name].items
|
|
items[#items + 1] = { class = "item", name = name }
|
|
end
|
|
|
|
--- @class ItemData
|
|
database.item[name] = {
|
|
accepted_equipment = equipment,
|
|
affects_recipes = {},
|
|
burned_in = {},
|
|
burnt_result = burnt_result,
|
|
burnt_result_of = {},
|
|
class = "item",
|
|
enabled_at_start = metadata.gathered_from[name] and true or false,
|
|
equipment_categories = equipment_categories,
|
|
fuel_acceleration_multiplier = has_fuel_value
|
|
and fuel_acceleration_multiplier ~= 1
|
|
and fuel_acceleration_multiplier
|
|
or nil,
|
|
fuel_category = fuel_category,
|
|
fuel_emissions_multiplier = has_fuel_value and fuel_emissions_multiplier ~= 1 and fuel_emissions_multiplier
|
|
or nil,
|
|
fuel_top_speed_multiplier = has_fuel_value and fuel_top_speed_multiplier ~= 1 and fuel_top_speed_multiplier
|
|
or nil,
|
|
fuel_value = has_fuel_value and fuel_value or nil,
|
|
gathered_from = metadata.gathered_from[name],
|
|
group = { class = "group", name = group.name },
|
|
hidden = prototype.has_flag("hidden"),
|
|
ingredient_in = {},
|
|
item_type = { class = "item_type", name = prototype.type },
|
|
mined_from = {},
|
|
module_category = util.convert_to_ident("module_category", prototype.category),
|
|
module_effects = module_effects,
|
|
place_as_equipment_result = place_as_equipment_result,
|
|
place_result = place_result,
|
|
product_of = {},
|
|
prototype_name = name,
|
|
recipe_categories = default_categories,
|
|
researched_in = {},
|
|
rocket_launch_product_of = {},
|
|
rocket_launch_products = launch_products,
|
|
science_packs = {},
|
|
stack_size = prototype.stack_size,
|
|
subgroup = { class = "group", name = prototype.subgroup.name },
|
|
unlocked_by = util.unique_obj_array(),
|
|
}
|
|
util.add_to_dictionary("item", name, prototype.localised_name)
|
|
util.add_to_dictionary("item_description", name, prototype.localised_description)
|
|
end
|
|
|
|
-- Add rocket launch payloads to their material tables
|
|
for product, payloads in pairs(rocket_launch_payloads) do
|
|
local product_data = database.item[product]
|
|
product_data.rocket_launch_product_of = table.array_copy(payloads)
|
|
for i = 1, #payloads do
|
|
local payload = payloads[i]
|
|
local payload_data = database.item[payload.name]
|
|
local payload_unlocked_by = payload_data.unlocked_by
|
|
for j = 1, #payload_unlocked_by do
|
|
product_data.unlocked_by[#product_data.unlocked_by + 1] = payload_unlocked_by[j]
|
|
end
|
|
end
|
|
end
|
|
|
|
metadata.modules = modules
|
|
metadata.place_as_equipment_results = place_as_equipment_results
|
|
metadata.place_results = place_results
|
|
end
|
|
|
|
-- When calling the module directly, call fluid_proc.build
|
|
setmetatable(item_proc, {
|
|
__call = function(_, ...)
|
|
return item_proc.build(...)
|
|
end,
|
|
})
|
|
|
|
return item_proc
|