diff --git a/bzsilicon2/data-util.lua b/bzsilicon2/data-util.lua index a4d6ac9..e2cbe2a 100644 --- a/bzsilicon2/data-util.lua +++ b/bzsilicon2/data-util.lua @@ -1,2172 +1,4 @@ --- WARNING WARNING WARNING --- This file will be overwritten in mod zipfiles, edit bzlib/data-util.lua --- WARNING WARNING WARNING - -local futil = require("util") local me = require("me") -local util = {} - -util.me = me -util.get_setting = util.me.get_setting - -util.titanium_plate = "" -util.titanium_processing = "" - -local item_sounds_helper = [[ -local item_sounds = require('__base__.prototypes.item_sounds') - - inventory_move_sound = item_sounds.wire_inventory_move, - pick_sound = item_sounds.wire_inventory_pickup, - drop_sound = item_sounds.wire_inventory_move, - - inventory_move_sound = item_sounds.metal_small_inventory_move, - pick_sound = item_sounds.metal_small_inventory_pickup, - drop_sound = item_sounds.metal_small_inventory_move, - - inventory_move_sound = item_sounds.resource_inventory_move, - pick_sound = item_sounds.resource_inventory_pickup, - drop_sound = item_sounds.resource_inventory_move, - - inventory_move_sound = item_sounds.brick_inventory_move, - pick_sound = item_sounds.brick_inventory_pickup, - drop_sound = item_sounds.brick_inventory_move, - - inventory_move_sound = item_sounds.sulfur_inventory_move, - pick_sound = item_sounds.resource_inventory_pickup, - drop_sound = item_sounds.sulfur_inventory_move, -]] - -util.A = {{"automation-science-pack", 1}} -util.AL = {{"automation-science-pack", 1}, {"logistic-science-pack", 1}} -util.ALC = {{"automation-science-pack", 1}, {"logistic-science-pack", 1}, {"chemical-science-pack", 1}} - -if mods["FactorioExtended-Plus-Core"] then - util.titanium_plate = "titanium-alloy" -else - util.titanium_plate = "titanium-plate" -end - -if mods["pyrawores"] then - util.titanium_processing = "titanium-mk01" -else - util.titanium_processing = "titanium-processing" -end - -util.vacuum_icon = { icon="__base__/graphics/icons/fluid/steam.png", tint={r=.1, g=.1, b=.5, a=.5} } -util.vacuum_icon_small = { icon="__base__/graphics/icons/fluid/steam.png", tint={r=.1, g=.1, b=.5, a=.5}, scale=0.25, shift={-8,-8}, } -util.vacuum_vis = {r=.1, g=.1, b=.5} - -function util.item(item, quantity, probability) - if not quantity then - quantity = 1 - end - if probability then - return {type="item", name=item, amount=quantity, probability=probability} - else - return {type="item", name=item, amount=quantity} - end -end - -function util.fluid(fluid, quantity) - if not quantity then - quantity = 10 - end - return {type="fluid", name=fluid, amount=quantity} -end - -function util.se6() - return mods["space-exploration"] and mods["space-exploration"] >= "0.6" -end - -function util.k2() - return mods.Krastorio2 or mods["Krastorio2-spaced-out"] -end - -util.cablesg = util.se6() and "electronic" or "cable" - -function get_setting(name) - if settings.startup[name] == nil then - return nil - end - return settings.startup[name].value -end - -allbypass = {} -if get_setting("bz-recipe-bypass") then - for recipe in string.gmatch(me.get_setting("bz-recipe-bypass"), '[^",%s]+') do - allbypass[recipe] = true - end -end - -function util.is_foundry() - return mods.bzfoundry2 and not me.get_setting("bzfoundry-minimal") -end - -function should_force(options) - return options and options.force -end - - -function bypass(recipe_name) - if me.bypass[recipe_name] then return true end - if allbypass[recipe_name] then return true end - if get_setting("bz-tabula-rasa") then return true end -end - -function util.fe_plus(sub) - if mods["FactorioExtended-Plus-"..sub] then - return true - end -end - -function util.get_stack_size(default) - if util.k2() and kr_adjust_stack_sizes then - return tonumber(200) - end - return default -end - -function util.k2assets() - if mods["Krastorio2Assets"] then - return "__Krastorio2Assets__" - end - return "__Krastorio2__/graphics" -end - --- check if a table contains a sought value -function util.contains(table, sought) - for i, value in pairs(table) do - if value == sought then - return true - end - end - return false -end - --- copies a recipe, giving the copy a new name -function util.copy_recipe(recipe_name, new_recipe_name) - if data.raw.recipe[recipe_name] then - new_recipe = futil.table.deepcopy(data.raw.recipe[recipe_name]) - new_recipe.name = new_recipe_name - data:extend({new_recipe}) - end -end - -function util.add_shiftite_recipe(item, shiftites, quantity) - if not mods["janus"] then return end - if not data.raw.item[item] then return end - local its = {} - for _, shiftite in pairs(shiftites) do - local it = "janus-shiftite-"..shiftite - if data.raw.item[it] then - table.insert(its, util.item(it, quantity)) - end - end - if its then - local name = "shiftite-to-"..item - data:extend({{ - type = "recipe", - name = name, - localised_name = {"", {"item-name."..item}, " ← Shiftite"}, - category = "janus-shiftite", - subgroup = "janus-basic-from-shiftite", - ingredients = its, - results = {util.item(item, 5)}, - energy_required = 2.5, - order = "zzz", - enabled = false, - auto_recycle = false, - }}) - util.add_unlock("janus-time-distorter", name) - end -end - --- Add the gleba rock. If it exists, still add resource to mine from it -local gleba_tint = {.6, .8, 1} -function util.add_gleba_rock(resource, amount_min, amount_max) - if (not data.raw.planet.gleba or - not data.raw.planet.gleba.map_gen_settings or -- attempted compatibility fixes - not data.raw.planet.gleba.map_gen_settings.autoplace_settings or - not data.raw.planet.gleba.map_gen_settings.autoplace_settings.entity or - not data.raw.planet.gleba.map_gen_settings.autoplace_settings.entity.settings - ) then return end - if not data.raw["simple-entity"]["gleba-rock"] then - local autoplace_utils = require("autoplace_utils") - local hit_effects = require ("__base__.prototypes.entity.hit-effects") - local sounds = require ("__base__.prototypes.entity.sounds") - local decorative_trigger_effects = require("__base__.prototypes.decorative.decorative-trigger-effects") - data.raw.planet.gleba.map_gen_settings.autoplace_settings.entity.settings["gleba-rock"] = {} - data:extend({ - { - type = "simple-entity", - name = "gleba-rock", - localised_name = {"entity-name.big-rock"}, - flags = {"placeable-neutral", "placeable-off-grid"}, - icons = {{icon = "__base__/graphics/icons/big-sand-rock.png", tint=gleba_tint}}, - subgroup = "grass", - order = "b[decorative]-l[rock]-a[big]", - deconstruction_alternative = "big-rock", - collision_box = {{-0.75, -0.75}, {0.75, 0.75}}, - selection_box = {{-1.0, -1.0}, {1.0, 0.75}}, - damaged_trigger_effect = hit_effects.rock(), - render_layer = "object", - max_health = 500, - autoplace = { - control = "gleba_plants", - order = "z[gleba]-a[rock]-b[big]", - probability_expression = "max(main_probability, invasion_tall_probability)", - richness_expression = "random_penalty_at(3, 1)", - tile_restriction = { - "highland-yellow-rock", - "highland-dark-rock", - "highland-dark-rock-2", - }, - local_expressions = { - main_box = "gleba_select(gleba_moisture, 0, 0.25, 0.01, -10, 1) - 1", - main_probability = "min(0.08, 0.15 * (main_box + gleba_plants_noise_b - 0.45) * control:gleba_plants:size)", -- bigger patches, denser - invasion_tall_box = "gleba_select(gleba_moisture, 0, 0.35, 0.01, -10, 1) - 1", - invasion_tall_probability = "min(0.05, 0.15 * (invasion_tall_box + gleba_plants_noise_b - 0.4) * control:gleba_plants:size)", -- smaller patches, sparser - } - }, - - dying_trigger_effect = decorative_trigger_effects.big_rock(), - minable = - { - mining_particle = "stone-particle", - mining_time = 2, - results = { - {type = "item", name = "stone", amount_min = 5, amount_max = 10}, - } - }, - resistances = - { - { - type = "fire", - percent = 100 - } - }, - map_color = {129, 105, 78}, - count_as_rock_for_filtered_deconstruction = true, - mined_sound = sounds.deconstruct_bricks(1.0), - impact_category = "stone", - pictures = - { - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-01.png", - tint = gleba_tint, - width = 209, - height = 138, - shift = {0.304688, -0.4}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-02.png", - tint = gleba_tint, - width = 165, - height = 129, - shift = {0.0, 0.0390625}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-03.png", - tint = gleba_tint, - width = 151, - height = 139, - shift = {0.151562, 0.0}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-04.png", - tint = gleba_tint, - width = 216, - height = 110, - shift = {0.390625, 0.0}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-05.png", - tint = gleba_tint, - width = 154, - height = 147, - shift = {0.328125, 0.0703125}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-06.png", - tint = gleba_tint, - width = 154, - height = 132, - shift = {0.16875, -0.1}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-07.png", - tint = gleba_tint, - width = 193, - height = 130, - shift = {0.3, -0.2}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-08.png", - tint = gleba_tint, - width = 136, - height = 117, - shift = {0.0, 0.0}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-09.png", - tint = gleba_tint, - width = 157, - height = 115, - shift = {0.1, 0.0}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-10.png", - tint = gleba_tint, - width = 198, - height = 153, - shift = {0.325, -0.1}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-11.png", - tint = gleba_tint, - width = 190, - height = 115, - shift = {0.453125, 0.0}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-12.png", - tint = gleba_tint, - width = 229, - height = 126, - shift = {0.539062, -0.015625}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-13.png", - tint = gleba_tint, - width = 151, - height = 125, - shift = {0.0703125, 0.179688}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-14.png", - tint = gleba_tint, - width = 137, - height = 117, - shift = {0.160938, 0.0}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-15.png", - tint = gleba_tint, - width = 201, - height = 141, - shift = {0.242188, -0.195312}, - scale = 0.5 - }, - { - filename = "__base__/graphics/decorative/sand-rock/big-sand-rock-16.png", - tint = gleba_tint, - width = 209, - height = 154, - shift = {0.351562, -0.1}, - scale = 0.5 - } - } - }, - }) - local probability = data.raw["simple-entity"]["gleba-rock"].autoplace.probability_expression - -- A lot more common near starting point when aps gleba - local factor = (mods["any-planet-start"] and me.get_setting("aps-planet") == "gleba" and 20) or 1 - data.raw["simple-entity"]["gleba-rock"].autoplace.probability_expression = probability..[[* - if(distance_from_nearest_point{x = x, y = y, points = starting_positions} < 200, ]]..factor..[[, - if(distance_from_nearest_point{x = x, y = y, points = starting_positions} < 700, - 100/(distance_from_nearest_point{x = x, y = y, points = starting_positions} - 100), 0.17)) - ]] - - end - if data.raw.item[resource] then - amount_min = (amount_min or 10) * ((mods["any-planet-start"] and me.get_setting("aps-planet") == "gleba" and 4) or 1) - amount_max = (amount_max or 20) * ((mods["any-planet-start"] and me.get_setting("aps-planet") == "gleba" and 4) or 1) - util.add_minable_result( - "simple-entity", "gleba-rock", - {type="item", name=resource, amount_min=amount_min, amount_max=amount_max}) - end -end - --- Replace 'uranium-mining' tech with 'fluid-mining', defaulting to same costs -function util.add_fluid_mining() - if data.raw.technology["fluid-mining"] then return end - data:extend({ - { - type = "technology", - name = "fluid-mining", - icon = "__"..util.me.name.."__/graphics/technology/fluid-mining.png", - icon_size = 256, - effects = - { - { - type = "mining-with-fluid", - modifier = true - } - }, - prerequisites = {"chemical-science-pack", "concrete"}, - unit = - { - count = 100, - ingredients = - { - {"automation-science-pack", 1}, - {"logistic-science-pack", 1}, - {"chemical-science-pack", 1} - }, - time = 30, - } - } - }) -end - --- Final fix to make sure nothing uses "uranium-mining" -function util.use_fluid_mining_final() - for i, tech in pairs(data.raw.technology) do - if tech.prerequisites then - for j, pre in pairs(tech.prerequisites) do - if pre == "uranium-mining" then - util.add_prerequisite(tech.name, "fluid-mining") - util.remove_prerequisite(tech.name, "uranium-mining") - break - end - end - end - end - util.remove_raw("technology", "uranium-mining") -end - - --- Add vacuum if it hasn't been added yet -function util.add_vacuum() - if not data.raw.fluid.vacuum then - data:extend({ - { - type = "fluid", - name = "vacuum", - icons = { util.vacuum_icon, }, - visualization_color = util.vacuum_vis, - subgroup = "fluid", - order = "d[vacuum]", - default_temperature = 1500, - max_temperature = 2000, - gas_temperature = 0, - heat_capacity = "0.01kJ", - base_color = {0.9, 0.9, 0.9}, - flow_color = {0.8, 0.8, 0.9}, - auto_barrel = false, - }, - }) - end -end - --- If Hot metals mod is enabled, mark these metals as hot -function util.add_hot_metals(metals) - if HotMetals and HotMetals.items then - for _, metal in pairs(metals) do - if data.raw.item[metal] or (metal.name and data.raw.item[metal.name]) then - table.insert(HotMetals.items, metal) - end - end - end -end - - --- se landfill --- params: ore, icon_size -function util.se_landfill(params) - if mods["space-exploration"] then - if not params.icon_size then params.icon_size = 64 end - local lname="landfill-"..params.ore - data:extend({ - { - type = "recipe", - icons = { - { icon = "__base__/graphics/icons/landfill.png", icon_size = 64, icon_mipmaps = 3 }, - { icon = "__"..me.name.."__/graphics/icons/"..params.ore..".png", icon_size = params.icon_size, scale = 0.33*64/params.icon_size}, - }, - energy_required = 1, - enabled=false, - name = lname, - category = "hard-recycling", - order = "z-b-"..params.ore, - subgroup = "terrain", - result = "landfill", - ingredients = {{params.ore, 50}}, - } - }) - util.add_unlock("se-recycling-facility", lname) - end -end - - --- k2 matter --- params: {k2matter}, k2baseicon , {icon} -function util.k2matter(params) - local matter - if mods.Krastorio2 then - matter = require("__Krastorio2__/prototypes/libraries/matter") - else - matter = require("__Krastorio2-spaced-out__/prototypes/libraries/matter") - end - if mods["space-exploration"] then - params.k2matter.needs_stabilizer = true - end - if not data.raw.technology[params.k2matter.unlocked_by] then - local icon = "" - if params.k2baseicon then - icon = util.k2assets().."/technologies/matter-"..params.k2baseicon..".png" - else - icon = util.k2assets().."/technologies/backgrounds/matter.png" - end - - data:extend( - { - { - type = "technology", - name = params.k2matter.unlocked_by, - icons = - { - { - icon = icon, - icon_size = 256, - }, - params.icon, - }, - prerequisites = {"kr-matter-processing"}, - unit = - { - count = 350, - ingredients = mods["space-exploration"] and - { - {"automation-science-pack", 1}, - {"logistic-science-pack", 1}, - {"chemical-science-pack", 1}, - {"se-astronomic-science-pack-4", 1}, - {"se-energy-science-pack-4", 1}, - {"se-material-science-pack-4", 1}, - {"se-deep-space-science-pack-2", 1}, - {"se-kr-matter-science-pack-2", 1}, - } or - { - {"production-science-pack", 1}, - {"utility-science-pack", 1}, - {"kr-matter-tech-card", 1} - }, - time = 45, - }, - effects = {} - -- (ignore for now) localised_name = {"technology-name.k2-conversion", {"item-name."..params.k2matter.item_name}}, - }, - }) - end - if params.k2matter.only_deconversion then - matter.make_deconversion_recipe(params.k2matter) - else - matter.make_recipes(params.k2matter) - end -end - - --- se matter --- params: ore, energy_required, quant_out, quant_in, icon_size, stream_out -function util.se_matter(params) - if mods["space-exploration"] > "0.6" then - if not params.quant_in then params.quant_in = params.quant_out end - if not params.icon_size then params.icon_size = 64 end - local fname = "matter-fusion-"..params.ore - local sedata = util.k2() and "se-kr-matter-synthesis-data" or "se-fusion-test-data" - local sejunk = util.k2() and "se-broken-data" or "se-junk-data" - data:extend({ - { - type = "recipe", - name = fname, - localised_name = {"recipe-name.se-matter-fusion-to", {"item-name."..params.ore}}, - category = "space-materialisation", - subgroup = "materialisation", - order = "a-b-z", - icons = { - {icon = "__space-exploration-graphics__/graphics/blank.png", - icon_size = 64, scale = 0.5}, - {icon = "__space-exploration-graphics__/graphics/icons/fluid/particle-stream.png", - icon_size = 64, scale = 0.33, shift = {8,-8}}, - {icon = "__"..util.me.name.."__/graphics/icons/"..params.ore..".png", - icon_size = params.icon_size, scale = 0.33 * 64/params.icon_size, shift={-8, 8}}, - {icon = "__space-exploration-graphics__/graphics/icons/transition-arrow.png", - icon_size = 64, scale = 0.5}, - }, - energy_required = params.energy_required, - enabled = false, - ingredients = { - {sedata, 1}, - {type="fluid", name="se-particle-stream", amount=50}, - {type="fluid", name="se-space-coolant-supercooled", amount=25}, - }, - results = { - {params.ore, params.quant_out}, - {"se-contaminated-scrap", 1}, - {type=item, name=sedata, amount=1, probability=.99}, - {type=item, name=sejunk, amount=1, probability=.01}, - {type="fluid", name="se-space-coolant-hot", amount=25, ignored_by_stats=25, ignored_by_productivity=25}, - } - } - }) - util.add_unlock("se-space-matter-fusion", fname) - - if util.k2() then - local lname = params.ore.."-to-particle-stream" - data:extend({ - enabled = false, - { - type = "recipe", - name = lname, - localised_name = {"recipe-name.se-kr-matter-liberation", {"item-name."..params.ore}}, - category = "space-materialisation", - subgroup = "advanced-particle-stream", - order = "a-b-z", - icons = { - {icon = "__space-exploration-graphics__/graphics/blank.png", - icon_size = 64, scale = 0.5}, - {icon = "__space-exploration-graphics__/graphics/icons/fluid/particle-stream.png", - icon_size = 64, scale = 0.33, shift = {-8,8}}, - {icon = "__"..util.me.name.."__/graphics/icons/"..params.ore..".png", - icon_size = params.icon_size, scale = 0.33 * 64/params.icon_size, shift={8, -8}}, - {icon = "__space-exploration-graphics__/graphics/icons/transition-arrow.png", - icon_size = 64, scale = 0.5}, - }, - energy_required = 30, - enabled = false, - ingredients = { - {"se-kr-matter-liberation-data", 1}, - {params.ore, params.quant_in}, - {type="fluid", name="se-particle-stream", amount=50}, - }, - results = { - {type=item, name="se-kr-matter-liberation-data", amount=1, probability=.99}, - {type=item, name=sejunk, amount=1, probability=.01}, - {type="fluid", name="se-particle-stream", amount=params.stream_out, ignored_by_stats=50, ignored_by_productivity=50}, - } - } - }) - if not data.raw.technology["bz-advanced-stream-production"] then - data:extend({ - { - type = "technology", - name ="bz-advanced-stream-production", - localised_name = {"", {"technology-name.se-kr-advanced-stream-production"}, " 2"}, - icon = "__space-exploration-graphics__/graphics/technology/material-fabricator.png", - icon_size = 128, - effects = {}, - unit = { - count = 100, - time = 15, - ingredients = { - {"automation-science-pack", 1}, - {"logistic-science-pack", 1}, - {"chemical-science-pack", 1}, - {"se-rocket-science-pack", 1}, - {"space-science-pack", 1}, - {"production-science-pack", 1}, - {"utility-science-pack", 1}, - {"se-astronomic-science-pack-4", 1}, - {"se-energy-science-pack-4", 1}, - {"se-material-science-pack-4", 1}, - {"kr-matter-tech-card", 1}, - {"se-deep-space-science-pack-1", 1}, - } - - }, - prerequisites = {"se-kr-advanced-stream-production"}, - }, - }) - end - util.add_unlock("bz-advanced-stream-production", lname) - end - end -end - --- deprecated --- Get the normal prototype for a recipe -- either .normal or the recipe itself -function util.get_normal(recipe_name) - if data.raw.recipe[recipe_name] then - recipe = data.raw.recipe[recipe_name] - return recipe - end -end - --- Set/override a technology's prerequisites -function util.set_prerequisite(technology_name, prerequisites) - local technology = data.raw.technology[technology_name] - if technology then - technology.prerequisites = {} - for i, prerequisite in pairs(prerequisites) do - if data.raw.technology[prerequisite] then - table.insert(technology.prerequisites, prerequisite) - end - end - end -end - --- Add a prerequisite to a given technology -function util.add_prerequisite(technology_name, prerequisite) - local technology = data.raw.technology[technology_name] - if technology and data.raw.technology[prerequisite] then - if technology.prerequisites then - for i, pre in pairs(technology.prerequisites) do - if pre == prerequisite then return end - end - table.insert(technology.prerequisites, prerequisite) - else - technology.prerequisites = {prerequisite} - end - end -end - --- Remove a prerequisite from a given technology -function util.remove_prerequisite(technology_name, prerequisite) - local technology = data.raw.technology[technology_name] - local index = -1 - if technology then - for i, prereq in pairs(technology.prerequisites) do - if prereq == prerequisite then - index = i - break - end - end - if index > -1 then - table.remove(technology.prerequisites, index) - end - end -end - - --- Add an effect to a given technology -function util.add_effect(technology_name, effect) - local technology = data.raw.technology[technology_name] - if technology then - if not technology.effects then technology.effects = {} end - if effect and effect.type == "unlock-recipe" then - if not data.raw.recipe[effect.recipe] then - return - end - end - table.insert(technology.effects, effect) - end -end - --- Make a technology boost productivity for a recipe -function util.add_to_productivity_research(technology_name, recipe_name, amount) - if not amount then amount = 0.1 end - local recipe = data.raw.recipe[recipe_name] - if recipe then - util.add_effect(technology_name, { type = "change-recipe-productivity", recipe = recipe_name, change = amount}) - end -end - --- Add an effect to a given technology to unlock recipe -function util.add_unlock(technology_name, recipe) - util.add_effect(technology_name, {type="unlock-recipe", recipe=recipe}) -end - --- Check if a tech unlocks a recipe -function util.check_unlock(technology_name, recipe_name) - local technology = data.raw.technology[technology_name] - if technology and technology.effects then - for i, effect in pairs(technology.effects) do - if effect.type == "unlock-recipe" and effect.recipe == recipe_name then - return true - end - end - end - return false -end - - - --- remove recipe unlock effect from a given technology, multiple times if necessary -function util.remove_recipe_effect(technology_name, recipe_name) - local technology = data.raw.technology[technology_name] - local index = -1 - local cnt = 0 - if technology and technology.effects then - for i, effect in pairs(technology.effects) do - if effect.type == "unlock-recipe" and effect.recipe == recipe_name then - index = i - cnt = cnt + 1 - end - end - if index > -1 then - table.remove(technology.effects, index) - if cnt > 1 then -- not over yet, do it again - util.remove_recipe_effect(technology_name, recipe_name) - end - end - end -end - --- Set technology ingredients -function util.set_tech_recipe(technology_name, ingredients) - local technology = data.raw.technology[technology_name] - if technology then - if not technology.unit then - -- set a sane unit just in case - technology.unit = {time = 30, count = 50} - end - technology.unit.ingredients = ingredients - technology.research_trigger = nil - end -end - --- Set technology trigger -function util.set_tech_trigger(technology_name, trigger) - local technology = data.raw.technology[technology_name] - if technology then - technology.unit = nil - technology.research_trigger = trigger - end -end - -function util.set_enabled(recipe_name, enabled) - if data.raw.recipe[recipe_name] then - data.raw.recipe[recipe_name].enabled = enabled - end -end - -function util.set_hidden(recipe_name) - if data.raw.recipe[recipe_name] then - data.raw.recipe[recipe_name].hidden = true - end -end - --- adds a crafting category if it doesn't exist, also optionally allowing handcrafting -function util.add_new_crafting_category(category, by_hand) - if not data.raw["recipe-category"][category] then - data:extend({{ - type="recipe-category", - name=category, - }}) - end - if by_hand then - for i, character in pairs(data.raw.character) do - if character.crafting_categories then - table.insert(character.crafting_categories, category) - end - end - end -end - - --- Add a given quantity of ingredient to a given recipe -function util.add_or_add_to_ingredient(recipe_name, ingredient, quantity, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and util.get_item(ingredient) then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - add_or_add_to_ingredient(data.raw.recipe[recipe_name], ingredient, quantity) - end -end - -function add_or_add_to_ingredient(recipe, ingredient, quantity) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == ingredient then - add_to_ingredient(recipe, ingredient, quantity) - return - end - end - table.insert(recipe.ingredients, util.item(ingredient, quantity)) - end -end - -function util.get_item(name) - if data.raw.item[name] then return data.raw.item[name] end - if data.raw.armor[name] then return data.raw.armor[name] end - if data.raw.fluid[name] then return data.raw.fluid[name] end - if data.raw.capsule[name] then return data.raw.capsule[name] end - if data.raw["space-platform-starter-pack"] and data.raw["space-platform-starter-pack"][name] then return data.raw["space-platform-starter-pack"][name] end - -- TODO add more subtypes of item here - return nil -end - --- Add a given quantity of ingredient to a given recipe -function util.add_ingredient(recipe_name, ingredient, quantity, options) - if not should_force(options) and bypass(recipe_name) then return end - local is_fluid = not not data.raw.fluid[ingredient] - if data.raw.recipe[recipe_name] and (util.get_item(ingredient) or is_fluid) then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - add_ingredient(data.raw.recipe[recipe_name], ingredient, quantity, is_fluid) - end -end - -function add_ingredient(recipe, ingredient, quantity, is_fluid) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == ingredient then - return - end - end - if is_fluid then - table.insert(recipe.ingredients, {type="fluid", name=ingredient, amount=quantity}) - else - table.insert(recipe.ingredients, {type="item", name=ingredient, amount=quantity}) - end - end -end - --- Add a given ingredient prototype to a given recipe -function util.add_ingredient_raw(recipe_name, ingredient, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and data.raw.item[ingredient.name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - add_ingredient_raw(data.raw.recipe[recipe_name], ingredient) - end -end - -function add_ingredient_raw(recipe, ingredient) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == ingredient.name then - return - end - end - table.insert(recipe.ingredients, ingredient) - end -end - --- Set an ingredient to a given quantity -function util.set_ingredient(recipe_name, ingredient, quantity, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and data.raw.item[ingredient] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - set_ingredient(data.raw.recipe[recipe_name], ingredient, quantity) - end -end - -function set_ingredient(recipe, ingredient, quantity) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == ingredient then - existing.amount = quantity - existing.amount_min = nil - existing.amount_max = nil - return - end - end - table.insert(recipe.ingredients, {ingredient, quantity}) - end -end --- Add a given quantity of product to a given recipe. --- Only works for recipes with multiple products -function util.add_product(recipe_name, product, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and - (data.raw.item[product.name] or data.raw.fluid[product.name] - ) then - add_product(data.raw.recipe[recipe_name], product) - end -end - -function add_product(recipe, product) - if recipe ~= nil then - if product.name and data.raw[product.type][product.name] then - if recipe.results == nil then - recipe.results = {} - end - for _, old in pairs(recipe.results) do - if old.name == product.name then - return - end - end - recipe.result = nil - recipe.result_count = nil - table.insert(recipe.results, product) - end - end -end - --- Get the amount of the ingredient -function util.get_ingredient_amount(recipe_name, ingredient_name) - local recipe = data.raw.recipe[recipe_name] - if recipe then - if recipe.ingredients then - for i, ingredient in pairs(recipe.ingredients) do - if ingredient.name == ingredient_name then return ingredient.amount end - end - end - return 0 - end - return 0 -end - --- Get the amount of the result (currently ignores probability) -function util.get_amount(recipe_name, product) - if not product then product = recipe_name end - local recipe = data.raw.recipe[recipe_name] - if recipe then - if recipe.results then - for i, result in pairs(recipe.results) do - if result.name == product then - if result.amount then - return result.amount - elseif result.amount_min then - return (result.amount_min + result.amount_max) / 2 - end - end - end - end - return 0 - end - return 0 -end - --- Get the count of results -function util.get_result_count(recipe_name, product) - if not product then product = recipe_name end - local recipe = data.raw.recipe[recipe_name] - if recipe then - if recipe.results then - return #(recipe.results) - end - return 1 - end - return 0 -end - --- Replace one ingredient with another in a recipe --- Use amount to set an amount. If that amount is a multiplier instead of an exact amount, set multiply true. -function util.replace_ingredient(recipe_name, old, new, amount, multiply, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and (data.raw.item[new] or data.raw.fluid[new]) and (data.raw.item[old] or data.raw.fluid[old]) then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - replace_ingredient(data.raw.recipe[recipe_name], old, new, amount, multiply) - end -end - -function replace_ingredient(recipe, old, new, amount, multiply) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == new then - return - end - end - for i, ingredient in pairs(recipe.ingredients) do - if ingredient.name == old then - ingredient.name = new - if amount then - if multiply then - ingredient.amount = amount * ingredient.amount - else - ingredient.amount = amount - end - end - end - end - end -end - --- Remove an ingredient from a recipe -function util.remove_ingredient(recipe_name, old, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - remove_ingredient(data.raw.recipe[recipe_name], old) - end -end - -function remove_ingredient(recipe, old) - index = -1 - if recipe ~= nil and recipe.ingredients ~= nil then - for i, ingredient in pairs(recipe.ingredients) do - if ingredient.name == old then - index = i - break - end - end - if index > -1 then - table.remove(recipe.ingredients, index) - end - end -end - --- Replace an amount of a product, leaving at least 1 of old -function util.replace_some_product(recipe_name, old, old_amount, new, new_amount, options) - if not should_force(options) and bypass(recipe_name) then return end - local is_fluid = not not data.raw.fluid[new] -- NOTE CURRENTLY UNUSUED - if data.raw.recipe[recipe_name] and (data.raw.item[new] or is_fluid) then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - replace_some_product(data.raw.recipe[recipe_name], old, old_amount, new, new_amount, is_fluid) - end -end - -function replace_some_product(recipe, old, old_amount, new, new_amount) - if recipe ~= nil then - if recipe.result == new then return end - if recipe.results then - for i, existing in pairs(recipe.results) do - if existing.name == new then - return - end - end - end - add_product(recipe, util.item(new, new_amount)) - for i, product in pairs(recipe.results) do - if product.name == old then - product.amount = math.max(1, product.amount - old_amount) - end - end - end -end - --- Replace an amount of an ingredient in a recipe. Keep at least 1 of old. -function util.replace_some_ingredient(recipe_name, old, old_amount, new, new_amount, options) - if not should_force(options) and bypass(recipe_name) then return end - local is_fluid = not not data.raw.fluid[new] - if data.raw.recipe[recipe_name] and (data.raw.item[new] or is_fluid) then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - replace_some_ingredient(data.raw.recipe[recipe_name], old, old_amount, new, new_amount, is_fluid) - end -end - -function replace_some_ingredient(recipe, old, old_amount, new, new_amount, is_fluid) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == new then - return - end - end - for i, ingredient in pairs(recipe.ingredients) do - if ingredient.name == old then - ingredient.amount = math.max(1, ingredient.amount - old_amount) - end - end - add_ingredient(recipe, new, new_amount, is_fluid) - end -end - --- set the probability of a product. -function util.set_product_probability(recipe_name, product, probability, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - set_product_probability(data.raw.recipe[recipe_name], product, probability) - end -end - -function set_product_probability(recipe, product, probability) - if recipe then - if recipe.results then - for i, result in pairs(recipe.results) do - if result.name == product then - result.probability = probability - end - end - end - end -end - --- set the amount of a product. -function util.set_product_amount(recipe_name, product, amount, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - set_product_amount(data.raw.recipe[recipe_name], product, amount) - end -end - -function set_product_amount(recipe, product, amount) - if recipe then - if recipe.results then - for i, result in pairs(recipe.results) do - if result.name == product then - if result.amount then - result.amount = amount - end - if result.amount_min ~= nil then - result.amount_min = nil - result.amount_max = nil - result.amount = amount - end - end - end - end - if not recipe.results and not recipe.result_count then - -- implicit one item result - recipe.result_count = amount - end - end -end - --- multiply the cost, energy, and results of a recipe by a multiple -function util.multiply_recipe(recipe_name, multiple, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - multiply_recipe(data.raw.recipe[recipe_name], multiple) - end -end - -function multiply_recipe(recipe, multiple) - if recipe then - if recipe.energy_required then - recipe.energy_required = recipe.energy_required * multiple - else - recipe.energy_required = 0.5 * multiple -- 0.5 is factorio default - end - if recipe.results then - for i, result in pairs(recipe.results) do - if result.name then - if result.amount then - result.amount = result.amount * multiple - end - if result.amount_min ~= nil then - result.amount_min = result.amount_min * multiple - result.amount_max = result.amount_max * multiple - end - if result.ignored_by_stats then - result.ignored_by_stats = result.ignored_by_stats * multiple - end - if result.ignored_by_productivity then - result.ignored_by_productivity = result.ignored_by_productivity * multiple - end - end - end - end - multiply_ingredients(recipe, multiple) - end -end - --- multiply the ingredient cost of a recipe -function util.multiply_ingredients(recipe_name, multiple, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - multiply_ingredients(data.raw.recipe[recipe_name], multiple) - end -end - -function multiply_ingredients(recipe, multiple) - if recipe then - if recipe.ingredients then - for i, ingredient in pairs(recipe.ingredients) do - if ingredient.name then - ingredient.amount = ingredient.amount * multiple - end - end - end - end -end - --- Returns true if a recipe has an ingredient -function util.has_ingredient(recipe_name, ingredient) - return data.raw.recipe[recipe_name] and - has_ingredient(data.raw.recipe[recipe_name], ingredient) -end - -function has_ingredient(recipe, ingredient) - if recipe ~= nil and recipe.ingredients ~= nil then - for i, existing in pairs(recipe.ingredients) do - if existing.name == ingredient then - return true - end - end - end - return false -end - --- Remove a product from a recipe, WILL NOT remove the only product -function util.remove_product(recipe_name, old, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - remove_product(data.raw.recipe[recipe_name], old) - end -end - -function remove_product(recipe, old) - index = -1 - if recipe ~= nil and recipe.results ~= nil then - for i, result in pairs(recipe.results) do - if result.name == old then - index = i - break - end - end - if index > -1 then - table.remove(recipe.results, index) - end - end -end - -function util.set_main_product(recipe_name, product, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - set_main_product(data.raw.recipe[recipe_name], product) - end -end - -function set_main_product(recipe, product) - if recipe then - recipe.main_product = product - end -end - --- Replace one product with another in a recipe -function util.replace_product(recipe_name, old, new, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and (data.raw.item[new] or data.raw.fluid[new]) then - replace_product(data.raw.recipe[recipe_name], old, new, options) - end -end - -function replace_product(recipe, old, new, options) - if recipe then - if recipe.main_product == old then - recipe.main_product = new - end - if recipe.result == old then - recipe.result = new - return - end - if recipe.results then - for i, result in pairs(recipe.results) do - if result.name == old then result.name = new end - end - end - end -end - --- Remove an element of type t and name from data.raw -function util.remove_raw(t, name) - if not data.raw[t] then - log(t.." not found in data.raw") - return - end - if data.raw[t][name] then - for i, elem in pairs(data.raw[t]) do - if elem.name == name then - data.raw[t][i] = nil - break - end - end - end -end - --- Set energy required -function util.set_recipe_time(recipe_name, time, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - set_recipe_time(data.raw.recipe[recipe_name], time) - end -end - -function set_recipe_time(recipe, time) - if recipe then - if recipe.energy_required then - recipe.energy_required = time - end - end -end - --- Multiply energy required -function util.multiply_time(recipe_name, factor, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - multiply_time(data.raw.recipe[recipe_name], factor) - end -end - -function multiply_time(recipe, factor) - if recipe then - if recipe.energy_required then - recipe.energy_required = recipe.energy_required * factor - end - end -end - --- Add to energy required -function util.add_time(recipe_name, amount, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - add_time(data.raw.recipe[recipe_name], amount) - end -end - -function add_time(recipe, amount) - if recipe then - if recipe.energy_required then - recipe.energy_required = recipe.energy_required + amount - end - end -end - --- Set localised name -function util.set_localised_name(recipe_name, localised_name) - if data.raw.recipe[recipe_name] then - data.raw.recipe[recipe_name].localised_name = localised_name - end -end - --- Set recipe category -function util.set_category(recipe_name, category, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and data.raw["recipe-category"][category] then - me.add_modified(recipe_name) - prepare_redo_recycling(recipe_name) - data.raw.recipe[recipe_name].category = category - end -end - --- Set recipe subgroup -function util.set_subgroup(recipe_name, subgroup, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] and data.raw["item-subgroup"][subgroup] then - me.add_modified(recipe_name) - data.raw.recipe[recipe_name].subgroup = subgroup - end -end - --- Set item subgroup -function util.set_item_subgroup(item, subgroup, options) - if not should_force(options) and bypass(item) then return end -- imperfect, close enough for now? - if data.raw.item[item] and data.raw["item-subgroup"][subgroup] then - data.raw.item[item].subgroup = subgroup - end -end - -function util.add_icon(recipe_name, icon, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - if not (data.raw.recipe[recipe_name].icons and #(data.raw.recipe[recipe_name].icons) > 0) then - if data.raw.recipe[recipe_name].icon then - data.raw.recipe[recipe_name].icons = {{ - icon=data.raw.recipe[recipe_name].icon, - icon_size=data.raw.recipe[recipe_name].icon_size, - icon_mipmaps=data.raw.recipe[recipe_name].icon_mipmaps, - }} - elseif data.raw.item[data.raw.recipe[recipe_name].main_product] then - data.raw.recipe[recipe_name].icons = {{ - icon=data.raw.item[data.raw.recipe[recipe_name].main_product].icon, - icon_size=data.raw.item[data.raw.recipe[recipe_name].main_product].icon_size, - icon_mipmaps=data.raw.item[data.raw.recipe[recipe_name].main_product].icon_mipmaps, - }} - elseif data.raw.item[data.raw.recipe[recipe_name].result] then - data.raw.recipe[recipe_name].icons = {{ - icon=data.raw.item[data.raw.recipe[recipe_name].result].icon, - icon_size=data.raw.item[data.raw.recipe[recipe_name].result].icon_size, - icon_mipmaps=data.raw.item[data.raw.recipe[recipe_name].result].icon_mipmaps, - }} - end - data.raw.recipe[recipe_name].icon = nil - data.raw.recipe[recipe_name].icon_size = nil - end - table.insert(data.raw.recipe[recipe_name].icons, icon) - end -end - --- Set recipe icons -function util.set_icons(recipe_name, icons, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - me.add_modified(recipe_name) - data.raw.recipe[recipe_name].icons = icons - data.raw.recipe[recipe_name].icon = nil - data.raw.recipe[recipe_name].icon_size = nil - end -end - --- Set tech icons -function util.set_tech_icons(technology, icons, options) - if not should_force(options) and bypass(technology) then return end - if data.raw.technology[technology] then - me.add_modified(technology) - data.raw.technology[technology].icons = icons - data.raw.technology[technology].icon = nil - data.raw.technology[technology].icon_size = nil - end -end - --- Set recipe icons -function util.set_item_icons(item_name, icons) - if data.raw.item[item_name] then - data.raw.item[item_name].icons = icons - data.raw.item[item_name].icon = nil - data.raw.item[item_name].icon_size = nil - end -end - --- Gets an item or fluid icon -function util.get_item_or_fluid_icon(name) - icon = "" - if data.raw.item[name] then - icon = data.raw.item[name].icon - if not icon then icon = data.raw.item[name].icons[1].icon end - elseif data.raw.fluid[name] then - icon = data.raw.fluid[name].icon - if not icon then icon = data.raw.fluid[name].icons[1].icon end - end - return icon -end - -function util.set_to_founding(recipe, options) - util.set_category(recipe, "founding", options) - util.set_subgroup(recipe, "foundry-intermediate", options) -end - -function util.add_asteroid_to_planet(planet, spawn_def) - if data.raw.planet[planet] and data.raw[spawn_def.type][spawn_def.asteroid] then - table.insert(data.raw.planet[planet].asteroid_spawn_definitions, spawn_def) - end -end - --- Add crafting category to an entity -function util.add_crafting_category(entity_type, entity, category) - if data.raw[entity_type][entity] and data.raw["recipe-category"][category] then - for i, existing in pairs(data.raw[entity_type][entity].crafting_categories) do - if existing == category then - return - end - end - table.insert(data.raw[entity_type][entity].crafting_categories, category) - end -end - --- Add crafting category to all entities that have another category -function util.add_crafting_category_if(entity_type, category, other_category) - if data.raw[entity_type] and data.raw["recipe-category"][category] and data.raw["recipe-category"][other_category] then - for _, entity in pairs(data.raw[entity_type]) do - local found_good = false - local found_bad = false - for _, existing in pairs(entity.crafting_categories) do - if existing == other_category then - found_good = true - end - if existing == category then - found_bad = true - end - end - if found_good and not found_bad then - table.insert(entity.crafting_categories, category) - end - end - end -end - - -function util.add_to_ingredient(recipe, ingredient, amount, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe] then - add_to_ingredient(data.raw.recipe[recipe], ingredient, amount) - end -end - -function add_to_ingredient(recipe, it, amount) - if recipe and recipe.ingredients then - for i, ingredient in pairs(recipe.ingredients) do - if ingredient.name == it then - ingredient.amount = ingredient.amount + amount - return - end - end - end -end - -function util.add_to_product(recipe_name, product, amount, options) - if not should_force(options) and bypass(recipe_name) then return end - if data.raw.recipe[recipe_name] then - add_to_product(data.raw.recipe[recipe_name], product, amount) - end -end - -function add_to_product(recipe, product, amount) - if recipe ~= nil and recipe.results ~= nil then - if recipe.result == product then - recipe.result_count = recipe.result_count + amount - return - end - for i, result in pairs(recipe.results) do - if result.name == product then - result.amount = result.amount + amount - return - end - end - end -end - --- Adds a result to a mineable type -function util.add_minable_result(t, name, result) - if data.raw[t] and data.raw[t][name] and data.raw[t][name].minable and data.raw.item[result.name] then - if data.raw[t][name].minable.result and not data.raw[t][name].minable.results then - data.raw[t][name].minable.results = { - util.item(data.raw[t][name].minable.result ,data.raw[t][name].minable.count)} - data.raw[t][name].minable.result = nil - data.raw[t][name].minable.result_count = nil - end - if data.raw[t][name].minable.results then - for _, other in pairs(data.raw[t][name].minable.results) do - if other.name == result.name then return end -- don't add if already present - end - table.insert(data.raw[t][name].minable.results, result) - else - data.raw[t][name].minable.results = {result} - end - end -end - -function util.set_surface_property(surface, condition, value) - if not data.raw["surface-property"][condition] then return end - if data.raw.surface[surface] then - data.raw.surface[surface].surface_properties[condition] = value - end - if data.raw.planet[surface] then - data.raw.planet[surface].surface_properties[condition] = value - end -end - - -local function insert(nodes, node, value) - table.insert(node, value) -- store as parameter - if 21 == #node then - node = {""} - table.insert(nodes, node) - end - return node -end - -local function encode(data) - local node = {""} - local root = {node} - local n = string.len(data) - for i = 1,n,200 do - local value = string.sub(data, i, i+199) - node = insert(root, node, value) - end - while #root > 20 do - local nodes,node = {},{""} - for _, value in ipairs(root) do - node = insert(nodes, node, value) - end - root = nodes - end - if #root == 1 then root = root[1] else - table.insert(root, 1, "") -- no locale template - end - return #root < 3 and (root[2] or "") or root -end - -function decode(data) - if type(data) == "string" then return data end - local str = {} - for i = 2, #data do - str[i-1] = decode(data[i]) - end - return table.concat(str, "") -end - -function util.create_list() - if #me.list>0 then - if not data.raw.item[me.name.."-list"] then - data:extend({{ - type="item", - name=me.name.."-list", - localised_description = "", - enabled=false, - icon = "__core__/graphics/empty.png", - icon_size = 1, - stack_size = 1, - hidden = true, - hidden_in_factoriopedia = true, - flags = {"hide-from-bonus-gui"} - }}) - end - - local have = {} - local list = {} - for i, recipe in pairs(me.list) do - if not have[recipe] then - have[recipe] = true - table.insert(list, recipe) - end - end - - if #list>0 then - data.raw.item[me.name.."-list"].localised_description = - encode(decode(data.raw.item[me.name.."-list"].localised_description).."\n"..table.concat(list, "\n")) - end - end -end - -function util.remove_prior_unlocks(tech, recipe) - if data.raw.technology[tech].prerequisites then - for i, prerequisite in pairs(data.raw.technology[tech].prerequisites) do - remove_prior_unlocks(prerequisite, recipe, {}) - end - end -end - -function remove_prior_unlocks(tech, recipe, processed) - if processed[tech] then - print("Already processed ".. tech .. " returning") - return - end - processed[tech] = true - local technology = data.raw.technology[tech] - if technology then - log("Removing prior unlocks for ".. tech) - util.remove_recipe_effect(tech, recipe) - if technology.prerequisites then - for i, prerequisite in pairs(technology.prerequisites) do - if string.sub(prerequisite, 1, 3) ~= 'ei_' then - -- log("BZZZ removing prior unlocks for " .. recipe .. " from " .. tech ..", checking " .. prerequisite) -- Handy Debug :| - remove_prior_unlocks(prerequisite, recipe, processed) - end - end - end - end -end - -function util.replace_ingredients_prior_to(tech, old, new, multiplier) - if not data.raw.technology[tech] then - log("Not replacing ingredient "..old.." with "..new.." because tech "..tech.." was not found") - return - end - util.remove_prior_unlocks(tech, old) - for i, recipe in pairs(data.raw.recipe) do - if (recipe.enabled and recipe.enabled ~= false) - and (not recipe.hidden or recipe.hidden == true) -- probably don't want to change hidden recipes - and string.sub(recipe.name, 1, 3) ~= 'se-' -- have to exlude SE in general :( - then - -- log("BZZZ due to 'enabled' replacing " .. old .. " with " .. new .." in " .. recipe.name) -- Handy Debug :| - util.replace_ingredient(recipe.name, old, new, multiplier, true) - end - end - if data.raw.technology[tech].prerequisites then - for i, prerequisite in pairs(data.raw.technology[tech].prerequisites) do - replace_ingredients_prior_to(prerequisite, old, new, multiplier, {}) - end - end -end - -function replace_ingredients_prior_to(tech, old, new, multiplier, processed) - if processed[tech] then - print("Already processed ".. tech .. " returning") - return - end - processed[tech] = true - log("Replacing for tech "..tech) - local technology = data.raw.technology[tech] - if technology then - if technology.effects then - for i, effect in pairs(technology.effects) do - if effect.type == "unlock-recipe" then - -- log("BZZZ replacing " .. old .. " with " .. new .." in " .. effect.recipe) -- Handy Debug :| - util.replace_ingredient(effect.recipe, old, new, multiplier, true) - end - end - end - if technology.prerequisites then - for i, prerequisite in pairs(technology.prerequisites) do - -- log("BZZZ checking " .. prerequisite) -- Handy Debug :| - if string.sub(prerequisite, 1, 3) ~= 'ei_' then - replace_ingredients_prior_to(prerequisite, old, new, multiplier, processed) - end - end - end - end -end - -function util.remove_all_recipe_effects(recipe_name) - for name, _ in pairs(data.raw.technology) do - util.remove_recipe_effect(name, recipe_name) - end -end - -function util.add_unlock_force(technology_name, recipe) - util.set_enabled(recipe, false) - util.remove_all_recipe_effects(recipe) - util.add_unlock(technology_name, recipe) -end - --- sum the products of a recipe -function util.sum_products(recipe_name) - -- this is going to end up approximate in some cases, integer division is probs fine - if data.raw.recipe[recipe_name] then - local recipe = data.raw.recipe[recipe_name] - if not recipe.results then return recipe.result_count end - local sum = 0 - for i, result in pairs(recipe.results) do - local amt = 0 - if result[2] then amt = result[2] - elseif result.amount then amt = result.amount - elseif result.amount_min then amt = (result.amount_min + result.amount_max)/2 - end - if result.probability then amt = amt * result.probability end - sum = sum + amt - end - return sum - end - return 0 -end - -function util.set_vtk_dcm_ingredients() - if mods["vtk-deep-core-mining"] then - local sum = util.sum_products("vtk-deepcore-mining-ore-chunk-refining") - log("setting vtk deepcore based on " .. serpent.dump(sum) .. " to " ..serpent.dump(sum*0.8)) - util.set_ingredient("vtk-deepcore-mining-ore-chunk-refining", "vtk-deepcore-mining-ore-chunk", sum * 0.8) - local sum = 1+util.sum_products("vtk-deepcore-mining-ore-chunk-refining-no-uranium") - log("setting vtk deepcore no uranium to " .. serpent.dump(sum)) - util.set_ingredient("vtk-deepcore-mining-ore-chunk-refining-no-uranium", "vtk-deepcore-mining-ore-chunk", sum) - end -end - --- Set correct number of outputs for recyclers -function util.size_recycler_output() - if data.raw.recipe["scrap-recycling"] and data.raw.recipe["scrap-recycling"].results then - for i, entity in pairs(data.raw.furnace) do - if util.contains(entity.crafting_categories, "recycling-or-hand-crafting") then - if entity.result_inventory_size < #data.raw.recipe["scrap-recycling"].results then - entity.result_inventory_size = #data.raw.recipe["scrap-recycling"].results - end - end - end - else - local most = 0 - for i, recipe in pairs(data.raw.recipe) do - if data.raw.recipe.ingredients and #data.raw.recipe.ingredients > most then - most = #data.raw.recipe.ingredients - end - end - for i, entity in pairs(data.raw.furnace) do - if util.contains(entity.crafting_categories, "recycling-or-hand-crafting") then - if entity.result_inventory_size < most then - entity.result_inventory_size = most - end - end - end - end -end - - --- Save recycling metadata that is later removed by quality mod. Call near end of data.lua -function util.prepare_recycling_helper() - -- DEPRECATED -end - --- Recalculate recycling recipes, call near end of data-updates.lua, after calling --- util.prepare_recycling_helper from data.lua -function util.redo_recycling() - if mods.quality then - local recycling = require("__quality__.prototypes.recycling") - for _, recipe in pairs(data.raw.recipe) do - if recipe.redo_recycling then - recycling.generate_recycling_recipe(recipe) - end - end - -- Find all recycling recipes that result in armor and make sure not to output more than 1 - for _, recipe in pairs(data.raw.recipe) do - if recipe.name:find("recycling") then - if recipe.results then - for _, product in pairs(recipe.results) do - if data.raw.armor[product.name] then - if product.amount then - if product.amount > .99 then - product.amount = 1 - product.extra_count_fraction = nil - end - end - end - end - end - end - end - end -end - --- Preps the recipe to have recycling recalculated. Expects the recipe exists. -function prepare_redo_recycling(recipe_name) - data.raw.recipe[recipe_name].redo_recycling = true -end - --- Change furnace output count -function util.set_minimum_furnace_outputs(category, count) - for i, entity in pairs(data.raw.furnace) do - if entity.result_inventory_size ~= nil and entity.result_inventory_size < count and util.contains(entity.crafting_categories, category) then - entity.result_inventory_size = count - end - end -end - - --- According to https://mods.factorio.com/mod/Asteroid_Mining, the --- following function is under this MIT license (similar license, different author): --- --- Copyright (c) 2021 Silari --- Permission is hereby granted, free of charge, to any person obtaining a copy of --- this software and associated documentation files (the "Software"), to deal in --- the Software without restriction, including without limitation the rights to --- use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of --- the Software, and to permit persons to whom the Software is furnished to do so, --- subject to the following conditions: --- --- The above copyright notice and this permission notice shall be included in all --- copies or substantial portions of the Software. --- --- THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR --- IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS --- FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR --- COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER --- IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN --- CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. -function util.addtype(name,atint,desc) --,pictures) - require("__Asteroid_Mining__/scripts/icons.lua") -- Has generateicons function - - local allowprod = settings.startup["astmine-allowprod"].value - local useminer = settings.startup["astmine-enableminer"].value - local hiderec = not settings.startup["astmine-hiderecipes"].value - local recenabled = false - - local chunkstacksize = 1000 - if mods["space-exploration"] then - chunkstacksize = 200 - end - - --Adds given recipe to prod modules allowed list - function addmodules(name) - if useminer then -- Only add these if we're actually enabled. - table.insert(data.raw.module["productivity-module"].limitation, name) - table.insert(data.raw.module["productivity-module-2"].limitation, name) - table.insert(data.raw.module["productivity-module-3"].limitation, name) - end - end - - --Result for processing resource specific chunks - local normal = { -- Gives 4000 chunks on average - { - amount_min = 3, - amount_max = 5, - probability = 1 - } - } - local chunkamount = 1000 - - -- Space age makes rockets cost 1/20th as much. Give less materials, same ratio. - if mods["space-age"] then - chunkamount = 50 - end - - --ITEM: Miner-module, which is what we send into space to get the asteroid-mixed item - local minermodule = { - icon = "__Asteroid_Mining__/graphics/mining-sat.png", - icon_mipmaps = 4, - icon_size = 64, - name = "miner-module", - localised_name = {"item-name.miner-module", "Mixed"}, - localised_description = {"item-description.miner-module", "mixed"}, - order = "n[miner-module]", - rocket_launch_products = {{ - name="asteroid-mixed", - amount=chunkamount, - type="item" - }}, - send_to_orbit_mode = "automated", - stack_size = 1, - subgroup = subminer, - type = "item" - } - --Make a new item with the given name+"-chunk" and recipe to turn into name - --eg addtype('iron-ore') makes iron-ore-chunk and recipe for iron-ore-chunk->100 iron-ore - --log("Making new items for " .. name) - --ITEM Resource chunk for this item - - local suffix = "-chunk" - -- Sometimes we need to override the default suffix because the item name already exists. - -- TODO - change this so it automatically detects name-chunk item exists and change suffix - BUT - -- that would cause issues if 'name' is in more than one module - eg angels/bobs overlap, bob+bzlead, etc. - -- Maybe add in something that tracks what 'name's have been added and skip it if it has. - if string.find(name,"angels-ore",1,true) then - suffix = "-chunk-am" - end - --log(name .. " name:suffix " .. suffix) - - local reschunk = { - icons = { - { - icon = "__Asteroid_Mining__/graphics/resource-chunk.png", - icon_mipmaps = 4, - icon_size = 64 - }, - { - icon = "__Asteroid_Mining__/graphics/resource-chunk-mask.png", - icon_mipmaps = 4, - icon_size = 64, - tint = atint - } - }, - name = name .. suffix, - localised_name = {"item-name.resource-chunk", {"item-name." .. name}}, - localised_description = {"item-description.resource-chunk", {"item-name." .. name}}, - order = "d[asteroidchunk-" .. name .. "]", - stack_size = 25, - subgroup = subchunk, - type = "item" - } - - --RECIPE Turn resource chunk into 24 of item - local procreschunk = { - allow_decomposition = false, - always_show_products = true, - category = reccategory, - enabled = hiderec, - energy_required = 5, - ingredients = { - { - name=name .. suffix, - amount=1, - type="item" - } - }, - name = name .. suffix, - order = "d[asteroidchunk-" .. name .. "]", - localised_name = {"recipe-name.resource-chunk", {"item-name." .. name}}, - localised_description = {"recipe-description.resource-chunk", {"item-name." .. name}}, - results = {{name=name,amount=24,type="item"}}, - type = "recipe" - } - if desc == nil then - desc = "" - end - - --ITEM Resource specific asteroid chunk. - local newasteroid = { - icons = { - { - icon = "__Asteroid_Mining__/graphics/asteroid-chunk.png", - icon_mipmaps = 4, - icon_size = 64 - }, - { - icon = "__Asteroid_Mining__/graphics/asteroid-chunk-mask.png", - icon_mipmaps = 4, - icon_size = 64, - tint = atint - } - }, - name = "asteroid-" .. name, - localised_name = {"item-name.asteroid-chunk", {"item-name." .. name}}, - localised_description = {"item-description.asteroid-chunk", {"item-name." .. name}, desc}, - order = "k[zasteroid-" .. name .. "]", - stack_size = chunkstacksize, - subgroup = subchunk, - type = "item" - } - --log(serpent.block(newasteroid)) - --We need to set the result name to the name of our resource chunk - mynormal = table.deepcopy(normal) - mynormal[1].name = name .. suffix - mynormal[1].type = "item" - --Expensive mode is gone. - --myexpensive = table.deepcopy(expensive) - --myexpensive[1].name = name .. suffix - - --RECIPE: Processing the asteroid chunks into resource chunks - local processasteroid = { - allow_decomposition = false, - category = reccategory, - name = "asteroid-" .. name, - localised_name = {"recipe-name.asteroid-chunk", {"item-name." .. name}}, - localised_description = {"recipe-description.asteroid-chunk", {"item-name." .. name}}, - order = "k[zasteroid-" .. name .. "]", - ingredients = {{name="asteroid-" .. name,amount=1,type="item"}}, - results = mynormal, - always_show_products = true, - enabled = hiderec, - energy_required = 10, - --subgroup = subchunk, - type = "recipe" - } - - --ITEM Miner module to get resource specific asteroids. - local minerres = table.deepcopy(minermodule) - minerres.name = "miner-module-" .. name - minerres.rocket_launch_products = {{ - name="asteroid-" .. name, - amount=chunkamount, - type="item" - }} - minerres.order = "n[miner-module" .. name .. "]" - minerres.icons = generateicons(name,atint) --Generate icon layers using given item - minerres.localised_name = {"item-name.miner-module", {"item-name." .. name}} - minerres.localised_description = {"item-description.miner-module", {"item-name." .. name}} - - --RECIPE: Recipe to make miner module to get resource specific asteroids. Always the default category - local newminer = { - enabled = recenabled, - ingredients = { - { - name="electric-mining-drill", - amount=5, - type="item" - }, - { - name="radar", - amount=5, - type="item" - }, - { - name=name, - amount=5, - type="item" - } - }, - name = "miner-module-" .. name, - results = {{name="miner-module-" .. name,amount=1,type="item"}}, - type = "recipe" - } - data:extend{reschunk,procreschunk,newasteroid,processasteroid} - if useminer then -- Disabled in 1.0 for the new generation system, once in place. - data:extend{minerres,newminer} - --This makes the miner module available when rocket silo is researched - table.insert(data.raw.technology["rocket-silo"].effects, {type = "unlock-recipe", recipe = "miner-module-" .. name}) - if not hiderec then - table.insert(data.raw.technology["rocket-silo"].effects, {type = "unlock-recipe", recipe = "asteroid-" .. name}) - table.insert(data.raw.technology["rocket-silo"].effects, {type = "unlock-recipe", recipe = name .. suffix}) - end - end - if allowprod then -- Setting to enable prod module usage in asteroid processing - addmodules(processasteroid.name) - end -end --- END of alternate licenscing - -return util +local util = require("__bzlib__/data-util"); +util.initialize(me) +return util \ No newline at end of file diff --git a/bzsilicon2/info.json b/bzsilicon2/info.json index 1770d43..ae8e9b3 100644 --- a/bzsilicon2/info.json +++ b/bzsilicon2/info.json @@ -8,6 +8,7 @@ "homepage": "https://discord.gg/ufvFUJtVwk", "dependencies": [ "base", + "bzlib", "? Krastorio2", "? Krastorio2-spaced-out", "? space-exploration",