se matter

changelog.txt

@@ -1,4 +1,14 @@
 ---------------------------------------------------------------------------------------------------
+Version: 0.6.10
+Date: 2022-08-17
+  Fixes:
+    - SE: Disable matter recipes at start
+---------------------------------------------------------------------------------------------------
+Version: 0.6.9
+Date: 2022-08-09
+  Features:
+    - Support for SE matter fusion and SE+K2 matter liberation
+---------------------------------------------------------------------------------------------------
 Version: 0.6.8
 Date: 2022-08-02
   Changes:

data-updates.lua

@@ -11,5 +11,8 @@ local util = require("data-util");
 
 if mods.Asteroid_Mining then
   require("__Asteroid_Mining__.scripts.addmodule")
-  amfunc.addtype("zircon", {a = 0,r = 0.75,g = 0.4,b = 0.5})
+  if not data.raw.item["asteroid-titanium-ore"] then
+    -- For Titanium we only add if it's not already added by Asteroid_Mining
+    amfunc.addtype("titanium-ore", {a = 0,r = 40, g = 70, b =110})
+  end
 end

data-util.lua

@@ -23,6 +23,41 @@ else
   util.titanium_processing = "titanium-processing"
 end
 
+function util.se6()
+  return mods["space-exploration"] and mods["space-exploration"] >= "0.6" 
+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.bzfoundry 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
@@ -54,6 +89,151 @@ function util.contains(table, sought)
   return false
 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
+
+-- 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 = mods.Krastorio2 and "se-kr-matter-synthesis-data" or "se-fusion-test-data"
+    local sejunk = mods.Krastorio2 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, catalyst_amount=25},
+        }
+      }
+    })
+    util.add_unlock("se-space-matter-fusion", fname) 
+
+    if mods.Krastorio2 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, catalyst_amount=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},
+                {"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
+
 -- Set/override a technology's prerequisites
 function util.set_prerequisite(technology_name, prerequisites)
   local technology = data.raw.technology[technology_name]
@@ -116,21 +296,25 @@ function util.add_unlock(technology_name, recipe)
   util.add_effect(technology_name, {type="unlock-recipe", recipe=recipe})
 end
 
--- remove recipe unlock effect from a given technology
+-- 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 technology = data.raw.technology[technology_name]
-  local index = -1
+    local index = -1
-  if technology and technology.effects then
+    local cnt = 0
-    for i, effect in pairs(technology.effects) do
+    if technology and technology.effects then
-      if effect.type == "unlock-recipe" and effect.recipe == recipe_name then
+        for i, effect in pairs(technology.effects) do
-        index = i
+            if effect.type == "unlock-recipe" and effect.recipe == recipe_name then
-        break
+                index = i
-      end
+                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
-    if index > -1 then
-      table.remove(technology.effects, index)
-    end
-  end
 end
 
 -- Set technology ingredients
@@ -158,8 +342,8 @@ function util.set_hidden(recipe_name)
 end
 
 -- Add a given quantity of ingredient to a given recipe
-function util.add_or_add_to_ingredient(recipe_name, ingredient, quantity)
+function util.add_or_add_to_ingredient(recipe_name, ingredient, quantity, options)
-  if me.bypass[recipe_name] then return end
+  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)
     add_or_add_to_ingredient(data.raw.recipe[recipe_name], ingredient, quantity)
@@ -181,8 +365,8 @@ function add_or_add_to_ingredient(recipe, ingredient, quantity)
 end
 
 -- Add a given quantity of ingredient to a given recipe
-function util.add_ingredient(recipe_name, ingredient, quantity)
+function util.add_ingredient(recipe_name, ingredient, quantity, options)
-  if me.bypass[recipe_name] then return end
+  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 (data.raw.item[ingredient] or is_fluid) then
     me.add_modified(recipe_name)
@@ -208,8 +392,8 @@ function add_ingredient(recipe, ingredient, quantity, is_fluid)
 end
 
 -- Add a given ingredient prototype to a given recipe
-function util.add_ingredient_raw(recipe_name, ingredient)
+function util.add_ingredient_raw(recipe_name, ingredient, options)
-  if me.bypass[recipe_name] then return end
+  if not should_force(options) and bypass(recipe_name) then return end
   if data.raw.recipe[recipe_name] and (data.raw.item[ingredient.name] or data.raw.item[ingredient[1]]) then
     me.add_modified(recipe_name)
     add_ingredient_raw(data.raw.recipe[recipe_name], ingredient)
@@ -233,8 +417,8 @@ function add_ingredient_raw(recipe, ingredient)
 end
 
 -- Set an ingredient to a given quantity
-function util.set_ingredient(recipe_name, ingredient, quantity)
+function util.set_ingredient(recipe_name, ingredient, quantity, options)
-  if me.bypass[recipe_name] then return end
+  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)
     set_ingredient(data.raw.recipe[recipe_name], ingredient, quantity)
@@ -261,8 +445,12 @@ function set_ingredient(recipe, ingredient, quantity)
 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)
+function util.add_product(recipe_name, product, options)
-  if data.raw.recipe[recipe_name] and (data.raw.item[product[1]] or data.raw.item[product.name]) then
+  if not should_force(options) and bypass(recipe_name) then return end
+  if data.raw.recipe[recipe_name] and 
+  (data.raw.item[product[1]] or data.raw.item[product.name] or
+   data.raw.fluid[product[1]] or data.raw.fluid[product.name]
+  ) then
     add_product(data.raw.recipe[recipe_name], product)
     add_product(data.raw.recipe[recipe_name].normal, product)
     add_product(data.raw.recipe[recipe_name].expensive, product)
@@ -328,17 +516,18 @@ function util.get_amount(recipe_name, product)
 end
 
 -- Replace one ingredient with another in a recipe
-function util.replace_ingredient(recipe_name, old, new, amount)
+--    Use amount to set an amount. If that amount is a multiplier instead of an exact amount, set multiply true.
-  if me.bypass[recipe_name] then return end
+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]) then
     me.add_modified(recipe_name)
-    replace_ingredient(data.raw.recipe[recipe_name], old, new, amount)
+    replace_ingredient(data.raw.recipe[recipe_name], old, new, amount, multiply)
-    replace_ingredient(data.raw.recipe[recipe_name].normal, old, new, amount)
+    replace_ingredient(data.raw.recipe[recipe_name].normal, old, new, amount, multiply)
-    replace_ingredient(data.raw.recipe[recipe_name].expensive, old, new, amount)
+    replace_ingredient(data.raw.recipe[recipe_name].expensive, old, new, amount, multiply)
   end
 end
 
-function replace_ingredient(recipe, old, new, amount)
+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[1] == new or existing.name == new then
@@ -348,19 +537,31 @@ function replace_ingredient(recipe, old, new, amount)
 		for i, ingredient in pairs(recipe.ingredients) do 
 			if ingredient.name == old then 
         ingredient.name = new 
-        if amount then ingredient.amount = amount end
+        if amount then
+          if multiply then
+            ingredient.amount = amount * ingredient.amount
+          else
+            ingredient.amount = amount
+          end
+        end
       end
 			if ingredient[1] == old then 
         ingredient[1] = new
-        if amount then ingredient[2] = amount end
+        if amount then
+          if multiply then
+            ingredient[2] = amount * ingredient[2]
+          else
+            ingredient[2] = amount
+          end
+        end
       end
 		end
 	end
 end
 
 -- Remove an ingredient from a recipe
-function util.remove_ingredient(recipe_name, old)
+function util.remove_ingredient(recipe_name, old, options)
-  if me.bypass[recipe_name] then return end
+  if not should_force(options) and bypass(recipe_name) then return end
   if data.raw.recipe[recipe_name] then
     me.add_modified(recipe_name)
     remove_ingredient(data.raw.recipe[recipe_name], old)
@@ -385,8 +586,8 @@ function remove_ingredient(recipe, old)
 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)
+function util.replace_some_ingredient(recipe_name, old, old_amount, new, new_amount, options)
-  if me.bypass[recipe_name] then return end
+  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)
@@ -416,10 +617,10 @@ function replace_some_ingredient(recipe, old, old_amount, new, new_amount, is_fl
 end
 
 -- set the amount of a product. 
-function util.set_product_amount(recipe_name, product, amount)
+function util.set_product_amount(recipe_name, product, amount, options)
+  if not should_force(options) and bypass(recipe_name) then return end
   me.add_modified(recipe_name)
   if data.raw.recipe[recipe_name] then
-    if me.bypass[recipe_name] then return end
     set_product_amount(data.raw.recipe[recipe_name], product, amount)
     set_product_amount(data.raw.recipe[recipe_name].normal, product, amount)
     set_product_amount(data.raw.recipe[recipe_name].expensive, product, amount)
@@ -456,10 +657,10 @@ function set_product_amount(recipe, product, amount)
 end
 
 -- multiply the cost, energy, and results of a recipe by a multiple
-function util.multiply_recipe(recipe_name, multiple)
+function util.multiply_recipe(recipe_name, multiple, options)
+  if not should_force(options) and bypass(recipe_name) then return end
   me.add_modified(recipe_name)
   if data.raw.recipe[recipe_name] then
-    if me.bypass[recipe_name] then return end
     multiply_recipe(data.raw.recipe[recipe_name], multiple)
     multiply_recipe(data.raw.recipe[recipe_name].normal, multiple)
     multiply_recipe(data.raw.recipe[recipe_name].expensive, multiple)
@@ -529,10 +730,10 @@ function has_ingredient(recipe, ingredient)
 end
 
 -- Remove a product from a recipe, WILL NOT remove the only product
-function util.remove_product(recipe_name, old)
+function util.remove_product(recipe_name, old, options)
+  if not should_force(options) and bypass(recipe_name) then return end
   me.add_modified(recipe_name)
   if data.raw.recipe[recipe_name] then
-    if me.bypass[recipe_name] then return end
     remove_product(data.raw.recipe[recipe_name], old)
     remove_product(data.raw.recipe[recipe_name].normal, old)
     remove_product(data.raw.recipe[recipe_name].expensive, old)
@@ -554,7 +755,8 @@ function remove_product(recipe, old)
   end
 end
 
-function util.set_main_product(recipe_name, product)
+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)
     set_main_product(data.raw.recipe[recipe_name].normal, product)
@@ -569,7 +771,8 @@ function set_main_product(recipe, product)
 end
 
 -- Replace one product with another in a recipe
-function util.replace_product(recipe_name, old, new)
+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] then
     replace_product(data.raw.recipe[recipe_name], old, new)
     replace_product(data.raw.recipe[recipe_name].normal, old, new)
@@ -612,10 +815,10 @@ function util.remove_raw(t, name)
 end
 
 -- Set energy required
-function util.set_recipe_time(recipe_name, time)
+function util.set_recipe_time(recipe_name, time, options)
+  if not should_force(options) and bypass(recipe_name) then return end
   me.add_modified(recipe_name)
   if data.raw.recipe[recipe_name] then
-    if me.bypass[recipe_name] then return end
     set_recipe_time(data.raw.recipe[recipe_name], time)
     set_recipe_time(data.raw.recipe[recipe_name].normal, time)
     set_recipe_time(data.raw.recipe[recipe_name].expensive, time)
@@ -631,10 +834,10 @@ function set_recipe_time(recipe, time)
 end
 
 -- Multiply energy required
-function util.multiply_time(recipe_name, factor)
+function util.multiply_time(recipe_name, factor, options)
+  if not should_force(options) and bypass(recipe_name) then return end
   me.add_modified(recipe_name)
   if data.raw.recipe[recipe_name] then
-    if me.bypass[recipe_name] then return end
     multiply_time(data.raw.recipe[recipe_name], factor)
     multiply_time(data.raw.recipe[recipe_name].normal, factor)
     multiply_time(data.raw.recipe[recipe_name].expensive, factor)
@@ -650,10 +853,10 @@ function multiply_time(recipe, factor)
 end
 
 -- Add to energy required
-function util.add_time(recipe_name, amount)
+function util.add_time(recipe_name, amount, options)
+  if not should_force(options) and bypass(recipe_name) then return end
   me.add_modified(recipe_name)
   if data.raw.recipe[recipe_name] then
-    if me.bypass[recipe_name] then return end
     add_time(data.raw.recipe[recipe_name], amount)
     add_time(data.raw.recipe[recipe_name].normal, amount)
     add_time(data.raw.recipe[recipe_name].expensive, amount)
@@ -669,8 +872,8 @@ function add_time(recipe, amount)
 end
 
 -- Set recipe category
-function util.set_category(recipe_name, category)
+function util.set_category(recipe_name, category, options)
-  if me.bypass[recipe_name] then return end
+  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)
     data.raw.recipe[recipe_name].category = category
@@ -678,8 +881,8 @@ function util.set_category(recipe_name, category)
 end
 
 -- Set recipe subgroup
-function util.set_subgroup(recipe_name, subgroup)
+function util.set_subgroup(recipe_name, subgroup, options)
-  if me.bypass[recipe_name] then return end
+  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].subgroup = subgroup
@@ -687,16 +890,16 @@ function util.set_subgroup(recipe_name, subgroup)
 end
 
 -- Set item subgroup
-function util.set_item_subgroup(item, subgroup)
+function util.set_item_subgroup(item, subgroup, options)
-  if me.bypass[item] then return end
+  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
 
 -- Set recipe icons
-function util.set_icons(recipe_name, icons)
+function util.set_icons(recipe_name, icons, options)
-  if me.bypass[recipe_name] then return end
+  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
@@ -714,9 +917,9 @@ function util.set_item_icons(item_name, icons)
   end
 end
 
-function util.set_to_founding(recipe)
+function util.set_to_founding(recipe, options)
-  util.set_category(recipe, "founding")
+  util.set_category(recipe, "founding", options)
-  util.set_subgroup(recipe, "foundry-intermediate")
+  util.set_subgroup(recipe, "foundry-intermediate", options)
 end
 
 -- Add crafting category to an entity
@@ -754,11 +957,12 @@ function add_to_ingredient(recipe, it, amount)
 	end
 end
 
-function util.add_to_product(recipe, product, amount)
+function util.add_to_product(recipe_name, product, amount, options)
-  if data.raw.recipe[recipe] then
+  if not should_force(options) and bypass(recipe_name) then return end
-    add_to_product(data.raw.recipe[recipe], product, amount)
+  if data.raw.recipe[recipe_name] then
-    add_to_product(data.raw.recipe[recipe].normal, product, amount)
+    add_to_product(data.raw.recipe[recipe_name], product, amount)
-    add_to_product(data.raw.recipe[recipe].expensive, product, amount)
+    add_to_product(data.raw.recipe[recipe_name].normal, product, amount)
+    add_to_product(data.raw.recipe[recipe_name].expensive, product, amount)
   end
 end
 
@@ -867,4 +1071,79 @@ function util.create_list()
   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)
+  local technology = data.raw.technology[tech]
+  if technology then
+    util.remove_recipe_effect(tech, recipe)
+    if technology.prerequisites then
+      for i, prerequisite in pairs(technology.prerequisites) do
+        -- log("BZZZ removing prior unlocks for " .. tech ..", checking " .. prerequisite) -- Handy Debug :|
+        remove_prior_unlocks(prerequisite, recipe)
+      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)
+  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 :|
+        replace_ingredients_prior_to(prerequisite, old, new, multiplier)
+      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
+
 return util

info.json

@@ -1,6 +1,6 @@
 {
     "name": "bzzirconium",
-    "version": "0.6.8",
+    "version": "0.6.10",
     "factorio_version": "1.1",
     "title": "Zirconium",
     "author": "Brevven",

me.lua

@@ -3,14 +3,16 @@ local me = {}
 me.name = "bzzirconium"
 
 function me.byproduct()
-  return me.get_setting("bzzirconium-byproduct")
+  return me.get_setting("bzzirconium-byproduct") and not me.get_setting("bz-no-byproduct")
 end
 
 function me.use_cermet()
+  if me.get_setting("bz-all-intermediates") then return true end
   return me.get_setting("bzzirconium-enable-intermediates") == "yes" or me.cermet_lds()
 end
 
 function me.cermet_lds()
+  if me.get_setting("bz-all-intermediates") then return true end
   return me.get_setting("bzzirconium-enable-intermediates") == "lds"
 end
 

zirconium-recipe-se.lua

@@ -5,23 +5,10 @@ if mods["space-exploration"] then
   se_delivery_cannon_recipes["zircon"] = {name= "zircon"}
   se_delivery_cannon_recipes["zirconia"] = {name= "zirconia"}
   se_delivery_cannon_recipes["zirconium-plate"] = {name= "zirconium-plate"}
+  util.se_landfill({ore="zircon"})
 
-  data:extend({
-  {
-    type = "recipe",
-    icons = {
-      { icon = "__base__/graphics/icons/landfill.png", icon_size = 64, icon_mipmaps = 3 },
-      { icon = "__bzzirconium__/graphics/icons/zircon.png", icon_size = 64, scale = 0.25},
-    },
-    name = "landfill-zircon",
-    category = "hard-recycling",
-    order = "z-b-zircon",
-    subgroup = "terrain",
-    result = "landfill",
-    ingredients = {{"zircon", 50}},
-  }
-  })
 if string.sub(mods["space-exploration"], 1, 3) == "0.6" then
+  util.se_matter({ore="zircon", energy_required=1.5, quant_out=10, stream_out=60})
   data:extend({
   {
     type = "item-subgroup",

zirconium-recipe.lua

@@ -1,6 +1,6 @@
 -- Zirconium smelting, etc
 
-local util = require("__bzzirconium__.data-util");
+local util = require("data-util");
 
 -- data:extend({
 --