691 lines
24 KiB
Lua
691 lines
24 KiB
Lua
-- Exile always registers the legacy/unused items, register the recipes so we can assign EMC
|
|
local extra_exile_crafting_recipes = {
|
|
{
|
|
type = "crafting_spot",
|
|
output = "tech:grinding_stone",
|
|
items = {'nodes_nature:granite_boulder', 'nodes_nature:sand 8'},
|
|
level = 1,
|
|
always_known = true,
|
|
},
|
|
{
|
|
type = "crafting_spot",
|
|
output = "tech:weaving_frame",
|
|
items = {'tech:stick 12', 'group:fibrous_plant 8'},
|
|
level = 1,
|
|
always_known = true,
|
|
},
|
|
{
|
|
type = "crafting_spot",
|
|
output = "tech:chopping_block",
|
|
items = {'group:log'},
|
|
level = 1,
|
|
always_known = true,
|
|
},
|
|
{
|
|
type = "chopping_block",
|
|
output = "tech:chopping_block",
|
|
items = {'group:log'},
|
|
level = 1,
|
|
always_known = true,
|
|
},
|
|
{
|
|
type = "chopping_block",
|
|
output = "tech:hammering_block",
|
|
items = {'group:log'},
|
|
level = 1,
|
|
always_known = true,
|
|
},
|
|
{
|
|
type = "mixing_spot",
|
|
output = "tech:potash_block",
|
|
items = {'tech:potash 2'},
|
|
level = 1,
|
|
always_known = true,
|
|
},
|
|
}
|
|
|
|
local function register_translated_recipes()
|
|
local seen_unknown_crafting_types = {}
|
|
local did_cooking_warning = false
|
|
local replacements_actions = {}
|
|
-- Exile doesn't have lava buckets and uses an alternative,
|
|
-- so just eat the input item
|
|
replacements_actions[dump({{
|
|
exchangeclone.itemstrings.lava_bucket,
|
|
exchangeclone.itemstrings.empty_bucket,
|
|
}})] = {just_eat_input = true}
|
|
-- we're already using a philosopher's stone to do the crafting,
|
|
-- don't add to recipe so we don't need two
|
|
replacements_actions[dump({{
|
|
"exchangeclone:philosophers_stone",
|
|
"exchangeclone:philosophers_stone",
|
|
}})] = {remove_from_input = "exchangeclone:philosophers_stone"}
|
|
-- used for recipe for iron band -- crafting mod doesn't support
|
|
-- replacements, there is another recipe for the iron band,
|
|
-- so just ignore the recipe
|
|
replacements_actions[dump({{
|
|
"exchangeclone:volcanite_amulet",
|
|
"exchangeclone:volcanite_amulet",
|
|
}})] = {ignore_recipe = true}
|
|
local replacement_itemstrings = {
|
|
["group:tree"] = "group:log",
|
|
}
|
|
for _, recipes in pairs(exchangeclone.recipes) do
|
|
for _, recipe in ipairs(recipes) do
|
|
local mt_craft_type = recipe.type and exchangeclone.craft_types[recipe.type].type
|
|
if not mt_craft_type or mt_craft_type == "shaped" or mt_craft_type == "shapeless" then
|
|
---@type table<string, integer>
|
|
local item_counts = {}
|
|
local remove_from_input = nil
|
|
local ignore_recipe = false
|
|
if recipe.replacements then
|
|
local replacements_value = dump(recipe.replacements)
|
|
local replacements_action = replacements_actions[replacements_value]
|
|
assert(replacements_action, "[ExchangeClone] unimplemented replacements style: "..replacements_value)
|
|
if replacements_action.remove_from_input then
|
|
remove_from_input = replacements_action.remove_from_input
|
|
elseif replacements_action.ignore_recipe then
|
|
ignore_recipe = true
|
|
else
|
|
assert(replacements_action.just_eat_input, "unhandled replacements_action"..dump(replacements_action))
|
|
end
|
|
end
|
|
local worklist = table.copy(recipe.recipe)
|
|
while #worklist > 0 do
|
|
local item = table.remove(worklist)
|
|
if type(item) == "table" then
|
|
for _, v in ipairs(item) do
|
|
table.insert(worklist, v)
|
|
end
|
|
elseif item and item ~= remove_from_input and item ~= "" then
|
|
local count = item_counts[item] or 0
|
|
item_counts[item] = count + 1
|
|
end
|
|
end
|
|
local items_array = {}
|
|
for itemstring, count in pairs(item_counts) do
|
|
itemstring = replacement_itemstrings[itemstring] or itemstring
|
|
local item = ItemStack(itemstring)
|
|
item:set_count(count)
|
|
if not itemstring:find("^group:") and not item:is_known() then
|
|
ignore_recipe = true
|
|
break
|
|
end
|
|
assert(item:to_string() ~= "", dump({itemstring=itemstring,count=count,recipe=recipe}))
|
|
table.insert(items_array, item:to_string())
|
|
end
|
|
if not ignore_recipe then
|
|
local final_recipe = {
|
|
type = "exchangeclone_crafting",
|
|
output = recipe.output,
|
|
items = items_array,
|
|
always_known = true,
|
|
}
|
|
minetest.log("verbose", "[ExchangeClone]: registered Exile crafting recipe: \n"..dump(final_recipe))
|
|
crafting.register_recipe(final_recipe)
|
|
end
|
|
elseif mt_craft_type == "cooking" then
|
|
if not did_cooking_warning then
|
|
minetest.log("warning", "[ExchangeClone] cooking crafts aren't implemented for Exile, ignoring")
|
|
end
|
|
did_cooking_warning = true
|
|
else
|
|
local unknown_craft_type = dump(mt_craft_type)
|
|
if not seen_unknown_crafting_types[unknown_craft_type] then
|
|
minetest.log("warning", "[ExchangeClone] unknown minetest crafting type: "..unknown_craft_type)
|
|
end
|
|
seen_unknown_crafting_types[unknown_craft_type] = true
|
|
end
|
|
end
|
|
end
|
|
local crafting_recipes = table.copy(crafting.recipes)
|
|
for _, recipe in ipairs(extra_exile_crafting_recipes) do
|
|
assert(crafting_recipes[recipe.type], "unknown exile crafting recipe type"..recipe.type)
|
|
crafting_recipes[recipe.type] = table.copy(crafting_recipes[recipe.type])
|
|
table.insert(crafting_recipes[recipe.type], recipe)
|
|
end
|
|
for craft_type, recipes in pairs(crafting_recipes) do
|
|
if craft_type ~= "exchangeclone_crafting" then
|
|
exchangeclone.register_craft_type(craft_type, "shapeless")
|
|
for _, orig_recipe in ipairs(recipes) do
|
|
local recipe = {}
|
|
for _, item in ipairs(orig_recipe.items) do
|
|
item = ItemStack(item)
|
|
for _ = 1, item:get_count() do
|
|
table.insert(recipe, item:get_name())
|
|
end
|
|
end
|
|
exchangeclone.register_craft({
|
|
type = orig_recipe.type,
|
|
output = orig_recipe.output,
|
|
recipe = recipe,
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
register_translated_recipes()
|
|
|
|
-- Exile always registers the legacy items, register the recipes so we can assign EMC
|
|
local function register_exile_legacy_recipes()
|
|
crafting.register_recipe({
|
|
type = "crafting_spot",
|
|
output = "tech:grinding_stone",
|
|
items = {'nodes_nature:granite_boulder', 'nodes_nature:sand 8'},
|
|
level = 1,
|
|
always_known = true,
|
|
})
|
|
crafting.register_recipe({ --weaving_frame
|
|
type = "crafting_spot",
|
|
output = "tech:weaving_frame",
|
|
items = {'tech:stick 12', 'group:fibrous_plant 8'},
|
|
level = 1,
|
|
always_known = true,
|
|
})
|
|
crafting.register_recipe({ --chopping_block
|
|
type = "crafting_spot",
|
|
output = "tech:chopping_block",
|
|
items = {'group:log'},
|
|
level = 1,
|
|
always_known = true,
|
|
})
|
|
crafting.register_recipe({
|
|
type = "chopping_block",
|
|
output = "tech:chopping_block",
|
|
items = {'group:log'},
|
|
level = 1,
|
|
always_known = true,
|
|
})
|
|
crafting.register_recipe({ --hammering block
|
|
type = "chopping_block",
|
|
output = "tech:hammering_block",
|
|
items = {'group:log'},
|
|
level = 1,
|
|
always_known = true,
|
|
})
|
|
end
|
|
|
|
register_exile_legacy_recipes()
|
|
|
|
local sorted_dump_action
|
|
---@param v any
|
|
---@param indent? nil|string
|
|
---@return string
|
|
local function sorted_dump(v, indent)
|
|
if not indent then
|
|
indent = ""
|
|
end
|
|
local action = sorted_dump_action[type(v)] or sorted_dump_action.default
|
|
return action(v, indent)
|
|
end
|
|
sorted_dump_action = {
|
|
["nil"] = function(v, indent)
|
|
return "nil"
|
|
end,
|
|
number = function(v, indent)
|
|
return tostring(v)
|
|
end,
|
|
string = function(v, indent)
|
|
return string.format("%q", v)
|
|
end,
|
|
boolean = function(v, indent)
|
|
return string.format("%q", v)
|
|
end,
|
|
table = function(v, indent)
|
|
local inner_indent = indent.." "
|
|
---@type any[]
|
|
local keys = {}
|
|
for key, _ in pairs(v) do
|
|
table.insert(keys, key)
|
|
end
|
|
table.sort(keys)
|
|
local is_array = true
|
|
for index, key in ipairs(keys) do
|
|
if index ~= key then
|
|
is_array = false
|
|
break
|
|
end
|
|
end
|
|
---@type string[]
|
|
local lines = {}
|
|
if is_array then
|
|
for _, key in ipairs(keys) do
|
|
table.insert(lines, sorted_dump(v[key], inner_indent))
|
|
end
|
|
else
|
|
for _, key in ipairs(keys) do
|
|
local value = sorted_dump(v[key], inner_indent)
|
|
if type(key) == "string" and key:match("^[a-zA-Z_][a-zA-Z0-9_]*$") then
|
|
table.insert(lines, key.." = "..value)
|
|
else
|
|
table.insert(lines, "["..sorted_dump(key, inner_indent).."] = "..value)
|
|
end
|
|
end
|
|
end
|
|
local lines_len_total = 0
|
|
for _, line in ipairs(lines) do
|
|
if line:match("\n") then
|
|
lines_len_total = math.huge
|
|
break
|
|
end
|
|
lines_len_total = lines_len_total + #line
|
|
end
|
|
if #lines == 0 then
|
|
return "{}"
|
|
end
|
|
if #lines == 1 then
|
|
return "{"..lines[1].."}"
|
|
end
|
|
if lines_len_total + 2 * #lines + 2 < 80 then
|
|
return "{"..table.concat(lines, ", ").."}"
|
|
end
|
|
return "{\n"..inner_indent..table.concat(lines, ",\n"..inner_indent).."\n"..indent.."}"
|
|
end,
|
|
default = function(v, indent)
|
|
return "<" .. type(v) .. ">"
|
|
end
|
|
}
|
|
|
|
---@class SedimentSoil
|
|
---@field soil string
|
|
---@field soil_wet string
|
|
|
|
---@class Sediment
|
|
---@field wet string
|
|
---@field wet_salty string
|
|
---@field ag string
|
|
---@field ag_wet string
|
|
---@field ag_depleted string
|
|
---@field ag_wet_depleted string
|
|
---@field soils? SedimentSoil[]
|
|
|
|
---@type table<string, Sediment>
|
|
local sediments = {}
|
|
|
|
for name, def in pairs(minetest.registered_items) do
|
|
if name:match("^artifacts:wayfinder_[1-9][0-9]*$") then
|
|
exchangeclone.register_alias("artifacts:wayfinder_0", name)
|
|
end
|
|
if def.groups.natural_slope or def.groups.not_in_creative_inventory then
|
|
goto continue
|
|
end
|
|
minetest.log("verbose", "[ExchangeClone] exile_on_mods_loaded examining: "..name.." = "..sorted_dump(def))
|
|
if def.groups.sediment then
|
|
if def.groups.natural_slope then
|
|
elseif def.groups.wet_sediment then
|
|
elseif def.groups.bare_sediment then
|
|
local dry = name
|
|
sediments[dry] = sediments[dry] or {}
|
|
sediments[dry].wet = def._wet_name
|
|
sediments[dry].wet_salty = def._wet_salty_name
|
|
elseif def.groups.agricultural_soil then
|
|
local dry = def.drop
|
|
sediments[dry] = sediments[dry] or {}
|
|
sediments[dry].ag = name
|
|
sediments[dry].ag_wet = def._wet_name
|
|
elseif def.groups.depleted_agricultural_soil then
|
|
local dry = def.drop
|
|
sediments[dry] = sediments[dry] or {}
|
|
sediments[dry].ag_depleted = name
|
|
sediments[dry].ag_wet_depleted = def._wet_name
|
|
else
|
|
local dry = def.drop
|
|
sediments[dry] = sediments[dry] or {}
|
|
sediments[dry].soils = sediments[dry].soils or {}
|
|
table.insert(sediments[dry].soils, {soil = name, soil_wet = def._wet_name})
|
|
end
|
|
end
|
|
::continue::
|
|
end
|
|
|
|
minetest.log("sediments = "..sorted_dump(sediments))
|
|
|
|
exchangeclone.register_craft_type("roasting", "cooking")
|
|
for recipe, output in pairs({
|
|
["tech:iron_and_slag"] = "tech:iron_bloom",
|
|
["tech:iron_smelting_mix"] = "tech:iron_and_slag",
|
|
["tech:crushed_iron_ore"] = "tech:roasted_iron_ore",
|
|
["tech:green_glass_mix"] = "tech:green_glass_ingot",
|
|
["tech:clear_glass_mix"] = "tech:clear_glass_ingot",
|
|
["tech:crushed_lime"] = "tech:quicklime",
|
|
}) do
|
|
exchangeclone.register_craft({
|
|
type = "roasting",
|
|
output = output,
|
|
recipe = recipe,
|
|
})
|
|
end
|
|
exchangeclone.register_craft_type("fire_pottery", "cooking")
|
|
for recipe, output in pairs({
|
|
["tech:loose_brick_unfired"] = "tech:loose_brick",
|
|
["tech:roof_tile_loose_unfired"] = "tech:roof_tile_loose",
|
|
["tech:tile_block_unfired"] = "tech:tile_block",
|
|
["tech:cooking_pot_unfired"] = "tech:cooking_pot",
|
|
["tech:clay_water_pot_unfired"] = "tech:clay_water_pot",
|
|
["tech:clay_storage_pot_unfired"] = "tech:clay_storage_pot",
|
|
["tech:clay_oil_lamp_unfired"] = "tech:clay_oil_lamp_empty",
|
|
["tech:clay_watering_can_unfired"] = "tech:clay_watering_can",
|
|
}) do
|
|
exchangeclone.register_craft({
|
|
type = "fire_pottery",
|
|
output = output,
|
|
recipe = recipe,
|
|
})
|
|
end
|
|
exchangeclone.register_craft_type("baking", "cooking")
|
|
local baking_map = {}
|
|
for name, _ in pairs(bake_table) do
|
|
baking_map[name] = name.."_cooked"
|
|
baking_map[name.."_cooked"] = name.."_burned"
|
|
end
|
|
for name, _ in pairs(exchangeclone.colors) do
|
|
baking_map["ncrafting:bundle_treated_"..name] = "ncrafting:bundle_treated_blue" -- burning
|
|
baking_map["ncrafting:bundle_"..name] = "ncrafting:bundle_treated_"..name
|
|
end
|
|
for recipe, output in pairs(baking_map) do
|
|
if minetest.registered_items[recipe] and minetest.registered_items[output] then
|
|
exchangeclone.register_craft({
|
|
type = "baking",
|
|
output = output,
|
|
recipe = recipe,
|
|
})
|
|
end
|
|
end
|
|
exchangeclone.register_craft_type("melting", "shapeless")
|
|
exchangeclone.register_craft({
|
|
type = "melting",
|
|
output = "tech:pane_tray_clear",
|
|
recipe = {"tech:clear_glass_ingot", "tech:pane_tray"},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "melting",
|
|
output = "tech:pane_tray_green",
|
|
recipe = {"tech:green_glass_ingot", "tech:pane_tray"},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "melting",
|
|
output = "tech:pane_clear",
|
|
recipe = {"tech:clear_glass_ingot"},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "melting",
|
|
output = "tech:pane_green",
|
|
recipe = {"tech:green_glass_ingot"},
|
|
})
|
|
local fire_kinds = {
|
|
["tech:small_wood_fire"] = {
|
|
unlit = "tech:small_wood_fire_unlit",
|
|
extinguished = "tech:small_wood_fire_ext",
|
|
smoldering = "tech:small_wood_fire_smoldering",
|
|
charcoal_fire = "tech:small_charcoal_fire",
|
|
},
|
|
["tech:large_wood_fire"] = {
|
|
unlit = "tech:large_wood_fire_unlit",
|
|
extinguished = "tech:large_wood_fire_ext",
|
|
smoldering = "tech:large_wood_fire_smoldering",
|
|
charcoal_fire = "tech:large_charcoal_fire",
|
|
},
|
|
["tech:small_charcoal_fire"] = {
|
|
unlit = "tech:charcoal",
|
|
extinguished = "tech:small_charcoal_fire_ext",
|
|
smoldering = "tech:small_charcoal_fire_smoldering",
|
|
},
|
|
["tech:large_charcoal_fire"] = {
|
|
unlit = "tech:charcoal_block",
|
|
extinguished = "tech:large_charcoal_fire_ext",
|
|
smoldering = "tech:large_charcoal_fire_smoldering",
|
|
},
|
|
["tech:lantern_lit"] = {
|
|
unlit = "tech:lantern_unlit",
|
|
extinguished = "tech:lantern_unlit",
|
|
},
|
|
["tech:clay_oil_lamp"] = {
|
|
unlit = "tech:clay_oil_lamp_unlit",
|
|
},
|
|
}
|
|
exchangeclone.register_craft_type("start_fire", "cooking")
|
|
exchangeclone.register_craft_type("extinguish_fire", "cooking", true)
|
|
exchangeclone.register_craft_type("to_smoldering", "cooking", true)
|
|
exchangeclone.register_craft_type("to_charcoal", "cooking")
|
|
for name, fire_kind in pairs(fire_kinds) do
|
|
exchangeclone.register_craft({
|
|
type = "start_fire",
|
|
output = name,
|
|
recipe = fire_kind.unlit,
|
|
})
|
|
if fire_kind.extinguished then
|
|
exchangeclone.register_craft({
|
|
type = "extinguish_fire",
|
|
output = fire_kind.extinguished,
|
|
recipe = name,
|
|
})
|
|
end
|
|
if fire_kind.smoldering then
|
|
exchangeclone.register_craft({
|
|
type = "to_smoldering",
|
|
output = fire_kind.smoldering,
|
|
recipe = name,
|
|
})
|
|
end
|
|
if fire_kind.charcoal_fire then
|
|
exchangeclone.register_craft({
|
|
type = "to_charcoal",
|
|
output = fire_kinds[fire_kind.charcoal_fire].unlit,
|
|
recipe = fire_kind.smoldering,
|
|
})
|
|
end
|
|
end
|
|
|
|
exchangeclone.register_craft_type("hammer_place", "cooking")
|
|
exchangeclone.register_craft({
|
|
type = "hammer_place",
|
|
output = "tech:hammer_basalt_placed",
|
|
recipe = "tech:hammer_basalt",
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "hammer_place",
|
|
output = "tech:hammer_granite_placed",
|
|
recipe = "tech:hammer_granite",
|
|
})
|
|
exchangeclone.register_craft_type("soaking", "cooking")
|
|
exchangeclone.register_craft({
|
|
type = "soaking",
|
|
output = "tech:retted_cana_bundle",
|
|
recipe = "tech:unretted_cana_bundle",
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "soaking",
|
|
output = "tech:maraka_flour",
|
|
recipe = "tech:maraka_flour_bitter",
|
|
})
|
|
--@type string[]
|
|
local liquid_containers = {
|
|
"tech:clay_water_pot",
|
|
"tech:wooden_water_pot",
|
|
"tech:glass_bottle_green",
|
|
"tech:glass_bottle_clear",
|
|
"tech:clay_watering_can",
|
|
}
|
|
|
|
---@class LiquidKind
|
|
---@field container_suffixes string[]
|
|
---@field source string
|
|
---@field ice? string
|
|
---@field water? true
|
|
|
|
---@type table<string, LiquidKind>
|
|
local liquid_kinds = {
|
|
freshwater = {
|
|
container_suffixes = {"_freshwater"},
|
|
source = "nodes_nature:freshwater_source",
|
|
ice = "nodes_nature:ice",
|
|
water = true,
|
|
},
|
|
salt_water = {
|
|
container_suffixes = {"_salt_water", "_saltwater"},
|
|
source = "nodes_nature:salt_water_source",
|
|
ice = "nodes_nature:sea_ice",
|
|
water = true,
|
|
},
|
|
potash = {
|
|
container_suffixes = {"_potash"},
|
|
source = "tech:potash_source",
|
|
}
|
|
}
|
|
exchangeclone.register_craft_type("make_ag_depleted", "cooking")
|
|
exchangeclone.register_craft_type("ag_soil_to_soil", "cooking")
|
|
exchangeclone.register_craft_type("wetten", "shapeless")
|
|
---@param name string|nil
|
|
---@param wet_name string|nil
|
|
---@param liquid_kind LiquidKind
|
|
local function register_wetten(name, wet_name, liquid_kind)
|
|
if not name or not wet_name then
|
|
return
|
|
end
|
|
for _, container_suffix in ipairs(liquid_kind.container_suffixes) do
|
|
local filled = liquid_containers[1]..container_suffix
|
|
if minetest.registered_craftitems[filled] then
|
|
exchangeclone.register_craft({
|
|
type = "wetten",
|
|
output = wet_name,
|
|
recipe = {name, filled},
|
|
replacements = {{filled, liquid_containers[1]}},
|
|
})
|
|
end
|
|
end
|
|
end
|
|
---@param name string|nil
|
|
---@param ag_depleted string|nil
|
|
local function register_make_ag_depleted(name, ag_depleted)
|
|
if not name or not ag_depleted then
|
|
return
|
|
end
|
|
exchangeclone.register_craft({
|
|
type = "make_ag_depleted",
|
|
output = ag_depleted,
|
|
recipe = name,
|
|
})
|
|
end
|
|
---@param ag string|nil
|
|
---@param soil string|nil
|
|
local function register_ag_soil_to_soil(ag, soil)
|
|
if not ag or not soil then
|
|
return
|
|
end
|
|
exchangeclone.register_craft({
|
|
type = "ag_soil_to_soil",
|
|
output = soil,
|
|
recipe = ag,
|
|
})
|
|
end
|
|
for name, sediment in pairs(sediments) do
|
|
register_wetten(name, sediment.wet, liquid_kinds.freshwater)
|
|
register_wetten(name, sediment.wet_salty, liquid_kinds.salt_water)
|
|
register_wetten(sediment.ag, sediment.ag_wet, liquid_kinds.freshwater)
|
|
register_wetten(sediment.ag_depleted, sediment.ag_wet_depleted, liquid_kinds.freshwater)
|
|
for _, soil in ipairs(sediment.soils or {}) do
|
|
register_wetten(soil.soil, soil.soil_wet, liquid_kinds.freshwater)
|
|
register_ag_soil_to_soil(sediment.ag, soil.soil)
|
|
end
|
|
register_make_ag_depleted(name, sediment.ag_depleted)
|
|
end
|
|
exchangeclone.register_craft_type("thawing", "cooking", true)
|
|
exchangeclone.register_craft_type("fill_water_pot", "shapeless")
|
|
for _, liquid_kind in pairs(liquid_kinds) do
|
|
if liquid_kind.ice then
|
|
exchangeclone.register_craft({
|
|
type = "thawing",
|
|
output = liquid_kind.source,
|
|
recipe = liquid_kind.ice,
|
|
})
|
|
end
|
|
for _, container in ipairs(liquid_containers) do
|
|
for _, container_suffix in ipairs(liquid_kind.container_suffixes) do
|
|
local filled = container..container_suffix
|
|
if minetest.registered_items[filled] then
|
|
exchangeclone.register_craft({
|
|
type = "fill_water_pot",
|
|
output = filled,
|
|
recipe = {container, liquid_kind.source},
|
|
})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
exchangeclone.register_craft_type("make_potash_source", "shapeless")
|
|
exchangeclone.register_craft({
|
|
type = "make_potash_source",
|
|
output = liquid_kinds.potash.source,
|
|
recipe = {"tech:wood_ash_block", liquid_kinds.freshwater.source},
|
|
})
|
|
exchangeclone.register_craft_type("make_potash", "shapeless")
|
|
exchangeclone.register_craft({
|
|
type = "make_potash",
|
|
output = "tech:dry_potash_pot",
|
|
recipe = {"tech:clay_water_pot_potash"},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "make_potash",
|
|
output = "tech:potash",
|
|
recipe = {"tech:clay_water_pot_potash"},
|
|
replacements = {{"tech:clay_water_pot_potash", "tech:clay_water_pot"}},
|
|
})
|
|
exchangeclone.register_craft_type("transporter_activate", "cooking")
|
|
exchangeclone.register_craft({
|
|
type = "transporter_activate",
|
|
output = "artifacts:transporter_pad_active",
|
|
recipe = "artifacts:transporter_pad_charging",
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "transporter_activate",
|
|
output = "artifacts:transporter_pad_charging",
|
|
recipe = "artifacts:transporter_pad",
|
|
})
|
|
exchangeclone.register_craft_type("make_latern", "shapeless")
|
|
exchangeclone.register_craft({
|
|
type = "make_latern",
|
|
output = "tech:lantern_case_wick",
|
|
recipe = {"tech:lantern_case", "tech:coarse_fibre"},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "make_latern",
|
|
output = "tech:lantern_case_glass",
|
|
recipe = {"tech:lantern_case", "tech:pane_clear"},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "make_latern",
|
|
output = "tech:lantern_unlit",
|
|
recipe = {"tech:lantern_case_wick", "tech:pane_clear"},
|
|
})
|
|
exchangeclone.register_craft_type("dye_crafting", "shapeless")
|
|
for name, color_data in pairs(exchangeclone.colors) do
|
|
exchangeclone.register_craft({
|
|
type = "make_latern",
|
|
output = color_data.dye.." 2",
|
|
recipe = {"ncrafting:bundle_treated_"..name},
|
|
})
|
|
end
|
|
exchangeclone.register_craft_type("lime_slaking", "shapeless")
|
|
exchangeclone.register_craft({
|
|
type = "lime_slaking",
|
|
output = "tech:slaked_lime",
|
|
recipe = {"tech:quicklime", liquid_kinds.freshwater.source},
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "lime_slaking",
|
|
output = "tech:slaked_lime_ruined",
|
|
recipe = {"tech:quicklime", liquid_kinds.salt_water.source},
|
|
})
|
|
exchangeclone.register_craft_type("fermenting", "cooking")
|
|
exchangeclone.register_craft({
|
|
type = "fermenting",
|
|
output = "tech:tang",
|
|
recipe = "tech:tang_unfermented",
|
|
})
|
|
exchangeclone.register_craft({
|
|
type = "fermenting",
|
|
output = "tech:wooden_tang",
|
|
recipe = "tech:wooden_tang_unfermented",
|
|
})
|