2.1.1

![image](/attachments/f900592e-41ad-4956-a382-ce622274a4bb)

Co-authored-by: pla
Reviewed-on: cacklingfiend/Cobalt2#1
Co-authored-by: pla <pla@noreply.example.org>
Co-committed-by: pla <pla@noreply.example.org>

Cobalt2/changelog.txt

@@ -1,4 +1,22 @@
 ---------------------------------------------------------------------------------------------------
+Version: 2.1.1
+Date: 16.03.2026
+  Bug Fixes:
+    - bzlib fixes
+    - SE: Fix scrap recycling
+---------------------------------------------------------------------------------------------------
+Version: 2.1.0
+Date: 11.03.2026
+  Changes:
+    - Switch to bzlib - Please install the new dependency
+  Bug Fixes:
+    - 248k: Fixes for 0.1.35 breaking changes (thanks Morganite)
+---------------------------------------------------------------------------------------------------
+Version: 2.0.4
+Date: 01.11.2025
+  Bug Fixes:
+    - Fix K2 matter integration (thanks pla)
+---------------------------------------------------------------------------------------------------
 Version: 2.0.3
 Date: 21.10.2025
   Changes:

Cobalt2/data-util.lua

@@ -1,930 +1,4 @@
-local util = {}
+local me = require("me")
-
+local util = require("__bzlib__/data-util");
--- se landfill
+util.initialize(me)
--- 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 = "__Cobalt2__/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",
-        results = {{type="item", name="landfill", amount=1}},
-        ingredients = {{type="item", name=params.ore, amount=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 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 = "__Cobalt2__/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 = {
-        {type = "item", name = sedata, amount=1},
-        {type="fluid", name="se-particle-stream", amount=50},
-        {type="fluid", name="se-space-coolant-supercooled", amount=25},
-      },
-      results = {
-        {type = "item", name = params.ore, amount = params.quant_out},
-        {type="item", name="se-contaminated-scrap", amount=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_productivity = 25, ignored_by_stats = 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 = "__Cobalt2__/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 = {
-          {type="item", name="se-kr-matter-liberation-data", amount=1},
-          {type="item", name=params.ore, amount=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_productivity = 50, ignored_by_stats = 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
-
--- 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]
-    if recipe.ingredients then
-      return recipe
-    end
-  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
-      table.insert(technology.effects, effect)
-    end
-  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
-
--- 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
-    technology.unit.ingredients = ingredients
-  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
-
--- Add a given quantity of ingredient to a given recipe
-function util.add_or_add_to_ingredient(recipe_name, ingredient, quantity)
-  if data.raw.recipe[recipe_name] and data.raw.item[ingredient] then
-    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[1] == ingredient or existing.name == ingredient then
-        add_to_ingredient(recipe, ingredient, quantity)
-        return
-      end
-    end
-    table.insert(recipe.ingredients, {ingredient, quantity})
-  end
-end
-
--- Add a given quantity of ingredient to a given recipe
-function util.add_ingredient(recipe_name, ingredient, quantity)
-  local is_fluid = not not data.raw.fluid[ingredient]
-  if data.raw.recipe[recipe_name] and (data.raw.item[ingredient] or is_fluid) then
-    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)
-  if data.raw.recipe[recipe_name] and (data.raw.item[ingredient.name] or data.raw.item[ingredient[1]]) then
-    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 and 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)
-  if data.raw.recipe[recipe_name] and data.raw.item[ingredient] then
-    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)
-  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 recipe.results == nil then
-      recipe.results = {}
-    end
-    table.insert(recipe.results, product)
-  end
-end
-
--- Get the amount of the ingredient, will check base/normal not expensive
-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 1
-  end
-  return 0
-end
-
--- Get the amount of the result, will check base/normal not expensive
-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 return result.amount end
-      end
-    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)
-  if data.raw.recipe[recipe_name] and (data.raw.item[new] or data.raw.fluid[new]) then
-    replace_ingredient(data.raw.recipe[recipe_name], old, new, amount or 1, 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 multiply then
-            ingredient.amount = amount * ingredient.amount
-          else
-            ingredient.amount = amount
-          end
-      end
-		end
-	end
-end
-
--- Remove an ingredient from a recipe
-function util.remove_ingredient(recipe_name, old)
-  if data.raw.recipe[recipe_name] then
-    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 an ingredient in a recipe. Keep at least 1 of old.
-function util.replace_some_ingredient(recipe_name, old, old_amount, new, new_amount)
-  local is_fluid = not not data.raw.fluid[new]
-  if data.raw.recipe[recipe_name] and (data.raw.item[new] or is_fluid) then
-    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 amount of a product.
-function util.set_product_amount(recipe_name, product, amount)
-  if data.raw.recipe[recipe_name] then
-    set_product_amount(data.raw.recipe[recipe_name], product, amount)
-	end
-end
-
-function set_product_amount(recipe, product, amount)
-  if recipe then
-    if recipe.result_count then
-      recipe.result_count = amount
-    end
-    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
-        if result[1] == product then
-          result[2] = amount
-        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)
-  if data.raw.recipe[recipe_name] then
-    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
-    end
-    if recipe.result_count then
-      recipe.result_count = recipe.result_count * multiple
-    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.catalyst_amount then
-            result.catalyst_amount = result.catalyst_amount * multiple
-          end
-        end
-        if result[1] then
-          result[2] = result[2] * multiple
-        end
-      end
-    end
-    if not recipe.results and not recipe.result_count then
-      -- implicit one item result
-      recipe.result_count = multiple
-    end
-    if recipe.ingredients then
-      for i, ingredient in pairs(recipe.ingredients) do
-        if ingredient.name then
-          ingredient.amount = ingredient.amount * multiple
-        end
-        if ingredient[1] then
-          ingredient[2] = ingredient[2] * 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[1] == ingredient or 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)
-  if data.raw.recipe[recipe_name] then
-    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 or result[1] == 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)
-  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)
-  if data.raw.recipe[recipe_name] then
-    replace_product(data.raw.recipe[recipe_name], old, new)
-  end
-end
-
-function replace_product(recipe, old, new)
-  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
-        if result[1] == old then result[1] = 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)
-  if data.raw.recipe[recipe_name] then
-    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)
-  if data.raw.recipe[recipe_name] then
-    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)
-  if data.raw.recipe[recipe_name] then
-    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 recipe category
-function util.set_category(recipe_name, category)
-  if data.raw.recipe[recipe_name] and data.raw["recipe-category"][category] then
-    data.raw.recipe[recipe_name].category = category
-  end
-end
-
--- Set recipe subgroup
-function util.set_subgroup(recipe_name, subgroup)
-  if data.raw.recipe[recipe_name] then
-    data.raw.recipe[recipe_name].subgroup = subgroup
-  end
-end
-
--- Set item subgroup
-function util.set_item_subgroup(item, subgroup)
-  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)
-  if data.raw.recipe[recipe_name] then
-    if not (data.raw.recipe[recipe_name].icons and #(data.raw.recipe[recipe_name].icons) > 0) 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,
-      }}
-      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)
-  if data.raw.recipe[recipe_name] then
-    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 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)
-  util.set_category(recipe, "founding")
-  util.set_subgroup(recipe, "foundry-intermediate")
-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
-
-function util.add_to_ingredient(recipe, ingredient, amount)
-  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 ~= nil and recipe.ingredients ~= nil then
-		for i, ingredient in pairs(recipe.ingredients) do
-			if ingredient.name == it then
-        ingredient.amount = ingredient.amount + amount
-        return
-      end
-			if ingredient[1] == it then
-        ingredient[2] = ingredient[2] + amount
-        return
-      end
-		end
-	end
-end
-
-function util.add_to_product(recipe_name, product, amount)
-  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
-			if result[1] == product then
-        result[2] = result[2] + 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 then
-    if data.raw[t][name].minable.result and not data.raw[t][name].minable.results then
-      data.raw[t][name].minable.results = {
-        {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
-      table.insert(data.raw[t][name].minable.results, result)
-    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)
-  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
-
--- 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.add_productivity(recipe)
-  data.raw.recipe[recipe].allow_productivity = true
-end
-
 return util

Cobalt2/info.json

@@ -1,6 +1,6 @@
 {
   "name": "Cobalt2",
-  "version": "2.0.3",
+  "version": "2.1.1",
   "factorio_version": "2.0",
   "title": "Cobalt",
   "description": "Cobalt is a mod adding the element Cobalt.\n\nThis mod is inspired by Brevven's BZ mods.",
@@ -8,7 +8,8 @@
   "homepage": "https://discord.gg/ufvFUJtVwk",
   "dependencies": [
     "base >= 2.0.0",
-    "? 248k-Redux",
+    "bzlib",
+    "? 248k-Redux >= 0.1.35",
     "? bobassembly",
     "? bzfoundry2",
     "? Chromium2",

Cobalt2/locale/en/Cobalt.cfg

@@ -3,6 +3,7 @@ cobalt-refining=Cobalt refining
 cobalt-carbide=Cobalt carbide
 cobalt-electromagnet=Cobalt electromagnet
 cobalt-substrates=Cobalt substrates
+cobalt-matter-processing=Cobalt conversion
 
 [technology-description]
 

Cobalt2/me.lua

@@ -0,0 +1,7 @@
+local me = {}
+
+me.name = "Cobalt2"
+me.bypass = {}
+me.add_modified = function() end
+
+return me

Cobalt2/prototypes/cobalt-matter.lua

@@ -10,15 +10,16 @@ data:extend(
     icons =
     {
       {
-        icon = "__Krastorio2Assets__/technologies/matter-coal.png",
+        icon = "__Krastorio2Assets__/technologies/backgrounds/matter.png",
         icon_size = 256,
       },
       {
         icon = "__Cobalt2__/graphics/icons/cobaltite-ore.png",
         icon_size = 64,
-        scale = 1.4,
+        scale = 1,
       }
     },
+    effects = {},
     prerequisites = {"kr-matter-processing"},
     unit =
   	{
@@ -38,16 +39,16 @@ matter.make_recipes({
   material = { type = "item", name = "cobaltite-ore", amount = 10 },
   matter_count = 5,
   energy_required = 1,
-  need_stabilizer = false,
+  needs_stabilizer = false,
-  unlocked_by_technology = "cobalt-matter-processing"
+  unlocked_by = "cobalt-matter-processing"
 })
 
-matter.make_recipes({
+matter.make_deconversion_recipe({
   material = { type = "item", name = "cobalt-plate", amount = 10 },
   matter_count = 10,
   energy_required = 3,
-  only_deconversion = true,
+  -- only_deconversion = true,
-  need_stabilizer = true,
+  needs_stabilizer = true,
-  unlocked_by_technology = "cobalt-matter-processing"
+  unlocked_by = "cobalt-matter-processing"
 })
 end

Cobalt2/recipe-modify.lua

@@ -40,7 +40,7 @@ if mods["bobassembly"] then
 end
 
 if mods["248k-Redux"] then
-    util.replace_ingredient("el_lithium_battery_recipe", "iron-plate", "cobalt-plate", 4)
+    util.replace_ingredient("el_lithium_battery", "iron-plate", "cobalt-plate", 4)
 end
 
 if mods["Krastorio2"] then
@@ -52,7 +52,7 @@ if mods["Krastorio2"] then
 end
 
 if mods["space-exploration"] then
-    util.add_product(mods["space-exploration"] and "se-scrap-recycling", {type="item", name="cobaltite-ore", amount=1, probability=0.05})
+    util.add_product(mods["space-exploration"] and "se-scrap-hard-recycling", {type="item", name="cobaltite-ore", amount=1, probability=0.05})
 
     util.remove_ingredient("se-space-plasma-generator", "nickel-electromagnet")
     util.add_ingredient("se-space-plasma-generator", "cobalt-electromagnet", 100)