bunch of work on mineclone ores, moved main config into df_dependencies

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")

df_dependencies/init.lua

@@ -31,6 +31,7 @@ df_dependencies.select_optional = function(def)
 	return ret
 end
 
+dofile(modpath.."/config.lua")
 dofile(modpath.."/sounds.lua")
 dofile(modpath.."/helper_functions.lua")
 dofile(modpath.."/nodes.lua")

df_dependencies/mapgen.lua

@@ -1,20 +1,31 @@
 local S = minetest.get_translator(minetest.get_current_modname())
 
-local prefix = "dfcaverns_"
--- NOTE: These defaults are from df_caverns' config. Update them if those change.
+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 lowest_elevation = tonumber(minetest.settings:get(prefix.."sunless_sea_min")) or -2512
-if minetest.settings:get_bool(prefix.."enable_oil_sea", true) then
-	lowest_elevation = (tonumber(minetest.settings:get(prefix.."oil_sea_level")) or -2700)
+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 minetest.settings:get_bool(prefix.."enable_lava_sea", true) then
-	lowest_elevation = (tonumber(minetest.settings:get(prefix.."lava_sea_level")) or -2900)
+if config.enable_lava_sea then
+	lowest_elevation = config.lava_sea_level
 end
-if minetest.settings:get_bool(prefix.."enable_underworld", true) then
-	lowest_elevation = (tonumber(minetest.settings:get(prefix.."underworld_level")) or -3200)
+if config.enable_underworld then
+	lowest_elevation = config.underworld_level
 end
-if minetest.settings:get_bool(prefix.."enable_primordial", true) then
-	lowest_elevation = (tonumber(minetest.settings:get(prefix.."primordial_min")) or -4032)
+if config.enable_primordial then
+	lowest_elevation = config.primordial_min
 end
 lowest_elevation = lowest_elevation - 193 -- add a little buffer space
 
@@ -26,19 +37,162 @@ df_dependencies.mods_required.mcl_mapgen = true
 
 local old_overworld_min
 
+local extend_ores = function()
+	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.seed = localseed
+		blob_copy.cluster_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot
+		blob_copy.y_min = ymin or stone_blobs.y_min
+		blob_copy.y_max = ymax or stone_blobs.y_max
+	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)
+		local scattered_copy = deep_copy(scattered_ore)
+		scattered_copy.ore = ore
+		scattered_copy.cluster_size = cluster_size*cluster_size*cluster_size
+		scattered_copy.clust_num_ores = math.ceil(scattered_copy.cluster_size/3)
+		scattered_copy.seed = localseed
+		scattered_copy.cluster_scarcity = cluster_scarcity_cuberoot*cluster_scarcity_cuberoot*cluster_scarcity_cuberoot
+		scattered_copy.threshold = threshold
+		scattered_copy.y_min = ymin or scattered_ore.y_min
+		scattered_copy.y_max = ymax or scattered_ore.y_max
+	end
+	local register_scattered = function(ore, cluster_size, cluster_scarcity_cuberoot, ymin, ymax)
+		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)
+		register_scattered_internal(ore, cluster_size*2, cluster_scarcity_cuberoot, 0.25, ymax)
+	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)
+	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
+	
+	
+	--"mcl_core:stone_with_diamond"
+	if ores_registered["mcl_core:stone_with_gold"] then
+		register_scattered("mcl_core:stone_with_gold", 2, 18)
+	end
+	--"mcl_copper:stone_with_copper"
+
+	-- more blobs
+	--"mcl_deepslate:deepslate"
+	--"mcl_deepslate:tuff"
+
+	-- apparently very rare
+	--"mcl_deepslate:deepslate_with_emerald"
+	--"mcl_core:stone_with_emerald"
+
+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_lava_overworld_max = mcl_vars.mg_overworld_min + 10
 	mcl_vars.mg_end_max = mcl_vars.mg_overworld_min - 2000
-	
-	-- Important note. This doesn't change the values for the various ores and mobs and biomes and whatnot that have already been registered.
-	-- TODO
 
-	dofile(minetest.get_modpath(minetest.get_current_modname()).."/ores.lua")
-	
+	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

df_dependencies/nodes.lua

@@ -1,17 +1,13 @@
 local S = minetest.get_translator(minetest.get_current_modname())
 
+local required_nodes = {}
 local function select_required(...)
 	local newdef = {}
 	for _, node in pairs({...}) do
 		newdef[string.match(node, "(.-):")] = node
 	end
 	local ret = df_dependencies.select_required(newdef)
-	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.
-		assert(minetest.registered_items[ret] ~= nil, "Node " .. ret .. " was returned by a selection call but is not registered.")
-	end)
+	table.insert(required_nodes, ret)
 	return ret
 end
 
@@ -21,14 +17,26 @@ local function select_optional(...)
 		newdef[string.match(node, "(.-):")] = node
 	end
 	local ret = df_dependencies.select_optional(newdef)
-	if ret ~= nil then
-		minetest.after(0, function()
-			assert(minetest.registered_items[ret] ~= nil, "Node " .. ret .. " was returned by an optional selection call but is not registered.")
-		end)
-	end
+	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/ores.lua

@@ -1,8 +0,0 @@
--- copied from mcl_mapgen_core with tweaked altitudes to cover the added depth
-
-if minetest.settings:get_bool("mcl_generate_ores", true) then
-
-
-
-
-end

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