diff --git a/df_caverns/init.lua b/df_caverns/init.lua index db2876c..ceeee01 100644 --- a/df_caverns/init.lua +++ b/df_caverns/init.lua @@ -1,11 +1,10 @@ df_caverns = {} +df_caverns.config = df_dependencies.config --grab a shorthand for the filepath of the mod local modpath = minetest.get_modpath(minetest.get_current_modname()) --load companion lua files -dofile(modpath.."/config.lua") - dofile(modpath.."/node_ids.lua") dofile(modpath.."/shared.lua") diff --git a/df_caverns/config.lua b/df_dependencies/config.lua similarity index 86% rename from df_caverns/config.lua rename to df_dependencies/config.lua index 84bbbb0..f3a484f 100644 --- a/df_caverns/config.lua +++ b/df_dependencies/config.lua @@ -1,6 +1,8 @@ local CONFIG_FILE_PREFIX = "dfcaverns_" -df_caverns.config = {} +local config = {} +df_dependencies.config = config + local print_settingtypes = false @@ -16,7 +18,7 @@ local function setting(stype, name, default, description) if value == nil then value = default end - df_caverns.config[name] = value + config[name] = value if print_settingtypes then minetest.debug(CONFIG_FILE_PREFIX..name.." ("..description..") "..stype.." "..tostring(default)) @@ -38,14 +40,14 @@ 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") -df_caverns.config.enable_oil_sea = df_caverns.config.enable_oil_sea and minetest.get_modpath("oil") ~= nil +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") -df_caverns.config.enable_underworld = df_caverns.config.enable_underworld and minetest.get_modpath("df_underworld_items") ~= nil +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") diff --git a/df_dependencies/init.lua b/df_dependencies/init.lua index 2b2be5c..b0c6b04 100644 --- a/df_dependencies/init.lua +++ b/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") diff --git a/df_dependencies/mapgen.lua b/df_dependencies/mapgen.lua index 68fe7a0..c45a0c5 100644 --- a/df_dependencies/mapgen.lua +++ b/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 diff --git a/df_dependencies/nodes.lua b/df_dependencies/nodes.lua index cfc26fe..b6ccd51 100644 --- a/df_dependencies/nodes.lua +++ b/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") diff --git a/df_dependencies/ores.lua b/df_dependencies/ores.lua deleted file mode 100644 index c9afca9..0000000 --- a/df_dependencies/ores.lua +++ /dev/null @@ -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 \ No newline at end of file diff --git a/df_caverns/settingtypes.txt b/df_dependencies/settingtypes.txt similarity index 100% rename from df_caverns/settingtypes.txt rename to df_dependencies/settingtypes.txt diff --git a/df_mapitems/castle_coral.lua b/df_mapitems/castle_coral.lua index c460f0e..a59d67d 100644 --- a/df_mapitems/castle_coral.lua +++ b/df_mapitems/castle_coral.lua @@ -51,6 +51,7 @@ df_mapitems.spawn_castle_coral = function(area, data, vi, iterations) local zstride = area.zstride local ystride = area.ystride while run > 0 do + -- TODO should this be checking for not-water instead of stone? if math.random() > 0.95 or data[index] == c_stone or not area:containsi(index) then return end data[index] = c_coral if iterations > 2 then