mirror of
https://github.com/FaceDeer/dfcaverns.git
synced 2024-11-17 16:08:23 +01:00
455 lines
15 KiB
Lua
455 lines
15 KiB
Lua
local c_water = df_caverns.node_id.water
|
|
local c_air = df_caverns.node_id.air
|
|
local c_dirt = df_caverns.node_id.dirt
|
|
local c_dirt_moss = df_caverns.node_id.dirt_moss
|
|
local c_sand = df_caverns.node_id.sand
|
|
local c_gravel = df_caverns.node_id.gravel
|
|
local c_wet_flowstone = df_caverns.node_id.wet_flowstone
|
|
local c_dry_flowstone = df_caverns.node_id.dry_flowstone
|
|
local c_lava = df_caverns.node_id.lava
|
|
local c_obsidian = df_caverns.node_id.obsidian
|
|
|
|
local chasms_path = minetest.get_modpath("chasms")
|
|
|
|
local log_location
|
|
if mapgen_helper.log_location_enabled then
|
|
log_location = mapgen_helper.log_first_location
|
|
end
|
|
|
|
local c_coral_table = {}
|
|
for node_name, node_def in pairs(minetest.registered_nodes) do
|
|
if minetest.get_item_group(node_name, "dfcaverns_cave_coral") > 0 then
|
|
table.insert(c_coral_table, minetest.get_content_id(node_name))
|
|
end
|
|
end
|
|
|
|
local towergoblin_shrublist
|
|
local fungispore_shrublist
|
|
|
|
if minetest.get_modpath("df_farming") then
|
|
towergoblin_shrublist = {
|
|
df_farming.spawn_plump_helmet_vm,
|
|
df_farming.spawn_plump_helmet_vm,
|
|
df_farming.spawn_dimple_cup_vm,
|
|
df_farming.spawn_dead_fungus_vm,
|
|
df_farming.spawn_cavern_fungi_vm,
|
|
}
|
|
fungispore_shrublist = {
|
|
df_farming.spawn_pig_tail_vm,
|
|
df_farming.spawn_sweet_pod_vm,
|
|
df_farming.spawn_cave_wheat_vm,
|
|
df_farming.spawn_cave_wheat_vm,
|
|
df_farming.spawn_dead_fungus_vm,
|
|
df_farming.spawn_cavern_fungi_vm,
|
|
}
|
|
end
|
|
|
|
------------------------------------------------------------------------------------------
|
|
|
|
local perlin_cave_sunless_sea = {
|
|
offset = 0,
|
|
scale = 1,
|
|
spread = {x=df_caverns.config.horizontal_cavern_scale * 2, y=df_caverns.config.vertical_cavern_scale * 0.5, z=df_caverns.config.horizontal_cavern_scale * 2},
|
|
seed = -400000000089,
|
|
octaves = 3,
|
|
persist = 0.67
|
|
}
|
|
|
|
local perlin_wave_sunless_sea = {
|
|
offset = 0,
|
|
scale = 1,
|
|
spread = {x=df_caverns.config.horizontal_cavern_scale * 4, y=df_caverns.config.vertical_cavern_scale * 0.5, z=df_caverns.config.horizontal_cavern_scale * 4}, -- squashed 2:1
|
|
seed = 59033,
|
|
octaves = 6,
|
|
persist = 0.63
|
|
}
|
|
|
|
local perlin_cave_rivers = {
|
|
offset = 0,
|
|
scale = 1,
|
|
spread = {x=400, y=400, z=400},
|
|
seed = -400000000089,
|
|
octaves = 3,
|
|
persist = 0.67,
|
|
flags = "", -- remove "eased" flag, makes the paths of rivers a bit jaggedier and more interesting that curvy smooth paths
|
|
}
|
|
|
|
-- large-scale rise and fall to make the seam between roof and floor less razor-flat and make the rivers shallower and deeper in various places
|
|
local perlin_wave_rivers = {
|
|
offset = 0,
|
|
scale = 1,
|
|
spread = {x=800, y=800, z=800},
|
|
seed = -4000089,
|
|
octaves = 3,
|
|
persist = 0.67,
|
|
}
|
|
|
|
local sea_level = df_caverns.config.level3_min - (df_caverns.config.level3_min - df_caverns.config.sunless_sea_min) * 0.5
|
|
|
|
local floor_mult = 100
|
|
local floor_displace = -10
|
|
local ceiling_mult = -200
|
|
local ceiling_displace = 20
|
|
local wave_mult = 7
|
|
local ripple_mult = 15
|
|
local y_max_river = sea_level + 2*wave_mult + ceiling_displace + ripple_mult
|
|
local y_min_river = sea_level - 2*wave_mult + floor_displace
|
|
|
|
local hot_zone_boundary = 70
|
|
local middle_zone_boundary = 50
|
|
local cool_zone_boundary = 30
|
|
|
|
df_caverns.register_biome_check(function(pos, heat, humidity)
|
|
if pos.y < df_caverns.config.sunless_sea_min or pos.y >= df_caverns.config.level3_min then
|
|
return nil
|
|
end
|
|
if pos.y < sea_level then
|
|
return "sunless undersea"
|
|
elseif heat > hot_zone_boundary then
|
|
return "barren" -- hot zone
|
|
elseif heat > middle_zone_boundary then
|
|
return "fungispore"
|
|
elseif heat > cool_zone_boundary then
|
|
return "towergoblin"
|
|
else
|
|
return "barren" -- cool zone
|
|
end
|
|
end)
|
|
|
|
local towergoblin_cavern_floor = function(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
local ystride = area.ystride
|
|
if abs_cracks < 0.1 then
|
|
df_caverns.stalagmites(abs_cracks, vert_rand, vi, area, data, data_param2, true)
|
|
elseif data[vi-ystride] ~= c_air and data[vi-ystride] ~= c_water then -- leave the ground as rock if it's only one node thick
|
|
if math.random() < 0.25 then
|
|
data[vi] = c_dirt
|
|
else
|
|
data[vi] = c_dirt_moss
|
|
end
|
|
if math.random() < 0.1 then
|
|
df_caverns.place_shrub(vi+ystride, area, data, data_param2, towergoblin_shrublist)
|
|
elseif abs_cracks > 0.25 then
|
|
if math.random() < 0.01 then
|
|
df_trees.spawn_tower_cap_vm(vi+ystride, area, data)
|
|
elseif math.random() < 0.01 then
|
|
df_trees.spawn_goblin_cap_vm(vi+ystride, area, data, data_param2)
|
|
elseif math.random() < 0.02 then
|
|
df_trees.spawn_spindlestem_vm(vi+ystride, area, data, data_param2)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local fungispore_cavern_floor = function(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
local ystride = area.ystride
|
|
if abs_cracks < 0.1 then
|
|
df_caverns.stalagmites(abs_cracks, vert_rand, vi, area, data, data_param2, true)
|
|
elseif data[vi-ystride] ~= c_air and data[vi-ystride] ~= c_water then -- leave the ground as rock if it's only one node thick
|
|
if math.random() < 0.25 then
|
|
data[vi] = c_dirt
|
|
else
|
|
data[vi] = c_dirt_moss
|
|
end
|
|
if math.random() < 0.1 then
|
|
df_caverns.place_shrub(vi+ystride, area, data, data_param2, fungispore_shrublist)
|
|
elseif abs_cracks > 0.35 then
|
|
if math.random() < 0.025 then
|
|
df_trees.spawn_fungiwood_vm(vi+ystride, area, data)
|
|
elseif math.random() < 0.025 then
|
|
df_trees.spawn_spore_tree_vm(vi+ystride, area, data, data_param2)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local cool_zone_ceiling = function(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
if abs_cracks < 0.1 then
|
|
df_caverns.stalactites(abs_cracks, vert_rand, vi, area, data, data_param2, false)
|
|
end
|
|
end
|
|
|
|
local hot_zone_ceiling = function(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
-- dry zone ceiling, add crystals
|
|
if abs_cracks < 0.1 then
|
|
df_caverns.stalactites(abs_cracks, vert_rand, vi, area, data, data_param2, false)
|
|
end
|
|
if abs_cracks > 0.3 and math.random() < 0.005 then
|
|
df_mapitems.place_big_crystal_cluster(area, data, data_param2, vi, math.random(0,3), true)
|
|
end
|
|
end
|
|
|
|
local cool_zone_floor = df_caverns.dry_cavern_floor
|
|
|
|
local hot_zone_floor = function(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
if abs_cracks < 0.075 then
|
|
df_caverns.stalagmites(abs_cracks, vert_rand, vi, area, data, data_param2, false)
|
|
elseif abs_cracks > 0.3 and math.random() < 0.005 then
|
|
df_mapitems.place_big_crystal_cluster(area, data, data_param2, vi+area.ystride, math.random(0,2), false)
|
|
end
|
|
end
|
|
|
|
|
|
local decorate_sunless_sea = function(minp, maxp, seed, vm, node_arrays, area, data)
|
|
math.randomseed(minp.x + minp.y*2^8 + minp.z*2^16 + seed) -- make decorations consistent between runs
|
|
|
|
local heatmap = minetest.get_mapgen_object("heatmap")
|
|
local data_param2 = df_caverns.data_param2
|
|
vm:get_param2_data(data_param2)
|
|
local nvals_cracks = mapgen_helper.perlin2d("df_cavern:cracks", minp, maxp, df_caverns.np_cracks)
|
|
|
|
local minp_below = minp.y <= sea_level
|
|
local maxp_above = maxp.y > sea_level
|
|
|
|
local nvals_cave = mapgen_helper.perlin2d("df_caverns:sunless_sea", minp, maxp, perlin_cave_rivers) --cave noise for structure
|
|
local nvals_wave = mapgen_helper.perlin2d("df_caverns:sunless_sea_wave", minp, maxp, perlin_wave_rivers) --cave noise for structure
|
|
|
|
local skip_next = false -- mapgen is proceeding upward on the y axis,
|
|
--if this is true it skips a step to allow for things to be placed above the floor
|
|
|
|
-- creates "river" caverns
|
|
for vi, x, y, z in area:iterp_yxz(minp, maxp) do
|
|
if not skip_next then
|
|
if y < y_max_river and y > y_min_river then
|
|
local index2d = mapgen_helper.index2d(minp, maxp, x, z)
|
|
local abs_cave = math.abs(nvals_cave[index2d])
|
|
local wave = nvals_wave[index2d] * wave_mult
|
|
local cracks = nvals_cracks[index2d]
|
|
|
|
local ripple = cracks * ((y - y_min_river) / (y_max_river - y_min_river)) * ripple_mult
|
|
|
|
-- above floor and below ceiling
|
|
local floor_height = math.floor(abs_cave * floor_mult + sea_level + floor_displace + wave)
|
|
local ceiling_height = math.floor(abs_cave * ceiling_mult + sea_level + ceiling_displace + wave + ripple)
|
|
|
|
-- deal with lava
|
|
if y <= floor_height and y > floor_height - 3 and y < sea_level + 5 and data[vi] == c_lava then
|
|
data[vi] = c_obsidian
|
|
end
|
|
|
|
if y == floor_height and y < sea_level and not mapgen_helper.buildable_to(data[vi]) then
|
|
if cracks > 0.2 then
|
|
data[vi] = c_sand
|
|
if cracks > 0.5 then
|
|
data[vi+area.ystride] = c_sand
|
|
skip_next = true
|
|
end
|
|
else
|
|
data[vi] = c_gravel
|
|
end
|
|
elseif y > floor_height and y < ceiling_height and data[vi] ~= c_wet_flowstone then
|
|
data[vi] = c_air
|
|
if log_location then log_location("sunless_sea_river", vector.new(x,y,z)) end
|
|
elseif y == ceiling_height and not mapgen_helper.buildable_to(data[vi]) then
|
|
df_caverns.glow_worm_cavern_ceiling(math.abs(cracks),
|
|
mapgen_helper.xz_consistent_randomi(area, vi), vi, area, data, data_param2)
|
|
end
|
|
|
|
-- Deal with lava
|
|
if y >= ceiling_height and y < ceiling_height + 5 and y > sea_level - 5 and data[vi] == c_lava then
|
|
data[vi] = c_obsidian
|
|
end
|
|
end
|
|
else
|
|
skip_next = false
|
|
end
|
|
end
|
|
|
|
if minp.y <= sea_level then
|
|
for vi, x, y, z in area:iterp_yxz(area.MinEdge, area.MaxEdge) do
|
|
-- convert all air below sea level into water
|
|
if y <= sea_level and data[vi] == c_air then
|
|
data[vi] = c_water
|
|
end
|
|
end
|
|
end
|
|
|
|
|
|
---------------------------------------------------------
|
|
-- Cavern floors
|
|
|
|
for _, vi in ipairs(node_arrays.cavern_floor_nodes) do
|
|
local index2d = mapgen_helper.index2di(minp, maxp, area, vi)
|
|
local heat = heatmap[index2d]
|
|
local cracks = nvals_cracks[index2d]
|
|
local abs_cracks = math.abs(cracks)
|
|
local vert_rand = mapgen_helper.xz_consistent_randomi(area, vi)
|
|
local y = area:get_y(vi)
|
|
|
|
-- The vertically squished aspect of these caverns produces too many very thin shelves, this blunts them
|
|
if mapgen_helper.buildable_to(data[vi-area.ystride]) then
|
|
if y <= sea_level then
|
|
data[vi] = c_water
|
|
else
|
|
data[vi] = c_air
|
|
end
|
|
end
|
|
|
|
-- extra test is needed because the rivers can remove nodes that Subterrane marked as floor.
|
|
if not mapgen_helper.buildable_to(data[vi]) then
|
|
if y >= sea_level then
|
|
if heat > hot_zone_boundary then
|
|
hot_zone_floor(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
if log_location then log_location("sunless_sea_hot", area:position(vi)) end
|
|
elseif heat > middle_zone_boundary then
|
|
fungispore_cavern_floor(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
if log_location then log_location("sunless_sea_fungispore", area:position(vi)) end
|
|
elseif heat > cool_zone_boundary then
|
|
towergoblin_cavern_floor(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
if log_location then log_location("sunless_sea_towergoblin", area:position(vi)) end
|
|
else
|
|
cool_zone_floor(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
if log_location then log_location("sunless_sea_cool", area:position(vi)) end
|
|
end
|
|
elseif y >= sea_level - 30 then
|
|
if math.random() < 0.005 then
|
|
df_mapitems.place_snareweed_patch(area, data, vi, data_param2, 6)
|
|
else
|
|
data[vi] = c_dirt
|
|
end
|
|
else
|
|
data[vi] = c_sand
|
|
if math.random() < 0.001 then
|
|
local iterations = math.random(1, 6)
|
|
df_mapitems.spawn_coral_pile(area, data, vi, iterations)
|
|
df_mapitems.spawn_castle_coral(area, data, vi+area.ystride, iterations)
|
|
if log_location then log_location("sunless_sea_castle_coral", area:position(vi)) end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
--------------------------------------
|
|
-- Cavern ceilings
|
|
|
|
for _, vi in ipairs(node_arrays.cavern_ceiling_nodes) do
|
|
local index2d = mapgen_helper.index2di(minp, maxp, area, vi)
|
|
local heat = heatmap[index2d]
|
|
local cracks = nvals_cracks[index2d]
|
|
local abs_cracks = math.abs(cracks)
|
|
local vert_rand = mapgen_helper.xz_consistent_randomi(area, vi)
|
|
local y = area:get_y(vi)
|
|
|
|
if y > sea_level and not mapgen_helper.buildable_to(data[vi]) then
|
|
if heat > hot_zone_boundary then
|
|
hot_zone_ceiling(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
elseif heat > cool_zone_boundary then
|
|
df_caverns.glow_worm_cavern_ceiling(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
else
|
|
cool_zone_ceiling(abs_cracks, vert_rand, vi, area, data, data_param2)
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
----------------------------------------------
|
|
-- Tunnel floors
|
|
|
|
for _, vi in ipairs(node_arrays.tunnel_floor_nodes) do
|
|
if area:get_y(vi) >= sea_level and not mapgen_helper.buildable_to(data[vi]) then
|
|
df_caverns.tunnel_floor(minp, maxp, area, vi, nvals_cracks, data, data_param2, true)
|
|
end
|
|
end
|
|
|
|
------------------------------------------------------
|
|
-- Tunnel ceiling
|
|
|
|
for _, vi in ipairs(node_arrays.tunnel_ceiling_nodes) do
|
|
if area:get_y(vi) > sea_level and not mapgen_helper.buildable_to(data[vi]) then
|
|
df_caverns.tunnel_ceiling(minp, maxp, area, vi, nvals_cracks, data, data_param2, true)
|
|
else
|
|
-- air pockets
|
|
local index2d = mapgen_helper.index2di(minp, maxp, area, vi)
|
|
local cracks = nvals_cracks[index2d]
|
|
local ystride = area.ystride
|
|
if cracks > 0.6 and data[vi-ystride] == c_water then
|
|
data[vi-ystride] = c_air
|
|
if cracks > 0.8 and data[vi-ystride*2] == c_water then
|
|
data[vi-ystride*2] = c_air
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
------------------------------------------------------
|
|
-- Warren ceiling
|
|
|
|
for _, vi in ipairs(node_arrays.warren_ceiling_nodes) do
|
|
if area:get_y(vi) > sea_level and not mapgen_helper.buildable_to(data[vi]) then
|
|
df_caverns.tunnel_ceiling(minp, maxp, area, vi, nvals_cracks, data, data_param2, true)
|
|
else
|
|
-- air pockets
|
|
local index2d = mapgen_helper.index2di(minp, maxp, area, vi)
|
|
local cracks = nvals_cracks[index2d]
|
|
local ystride = area.ystride
|
|
if cracks > 0.6 and data[vi-ystride] == c_water then
|
|
data[vi-ystride] = c_air
|
|
if cracks > 0.8 and data[vi-ystride*2] == c_water then
|
|
data[vi-ystride*2] = c_air
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
----------------------------------------------
|
|
-- Warren floors
|
|
|
|
for _, vi in ipairs(node_arrays.warren_floor_nodes) do
|
|
if area:get_y(vi) >= sea_level and not mapgen_helper.buildable_to(data[vi]) then
|
|
df_caverns.tunnel_floor(minp, maxp, area, vi, nvals_cracks, data, data_param2, true)
|
|
if log_location then log_location("sunless_sea_warren", area:position(vi)) end
|
|
end
|
|
end
|
|
|
|
-- columns
|
|
for _, vi in ipairs(node_arrays.column_nodes) do
|
|
if data[vi] == c_wet_flowstone then
|
|
if area:get_y(vi) > sea_level then
|
|
local index2d = mapgen_helper.index2di(minp, maxp, area, vi)
|
|
local heat = heatmap[index2d]
|
|
if heat > hot_zone_boundary then
|
|
data[vi] = c_dry_flowstone
|
|
end
|
|
else
|
|
data[vi] = c_coral_table[math.random(1,3)]
|
|
data_param2[vi] = math.random(1,4)-1
|
|
minetest.get_node_timer(area:position(vi)):start(math.random(10, 60))
|
|
end
|
|
|
|
if chasms_path then
|
|
local pos = area:position(vi)
|
|
if chasms.is_in_chasm(pos) then
|
|
if pos.y <= sea_level then
|
|
data[vi] = c_water
|
|
else
|
|
data[vi] = c_air
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
vm:set_param2_data(data_param2)
|
|
end
|
|
|
|
--Sunless Sea
|
|
subterrane.register_layer({
|
|
name = "sunless sea",
|
|
y_max = df_caverns.config.level3_min-1,
|
|
y_min = df_caverns.config.sunless_sea_min,
|
|
cave_threshold = df_caverns.config.sunless_sea_threshold,
|
|
perlin_cave = perlin_cave_sunless_sea,
|
|
perlin_wave = perlin_wave_sunless_sea,
|
|
solidify_lava = true,
|
|
columns = {
|
|
maximum_radius = 20,
|
|
minimum_radius = 5,
|
|
node = "df_mapitems:wet_flowstone",
|
|
weight = 0.5,
|
|
maximum_count = 60,
|
|
minimum_count = 10,
|
|
},
|
|
decorate = decorate_sunless_sea,
|
|
double_frequency = false,
|
|
is_ground_content = df_caverns.is_ground_content,
|
|
})
|