make legacy code not crash when default mod isn't present. Remove the old cave registration code, it's been years and this is easier than fixing it.

This commit is contained in:
FaceDeer 2022-08-04 11:45:24 -06:00
parent 40215b772e
commit c5f46e113e

View File

@ -17,11 +17,16 @@ subterrane.register_stalagmite_nodes("subterrane:dry_stal", {
sounds = default.node_sound_stone_defaults(), sounds = default.node_sound_stone_defaults(),
}) })
local flowstone_drops
if minetest.get_modpath("default") then
flowstone_drops = 'default:cobble'
end
minetest.register_node("subterrane:dry_flowstone", { minetest.register_node("subterrane:dry_flowstone", {
description = S("Dry Flowstone"), description = S("Dry Flowstone"),
tiles = {"default_stone.png^[brighten"}, tiles = {"default_stone.png^[brighten"},
groups = {cracky = 3, stone = 1}, groups = {cracky = 3, stone = 1},
drop = 'default:cobble', drop = flowstone_drops,
sounds = default.node_sound_stone_defaults(), sounds = default.node_sound_stone_defaults(),
}) })
@ -40,7 +45,7 @@ minetest.register_node("subterrane:wet_flowstone", {
description = S("Wet Flowstone"), description = S("Wet Flowstone"),
tiles = {"default_stone.png^[brighten^subterrane_dripstone_streaks.png"}, tiles = {"default_stone.png^[brighten^subterrane_dripstone_streaks.png"},
groups = {cracky = 3, stone = 1, subterrane_wet_dripstone = 1}, groups = {cracky = 3, stone = 1, subterrane_wet_dripstone = 1},
drop = 'default:cobble', drop = flowstone_drops,
sounds = default.node_sound_stone_defaults(), sounds = default.node_sound_stone_defaults(),
}) })
@ -61,375 +66,6 @@ end
function subterrane:giant_shroom(vi, area, data, stem_material, cap_material, gill_material, stem_height, cap_radius, ignore_bounds) function subterrane:giant_shroom(vi, area, data, stem_material, cap_material, gill_material, stem_height, cap_radius, ignore_bounds)
subterrane.giant_mushroom(vi, area, data, stem_material, cap_material, gill_material, stem_height, cap_radius, ignore_bounds) subterrane.giant_mushroom(vi, area, data, stem_material, cap_material, gill_material, stem_height, cap_radius, ignore_bounds)
end end
-------------------------------------------------------------------------------------
-- Original cave registration code.
local c_lava = minetest.get_content_id("default:lava_source")
local c_obsidian = minetest.get_content_id("default:obsidian")
local c_stone = minetest.get_content_id("default:stone")
local c_air = minetest.get_content_id("air")
subterrane.default_perlin_cave = {
offset = 0,
scale = 1,
spread = {x=256, y=256, z=256},
seed = -400000000089,
octaves = 3,
persist = 0.67
}
subterrane.default_perlin_wave = {
offset = 0,
scale = 1,
spread = {x=512, y=256, z=512}, -- squashed 2:1
seed = 59033,
octaves = 6,
persist = 0.63
}
-- cave_layer_def
--{
-- minimum_depth = -- required, the highest elevation this cave layer will be generated in.
-- maximum_depth = -- required, the lowest elevation this cave layer will be generated in.
-- cave_threshold = -- optional, Cave threshold. Defaults to 0.5. 1 = small rare caves, 0.5 = 1/3rd ground volume, 0 = 1/2 ground volume
-- boundary_blend_range = -- optional, range near ymin and ymax over which caves diminish to nothing. Defaults to 128.
-- perlin_cave = -- optional, a 3D perlin noise definition table to define the shape of the caves
-- perlin_wave = -- optional, a 3D perlin noise definition table that's averaged with the cave noise to add more horizontal surfaces (squash its spread on the y axis relative to perlin_cave to accomplish this)
-- columns = -- optional, a column_def table for producing truly enormous dripstone formations
--}
-- column_def
--{
-- max_column_radius = -- Maximum radius for individual columns, defaults to 10
-- min_column_radius = -- Minimum radius for individual columns, defaults to 2 (going lower can increase the likelihood of "intermittent" columns with floating sections)
-- node = -- node name to build columns out of. Defaults to default:stone
-- weight = -- a floating point value (usually in the range of 0.5-1) to modify how strongly the column is affected by the surrounding cave. Lower values create a more variable, tapered stalactite/stalagmite combination whereas a value of 1 produces a roughly cylindrical column. Defaults to 0.5
-- maximum_count = -- The maximum number of columns placed in any given column region (each region being a square 4 times the length and width of a map chunk). Defaults to 100
-- minimum_count = -- The minimum number of columns placed in a column region. The actual number placed will be randomly selected between this range. Defaults to 25.
--}
--extra biome properties used by subterrane
--{
-- _subterrane_ceiling_decor = -- function for putting stuff on the ceiling of the big caverns
-- _subterrane_floor_decor = -- function for putting stuff on the floor of the big caverns
-- _subterrane_fill_node = -- node to fill the cavern with (defaults to air)
-- _subterrane_column_node = -- override the node the giant columns in this biome are made from
-- _subterrane_cave_floor_decor = -- function for putting stuff on the floors of other preexisting open space
-- _subterrane_cave_ceiling_decor = -- function for putting stuff on the ceiling of other preexisting open space
-- _subterrane_mitigate_lava = -- try to patch the walls of big caverns with obsidian plugs when lava intersects. Not perfect, but helpful.
-- _subterrane_override_sea_level = -- Y coordinate where an underground sea level begins. Biomes' y coordinate cutoffs are unreliable underground, this forces subterrane to take this sea level cutoff into account.
-- _subterrane_override_under_sea_biome = -- When below the override_sea_level, the biome with this name will be looked up and substituted.
-- _subterrane_column_node = -- overrides the node type of a cavern layer's column_def, if there are columns here.
--}
local default_column = {
max_column_radius = 10,
min_column_radius = 2,
node = c_stone,
weight = 0.25,
maximum_count = 100,
minimum_count = 25,
}
function subterrane:register_cave_layer(cave_layer_def)
table.insert(subterrane.registered_layers, cave_layer_def)
local YMIN = cave_layer_def.maximum_depth
local YMAX = cave_layer_def.minimum_depth
local BLEND = math.min(cave_layer_def.boundary_blend_range or 128, (YMAX-YMIN)/2)
local TCAVE = cave_layer_def.cave_threshold or 0.5
local np_cave = cave_layer_def.perlin_cave or subterrane.default_perlin_cave
local np_wave = cave_layer_def.perlin_wave or subterrane.default_perlin_wave
local yblmin = YMIN + BLEND * 1.5
local yblmax = YMAX - BLEND * 1.5
local column_def = cave_layer_def.columns
local c_column
if column_def then
column_def.max_column_radius = column_def.max_column_radius or default_column.max_column_radius
column_def.min_column_radius = column_def.min_column_radius or default_column.min_column_radius
c_column = column_def.node or default_column.node
column_def.weight = column_def.weight or default_column.weight
column_def.maximum_count = column_def.maximum_count or default_column.maximum_count
column_def.minimum_count = column_def.minimum_count or default_column.minimum_count
end
-- On generated function
minetest.register_on_generated(function(minp, maxp, seed)
--if out of range of cave definition limits, abort
if minp.y > YMAX or maxp.y < YMIN then
return
end
local t_start = os.clock()
local y_max = maxp.y
local y_min = minp.y
minetest.log("info", "[subterrane] chunk minp " .. minetest.pos_to_string(minp)) --tell people you are generating a chunk
local vm, data, data_param2, area = mapgen_helper.mapgen_vm_data_param2()
local layer_range_name = tostring(YMIN).." to "..tostring(YMAX)
local nvals_cave, cave_area = mapgen_helper.perlin3d("cave "..layer_range_name, minp, maxp, np_cave) --cave noise for structure
local nvals_wave = mapgen_helper.perlin3d("wave "..layer_range_name, minp, maxp, np_wave) --wavy structure of cavern ceilings and floors
local cave_iterator = cave_area:iterp(minp, maxp)
local biomemap = minetest.get_mapgen_object("biomemap")
local column_points = nil
local column_weight = nil
if column_def then
column_points = subterrane.get_column_points(minp, maxp, column_def)
column_weight = column_def.weight
end
for vi, x, y, z in area:iterp_xyz(minp, maxp) do
local index_3d = cave_iterator()
local index_2d = mapgen_helper.index2d(minp, maxp, x, z)
local tcave --declare variable
--determine the overall cave threshold
if y < yblmin then
tcave = TCAVE + ((yblmin - y) / BLEND) ^ 2
elseif y > yblmax then
tcave = TCAVE + ((y - yblmax) / BLEND) ^ 2
else
tcave = TCAVE
end
local biome
if biomemap then
biome = mapgen_helper.get_biome_def(biomemap[index_2d])
end
if biome and biome._subterrane_override_sea_level and y <= biome._subterrane_override_sea_level then
local override_name = biome._subterrane_override_under_sea_biome
if override_name then
biome = minetest.registered_biomes[override_name]
else
biome = nil
end
end
local fill_node = c_air
local column_node = c_column
if biome then
if biome._subterrane_fill_node then
fill_node = biome._subterrane_fill_node
end
if biome._subterrane_column_node then
column_node = biome._subterrane_column_node
end
end
local cave_value = (nvals_cave[index_3d] + nvals_wave[index_3d])/2
if cave_value > tcave then --if node falls within cave threshold
local column_value = 0
if column_def then
column_value = subterrane.get_point_heat({x=x, y=y, z=z}, column_points)
end
if column_value > 0 and cave_value - column_value * column_weight < tcave then
data[vi] = column_node -- add a column
else
data[vi] = fill_node --hollow it out to make the cave
end
elseif biome and biome._subterrane_cave_fill_node and data[vi] == c_air then
data[vi] = biome._subterrane_cave_fill_node
end
if biome and biome._subterrane_mitigate_lava and cave_value > tcave - 0.1 then -- Eliminate nearby lava to keep it from spilling in
if data[vi] == c_lava then
data[vi] = c_obsidian
end
end
end
cave_iterator = cave_area:iterp(minp, maxp) -- reset this iterator
for vi, x, y, z in area:iterp_xyz(minp, maxp) do
local index_3d = cave_iterator()
local index_2d = mapgen_helper.index2d(minp, maxp, x, z)
local ai = vi + area.ystride
local bi = vi - area.ystride
local tcave --same as above
if y < yblmin then
tcave = TCAVE + ((yblmin - y) / BLEND) ^ 2
elseif y > yblmax then
tcave = TCAVE + ((y - yblmax) / BLEND) ^ 2
else
tcave = TCAVE
end
local biome
if biomemap then
biome = mapgen_helper.get_biome_def(biomemap[index_2d])
end
local fill_node = c_air
local cave_fill_node = c_air
if biome and biome._subterrane_override_sea_level and y <= biome._subterrane_override_sea_level then
local override_name = biome._subterrane_override_under_sea_biome
if override_name then
biome = minetest.registered_biomes[override_name]
else
biome = nil
end
end
if biome then
local cave_value = (nvals_cave[index_3d] + nvals_wave[index_3d])/2
-- only check nodes near the edges of caverns
if cave_value > tcave - 0.05 and cave_value < tcave + 0.05 then
if biome._subterrane_fill_node then
fill_node = biome._subterrane_fill_node
end
--ceiling
if biome._subterrane_ceiling_decor
and data[ai] ~= fill_node
and data[vi] == fill_node
and y < y_max
then --ceiling
biome._subterrane_ceiling_decor(area, data, ai, vi, bi, data_param2)
end
--floor
if biome._subterrane_floor_decor
and data[bi] ~= fill_node
and data[vi] == fill_node
and y > y_min
then --floor
biome._subterrane_floor_decor(area, data, ai, vi, bi, data_param2)
end
elseif cave_value <= tcave then --if node falls outside cave threshold
-- decorate other "native" caves and tunnels
if biome._subterrane_cave_fill_node then
cave_fill_node = biome._subterrane_cave_fill_node
if data[vi] == c_air then
data[vi] = cave_fill_node
end
end
if biome._subterrane_cave_ceiling_decor
and data[ai] ~= cave_fill_node
and data[vi] == cave_fill_node
and y < y_max
then --ceiling
biome._subterrane_cave_ceiling_decor(area, data, ai, vi, bi, data_param2)
end
if biome._subterrane_cave_floor_decor
and data[bi] ~= cave_fill_node
and data[vi] == cave_fill_node
and y > y_min
then --ground
biome._subterrane_cave_floor_decor(area, data, ai, vi, bi, data_param2)
end
end
end
end
--send data back to voxelmanip
vm:set_data(data)
vm:set_param2_data(data_param2)
--calc lighting
vm:set_lighting({day = 0, night = 0})
vm:calc_lighting()
--write it to world
vm:write_to_map()
local chunk_generation_time = math.ceil((os.clock() - t_start) * 1000) --grab how long it took
if chunk_generation_time < 1000 then
minetest.log("info", "[subterrane] "..chunk_generation_time.." ms") --tell people how long
else
minetest.log("warning", "[subterrane] took "..chunk_generation_time.." ms to generate map block "
.. minetest.pos_to_string(minp) .. minetest.pos_to_string(maxp))
end
end)
end
function subterrane:register_cave_decor(minimum_depth, maximum_depth)
-- On generated function
minetest.register_on_generated(function(minp, maxp, seed)
--if out of range of cave definition limits, abort
if minp.y > minimum_depth or maxp.y < maximum_depth then
return
end
--easy reference to commonly used values
local t_start = os.clock()
local y_max = maxp.y
local y_min = minp.y
minetest.log("info", "[subterrane] chunk minp " .. minetest.pos_to_string(minp)) --tell people you are generating a chunk
local vm, data, data_param2, area = mapgen_helper.mapgen_vm_data_param2()
local biomemap = minetest.get_mapgen_object("biomemap")
for vi, x, y, z in area:iterp_xyz(minp, maxp) do
--decoration loop, places nodes on floor and ceiling
local index_2d = mapgen_helper.index2d(minp, maxp, x, z)
local ai = vi + area.ystride
local bi = vi - area.ystride
local biome
if biomemap then
biome = mapgen_helper.get_biome_def(biomemap[index_2d])
end
local cave_fill_node = c_air
if biome then
-- decorate "native" caves and tunnels
if biome._subterrane_cave_fill_node then
cave_fill_node = biome._subterrane_cave_fill_node
if data[vi] == c_air then
data[vi] = cave_fill_node
end
end
if biome._subterrane_cave_ceiling_decor
and data[ai] ~= cave_fill_node
and data[vi] == cave_fill_node
and y < y_max
then --ceiling
biome._subterrane_cave_ceiling_decor(area, data, ai, vi, bi, data_param2)
end
--ground
if biome._subterrane_cave_floor_decor
and data[bi] ~= cave_fill_node
and data[vi] == cave_fill_node
and y > y_min
then --ground
biome._subterrane_cave_floor_decor(area, data, ai, vi, bi, data_param2)
end
end
end
--send data back to voxelmanip
vm:set_data(data)
vm:set_param2_data(data_param2)
--calc lighting
vm:set_lighting({day = 0, night = 0})
vm:calc_lighting()
--write it to world
vm:write_to_map()
local chunk_generation_time = math.ceil((os.clock() - t_start) * 1000) --grab how long it took
if chunk_generation_time < 1000 then
minetest.log("info", "[subterrane] "..chunk_generation_time.." ms") --tell people how long
else
minetest.log("warning", "[subterrane] took "..chunk_generation_time.." ms to generate a map block")
end
end)
end
--FUNCTIONS-- --FUNCTIONS--