many worldgen mods and gonna try technic now

mods/dfcaverns/df_dependencies/README.md

@@ -0,0 +1,5 @@
+The DF_Caverns modpack was originally written based on the minetest_game. It made extensive use of various nodes and helper functions that came from minetest_game's constituent mods.
+
+When Mineclone games rose in popularity, the task of making it compatible was a daunting one - there were dependencies on minetest_game's mods scattered everywhere. To make the task manageable, I created this mod to serve as a central location where analogous objects could be taken from those games to be referenced in a generic way.
+
+This requires abusing the "dependencies" system of Minetest, unfortunately. This mod is an enormous collection of either/or dependencies - things that can come from either mod A or mod B, but must come from one of them.

mods/dfcaverns/df_dependencies/config.lua

@@ -0,0 +1,59 @@
+local CONFIG_FILE_PREFIX = "dfcaverns_"
+
+local config = {}
+df_dependencies.config = config
+
+
+local print_settingtypes = false
+
+local function setting(stype, name, default, description)
+	local value
+	if stype == "bool" then
+		value = minetest.settings:get_bool(CONFIG_FILE_PREFIX..name, default)
+	elseif stype == "string" then
+		value = minetest.settings:get(CONFIG_FILE_PREFIX..name)
+	elseif stype == "int" or stype == "float" then
+		value = tonumber(minetest.settings:get(CONFIG_FILE_PREFIX..name))
+	end
+	if value == nil then
+		value = default
+	end
+	config[name] = value
+	
+	if print_settingtypes then
+		minetest.debug(CONFIG_FILE_PREFIX..name.." ("..description..") "..stype.." "..tostring(default))
+	end	
+end
+
+--Caverns
+
+setting("float", "vertical_cavern_scale", 256, "Vertical cavern dimension scale")
+setting("float", "horizontal_cavern_scale", 256, "Horizontal cavern dimension scale")
+setting("float", "cavern_threshold", 0.5, "Cavern threshold")
+setting("float", "sunless_sea_threshold", 0.4, "Cavern threshold for sunless seas (higher number means sparser caverns)")
+setting("float", "tunnel_flooding_threshold", 0.25, "Threshold for flooding tunnels around flooded caverns")
+
+setting("int", "ymax", -193, "Upper limit of level 1")
+setting("int", "level1_min", -832, "Upper limit of level 2")
+setting("int", "level2_min", -1472, "Upper limit of level 3")
+setting("int", "level3_min", -2112, "Upper limit of the sunless seas")
+setting("int", "sunless_sea_min", -2512, "Lower limit of the sunless seas")
+
+setting("bool", "enable_oil_sea", true, "Enable oil sea")
+config.enable_oil_sea = config.enable_oil_sea and minetest.get_modpath("oil") ~= nil
+setting("int", "oil_sea_level", -2700, "Oil sea level")
+
+setting("bool", "enable_lava_sea", true, "Enable magma sea")
+setting("int", "lava_sea_level", -2900, "Lava sea level")
+
+setting("bool", "enable_underworld", true, "Enable underworld")
+config.enable_underworld = config.enable_underworld and minetest.get_modpath("df_underworld_items") ~= nil
+setting("int", "underworld_level", -3200, "Underworld level")
+setting("int", "underworld_glowing_pit_mapblocks", 8, "Average pit spacing measured in mapblocks")
+
+setting("bool", "enable_primordial", true, "Enable primordial cavern")
+setting("int", "primordial_max", -3393, "Upper limit to primordial caverns")
+setting("int", "primordial_min", -4032, "Lower limit to primordial caverns")
+
+setting("bool", "restrict_trees_to_biomes", false, "Restrict underground tree growth to their home biomes")
+setting("bool", "restrict_farmables_to_biomes", false, "Restrict underground farmable plant growth to their home biomes")

mods/dfcaverns/df_dependencies/fireflies.lua

@@ -0,0 +1,187 @@
+-- firefly/init.lua
+
+-- Load support for MT game translation.
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local bottle = df_dependencies.node_name_glass_bottle
+
+minetest.register_node("df_dependencies:firefly", {
+	description = S("Firefly"),
+	drawtype = "plantlike",
+	tiles = {{
+		name = "fireflies_firefly_animated.png",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 16,
+			aspect_h = 16,
+			length = 1.5
+		},
+	}},
+	inventory_image = "fireflies_firefly.png",
+	wield_image =  "fireflies_firefly.png",
+	waving = 1,
+	paramtype = "light",
+	sunlight_propagates = true,
+	buildable_to = true,
+	walkable = false,
+	groups = {catchable = 1, destroy_by_lava_flow=1},
+	selection_box = {
+		type = "fixed",
+		fixed = {-0.1, -0.1, -0.1, 0.1, 0.1, 0.1},
+	},
+	light_source = 6,
+	floodable = true,
+	_mcl_blast_resistance = 0.2,
+	_mcl_hardness = 0.2,
+	on_place = function(itemstack, placer, pointed_thing)
+		local player_name = placer:get_player_name()
+		local pos = pointed_thing.above
+
+		if not minetest.is_protected(pos, player_name) and
+				not minetest.is_protected(pointed_thing.under, player_name) and
+				minetest.get_node(pos).name == "air" then
+			minetest.set_node(pos, {name = "df_dependencies:firefly"})
+			minetest.get_node_timer(pos):start(1)
+			itemstack:take_item()
+		end
+		return itemstack
+	end,
+	on_timer = function(pos, elapsed)
+		if minetest.get_node_light(pos) > 11 then
+			minetest.set_node(pos, {name = "df_dependencies:hidden_firefly"})
+		end
+		minetest.get_node_timer(pos):start(30)
+	end
+})
+
+minetest.register_node("df_dependencies:hidden_firefly", {
+	description = S("Hidden Firefly"),
+	drawtype = "airlike",
+	inventory_image = "fireflies_firefly.png^default_invisible_node_overlay.png",
+	wield_image =  "fireflies_firefly.png^default_invisible_node_overlay.png",
+	paramtype = "light",
+	sunlight_propagates = true,
+	walkable = false,
+	pointable = false,
+	diggable = false,
+	buildable_to = true,
+	drop = "",
+	groups = {not_in_creative_inventory = 1, destroy_by_lava_flow=1},
+	floodable = true,
+	_mcl_blast_resistance = 0.2,
+	_mcl_hardness = 0.2,
+	on_place = function(itemstack, placer, pointed_thing)
+		local player_name = placer:get_player_name()
+		local pos = pointed_thing.above
+
+		if not minetest.is_protected(pos, player_name) and
+				not minetest.is_protected(pointed_thing.under, player_name) and
+				minetest.get_node(pos).name == "air" then
+			minetest.set_node(pos, {name = "df_dependencies:hidden_firefly"})
+			minetest.get_node_timer(pos):start(1)
+			itemstack:take_item()
+		end
+		return itemstack
+	end,
+	on_timer = function(pos, elapsed)
+		if minetest.get_node_light(pos) <= 11 then
+			minetest.set_node(pos, {name = "df_dependencies:firefly"})
+		end
+		minetest.get_node_timer(pos):start(30)
+	end
+})
+
+
+-- bug net
+minetest.register_tool("df_dependencies:bug_net", {
+	description = S("Bug Net"),
+	inventory_image = "fireflies_bugnet.png",
+	on_use = function(itemstack, player, pointed_thing)
+		local player_name = player and player:get_player_name() or ""
+		if not pointed_thing or pointed_thing.type ~= "node" or
+				minetest.is_protected(pointed_thing.under, player_name) then
+			return
+		end
+		local node_name = minetest.get_node(pointed_thing.under).name
+		local inv = player:get_inventory()
+		if minetest.get_item_group(node_name, "catchable") == 1 then
+			minetest.set_node(pointed_thing.under, {name = "air"})
+			local stack = ItemStack(node_name.." 1")
+			local leftover = inv:add_item("main", stack)
+			if leftover:get_count() > 0 then
+				minetest.add_item(pointed_thing.under, node_name.." 1")
+			end
+		end
+		if not minetest.is_creative_enabled(player_name) then
+			itemstack:add_wear_by_uses(256)
+			return itemstack
+		end
+	end
+})
+
+minetest.register_craft( {
+	output = "df_dependencies:bug_net",
+	recipe = {
+		{df_dependencies.node_name_string, df_dependencies.node_name_string},
+		{df_dependencies.node_name_string, df_dependencies.node_name_string},
+		{"group:stick", ""}
+	}
+})
+
+
+-- firefly in a bottle
+minetest.register_node("df_dependencies:firefly_bottle", {
+	description = S("Firefly in a Bottle"),
+	inventory_image = "fireflies_bottle.png",
+	wield_image = "fireflies_bottle.png",
+	tiles = {{
+		name = "fireflies_bottle_animated.png",
+		animation = {
+			type = "vertical_frames",
+			aspect_w = 16,
+			aspect_h = 16,
+			length = 1.5
+		},
+	}},
+	drawtype = "plantlike",
+	paramtype = "light",
+	sunlight_propagates = true,
+	light_source = 9,
+	walkable = false,
+	groups = {vessel = 1, dig_immediate = 3, attached_node = 1, material_glass = 1, destroy_by_lava_flow=1},
+	selection_box = {
+		type = "fixed",
+		fixed = {-0.25, -0.5, -0.25, 0.25, 0.3, 0.25}
+	},
+	sounds = df_dependencies.sound_glass(),
+	on_rightclick = function(pos, node, player, itemstack, pointed_thing)
+		local lower_pos = {x = pos.x, y = pos.y + 1, z = pos.z}
+		if minetest.is_protected(pos, player:get_player_name()) or
+				minetest.get_node(lower_pos).name ~= "air" then
+			return
+		end
+
+		local upper_pos = {x = pos.x, y = pos.y + 2, z = pos.z}
+		local firefly_pos
+
+		if not minetest.is_protected(upper_pos, player:get_player_name()) and
+				minetest.get_node(upper_pos).name == "air" then
+			firefly_pos = upper_pos
+		elseif not minetest.is_protected(lower_pos, player:get_player_name()) then
+			firefly_pos = lower_pos
+		end
+
+		if firefly_pos then
+			minetest.add_item(pos, bottle)
+			minetest.set_node(pos, {name = "air"})
+			minetest.set_node(firefly_pos, {name = "df_dependencies:firefly"})
+			minetest.get_node_timer(firefly_pos):start(1)
+		end
+	end
+})
+
+minetest.register_craft( {
+	output = "df_dependencies:firefly_bottle",
+	type = "shapeless",
+	recipe = {"df_dependencies:firefly", bottle},
+})

mods/dfcaverns/df_dependencies/fireflies_license.txt

@@ -0,0 +1,58 @@
+License of source code
+----------------------
+
+The MIT License (MIT)
+Copyright (c) 2018 Shara RedCat
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this
+software and associated documentation files (the "Software"), to deal in the Software
+without restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to permit
+persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
+FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+
+For more details:
+https://opensource.org/licenses/MIT
+
+Licenses of media (textures)
+----------------------------
+
+Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+Copyright (C) 2018 Shara RedCat
+
+You are free to:
+Share — copy and redistribute the material in any medium or format.
+Adapt — remix, transform, and build upon the material for any purpose, even commercially.
+The licensor cannot revoke these freedoms as long as you follow the license terms.
+
+Under the following terms:
+
+Attribution — You must give appropriate credit, provide a link to the license, and
+indicate if changes were made. You may do so in any reasonable manner, but not in any way
+that suggests the licensor endorses you or your use.
+
+ShareAlike — If you remix, transform, or build upon the material, you must distribute
+your contributions under the same license as the original.
+
+No additional restrictions — You may not apply legal terms or technological measures that
+legally restrict others from doing anything the license permits.
+
+Notices:
+
+You do not have to comply with the license for elements of the material in the public
+domain or where your use is permitted by an applicable exception or limitation.
+No warranties are given. The license may not give you all of the permissions necessary
+for your intended use. For example, other rights such as publicity, privacy, or moral
+rights may limit how you use the material.
+
+For more details:
+http://creativecommons.org/licenses/by-sa/3.0/

mods/dfcaverns/df_dependencies/helper_functions.lua

@@ -0,0 +1,218 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+if minetest.get_modpath("default") then
+	df_dependencies.register_leafdecay = default.register_leafdecay
+	df_dependencies.after_place_leaves = default.after_place_leaves
+elseif ("mcl_core") then
+	-- Mineclone does leaf decay differently, it uses the "leafdecay" group to require that leaves remain
+	-- within the group value distance of any node of group "tree".
+	-- make sure to add place_param2 = 1 to leaves to prevent decay of player-placed leaves
+	df_dependencies.register_leafdecay = function() end
+	df_dependencies.after_place_leaves = function() end
+end
+
+
+df_dependencies.mods_required.bucket = true
+df_dependencies.mods_required.mcl_buckets = true
+if minetest.get_modpath("bucket") then
+	df_dependencies.bucket_register_liquid = bucket.register_liquid
+elseif minetest.get_modpath("mcl_buckets") then
+	df_dependencies.bucket_register_liquid = function(source_liquid, flowing_liquid, bucket_node, texture, desc)
+		mcl_buckets.register_liquid({
+			bucketname = bucket_node,
+			source_take = {source_liquid},
+			source_place = source_liquid,
+			inventory_image = texture,
+			name = desc})
+		end
+end
+
+
+-- Note that a circular table reference will result in a crash, TODO: guard against that.
+-- Unlikely to be needed, though - it'd take a lot of work for users to get into this bit of trouble.
+local function deep_copy(table_in)
+	local table_out = {}
+
+	for index, value in pairs(table_in) do
+		if type(value) == "table" then
+			table_out[index] = deep_copy(value)
+		else
+			table_out[index] = value
+		end
+	end
+	return table_out
+end
+
+df_dependencies.mods_required.stairs = true
+df_dependencies.mods_required.moreblocks = true
+df_dependencies.mods_required.doors = true
+df_dependencies.mods_required.mcl_stairs = true
+df_dependencies.mods_required.mcl_fences = true
+df_dependencies.mods_required.mcl_core = true
+
+local node_name_to_stair_properties = function(name, override_def)
+	local mod = minetest.get_current_modname()
+
+	local node_def = minetest.registered_nodes[mod..":"..name]
+	override_def = override_def or {}
+		
+	local node_copy = deep_copy(node_def)
+	for index, value in pairs(override_def) do
+		node_copy[index] = value
+	end
+	return mod, node_copy
+end
+
+df_dependencies.register_stairs = function(name, override_def)
+	local mod, node_copy = node_name_to_stair_properties(name, override_def)
+	if minetest.get_modpath("stairs") and stairs.register_stair_and_slab then
+		stairs.register_stair_and_slab(
+			name,
+			mod ..":" .. name,
+			node_copy.groups,
+			node_copy.tiles,
+			S("@1 Stair", node_copy.description),
+			S("@1 Slab", node_copy.description),
+			node_copy.sounds
+		)
+	end
+	if minetest.get_modpath("mcl_stairs") and mcl_stairs.register_stair_and_slab_simple then
+		mcl_stairs.register_stair_and_slab_simple(
+			name,
+			mod ..":" .. name,
+			S("@1 Stair", node_copy.description),
+			S("@1 Slab", node_copy.description),
+			S("Double @1 Slab", node_copy.description)
+		)
+	end
+end
+
+df_dependencies.register_more_stairs = function(name, override_def)
+	local mod, node_copy = node_name_to_stair_properties(name, override_def)
+	if minetest.get_modpath("moreblocks") and stairsplus.register_all then
+		stairsplus:register_all(mod, name, mod..":"..name, node_copy)
+	end
+end
+
+df_dependencies.register_all_fences = function (name, override_def)
+	local mod, node_def = node_name_to_stair_properties(name, override_def)
+
+	override_def = override_def or {}
+	
+	local material = override_def.material or mod..":"..name
+	local burntime = override_def.burntime
+	local texture = override_def.texture or node_def.tiles[1]
+	
+	if minetest.get_modpath("default") then
+		if default.register_fence then
+			default.register_fence(material .. "_fence", {
+				description = S("@1 Fence", node_def.description),
+				texture = texture,
+				material = material,
+				groups = deep_copy(node_def.groups or {}), -- the default register_fence function modifies the groups table passed in, so send a copy instead to be on the safe side.
+				sounds = node_def.sounds
+			})
+			if burntime then
+				minetest.register_craft({
+					type = "fuel",
+					recipe = material .. "_fence",
+					burntime = burntime, -- ignoring two sticks
+				})
+			end
+		end
+		
+		if default.register_fence_rail then
+			default.register_fence_rail(material .. "_fence_rail", {
+				description = S("@1 Fence Rail", node_def.description),
+				texture = texture,
+				material = material,
+				groups = deep_copy(node_def.groups or {}), -- the default register_fence_rail function modifies the groups table passed in, so send a copy instead to be on the safe side.
+				sounds = node_def.sounds
+			})
+			if burntime then
+				minetest.register_craft({
+					type = "fuel",
+					recipe = material .. "_fence_rail",
+					burntime = burntime * 4/16,
+				})
+			end
+		end
+
+		if default.register_mesepost then
+			default.register_mesepost(material .. "_mese_light", {
+				description = S("@1 Mese Post Light", node_def.description),
+				texture = texture,
+				material = material,
+				groups = deep_copy(node_def.groups or {}), -- the default register_fence_rail function modifies the groups table passed in, so send a copy instead to be on the safe side.
+				sounds = node_def.sounds
+			})
+		end
+	end
+	
+	if minetest.get_modpath("doors") and doors.register_fencegate then
+		doors.register_fencegate(material .. "_fence_gate", {
+			description = S("@1 Fence Gate", node_def.description),
+			texture = texture,
+			material = material,
+			groups = deep_copy(node_def.groups or {}), -- the default register_fence_rail function modifies the groups table passed in, so send a copy instead to be on the safe side.
+			sounds = node_def.sounds
+		})
+		
+		if burntime then
+			minetest.register_craft({
+				type = "fuel",
+				recipe = material .. "_fence_gate_closed",
+				burntime = burntime * 2, -- ignoring four sticks
+			})
+		end
+	end
+	
+	if minetest.get_modpath("mcl_fences") and mcl_fences.register_fence_and_fence_gate then
+		local groups = deep_copy(node_def.groups or {})
+		groups.fence_wood = 1
+		mcl_fences.register_fence_and_fence_gate(name .. "_fence", 
+			S("@1 Fence", node_def.description),
+			S("@1 Fence Gate", node_def.description),
+			texture,
+			groups,
+			node_def._mcl_hardness or minetest.registered_nodes["mcl_core:wood"]._mcl_hardness,
+			node_def._mcl_blast_resistance or minetest.registered_nodes["mcl_core:wood"]._mcl_blast_resistance,
+			{"group:fence_wood"}
+		)
+	end
+end
+
+df_dependencies.register_all_stairs_and_fences = function(name, override_def)
+	df_dependencies.register_stairs(name, override_def)
+	df_dependencies.register_more_stairs(name, override_def)
+	df_dependencies.register_all_fences(name, override_def)
+end
+
+df_dependencies.mods_required.tnt = true
+df_dependencies.mods_required.mcl_explosions = true
+
+if minetest.get_modpath("tnt") then
+	df_dependencies.tnt_boom = tnt.boom
+elseif minetest.get_modpath("mcl_explosions") then
+	df_dependencies.tnt_boom = function(pos, def)
+		local strength = def.radius * 5
+		mcl_explosions.explode(pos, strength)
+	end
+end
+
+df_dependencies.mods_required.mcl_formspec = true
+df_dependencies.get_itemslot_bg = function(X,Y,W,H) return "" end
+df_dependencies.get_itemslot_bg_padded = function(X,Y,W,H) return "" end
+if minetest.get_modpath("mcl_formspec") then
+	df_dependencies.get_itemslot_bg = mcl_formspec.get_itemslot_bg
+	
+	df_dependencies.get_itemslot_bg_padded = function(x,y,w,h, padding)
+		local out = ""
+		for i = 0, w - 1, 1 do
+			for j = 0, h - 1, 1 do
+				out = out .. mcl_formspec.get_itemslot_bg(x+i+(i*padding), y+j+(j*padding), 1, 1)
+			end
+		end
+		return out
+	end
+end

mods/dfcaverns/df_dependencies/init.lua

@@ -0,0 +1,55 @@
+df_dependencies = {}
+local modpath = minetest.get_modpath(minetest.get_current_modname())
+
+df_dependencies.mods_required = {}
+
+df_dependencies.select_required = function(def)
+	local ret
+	for _, dependency in ipairs(def) do
+		local mod = dependency[1]
+		local item = dependency[2]
+		df_dependencies.mods_required[mod] = true
+		if minetest.get_modpath(mod) then
+			ret = item
+		end
+	end
+	assert(ret, "Unable to find item for dependency set " .. dump(def))
+	return ret
+end
+
+df_dependencies.select_optional = function(def)
+	local ret
+	for _, dependency in ipairs(def) do
+		local mod = dependency[1]
+		local item = dependency[2]
+		df_dependencies.mods_required[mod] = true
+		if minetest.get_modpath(mod) then
+			ret = item
+		end
+	end
+	return ret
+end
+
+dofile(modpath.."/config.lua")
+dofile(modpath.."/sounds.lua")
+dofile(modpath.."/helper_functions.lua")
+dofile(modpath.."/nodes.lua")
+dofile(modpath.."/misc.lua")
+dofile(modpath.."/mapgen.lua")
+
+local list_mods_required = function()
+	local mods_required = ""
+	local mods_sorted = {}
+	for mod, _ in pairs(df_dependencies.mods_required) do
+		table.insert(mods_sorted, mod)
+	end
+	table.sort(mods_sorted)
+	for _, mod in ipairs(mods_sorted) do
+		mods_required = mods_required .. ", " .. mod
+	end
+	minetest.debug(mods_required)
+end
+--list_mods_required()
+
+-- This mod is meant to only exist at initialization time. Other mods should make copies of anything it points to for their own use.
+minetest.after(1, function() df_dependencies = nil end)

mods/dfcaverns/df_dependencies/locale/df_dependencies.de.tr

@@ -0,0 +1,27 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Insektennetz
+# textdomain: fireflies
+Firefly=Glühwürmchen
+Firefly in a Bottle=Glühwürmchen in einer Flasche
+Hidden Firefly=Verborgenes Glühwürmchen
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+#WARNING: AUTOTRANSLATED BY GOOGLE TRANSLATE
+@1 Slab=@1 Platte
+#WARNING: AUTOTRANSLATED BY GOOGLE TRANSLATE
+@1 Stair=@1 Treppe
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.eo.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Insekta Reto
+# textdomain: fireflies
+Firefly=Lampiro
+Firefly in a Bottle=Lampiro en Botelo
+Hidden Firefly=Kaŝita Lampiro
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.es.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Red de insectos
+# textdomain: fireflies
+Firefly=Luciérnaga
+Firefly in a Bottle=Luciérnaga en botella
+Hidden Firefly=Luciérnaga oculta
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.fr.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Filet à papillon
+# textdomain: fireflies
+Firefly=Luciole
+Firefly in a Bottle=Luciole en bouteille
+Hidden Firefly=Luciole cachée
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.id.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Jaring Serangga
+# textdomain: fireflies
+Firefly=Kunang-Kunang
+Firefly in a Bottle=Kunang-Kunang dalam Botol
+Hidden Firefly=Kunang-Kunang Tersembunyi
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.it.tr

@@ -0,0 +1,27 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Retino
+# textdomain: fireflies
+Firefly=Lucciola
+Firefly in a Bottle=Lucciola imbottigliata
+Hidden Firefly=Lucciola nascosta
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+#WARNING: AUTOTRANSLATED BY GOOGLE TRANSLATE
+@1 Slab=@1 Lastra
+#WARNING: AUTOTRANSLATED BY GOOGLE TRANSLATE
+@1 Stair=@1 Scala
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=Cappello del Nether

mods/dfcaverns/df_dependencies/locale/df_dependencies.ja.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=虫取り網
+# textdomain: fireflies
+Firefly=ホタル
+Firefly in a Bottle=ホタルの入った瓶
+Hidden Firefly=隠されたホタル
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.jbo.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=lo cinki julne
+# textdomain: fireflies
+Firefly=lo gusycinki
+Firefly in a Bottle=lo gusycinki poi nenri lo botpi
+Hidden Firefly=lo se mipri gusycinki
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.ms.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Jaring Pepijat
+# textdomain: fireflies
+Firefly=Kelip-Kelip
+Firefly in a Bottle=Kelip-Kelip dalam Botol
+Hidden Firefly=Kelip-Kelip Tersembunyi
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.pl.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Siatka na owady
+# textdomain: fireflies
+Firefly=Świetlik
+Firefly in a Bottle=Świetlik w butelce
+Hidden Firefly=Ukryty świetlik
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.pt_BR.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Rede de Insetos
+# textdomain: fireflies
+Firefly=Vaga-lume
+Firefly in a Bottle=Vaga-lume em uma garrafa
+Hidden Firefly=Vaga-lume escondido
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.ru.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Сачок Для Ловли Насекомых
+# textdomain: fireflies
+Firefly=Светлячок
+Firefly in a Bottle=Светлячок в Бутылке
+Hidden Firefly=Притаившийся Светлячок
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.sk.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Sieťka na hmyz
+# textdomain: fireflies
+Firefly=Svetluška
+Firefly in a Bottle=Svetluška vo fľaši
+Hidden Firefly=Skrytá svetluška
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.sv.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Insektshåv
+# textdomain: fireflies
+Firefly=Eldfluga
+Firefly in a Bottle=Eldfluga i en flaska
+Hidden Firefly=Gömd eldfluga
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.uk.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=Сачок Для Ловлі Комах
+# textdomain: fireflies
+Firefly=Світлячок
+Firefly in a Bottle=Світлячок у Пляшці
+Hidden Firefly=Світлячок, що причаївся
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.zh_CN.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=虫网
+# textdomain: fireflies
+Firefly=萤火虫
+Firefly in a Bottle=放在瓶子里的萤火虫
+Hidden Firefly=隐藏的萤火虫
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/df_dependencies.zh_TW.tr

@@ -0,0 +1,25 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=蟲網
+# textdomain: fireflies
+Firefly=螢火蟲
+Firefly in a Bottle=放在瓶子裡的螢火蟲
+Hidden Firefly=隱藏的螢火蟲
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/locale/template.txt

@@ -0,0 +1,24 @@
+# textdomain: df_dependencies
+
+
+### fireflies.lua ###
+
+Bug Net=
+Firefly=
+Firefly in a Bottle=
+Hidden Firefly=
+
+### helper_functions.lua ###
+
+@1 Fence=
+@1 Fence Gate=
+@1 Fence Rail=
+@1 Mese Post Light=
+@1 Slab=
+@1 Stair=
+Double @1 Slab=
+
+### misc.lua ###
+
+Icecap=
+Nethercap=

mods/dfcaverns/df_dependencies/mapgen.lua

@@ -0,0 +1,305 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local function deep_copy(table_in)
+	local table_out = {}
+	for index, value in pairs(table_in) do
+		if type(value) == "table" then
+			table_out[index] = deep_copy(value)
+		else
+			table_out[index] = value
+		end
+	end
+	return table_out
+end
+
+local config = df_dependencies.config
+
+local lowest_elevation = config.sunless_sea_min
+if config.enable_oil_sea then
+	lowest_elevation = config.oil_sea_level
+end
+if config.enable_lava_sea then
+	lowest_elevation = config.lava_sea_level
+end
+if config.enable_underworld then
+	lowest_elevation = config.underworld_level
+end
+if config.enable_primordial then
+	lowest_elevation = config.primordial_min
+end
+lowest_elevation = lowest_elevation - 193 -- add a little buffer space
+
+df_dependencies.mods_required.mcl_init = true
+df_dependencies.mods_required.mcl_worlds = true
+df_dependencies.mods_required.mcl_strongholds = true
+df_dependencies.mods_required.mcl_compatibility = true
+df_dependencies.mods_required.mcl_mapgen = true
+
+local old_overworld_min
+
+local ores_extended = false
+local extend_ores = function()
+	if ores_extended then return end -- should only do this once.
+	ores_extended = true
+	local ores_registered = {}
+	for key, val in pairs(minetest.registered_ores) do
+		ores_registered[val.ore] = true
+	end
+
+	local wherein_stonelike = {"mcl_core:stone"}
+	local localseed = 12345
+	
+	local stone_blobs = {
+		wherein = wherein_stonelike,
+		clust_scarcity = 1000,
+		clust_size = 7,
+		y_min = lowest_elevation,
+		y_max = old_overworld_min,
+		ore_type = "blob",
+		clust_num_ores = 58,
+		noise_params = {
+			octaves = 3,
+			seed = 12345,
+			lacunarity = 2,
+			spread = {
+				y = 250,
+				x = 250,
+				z = 250
+			},
+			persist = 0.6,
+			flags = "defaults",
+			offset = 0,
+			scale = 1
+		},
+	}
+	
+	local register_blob = function(ore, cluster_size, cluster_scarcity_cuberoot, ymin, ymax)
+		localseed = localseed + 1 -- increment this every time it's called to ensure different distributions
+		local blob_copy = deep_copy(stone_blobs)
+		blob_copy.ore = ore
+		blob_copy.clust_num_ores = cluster_size
+		blob_copy.clust_size = math.ceil(math.sqrt(cluster_size))
+		blob_copy.clust_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot
+		blob_copy.seed = localseed
+		blob_copy.y_min = ymin or stone_blobs.y_min
+		blob_copy.y_max = ymax or stone_blobs.y_max
+		--minetest.debug(dump(blob_copy))
+		minetest.register_ore(blob_copy)
+	end
+
+	local scattered_ore = {
+		wherein        = wherein_stonelike,
+		ore_type       = "scatter",
+		--ore            = "mcl_core:stone_with_coal",
+		clust_scarcity = 525*3,
+		clust_num_ores = 5,
+		clust_size     = 3,
+		y_min = lowest_elevation,
+		y_max = old_overworld_min,
+		noise_params   = deep_copy(stone_blobs.noise_params), -- since there's so much volume to scatter ore in, using noise to make some regions "rich" and others "poor" for variety
+		noise_threshold= 0,
+	}
+
+	local register_scattered_internal = function(ore, cluster_size, cluster_scarcity_cuberoot, threshold, ymin, ymax, wherein)
+		local scattered_copy = deep_copy(scattered_ore)
+		scattered_copy.ore = ore
+		scattered_copy.clust_size = cluster_size*cluster_size*cluster_size
+		scattered_copy.clust_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot
+		scattered_copy.clust_num_ores = math.ceil(scattered_copy.clust_size/3)
+		scattered_copy.seed = localseed
+		scattered_copy.threshold = threshold
+		scattered_copy.y_min = ymin or scattered_ore.y_min
+		scattered_copy.y_max = ymax or scattered_ore.y_max
+		scattered_copy.wherein = wherein or scattered_ore.wherein
+		--minetest.debug(dump(scattered_copy))
+		minetest.register_ore(scattered_copy)
+	end
+	local register_scattered = function(ore, cluster_size, cluster_scarcity_cuberoot, ymin, ymax, wherein)
+		assert(not (ymin and ymax) or ymin < ymax, "Elevation parameter error for register_scattered")
+		localseed = localseed + 1 -- increment this every time it's called to ensure different distributions
+		-- same seed makes the noise patterns overlap.
+		-- one produces widespread smaller clusters, other produces larger clusters at the peaks of the noise in addition to the smaller ones
+		register_scattered_internal(ore, cluster_size, cluster_scarcity_cuberoot, 0, ymin, ymax, wherein)
+		register_scattered_internal(ore, cluster_size*2, cluster_scarcity_cuberoot, 0.25, ymin, ymax, wherein)
+	end
+
+	if ores_registered["mcl_core:diorite"] then
+		register_blob("mcl_core:diorite", 58, 10)
+		register_blob("mcl_core:diorite", 33, 15)
+		table.insert(wherein_stonelike, "mcl_core:diorite")
+	end
+	if ores_registered["mcl_core:andesite"] then
+		register_blob("mcl_core:andesite", 58, 10)
+		register_blob("mcl_core:andesite", 33, 15)
+		table.insert(wherein_stonelike, "mcl_core:andesite")
+	end
+	if ores_registered["mcl_core:granite"] then
+		register_blob("mcl_core:granite", 58, 10)
+		register_blob("mcl_core:granite", 33, 15)
+		table.insert(wherein_stonelike, "mcl_core:granite")
+	end
+	if ores_registered["mcl_core:dirt"] then
+		register_blob("mcl_core:dirt", 33, 15, config.sunless_sea_min)
+		if config.enable_primordial then
+			register_blob("mcl_core:dirt", 33, 15, config.primordial_min, config.primoridal_max)
+		end
+	end
+	if ores_registered["mcl_core:gravel"] then
+		register_blob("mcl_core:gravel", 33, 14)
+	end
+
+	if ores_registered["mcl_core:stone_with_iron"] then
+		register_scattered("mcl_core:stone_with_iron", 3, 12)
+	end
+	if ores_registered["mcl_core:stone_with_coal"] then
+		register_scattered("mcl_core:stone_with_coal", 3, 12)
+		if config.enable_oil_sea then
+			register_blob("mcl_core:stone_with_coal", 80, 10, config.oil_sea_level-200, config.oil_sea_level+200) -- tons of coal in the oil sea
+		end
+	end
+	
+	if ores_registered["mcl_core:stone_with_lapis"] then
+		register_scattered("mcl_core:stone_with_lapis", 3, 25, config.sunless_sea_min, config.level3_min) -- Lapis is an ocean gem, I decided
+		if config.enable_primordial then
+			register_scattered("mcl_core:stone_with_lapis", 3, 25, config.primordial_min, config.primordial_max)
+		end
+	end
+	
+	if ores_registered["mcl_core:stone_with_redstone"] then
+		register_scattered("mcl_core:stone_with_redstone", 3, 15, config.level3_min, config.level2_min) -- Level 3 is the most magical, scatter redstone there
+		if config.enable_lava_sea then
+			register_scattered("mcl_core:stone_with_redstone", 4, 15, config.lava_sea_level-200, config.lava_sea_level+100) -- and of course plenty of redstone in the lava sea
+		end
+	end
+	
+	if ores_registered["mcl_core:stone_with_diamond"] then
+		register_scattered("mcl_core:stone_with_diamond", 2, 18, config.sunless_sea_min, config.level2_min)
+		if config.enable_oil_sea then
+			register_scattered("mcl_core:stone_with_diamond", 3, 18, config.oil_sea_level-200, config.oil_sea_level+200)
+		end
+		if config.enable_primordial then
+			register_scattered("mcl_core:stone_with_diamond", 3, 15, config.primordial_min, config.primordial_max)
+		end
+	end
+	
+	if ores_registered["mcl_core:stone_with_gold"] then
+		register_scattered("mcl_core:stone_with_gold", 2, 18)
+		if config.enable_primordial then
+			register_scattered("mcl_core:stone_with_gold", 3, 15, config.primordial_min, config.primordial_max)
+		end
+	end
+
+	if ores_registered["mcl_core:stone_with_copper"] then
+		register_scattered("mcl_core:stone_with_copper", 3, 18)
+	end
+
+	if ores_registered["mcl_deepslate:deepslate"] then
+		register_blob("mcl_deepslate:deepslate", 33, 15, lowest_elevation, config.sunless_sea_min) -- it's called deepslate, so put it deep
+	end
+	if ores_registered["mcl_deepslate:tuff"] then
+		register_blob("mcl_deepslate:tuff", 33, 15, lowest_elevation, config.sunless_sea_min)
+	end
+
+	if ores_registered["mcl_deepslate:deepslate_with_emerald"] then
+		register_scattered("mcl_deepslate:deepslate_with_emerald", 1, 25, lowest_elevation, config.sunless_sea_min, "mcl_deepslate:deepslate")
+	end
+	if ores_registered["mcl_core:stone_with_emerald"] then
+		register_scattered("mcl_core:stone_with_emerald", 1, 25, lowest_elevation, config.sunless_sea_min)
+	end
+
+end
+
+if minetest.get_modpath("mcl_init") then -- Mineclone 2
+	
+	old_overworld_min = mcl_vars.mg_overworld_min -- remember this for weather control
+	
+	mcl_vars.mg_overworld_min = lowest_elevation
+	mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min
+	mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_overworld_min + 4
+	mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min + 10
+	mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000
+	mcl_vars.mg_realm_barrier_overworld_end_max = mcl_vars.mg_end_max
+	mcl_vars.mg_realm_barrier_overworld_end_min = mcl_vars.mg_end_max - 11
+
+	-- try to detect any variables that should have been modified but weren't
+	local bad_entries = {}
+	for k, v in pairs(mcl_vars) do
+		-- if a value is in this range, it's probably a new value added by MineClone2 that we should be adjusting, add it to the table
+		if type(v) == "number" and v <= old_overworld_min + 10 and v >= mcl_vars.mg_overworld_min + 100 then
+			bad_entries[k] = v
+		end
+	end
+
+	-- mark variables as ignored that we intentionally don't change, like so:
+	-- bad_entries.mg_value_that_shouldnt_be_adjusted = nil
+
+	for k, v in pairs(bad_entries) do
+		local new_value = v + mcl_vars.mg_overworld_min - old_overworld_min
+		minetest.log("error", "dfcaverns: variable wasn't modified or marked as ignored! guessing new value:")
+		minetest.log("error", "mcl_var." .. tostring(k) .. " = " .. tostring(new_value) .. " -- was " .. tostring(v))
+		minetest.log("error", "if it shouldn't be changed, mark it as ignored in df_dependencies/mapgen.lua like so:")
+		minetest.log("error", "bad_entries." .. tostring(k) .. " = nil")
+		minetest.log("error", "This is a bug, please report it to https://github.com/FaceDeer/dfcaverns/issues/new")
+		mcl_vars[k] = new_value
+	end
+
+	-- shouldn't need to worry about the setting, extend_ores checks if the ores
+	-- have already been registered.
+	--if minetest.settings:get_bool("mcl_generate_ores", true) then
+		extend_ores()
+	--end
+
+	df_dependencies.mods_required.mcl_structures = true
+	-- never mind - add dependency on mcl_strongholds and these will get generated before overworld_min gets changed.
+	--if minetest.get_modpath("mcl_structures") and minetest.get_modpath("mcl_strongholds") then
+	--	local elevation_delta = old_overworld_min - lowest_elevation
+	--	local strongholds = mcl_structures.get_structure_data("stronghold")
+	--	mcl_structures.register_structure_data("stronghold", strongholds)	
+	--end
+end
+if minetest.get_modpath("mcl_compatibility") then -- Mineclone 5
+	old_overworld_min = mcl_vars.mg_overworld_min -- remember this for weather control
+
+	mcl_vars.mg_overworld_min = lowest_elevation
+	mcl_vars.mg_bedrock_overworld_min = mcl_vars.mg_overworld_min
+	mcl_vars.mg_bedrock_overworld_max = mcl_vars.mg_overworld_min+4
+	mcl_vars.mg_lava_overworld_max = mcl_vars.mg_overworld_min+6
+	mcl_vars.mg_lava = false
+	mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000
+	mcl_vars.mg_realm_barrier_overworld_end_max = mcl_vars.mg_end_max
+	mcl_vars.mg_realm_barrier_overworld_end_min = mcl_vars.mg_end_max-11
+end
+if minetest.get_modpath("mcl_mapgen") then -- Mineclone 5
+	old_overworld_min = mcl_mapgen.overworld.min -- remember this for weather control
+
+	mcl_mapgen.overworld.min = lowest_elevation
+	mcl_mapgen.overworld.bedrock_min = mcl_mapgen.overworld.min
+	mcl_mapgen.overworld.bedrock_max = mcl_mapgen.overworld.bedrock_min + (mcl_mapgen.bedrock_is_rough and 4 or 0)
+	mcl_mapgen.overworld.lava_max = mcl_mapgen.overworld.min+6
+	mcl_mapgen.overworld.railcorridors_height_min = -50
+	mcl_mapgen.overworld.railcorridors_height_max = -2
+	
+	mcl_mapgen.end_.max = mcl_mapgen.overworld.min - 2000
+	mcl_mapgen.realm_barrier_overworld_end_max = mcl_mapgen.end_.max
+	mcl_mapgen.realm_barrier_overworld_end_min = mcl_mapgen.end_.max - 11
+
+	if mcl_mapgen.on_settings_changed then
+		mcl_mapgen.on_settings_changed()
+	else
+		minetest.log("error", "The installed version of the mcl_mapgen mod (part of Mineclone 5) "
+		.."does not have an mcl_mapgen.on_settings_changed method. This will likely result in "
+		.."altitudes below the original bedrock being inaccessible to players.")
+	end
+	
+	extend_ores()
+end
+if minetest.get_modpath("mcl_worlds") then
+	local old_has_weather = mcl_worlds.has_weather
+	mcl_worlds.has_weather = function(pos)
+		-- No weather in the deep caverns
+		if pos.y >= lowest_elevation and pos.y <= old_overworld_min then
+			return false
+		end
+		return old_has_weather(pos)
+	end
+end

mods/dfcaverns/df_dependencies/misc.lua

@@ -0,0 +1,76 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local select_required = df_dependencies.select_required
+local select_optional = df_dependencies.select_optional
+
+df_dependencies.mods_required.farming = true
+
+-- If the farming mod is installed, add the "straw" group to farming straw.
+-- This way goblin caps just need to check for group:straw to get cave straw as well
+local straw_def = minetest.registered_items["farming:straw"]
+if straw_def then
+	local new_groups = {}
+	for group, val in pairs(straw_def.groups) do
+		new_groups[group] = val
+	end
+	new_groups.straw = 1
+	minetest.override_item("farming:straw", {
+		groups = new_groups
+	})
+end
+
+-- used to determine colour of spindlestem caps
+if minetest.get_modpath("default") then
+	df_dependencies.data_iron_containing_nodes = {"default:stone_with_iron", "default:steelblock"}
+	df_dependencies.data_copper_containing_nodes = {"default:stone_with_copper", "default:copperblock"}
+	df_dependencies.data_mese_containing_nodes = {"default:stone_with_mese", "default:mese"}
+elseif minetest.get_modpath("mcl_core") then
+	df_dependencies.data_iron_containing_nodes = {}
+	minetest.after(0, function()
+		for nodename, _ in pairs(minetest.registered_nodes) do
+			if string.find(nodename, "iron") then
+				table.insert(df_dependencies.data_iron_containing_nodes, nodename)
+			end
+		end
+	end)
+	df_dependencies.data_copper_containing_nodes = {}
+	minetest.after(0, function()
+		for nodename, _ in pairs(minetest.registered_nodes) do
+			if string.find(nodename, "copper") then
+				table.insert(df_dependencies.data_copper_containing_nodes, nodename)
+			end
+		end
+	end)
+	df_dependencies.data_mese_containing_nodes = {"mcl_deepslate:deepslate_with_redstone", "mcl_deepslate:deepslate_with_redstone_lit",
+		"mcl_core:stone_with_redstone", "mcl_core:stone_with_redstone_lit", "group:mesecon_conductor_craftable", "group:mesecon", "group:mesecon_effector_off"}
+end
+
+-- common nodes that can be found next to pit plasma, triggering matter degradation
+-- don't trigger on air, that's for sparkle generation
+df_dependencies.abm_pit_plasma_neighbors = {"group:stone", "group:lava", "group:water", "group:material_stone"}
+
+df_dependencies.texture_cobble = select_required({{"default", "default_cobble.png"}, {"mcl_core", "default_cobble.png"}})
+df_dependencies.texture_coral_skeleton = select_required({{"default", "default_coral_skeleton.png"}, {"mcl_ocean", "mcl_ocean_dead_horn_coral_block.png"}})
+df_dependencies.texture_dirt = select_required({{"default", "default_dirt.png"}, {"mcl_core", "default_dirt.png"}})
+df_dependencies.texture_gold_block = select_required({{"default", "default_gold_block.png"}, {"mcl_core", "default_gold_block.png"}})
+df_dependencies.texture_ice = select_required({{"default", "default_ice.png"}, {"mcl_core", "default_ice.png"}})
+df_dependencies.texture_sand = select_required({{"default", "default_sand.png"}, {"mcl_core", "default_sand.png"}})
+df_dependencies.texture_stone = select_required({{"default", "default_stone.png"}, {"mcl_core", "default_stone.png"}})
+df_dependencies.texture_wood = select_required({{"default", "default_wood.png"}, {"mcl_core", "default_wood.png"}})
+df_dependencies.texture_mineral_coal = select_required({{"default", "default_mineral_coal.png"}, {"mcl_core", "mcl_core_coal_ore.png"}}) -- MCL's coal texture isn't transparent, but is only used with gas seeps and should work fine that way
+df_dependencies.texture_glass_bottle = select_required({{"vessels", "vessels_glass_bottle.png"}, {"mcl_potions", "mcl_potions_potion_bottle.png"}})
+df_dependencies.texture_meselamp = "dfcaverns_glow_mese.png"
+
+df_dependencies.texture_tool_steelhoe = select_required({{"default", "farming_tool_steelhoe.png"}, {"mcl_farming", "farming_tool_steelhoe.png"}})
+df_dependencies.texture_tool_steelpick = select_required({{"default", "default_tool_steelpick.png"}, {"mcl_farming", "default_tool_steelpick.png"}})
+df_dependencies.texture_tool_steelshovel = select_required({{"default", "default_tool_steelshovel.png"}, {"mcl_farming", "default_tool_steelshovel.png"}})
+df_dependencies.texture_farming_soil = select_required({{"default", "(default_dirt.png^farming_soil.png)"}, {"mcl_farming", "mcl_farming_farmland_dry.png"}})
+
+df_dependencies.texture_mapping_kit = select_required({{"default", "map_mapping_kit.png"}, {"mcl_maps", "mcl_maps_map_filled.png"}})
+
+df_dependencies.nethercap_name = S("Nethercap")
+if minetest.get_modpath("mcl_mapgen_core") then
+	-- since there's a whole layer called the Nether in Mineclone and it has its own mushrooms, rename
+	-- nethercaps when that's present to avoid confusion.
+	df_dependencies.nethercap_name = S("Icecap")
+end

mods/dfcaverns/df_dependencies/mod.conf

@@ -0,0 +1,5 @@
+name = df_dependencies
+description = A utility mod for df_caverns that gathers all dependencies on minetest_game in one place, to ease cross-compatibility efforts with Minetest Game, MineClone2 and MineClone5.
+depends =
+optional_depends = beds, bucket, default, doors, farming, fireflies, mcl_beds, mcl_buckets, mcl_chests, mcl_compatibility, mcl_copper, mcl_core, mcl_doors, mcl_explosions, mcl_farming, mcl_fences, mcl_formspec, mcl_furnaces, mcl_init, mcl_mapgen, mcl_maps, mcl_mobitems, mcl_ocean, mcl_potions, mcl_sounds, mcl_stairs, mcl_strongholds, mcl_tnt, mcl_torches, mcl_wool, mcl_worlds, mclx_core, mesecons, moreblocks, stairs, tnt, vessels, wool
+supported_games = minetest_game, MineClone2

mods/dfcaverns/df_dependencies/nodes.lua

@@ -0,0 +1,126 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local required_nodes = {}
+local function select_required(def)
+	local newdef = {}
+	for _, node in ipairs(def) do
+		table.insert(newdef, {string.match(node, "(.-):"), node})
+	end
+	local ret = df_dependencies.select_required(newdef)
+	table.insert(required_nodes, ret)
+	return ret
+end
+
+local function select_optional(def)
+	local newdef = {}
+	for _, node in ipairs(def) do
+		table.insert(newdef, {string.match(node, "(.-):"), node})
+	end
+	local ret = df_dependencies.select_optional(newdef)
+	table.insert(required_nodes, ret)
+	return ret
+end
+
+
+minetest.after(0, function()
+	-- "after" needs to be used here because some of these nodes actually get registered in DF Caverns itself
+	-- stair nodes, for example, depend on the stairs mod but get registered from here. Kind of weird but
+	-- one goes to war with the mods one has.
+	local problem_nodes = {}
+	for _, node_name in pairs(required_nodes) do
+		if minetest.registered_items[node_name] == nil then
+			table.insert(problem_nodes, node_name)
+		end
+	end
+	
+	assert(#problem_nodes == 0, "Nodes " .. table.concat(problem_nodes, ", ") .. " were returned by a selection call but are not registered.")
+end)
+
+
+df_dependencies.node_name_apple = select_required({"default:apple", "mcl_core:apple"})
+df_dependencies.node_name_chest = select_required({"default:chest", "mcl_chests:chest"})
+df_dependencies.node_name_coalblock = select_required({"default:coalblock", "mcl_core:coalblock"})
+df_dependencies.node_name_coal_lump = select_required({"default:coal_lump", "mcl_core:coal_lump"})
+df_dependencies.node_name_cobble = select_required({"default:cobble", "mcl_core:cobble"})
+df_dependencies.node_name_coral_skeleton = select_required({"default:coral_skeleton", "mcl_ocean:dead_horn_coral_block"})
+df_dependencies.node_name_desert_sand = select_required({"default:desert_sand", "mcl_core:redsand"})
+df_dependencies.node_name_dirt = select_required({"default:dirt", "mcl_core:dirt"})
+df_dependencies.node_name_dry_grass_3 = select_required({"default:dry_grass_3", "mcl_core:deadbush"})  -- There doesn't seem to be an MCL equivalent of this
+df_dependencies.node_name_dry_grass_4 = select_required({"default:dry_grass_4", "mcl_core:deadbush"}) -- There doesn't seem to be an MCL equivalent of this
+df_dependencies.node_name_dry_shrub = select_required({"default:dry_shrub", "mcl_core:deadbush"})
+df_dependencies.node_name_furnace = select_required({"default:furnace", "mcl_furnaces:furnace"})
+df_dependencies.node_name_gold_ingot = select_required({"default:gold_ingot", "mcl_core:gold_ingot"})
+df_dependencies.node_name_gravel = select_required({"default:gravel", "mcl_core:gravel"})
+df_dependencies.node_name_ice = select_required({"default:ice", "mcl_core:ice"})
+df_dependencies.node_name_junglewood = select_required({"default:junglewood", "mcl_core:junglewood"})
+df_dependencies.node_name_lava_source = select_required({"default:lava_source", "mcl_core:lava_source"})
+df_dependencies.node_name_mese_crystal = select_required({"mesecons:wire_00000000_off", "default:mese_crystal"}) --make sure default:mese_crystal is second, so that default will take priority if mesecons is also installed.
+df_dependencies.node_name_mossycobble = select_required({"default:mossycobble", "mcl_core:mossycobble"})
+df_dependencies.node_name_obsidian = select_required({"default:obsidian", "mcl_core:obsidian"})
+df_dependencies.node_name_paper = select_required({"default:paper", "mcl_core:paper"})
+df_dependencies.node_name_river_water_flowing = select_required({"default:river_water_flowing", "mclx_core:river_water_flowing"})
+df_dependencies.node_name_river_water_source = select_required({"default:river_water_source", "mclx_core:river_water_source"})
+df_dependencies.node_name_sand = select_required({"default:sand", "mcl_core:sand"})
+df_dependencies.node_name_silver_sand = select_required({"default:silver_sand", "mcl_core:sand"}) -- There doesn't seem to be an MCL equivalent of this
+df_dependencies.node_name_snow = select_required({"default:snow", "mcl_core:snow"})
+df_dependencies.node_name_stone = select_required({"default:stone", "mcl_core:stone"})
+df_dependencies.node_name_stone_with_coal = select_required({"default:stone_with_coal", "mcl_core:stone_with_coal"})
+df_dependencies.node_name_stone_with_mese = select_required({"default:stone_with_mese", "mcl_core:stone_with_redstone"})
+df_dependencies.node_name_torch = select_required({"default:torch", "mcl_torches:torch"})
+df_dependencies.node_name_torch_wall = select_required({"default:torch_wall", "mcl_torches:torch_wall"})
+df_dependencies.node_name_water_flowing = select_required({"default:water_flowing", "mcl_core:water_flowing"})
+df_dependencies.node_name_water_source = select_required({"default:water_source", "mcl_core:water_source"})
+df_dependencies.node_name_stone_with_iron = select_required({"default:stone_with_iron", "mcl_core:stone_with_iron"})
+df_dependencies.node_name_steelblock = select_required({"default:steelblock", "mcl_core:ironblock"})
+df_dependencies.node_name_stone_with_copper = select_required({"default:stone_with_copper", "mcl_copper:stone_with_copper"})
+df_dependencies.node_name_copperblock = select_required({"default:copperblock", "mcl_copper:block_raw"})
+
+df_dependencies.node_name_dirt_furrowed = select_required({"farming:soil", "mcl_farming:soil"})
+df_dependencies.node_name_dirt_wet = select_required({"farming:soil_wet", "mcl_farming:soil_wet"})
+--df_dependencies.node_name_mortar_pestle = select_optional({"farming:mortar_pestle"}) -- TODO where did this go?
+df_dependencies.node_name_string = select_required({"farming:string", "mcl_mobitems:string"})
+
+df_dependencies.node_name_bucket_empty = select_required({"bucket:bucket_empty", "mcl_buckets:bucket_empty"})
+df_dependencies.node_name_bucket_lava = select_required({"bucket:bucket_lava", "mcl_buckets:bucket_lava"})
+
+-- from "wool"
+
+df_dependencies.node_name_wool_white = select_required({"wool:white", "mcl_wool:white"})
+
+-- from "fireflies"
+df_dependencies.node_name_fireflies = select_optional({"fireflies:firefly"})
+
+-- from "vessels"
+df_dependencies.node_name_glass_bottle = select_required({"vessels:glass_bottle", "mcl_potions:glass_bottle"})
+df_dependencies.node_name_shelf = select_optional({"vessels:shelf"})
+
+-- from "beds"
+df_dependencies.node_name_bed_bottom = select_required({"beds:bed_bottom", "mcl_beds:bed_red_bottom"})
+df_dependencies.node_name_bed_top = select_required({"beds:bed_top", "mcl_beds:bed_red_top"})
+
+-- from "doors"
+df_dependencies.node_name_door_wood_a = select_required({"doors:door_wood_a", "mcl_doors:wooden_door_b_1"})
+df_dependencies.node_name_door_hidden = select_required({"doors:hidden", "mcl_doors:wooden_door_t_1"})
+
+-- from "stairs"
+
+df_dependencies.node_name_slab_goblin_cap_stem_wood = select_required({"stairs:slab_goblin_cap_stem_wood", "mcl_stairs:slab_goblin_cap_stem_wood"})
+df_dependencies.node_name_slab_slade_brick = select_required({"stairs:slab_slade_brick", "mcl_stairs:slab_slade_brick"})
+df_dependencies.node_name_stair_goblin_cap_stem_wood = select_required({"stairs:stair_goblin_cap_stem_wood", "mcl_stairs:stair_goblin_cap_stem_wood"})
+df_dependencies.node_name_stair_inner_slade_brick = select_required({"stairs:stair_inner_slade_brick", "mcl_stairs:stair_slade_brick_inner"})
+df_dependencies.node_name_stair_outer_slade_brick = select_required({"stairs:stair_outer_slade_brick", "mcl_stairs:stair_slade_brick_outer"})
+df_dependencies.node_name_stair_slade_block = select_required({"stairs:stair_slade_block", "mcl_stairs:stair_slade_block"})
+df_dependencies.node_name_slab_slade_block = select_required({"stairs:slab_slade_block", "mcl_stairs:slab_slade_block"})
+df_dependencies.node_name_stair_slade_brick = select_required({"stairs:stair_slade_brick", "mcl_stairs:stair_slade_brick"})
+df_dependencies.node_name_slab_slade_block_top = select_optional({"mcl_stairs:slab_slade_block_top"})
+
+-- from "tnt"
+
+df_dependencies.node_name_gunpowder = select_optional({"tnt:gunpowder", "mcl_mobitems:gunpowder"})
+
+local modpath = minetest.get_modpath(minetest.get_current_modname())
+
+if not df_dependencies.node_name_fireflies then
+	dofile(modpath.."/fireflies.lua")
+	df_dependencies.node_name_fireflies = "df_dependencies:firefly"
+end

mods/dfcaverns/df_dependencies/settingtypes.txt

@@ -0,0 +1,81 @@
+[Cavern dimensions]
+
+#Note that this doesn't guarantee caverns of this setting's size. This setting
+#affects the scale of features in the perlin noise that is used to build caverns.
+#Most caverns will be smaller than this (and a few might be larger)
+dfcaverns_vertical_cavern_scale (Vertical cavern dimension scale) float 256
+#Note that this doesn't guarantee caverns of this setting's size. This setting
+#affects the scale of features in the perlin noise that is used to build caverns.
+#Most caverns will be smaller than this (and a few might be larger)
+dfcaverns_horizontal_cavern_scale (Horizontal cavern dimension scale) float 256
+#Determines threshold for cave generation. Higher number means sparser, smaller caverns
+dfcaverns_cavern_threshold (Cavern threshold) float 0.5 0.0 1.0
+#Determines threshold for lower sea cave generation. Higher number means sparser, smaller caverns
+dfcaverns_sunless_sea_threshold (Cavern threshold for sunless sea) float 0.4 0.0 1.0
+#Determines how far out water extends into tunnels below the 'sea level' of from flooded
+#caverns. Lower numbers give more flooded tunnel. If this number equals the cavern
+#threshold tunnels will not be flooded at all, if it is 0 then half the tunnels will be flooded.
+dfcaverns_tunnel_flooding_threshold (Tunnel flooding threshold) float 0.25 0.0 1.0
+
+[Cavern depth borders]
+
+#maximum boundary for cavern depths are most efficient when they fit the formula (x*80-32-1)
+#where x is an integer. That way you don't get map blocks that straddle two cavern layers.
+dfcaverns_ymax (Upper limit of level 1) int -193
+#minimum boundaries for cavern depths are most efficient when they fit the formula (x*80-32)
+#where x is an integer. that way you don't get map blocks that straddle two cavern layers.
+dfcaverns_level1_min (Upper limit of level 2) int -832
+dfcaverns_level2_min (Upper limit of level 3) int -1472
+dfcaverns_level3_min (Upper limit of the sunless sea) int -2112
+dfcaverns_sunless_sea_min (Lower limit of the sunless sea) int -2512
+
+[Lower Levels]
+
+dfcaverns_enable_oil_sea (Generate oil sea) bool true
+dfcaverns_oil_sea_level (Oil sea level) int -2700
+
+dfcaverns_enable_lava_sea (Generate magma sea) bool true
+dfcaverns_lava_sea_level (Lava sea level) int -2900
+
+dfcaverns_enable_underworld (Generate underworld) bool true
+dfcaverns_underworld_level (Underworld level) int -3200
+#Set this to 0 to disable glowing pit generation entirely.
+dfcaverns_underworld_glowing_pit_mapblocks(Average pit spacing measured in mapblocks) int 8
+
+[Underworld feature HUD]
+
+dfcaverns_underworld_hud_requires_item (Require an item to view waypoints) bool true
+#Players can still discover the locations of volcanoes without this, but waypoints
+#will only be visible in their hud if they have this item in their inventory. You can also
+#specify "group:groupname" here. Leave it blank to default to map:mapping_kit.
+dfcaverns_underworld_hud_item_required (Specify the item or group required) string map:mapping_kit
+
+dfcaverns_show_pits_in_hud (Show pit locations in HUD) bool true
+dfcaverns_pit_discovery_range (Pit discovery range) int 60
+dfcaverns_pit_visibility_range (Pit visibility range) int 500
+
+dfcaverns_show_seals_in_hud (Seal locations in HUD) bool true
+dfcaverns_seal_discovery_range (Seal discovery range) int 10
+dfcaverns_seal_visibility_range (Seal visibility range) int 200
+
+dfcaverns_show_ruins_in_hud (Ruin locations visible in HUD) bool true
+dfcaverns_ruin_discovery_range (Ruin discovery range) int 40
+dfcaverns_ruin_visibility_range (Ruin visibility range) int 250
+
+[Primordial]
+
+dfcaverns_enable_primordial (Generate primordial caverns) bool true
+dfcaverns_primordial_max (Upper limit of primordial caverns) int -3393
+dfcaverns_primordial_min (Lower limit of primordial caverns) int -4032
+
+# This setting is pretty technical, it spreads out the
+# construction of giant mycelium networks on mapgen
+# over this many seconds. If you're experiencing lag spikes
+# during mapgen of Primordial cavern layer mushroom caverns
+# then increasing this number may help.
+dcaverns_giant_mycelium_timer_spread (Giant Mycelium mapgen timer spread) int 10
+
+[Plant growth restrictions]
+
+dfcaverns_restrict_trees_to_biomes (Restrict underground tree growth to their home biomes) bool false
+dfcaverns_restrict_farmables_to_biomes (Restrict underground farmable plant growth to their home biomes) bool false

mods/dfcaverns/df_dependencies/sounds.lua

@@ -0,0 +1,38 @@
+local S = minetest.get_translator(minetest.get_current_modname())
+
+local select_required = df_dependencies.select_required
+local select_optional = df_dependencies.select_optional
+
+df_dependencies.mods_required.mcl_sounds = true
+
+if minetest.get_modpath("default") then
+	df_dependencies.sound_dirt = default.node_sound_dirt_defaults
+	df_dependencies.sound_glass = default.node_sound_glass_defaults
+	df_dependencies.sound_gravel = default.node_sound_gravel_defaults
+	df_dependencies.sound_leaves = default.node_sound_leaves_defaults
+	df_dependencies.sound_sand = default.node_sound_sand_defaults
+	df_dependencies.sound_stone = default.node_sound_stone_defaults
+	df_dependencies.sound_water = default.node_sound_water_defaults
+	df_dependencies.sound_wood = default.node_sound_wood_defaults
+elseif minetest.get_modpath("mcl_sounds") then
+	df_dependencies.sound_dirt = mcl_sounds.node_sound_dirt_defaults
+	df_dependencies.sound_glass = mcl_sounds.node_sound_glass_defaults
+	df_dependencies.sound_gravel = function(table)
+		table = table or {}
+		table.footstep = table.footstep or {name="default_gravel_footstep", gain=0.45}
+		return mcl_sounds.node_sound_dirt_defaults(table)
+	end
+	df_dependencies.sound_leaves = mcl_sounds.node_sound_leaves_defaults
+	df_dependencies.sound_sand = mcl_sounds.node_sound_sand_defaults
+	df_dependencies.sound_stone = mcl_sounds.node_sound_stone_defaults
+	df_dependencies.sound_water = mcl_sounds.node_sound_water_defaults
+	df_dependencies.sound_wood = mcl_sounds.node_sound_wood_defaults
+else
+	assert(false, "One of [default] or [mcl_sounds] must be active")
+end
+
+df_dependencies.soundfile_grass_footstep = select_required({{"default", "default_grass_footstep"}, {"mcl_sounds", "default_grass_footstep"}})
+df_dependencies.soundfile_snow_footstep = select_required({{"default", "default_snow_footstep"}, {"mcl_sounds", "pedology_snow_soft_footstep"}})
+df_dependencies.soundfile_gravel_footstep = select_required({{"default", "default_gravel_footstep"}, {"mcl_sounds", "default_gravel_footstep"}})
+df_dependencies.soundfile_cool_lava = select_required({{"default", "default_cool_lava"}, {"mcl_sounds", "default_cool_lava"}})
+df_dependencies.soundfile_tnt_ignite = select_required({{"default", "tnt_ignite"}, {"mcl_tnt", "tnt_ignite"}})