diff --git a/bzgold2/changelog.txt b/bzgold2/changelog.txt index 5d1ccff..4d308d3 100644 --- a/bzgold2/changelog.txt +++ b/bzgold2/changelog.txt @@ -1,28 +1,4 @@ --------------------------------------------------------------------------------------------------- -Version: 2.1.1 -Date: 16.03.2026 - Bug Fixes: - - Correct renamed "efficiency-module" ---------------------------------------------------------------------------------------------------- -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.3 -Date: 10.12.2025 - Bug Fixes: - - Fix tech coal-liquefaction has no prereq with catalysis off - - Fix recipe name of blank-tech-card-silver - - Fix autoplace of rich-copper-ore ---------------------------------------------------------------------------------------------------- -Version: 2.0.2 -Date: 01.11.2025 - Bug Fixes: - - Fix K2 matter integration (thanks pla) ---------------------------------------------------------------------------------------------------- Version: 2.0.1 Date: 21.10.2025 Changes: diff --git a/bzgold2/compatibility/248k-final.lua b/bzgold2/compatibility/248k-final.lua index bc7a7d6..d45be4c 100644 --- a/bzgold2/compatibility/248k-final.lua +++ b/bzgold2/compatibility/248k-final.lua @@ -1,7 +1,7 @@ local util = require("data-util"); if mods["248k-Redux"] then - local au2 = "fu_gold_ingot" + local au2 = "fu_materials_gold_ingot" -- Swap out all 248k gold ingot for BZ gold ingot for i, recipe in pairs(data.raw.recipe) do diff --git a/bzgold2/compatibility/248k.lua b/bzgold2/compatibility/248k.lua index 6bd53c0..da7600e 100644 --- a/bzgold2/compatibility/248k.lua +++ b/bzgold2/compatibility/248k.lua @@ -1,6 +1,6 @@ local util = require("data-util"); -- Update 248k gold production chain to include gold ore -util.add_ingredient("fi_pure_gold", "gold-ore", 10) -util.add_to_product("fi_pure_gold", "fi_pure_gold", 2) +util.add_ingredient("fi_pure_gold_recipe", "gold-ore", 10) +util.add_to_product("fi_pure_gold_recipe", "fi_materials_pure_gold", 2) diff --git a/bzgold2/data-util.lua b/bzgold2/data-util.lua index e2cbe2a..3825ac6 100644 --- a/bzgold2/data-util.lua +++ b/bzgold2/data-util.lua @@ -1,4 +1,1270 @@ +-- WARNING WARNING WARNING +-- This file will be overwritten in mod zipfiles, edit bzlib/data-util.lua +-- WARNING WARNING WARNING + local me = require("me") -local util = require("__bzlib__/data-util"); -util.initialize(me) -return util \ No newline at end of file +local util = {} + +util.me = me +util.get_setting = util.me.get_setting + +util.titanium_plate = "" +util.titanium_processing = "" + +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 + +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.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.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 + + +-- 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", + results = {{type="item", name="landfill", amount=1}}, + ingredients = {{type="item", name=params.ore, amount=50}}, + } + }) + util.add_unlock("se-recycling-facility", lname) + end +end + + +-- k2 matter +-- params: {k2matter}, k2baseicon , {icon} +function util.k2matter(params) + local matter = require("__Krastorio2__/prototypes/libraries/matter") + if mods["space-exploration"] then + params.k2matter.need_stabilizer = true + end + if not params.k2matter.minimum_conversion_quantity then + params.k2matter.minimum_conversion_quantity = 10 + end + if not data.raw.technology[params.k2matter.unlocked_by_technology] 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_technology, + 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, + }, + localised_name = {"technology-name.k2-conversion", {"item-name."..params.k2matter.item_name}}, + }, + }) + end + matter.make_recipes(params.k2matter) +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 = { + {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}, + } + } + }) + 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 = { + {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}, + } + } + }) + 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 + +-- 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 + +-- Check if a tech unlocks a recipe +function util.check_unlock(technology_name, recipe) + 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 + 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, 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) + 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, 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 (data.raw.item[ingredient] or is_fluid) then + me.add_modified(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[1] == ingredient or 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] or data.raw.item[ingredient[1]]) then + me.add_modified(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[1] and (existing[1] == ingredient[1] or existing[1] == ingredient.name)) or + (existing.name and (existing.name == ingredient[1] or 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) + 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[1] == ingredient then + existing[2] = quantity + return + elseif 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 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[1] == ingredient_name then return ingredient[2] end + 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[1] == product then return result[2] end + if result.name == product then return result.amount end + end + elseif recipe.result_count then + return recipe.result_count + end + return 1 + 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]) then + me.add_modified(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[1] == new or 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 + if ingredient[1] == old then + ingredient[1] = new + 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, 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) + 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 or ingredient[1] == 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) + 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, is_fluid) + 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, {type=is_fluid and "fluid" or "item", name=new, amount=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) + 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[1] == new or 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 + if ingredient[1] == old then + ingredient[2] = math.max(1, ingredient[2] - 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, 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 + 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, 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 + 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.ignored_by_productivity then + result.ignored_by_productivity = result.ignored_by_productivity * 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, 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 + 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, 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] 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, 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 + 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 + me.add_modified(recipe_name) + 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, 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 + 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, 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) + 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] 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 + data.raw.recipe[recipe_name].icons = {} + 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, + }} + data.raw.recipe[recipe_name].icon = nil + data.raw.recipe[recipe_name].icon_size = nil + end + 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 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 + +-- 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, 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 ~= 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, 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 + 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 + + +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, + flags = {"hidden", "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) + 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.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 + +return util diff --git a/bzgold2/data.lua b/bzgold2/data.lua index a109d88..727db4a 100644 --- a/bzgold2/data.lua +++ b/bzgold2/data.lua @@ -21,5 +21,8 @@ require("compatibility/248k") local util = require("data-util"); +if util.se6() then +end + -- Must be last util.create_list() diff --git a/bzgold2/info.json b/bzgold2/info.json index 774b5cf..9cbe7ad 100644 --- a/bzgold2/info.json +++ b/bzgold2/info.json @@ -1,6 +1,6 @@ { "name": "bzgold2", - "version": "2.1.1", + "version": "2.0.1", "factorio_version": "2.0", "title": "Noble Metals", "description": "Adds silver, gold, platinum, palladium and more to the base game. Reworks processing units.", @@ -8,7 +8,6 @@ "homepage": "https://discord.gg/ufvFUJtVwk", "dependencies": [ "base >= 2.0.0", - "bzlib", "? bzfoundry2 >= 2.0.0", "? bztitanium2 >= 2.0.27", "? bzlead2 >= 2.0.29", @@ -18,7 +17,7 @@ "? bztin2 >= 2.1.16", "? bzgas2", "? bzchlorine2", - "? 248k-Redux >= 0.1.35", + "? 248k-Redux >= 0.1.22", "? space-exploration >= 0.7.34", "? aai-industry", "(?) aai-loaders", diff --git a/bzgold2/matter.lua b/bzgold2/matter.lua index 728e9da..10ea30c 100644 --- a/bzgold2/matter.lua +++ b/bzgold2/matter.lua @@ -1,31 +1,30 @@ -- Matter recipes for Krastorio2 if mods["Krastorio2"] then - local util = require("data-util") + local util = require("data-util"); - if not data.raw.recipe["kr-gold-ore-to-matter"] then - util.k2matter({ - k2matter = { - material = { type = "item", name = "gold-ore", amount = 30 }, - item_name = "gold-ore", - matter_count = 30, - energy_required = 10, - needs_stabilizer = false, - unlocked_by = "gold-matter-processing", - }, - icon = { icon = "__bzgold2__/graphics/icons/gold-ore.png", icon_size = 128, scale = 0.5 }, - }) - end - if settings.startup["bzgold-silver"].value then - util.k2matter({ - k2matter = { - material = { type = "item", name = "silver-ore", amount = 8 }, - item_name = "silver-ore", - matter_count = 8, - energy_required = 5, - needs_stabilizer = false, - unlocked_by = "silver-matter-processing", - }, - icon = { icon = "__bzgold2__/graphics/icons/silver-ore.png", icon_size = 128, scale = 0.5 }, - }) - end + util.k2matter({ + k2matter = { + material = { type = "item", name = "gold-ore", amount = 30 }, + item_name = "gold-ore", + matter_count = 30, + energy_required = 10, + need_stabilizer = false, + unlocked_by_technology = "gold-matter-processing", + }, + k2baseicon = "stone", + icon = {icon = "__bzgold2__/graphics/icons/gold-ore.png", icon_size = 128, scale = 1} + }) + + util.k2matter({ + k2matter = { + material = { type = "item", name = "silver-ore", amount = 8 }, + item_name = "silver-ore", + matter_count = 8, + energy_required = 5, + need_stabilizer = false, + unlocked_by_technology = "silver-matter-processing", + }, + k2baseicon = "stone", + icon = {icon = "__bzgold2__/graphics/icons/silver-ore.png", icon_size = 128, scale = 1} + }) end diff --git a/bzgold2/prototypes/enriched-gold.lua b/bzgold2/prototypes/enriched-gold.lua index a8d9734..6190f58 100644 --- a/bzgold2/prototypes/enriched-gold.lua +++ b/bzgold2/prototypes/enriched-gold.lua @@ -1,4 +1,4 @@ -local util = require("data-util") +local util = require("data-util"); if mods.Krastorio2 then @@ -92,7 +92,7 @@ data:extend({ { icon = data.raw.item["gold-ore"].icon, icon_size = data.raw.item["gold-ore"].icon_size, - scale = 0.2 * 64 / (data.raw.item["gold-ore"].icon_size or 64), + scale = 0.2, shift = {0, 4} } }, diff --git a/bzgold2/prototypes/enriched-silver.lua b/bzgold2/prototypes/enriched-silver.lua index 0914e19..c5a8495 100644 --- a/bzgold2/prototypes/enriched-silver.lua +++ b/bzgold2/prototypes/enriched-silver.lua @@ -1,4 +1,4 @@ -local util = require("data-util") +local util = require("data-util"); if mods.Krastorio2 and util.me.silver() then data:extend({ @@ -111,7 +111,7 @@ data:extend({ { icon = data.raw.item["silver-ore"].icon, icon_size = data.raw.item["silver-ore"].icon_size, - scale = 0.2 * 64 / (data.raw.item["silver-ore"].icon_size or 64), + scale = 0.2, shift = {0, 4} } }, diff --git a/bzgold2/prototypes/recipe-updates-se.lua b/bzgold2/prototypes/recipe-updates-se.lua index 37c9fe3..3d28799 100644 --- a/bzgold2/prototypes/recipe-updates-se.lua +++ b/bzgold2/prototypes/recipe-updates-se.lua @@ -95,10 +95,10 @@ if util.se6() then -------- --TODO rebalance SE modules more completely - util.replace_ingredient("efficiency-module-5", "se-holmium-cable", "platinum-ingot", 10) - util.replace_ingredient("efficiency-module-5", "se-holmium-cable", "silver-plate") - util.replace_ingredient("efficiency-module-5", "se-holmium-cable", "palladium-ingot", 10) - util.replace_ingredient("efficiency-module-5", "se-holmium-cable", "gold-ingot", 10) + util.replace_ingredient("effectivity-module-5", "se-holmium-cable", "platinum-ingot", 10) + util.replace_ingredient("effectivity-module-5", "se-holmium-cable", "silver-plate") + util.replace_ingredient("effectivity-module-5", "se-holmium-cable", "palladium-ingot", 10) + util.replace_ingredient("effectivity-module-5", "se-holmium-cable", "gold-ingot", 10) util.replace_ingredient("speed-module-5", "se-heavy-girder", "gold-ingot", 10) util.replace_ingredient("speed-module-5", "se-heavy-girder", "palladium-ingot", 10) diff --git a/bzgold2/prototypes/recipe-updates.lua b/bzgold2/prototypes/recipe-updates.lua index 4483e6d..690c811 100644 --- a/bzgold2/prototypes/recipe-updates.lua +++ b/bzgold2/prototypes/recipe-updates.lua @@ -28,10 +28,10 @@ else end util.add_ingredient("speed-module-3", "mlcc", 5) -util.add_ingredient("efficiency-module-3", "mlcc", 5) +util.add_ingredient("effectivity-module-3", "mlcc", 5) util.add_ingredient("productivity-module-3", "mlcc", 5) util.remove_ingredient("speed-module-3", "cermet") -util.remove_ingredient("efficiency-module-3", "cermet") +util.remove_ingredient("effectivity-module-3", "cermet") util.remove_ingredient("productivity-module-3", "cermet") util.add_ingredient("gas-extractor", "silver-brazing-alloy", 10) @@ -72,7 +72,6 @@ end if mods.Krastorio2 and util.me.silver() then local tc = futil.table.deepcopy(data.raw.recipe["kr-blank-tech-card"]) tc.name = "blank-tech-card-silver" - tc.localised_name = { "item-name.blank-tech-card" } data:extend({tc}) util.replace_ingredient("blank-tech-card-silver", "copper-cable", "silver-wire") local amt = util.get_amount("kr-blank-tech-card") diff --git a/bzgold2/prototypes/rich-copper.lua b/bzgold2/prototypes/rich-copper.lua index 8406cbf..1402ec7 100644 --- a/bzgold2/prototypes/rich-copper.lua +++ b/bzgold2/prototypes/rich-copper.lua @@ -4,153 +4,154 @@ local futil = require("util"); local util = require("data-util"); if util.me.platinum() or util.me.palladium() then - if mods.Krastorio2 then - -- no rich copper - local rm = futil.table.deepcopy(data.raw.recipe["kr-rare-metals"]) - rm.name = "rare-metals-1" - data:extend({ rm }) - util.add_unlock("platinum-processing", "rare-metals-1") - util.add_unlock("palladium-processing", "rare-metals-1") - util.add_icon("rare-metals-1", { icon = "__bzgold2__/graphics/icons/platinum-powder.png", - icon_size = 64, scale = 0.25, shift = { -8, 8 } }) +if mods.Krastorio2 then + -- no rich copper + local rm = futil.table.deepcopy(data.raw.recipe["kr-rare-metals"]) + rm.name = "rare-metals-1" + data:extend({rm}) + util.add_unlock("platinum-processing", "rare-metals-1") + util.add_unlock("palladium-processing", "rare-metals-1") + util.add_icon("rare-metals-1", {icon = "__bzgold2__/graphics/icons/platinum-powder.png", + icon_size = 64, scale = 0.25, shift = {-8,8}}) - util.multiply_recipe("kr-rare-metals", 2) - util.multiply_recipe("rare-metals-1", 2) - util.multiply_recipe("rare-metals-2", 2) + util.multiply_recipe("kr-rare-metals", 2) + util.multiply_recipe("rare-metals-1", 2) + util.multiply_recipe("rare-metals-2", 2) - util.set_main_product("kr-rare-metals", "kr-rare-metals") - util.set_product_amount("kr-rare-metals", "kr-rare-metals", 6) - util.set_main_product("rare-metals-1", "kr-rare-metals") - util.set_main_product("rare-metals-2", "kr-rare-metals") + util.set_main_product("kr-rare-metals", "kr-rare-metals") + util.set_product_amount("kr-rare-metals", "kr-rare-metals", 6) + util.set_main_product("rare-metals-1", "kr-rare-metals") + util.set_main_product("rare-metals-2", "kr-rare-metals") - if util.me.platinum() and util.me.palladium() then - util.replace_some_product("rare-metals-1", "kr-rare-metals", 2, "platinum-powder", 2, { force = true }) - util.replace_some_product("rare-metals-1", "kr-rare-metals", 2, "palladium-powder", 2, { force = true }) - util.replace_some_product("rare-metals-2", "kr-rare-metals", 3, "platinum-powder", 3, { force = true }) - util.replace_some_product("rare-metals-2", "kr-rare-metals", 3, "palladium-powder", 3, { force = true }) - elseif util.me.platinum() then - util.replace_some_product("rare-metals-1", "kr-rare-metals", 3, "platinum-powder", 4, { force = true }) - util.replace_some_product("rare-metals-2", "kr-rare-metals", 6, "platinum-powder", 6, { force = true }) - elseif util.me.palladium() then - util.replace_some_product("rare-metals-1", "kr-rare-metals", 3, "palladium-powder", 4, { force = true }) - util.replace_some_product("rare-metals-2", "kr-rare-metals", 6, "palladium-powder", 6, { force = true }) - end + + if util.me.platinum() and util.me.palladium() then + util.replace_some_product("rare-metals-1", "kr-rare-metals", 2, "platinum-powder", 2, {force=true}) + util.replace_some_product("rare-metals-1", "kr-rare-metals", 2, "palladium-powder", 2, {force=true}) + util.replace_some_product("rare-metals-2", "kr-rare-metals", 3, "platinum-powder", 3, {force=true}) + util.replace_some_product("rare-metals-2", "kr-rare-metals", 3, "palladium-powder", 3, {force=true}) + elseif util.me.platinum() then + util.replace_some_product("rare-metals-1", "kr-rare-metals", 3, "platinum-powder", 4, {force=true}) + util.replace_some_product("rare-metals-2", "kr-rare-metals", 6, "platinum-powder", 6, {force=true}) + elseif util.me.palladium() then + util.replace_some_product("rare-metals-1", "kr-rare-metals", 3, "palladium-powder", 4, {force=true}) + util.replace_some_product("rare-metals-2", "kr-rare-metals", 6, "palladium-powder", 6, {force=true}) + end +else + +local results = {} +if util.me.silver() and util.me.platinum() and util.me.palladium() then + results = { + {type="item", name="copper-plate", amount=1}, + {type="item", name="silver-ore", amount=1, probability=0.5}, + {type="item", name="platinum-powder", amount=1, probability=0.25}, + {type="item", name="palladium-powder", amount=1, probability=0.25}, + } +elseif util.me.silver() and util.me.platinum() then + results = { + {type="item", name="copper-plate", amount=1}, + {type="item", name="silver-ore", amount=1, probability=0.67}, + {type="item", name="platinum-powder", amount=1, probability=0.33}, + } +elseif util.me.silver() and util.me.palladium() then + results = { + {type="item", name="copper-plate", amount=1}, + {type="item", name="silver-ore", amount=1, probability=0.67}, + {type="item", name="palladium-powder", amount=1, probability=0.33}, + } +elseif util.me.platinum() and util.me.palladium() then + results = { + {type="item", name="copper-plate", amount=1}, + {type="item", name="platinum-powder", amount=1, probability=0.5}, + {type="item", name="palladium-powder", amount=1, probability=0.5}, + } +elseif util.me.platinum() then + results = { + {type="item", name="copper-plate", amount=2, probability = 0.75}, + {type="item", name="platinum-powder", amount=1, probability=0.5}, + } +elseif util.me.palladium() then + results = { + {type="item", name="copper-plate", amount=2, probability = 0.75}, + {type="item", name="palladium-powder", amount=1, probability=0.5}, + } +else -- should never happen + results = { + {type="item", name="copper-plate", amount=2}, + } +end + + +if data.raw.resource["copper-ore"] then + if mods["space-exploration"] then + -- decrease richness of copper a bit (ok if it stacks with aluminum) + data.raw.resource["copper-ore"].autoplace.richness_expression = + data.raw.resource["copper-ore"].autoplace.richness_expression .. "*(3/4)" else + log("Replacing vanilla copper-ore autoplace") + local resource_autoplace = require('resource-autoplace'); + data.raw.resource["copper-ore"].autoplace = resource_autoplace.resource_autoplace_settings{ + name = "copper-ore", + order = "b", + base_density = mods.bzaluminum2 and 3 or 4, + has_starting_area_placement = true, + regular_rq_factor_multiplier = 1.1, + starting_rq_factor_multiplier = 1.1, + candidate_spot_count = 22, + } + end +end - local results = {} - if util.me.silver() and util.me.platinum() and util.me.palladium() then - results = { - { type = "item", name = "copper-plate", amount = 1 }, - { type = "item", name = "silver-ore", amount = 1, probability = 0.5 }, - { type = "item", name = "platinum-powder", amount = 1, probability = 0.25 }, - { type = "item", name = "palladium-powder", amount = 1, probability = 0.25 }, - } - elseif util.me.silver() and util.me.platinum() then - results = { - { type = "item", name = "copper-plate", amount = 1 }, - { type = "item", name = "silver-ore", amount = 1, probability = 0.67 }, - { type = "item", name = "platinum-powder", amount = 1, probability = 0.33 }, - } - elseif util.me.silver() and util.me.palladium() then - results = { - { type = "item", name = "copper-plate", amount = 1 }, - { type = "item", name = "silver-ore", amount = 1, probability = 0.67 }, - { type = "item", name = "palladium-powder", amount = 1, probability = 0.33 }, - } - elseif util.me.platinum() and util.me.palladium() then - results = { - { type = "item", name = "copper-plate", amount = 1 }, - { type = "item", name = "platinum-powder", amount = 1, probability = 0.5 }, - { type = "item", name = "palladium-powder", amount = 1, probability = 0.5 }, - } - elseif util.me.platinum() then - results = { - { type = "item", name = "copper-plate", amount = 2, probability = 0.75 }, - { type = "item", name = "platinum-powder", amount = 1, probability = 0.5 }, - } - elseif util.me.palladium() then - results = { - { type = "item", name = "copper-plate", amount = 2, probability = 0.75 }, - { type = "item", name = "palladium-powder", amount = 1, probability = 0.5 }, - } - else - -- should never happen - results = { - { type = "item", name = "copper-plate", amount = 2 }, - } - end +if util.se6() then + data:extend({ + { + type = "autoplace-control", + category = "resource", + name = "rich-copper-ore", + richness = true, + order = "zzzzzzzzzzz" + }, + }) +end - if data.raw.resource["copper-ore"] then - if mods["space-exploration"] then - -- decrease richness of copper a bit (ok if it stacks with aluminum) - data.raw.resource["copper-ore"].autoplace.richness_expression = data.raw.resource["copper-ore"].autoplace.richness_expression .. "*(3/4)" - else - log("Replacing vanilla copper-ore autoplace") - local resource_autoplace = require('resource-autoplace'); - data.raw.resource["copper-ore"].autoplace = resource_autoplace.resource_autoplace_settings { - name = "copper-ore", - order = "b", - base_density = mods.bzaluminum2 and 3 or 4, - has_starting_area_placement = true, - regular_rq_factor_multiplier = 1.1, - starting_rq_factor_multiplier = 1.1, - candidate_spot_count = 22, - } - end - end +data:extend({ + { + type = "resource", + name = "rich-copper-ore", + icon = "__bzgold2__/graphics/icons/rich-copper-ore.png", + icon_size = 64, icon_mipmaps = 4, + flags = {"placeable-neutral"}, + order="a-b-a", + map_color = {r=0.9, g=0.5, b=0.4}, + tree_removal_probability = 0.7, + tree_removal_max_distance = 32 * 32, + minable = + { + hardness = 1, + mining_particle = "copper-ore-particle", + mining_time = 1, + fluid_amount = 1, + required_fluid = "water", + result = "rich-copper-ore" + }, + collision_box = {{ -0.1, -0.1}, {0.1, 0.1}}, + selection_box = {{ -0.5, -0.5}, {0.5, 0.5}}, - if util.se6() then - data.raw.planet.nauvis.map_gen_settings.autoplace_controls["rich-copper-ore"] = {} - data:extend({ + autoplace = resource_autoplace.resource_autoplace_settings{ + name = "rich-copper-ore", + autoplace_control_name = util.se6() and "rich-copper-ore" or "copper-ore", + order = "b-z", + base_density = 4, + base_spots_per_km2 = 1, + has_starting_area_placement = false, + regular_rq_factor_multiplier = 1, + starting_rq_factor_multiplier = 1, + }, + + stage_counts = {15000, 9500, 5500, 2900, 1300, 400, 150, 80}, + stages = { - type = "autoplace-control", - category = "resource", - name = "rich-copper-ore", - richness = true, - order = "zzzzzzzzzzz" - }, - }) - end - - data.raw.planet.nauvis.map_gen_settings.autoplace_settings.entity.settings["rich-copper-ore"] = {} - resource_autoplace.initialize_patch_set("rich-copper-ore", true) - - data:extend({ - { - type = "resource", - name = "rich-copper-ore", - icon = "__bzgold2__/graphics/icons/rich-copper-ore.png", - icon_size = 64, icon_mipmaps = 4, - flags = { "placeable-neutral" }, - order = "a-b-a", - map_color = { r = 0.9, g = 0.5, b = 0.4 }, - tree_removal_probability = 0.7, - tree_removal_max_distance = 32 * 32, - minable = { - hardness = 1, - mining_particle = "copper-ore-particle", - mining_time = 1, - fluid_amount = 1, - required_fluid = "water", - result = "rich-copper-ore" - }, - collision_box = { { -0.1, -0.1 }, { 0.1, 0.1 } }, - selection_box = { { -0.5, -0.5 }, { 0.5, 0.5 } }, - - autoplace = resource_autoplace.resource_autoplace_settings { - name = "rich-copper-ore", - autoplace_control_name = util.se6() and "rich-copper-ore" or "copper-ore", - order = "b-z", - base_density = 4, - base_spots_per_km2 = 1, - has_starting_area_placement = false, - regular_rq_factor_multiplier = 1, - starting_rq_factor_multiplier = 1, - }, - - stage_counts = { 15000, 9500, 5500, 2900, 1300, 400, 150, 80 }, - stages = { - sheet = { + sheet = + { filename = "__bzgold2__/graphics/entity/ores/hr-rich-copper-ore.png", priority = "extra-high", size = 128, @@ -158,56 +159,57 @@ if util.me.platinum() or util.me.palladium() then variation_count = 8, scale = 0.5 } - }, + }, + }, + { + type = "item", + name = "rich-copper-ore", + icon_size = 64, icon_mipmaps=4, + icon = "__bzgold2__/graphics/icons/rich-copper-ore.png", + pictures = { + {filename="__bzgold2__/graphics/icons/rich-copper-ore.png", size=64, scale=0.5}, + {filename="__bzgold2__/graphics/icons/rich-copper-ore-1.png", size=64, scale=0.5}, + {filename="__bzgold2__/graphics/icons/rich-copper-ore-2.png", size=64, scale=0.5}, + {filename="__bzgold2__/graphics/icons/rich-copper-ore-3.png", size=64, scale=0.5}, }, - { - type = "item", - name = "rich-copper-ore", - icon_size = 64, icon_mipmaps = 4, - icon = "__bzgold2__/graphics/icons/rich-copper-ore.png", - pictures = { - { filename = "__bzgold2__/graphics/icons/rich-copper-ore.png", size = 64, scale = 0.5 }, - { filename = "__bzgold2__/graphics/icons/rich-copper-ore-1.png", size = 64, scale = 0.5 }, - { filename = "__bzgold2__/graphics/icons/rich-copper-ore-2.png", size = 64, scale = 0.5 }, - { filename = "__bzgold2__/graphics/icons/rich-copper-ore-3.png", size = 64, scale = 0.5 }, - }, - subgroup = "raw-resource", - order = "t-c-a", - stack_size = 50 - }, - }) + subgroup = "raw-resource", + order = "t-c-a", + stack_size = 50 + }, +}) - data:extend({ - { - type = "recipe", - name = "rich-copper", - localised_name = { "item-name.copper-plate" }, - category = "smelting", - main_product = "copper-plate", - order = "d[copper-plate]", - enabled = false, - icons = { - { icon = "__base__/graphics/icons/copper-plate.png", icon_size = 64, icon_mipmaps = 4 }, - { icon = "__bzgold2__/graphics/icons/rich-copper-ore.png", icon_size = 64, scale = 0.25, shift = { -8, 8 } }, - -- {icon = "__bzgold__/graphics/icons/silver-ore.png", icon_size = 128, scale=0.125, shift = {8,8}}, - -- {icon = "__bzgold__/graphics/icons/platinum-powder.png", icon_size = 64, scale=0.25, shift = {8,-8}}, - -- {icon = "__bzgold__/graphics/icons/palladium-powder.png", icon_size = 64, scale=0.25, shift = {-8,-8}}, - }, - energy_required = 6.4, - ingredients = { { type = "item", name = "rich-copper-ore", amount = 2 } }, - results = results, - }, - }) - util.add_unlock("platinum-processing", "rich-copper") - util.add_unlock("palladium-processing", "rich-copper") - if util.se6() then - se_resources["rich-copper-ore"] = { - order = "b-z-c", - has_starting_area_placement = false, - base_density = 4, - base_spots_per_km2 = 1, - } - end - end +data:extend({ + { + type = "recipe", + name = "rich-copper", + localised_name = {"item-name.copper-plate"}, + category = "smelting", + main_product = "copper-plate", + order = "d[copper-plate]", + enabled = false, + icons = { + {icon = "__base__/graphics/icons/copper-plate.png", icon_size = 64, icon_mipmaps=4}, + {icon = "__bzgold2__/graphics/icons/rich-copper-ore.png", icon_size = 64, scale=0.25, shift = {-8,8}}, + -- {icon = "__bzgold__/graphics/icons/silver-ore.png", icon_size = 128, scale=0.125, shift = {8,8}}, + -- {icon = "__bzgold__/graphics/icons/platinum-powder.png", icon_size = 64, scale=0.25, shift = {8,-8}}, + -- {icon = "__bzgold__/graphics/icons/palladium-powder.png", icon_size = 64, scale=0.25, shift = {-8,-8}}, + }, + energy_required = 6.4, + ingredients = {{type="item", name="rich-copper-ore", amount=2}}, + results = results, + }, +}) +util.add_unlock("platinum-processing", "rich-copper") +util.add_unlock("palladium-processing", "rich-copper") + +if util.se6() then + se_resources["rich-copper-ore"] = { + order = "b-z-c", + has_starting_area_placement = false, + base_density = 4, + base_spots_per_km2 = 1, + } +end +end end diff --git a/bzgold2/prototypes/tech-updates.lua b/bzgold2/prototypes/tech-updates.lua index a5a738c..ad6b5ab 100644 --- a/bzgold2/prototypes/tech-updates.lua +++ b/bzgold2/prototypes/tech-updates.lua @@ -21,8 +21,6 @@ end util.add_unlock("processing-unit", "cpu") util.add_unlock("processing-unit", "mainboard") -if settings.startup["bzgold-catalysis"].value == true then - util.add_prerequisite("coal-liquefaction", "catalysis") - util.remove_prerequisite("coal-liquefaction", "production-science-pack") - util.remove_prerequisite("coal-liquefaction", "advanced-oil-processing") -end +util.add_prerequisite("coal-liquefaction", "catalysis") +util.remove_prerequisite("coal-liquefaction", "production-science-pack") +util.remove_prerequisite("coal-liquefaction", "advanced-oil-processing")