306 lines
12 KiB
Lua
306 lines
12 KiB
Lua
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
|