forked from VoxeLibre/VoxeLibre
833 lines
25 KiB
Lua
833 lines
25 KiB
Lua
local WITCH_HUT_HEIGHT = 3 -- Exact Y level to spawn witch huts at. This height refers to the height of the floor
|
|
|
|
local function register_mgv6_decorations()
|
|
-- Cacti
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:sand"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = -0.012,
|
|
scale = 0.024,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 257,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
y_min = 4,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
decoration = "mcl_core:cactus",
|
|
height = 1,
|
|
height_max = 3,
|
|
})
|
|
|
|
-- Sugar canes
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"mcl_core:dirt", "mcl_core:coarse_dirt", "group:grass_block_no_snow", "group:sand", "mcl_core:podzol", "mcl_core:reeds"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = -0.3,
|
|
scale = 0.7,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 465,
|
|
octaves = 3,
|
|
persist = 0.7
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
decoration = "mcl_core:reeds",
|
|
height = 1,
|
|
height_max = 3,
|
|
spawn_by = { "mcl_core:water_source", "group:frosted_ice" },
|
|
num_spawn_by = 1,
|
|
})
|
|
|
|
-- Doubletall grass
|
|
minetest.register_decoration({
|
|
deco_type = "schematic",
|
|
schematic = {
|
|
size = { x=1, y=3, z=1 },
|
|
data = {
|
|
{ name = "air", prob = 0 },
|
|
{ name = "mcl_flowers:double_grass", param1 = 255, },
|
|
{ name = "mcl_flowers:double_grass_top", param1 = 255, },
|
|
},
|
|
},
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 8,
|
|
noise_params = {
|
|
offset = -0.0025,
|
|
scale = 0.03,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 420,
|
|
octaves = 3,
|
|
persist = 0.0,
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
})
|
|
|
|
-- Large ferns
|
|
minetest.register_decoration({
|
|
deco_type = "schematic",
|
|
schematic = {
|
|
size = { x=1, y=3, z=1 },
|
|
data = {
|
|
{ name = "air", prob = 0 },
|
|
{ name = "mcl_flowers:double_fern", param1=255, },
|
|
{ name = "mcl_flowers:double_fern_top", param1=255, },
|
|
},
|
|
},
|
|
-- v6 hack: This makes sure large ferns only appear in jungles
|
|
spawn_by = { "mcl_core:jungletree", "mcl_flowers:fern" },
|
|
num_spawn_by = 1,
|
|
place_on = {"group:grass_block_no_snow"},
|
|
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0,
|
|
scale = 0.01,
|
|
spread = {x = 250, y = 250, z = 250},
|
|
seed = 333,
|
|
octaves = 2,
|
|
persist = 0.66,
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
})
|
|
|
|
-- Large flowers
|
|
local function register_large_flower(name, seed, offset)
|
|
minetest.register_decoration({
|
|
deco_type = "schematic",
|
|
schematic = {
|
|
size = { x=1, y=3, z=1 },
|
|
data = {
|
|
{ name = "air", prob = 0 },
|
|
{ name = "mcl_flowers:"..name, param1=255, },
|
|
{ name = "mcl_flowers:"..name.."_top", param1=255, },
|
|
},
|
|
},
|
|
place_on = {"group:grass_block_no_snow"},
|
|
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = offset,
|
|
scale = 0.01,
|
|
spread = {x = 300, y = 300, z = 300},
|
|
seed = seed,
|
|
octaves = 5,
|
|
persist = 0.62,
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.overworld_max,
|
|
flags = "",
|
|
})
|
|
end
|
|
|
|
register_large_flower("rose_bush", 9350, -0.008)
|
|
register_large_flower("peony", 10450, -0.008)
|
|
register_large_flower("lilac", 10600, -0.007)
|
|
register_large_flower("sunflower", 2940, -0.005)
|
|
|
|
-- Lily pad
|
|
minetest.register_decoration({
|
|
deco_type = "schematic",
|
|
schematic = {
|
|
size = { x=1, y=3, z=1 },
|
|
data = {
|
|
{ name = "mcl_core:water_source", prob = 0 },
|
|
{ name = "mcl_core:water_source" },
|
|
{ name = "mcl_flowers:waterlily", param1 = 255 },
|
|
},
|
|
},
|
|
place_on = "mcl_core:dirt",
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = -0.12,
|
|
scale = 0.3,
|
|
spread = {x = 200, y = 200, z = 200},
|
|
seed = 503,
|
|
octaves = 6,
|
|
persist = 0.7,
|
|
},
|
|
y_min = 0,
|
|
y_max = 0,
|
|
rotation = "random",
|
|
})
|
|
|
|
-- Pumpkin
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
decoration = "mcl_farming:pumpkin",
|
|
param2 = 0,
|
|
param2_max = 3,
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = -0.008,
|
|
scale = 0.00666,
|
|
spread = {x = 250, y = 250, z = 250},
|
|
seed = 666,
|
|
octaves = 6,
|
|
persist = 0.666
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.overworld_max,
|
|
})
|
|
|
|
-- Melon
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0.002,
|
|
scale = 0.006,
|
|
spread = {x = 250, y = 250, z = 250},
|
|
seed = 333,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
-- Small trick to make sure melon spawn in jungles
|
|
spawn_by = { "mcl_core:jungletree", "mcl_flowers:fern" },
|
|
num_spawn_by = 1,
|
|
y_min = 1,
|
|
y_max = 40,
|
|
decoration = "mcl_farming:melon",
|
|
})
|
|
|
|
-- Tall grass
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 8,
|
|
noise_params = {
|
|
offset = 0.01,
|
|
scale = 0.3,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 420,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.overworld_max,
|
|
decoration = "mcl_flowers:tallgrass",
|
|
})
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 8,
|
|
noise_params = {
|
|
offset = 0.04,
|
|
scale = 0.03,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 420,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.overworld_max,
|
|
decoration = "mcl_flowers:tallgrass",
|
|
})
|
|
|
|
-- Seagrass and kelp
|
|
local materials = {"dirt","sand"}
|
|
for i=1, #materials do
|
|
local mat = materials[i]
|
|
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
spawn_by = {"group:water"},
|
|
num_spawn_by = 1,
|
|
place_on = {"mcl_core:"..mat},
|
|
sidelen = 8,
|
|
noise_params = {
|
|
offset = 0.04,
|
|
scale = 0.3,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 421,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
flags = "force_placement",
|
|
place_offset_y = -1,
|
|
y_min = mcl_vars.overworld_min,
|
|
y_max = 0,
|
|
decoration = "mcl_ocean:seagrass_"..mat,
|
|
})
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
spawn_by = {"group:water"},
|
|
num_spawn_by = 1,
|
|
place_on = {"mcl_core:mat"},
|
|
sidelen = 8,
|
|
noise_params = {
|
|
offset = 0.08,
|
|
scale = 0.03,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 421,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
flags = "force_placement",
|
|
place_offset_y = -1,
|
|
y_min = mcl_vars.overworld_min,
|
|
y_max = -5,
|
|
decoration = "mcl_ocean:seagrass_"..mat,
|
|
})
|
|
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
spawn_by = {"group:water"},
|
|
num_spawn_by = 1,
|
|
place_on = {"mcl_core:"..mat},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0.01,
|
|
scale = 0.01,
|
|
spread = {x = 300, y = 300, z = 300},
|
|
seed = 505,
|
|
octaves = 5,
|
|
persist = 0.62,
|
|
},
|
|
flags = "force_placement",
|
|
place_offset_y = -1,
|
|
y_min = mcl_vars.overworld_min,
|
|
y_max = -6,
|
|
decoration = "mcl_ocean:kelp_"..mat,
|
|
param2 = 16,
|
|
param2_max = 96,
|
|
})
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
spawn_by = {"group:water"},
|
|
num_spawn_by = 1,
|
|
place_on = {"mcl_core:"..mat},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0.01,
|
|
scale = 0.01,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 506,
|
|
octaves = 5,
|
|
persist = 0.62,
|
|
},
|
|
flags = "force_placement",
|
|
place_offset_y = -1,
|
|
y_min = mcl_vars.overworld_min,
|
|
y_max = -15,
|
|
decoration = "mcl_ocean:kelp_"..mat,
|
|
param2 = 32,
|
|
param2_max = 160,
|
|
})
|
|
|
|
end
|
|
|
|
-- Wet Sponge
|
|
-- TODO: Remove this when we got ocean monuments
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
decoration = "mcl_sponges:sponge_wet",
|
|
spawn_by = {"group:water"},
|
|
num_spawn_by = 1,
|
|
place_on = {"mcl_core:dirt","mcl_core:sand"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0.00295,
|
|
scale = 0.006,
|
|
spread = {x = 250, y = 250, z = 250},
|
|
seed = 999,
|
|
octaves = 3,
|
|
persist = 0.666
|
|
},
|
|
flags = "force_placement",
|
|
y_min = mcl_vars.mg_lava_overworld_max + 5,
|
|
y_max = -20,
|
|
})
|
|
|
|
-- Add a small amount of tall grass everywhere to avoid areas completely empty devoid of tall grass
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 8,
|
|
fill_ratio = 0.004,
|
|
y_min = 1,
|
|
y_max = mcl_vars.overworld_max,
|
|
decoration = "mcl_flowers:tallgrass",
|
|
})
|
|
|
|
local mushrooms = {"mcl_mushrooms:mushroom_red", "mcl_mushrooms:mushroom_brown"}
|
|
local mseeds = { 7133, 8244 }
|
|
for m=1, #mushrooms do
|
|
-- Mushrooms next to trees
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_no_snow", "mcl_core:dirt", "mcl_core:podzol", "mcl_core:mycelium", "mcl_core:stone", "mcl_core:andesite", "mcl_core:diorite", "mcl_core:granite"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0.04,
|
|
scale = 0.04,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = mseeds[m],
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
y_min = 1,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
decoration = mushrooms[m],
|
|
spawn_by = { "mcl_core:tree", "mcl_core:sprucetree", "mcl_core:darktree", "mcl_core:birchtree", },
|
|
num_spawn_by = 1,
|
|
})
|
|
end
|
|
|
|
-- Dead bushes
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:sand", "mcl_core:podzol", "mcl_core:dirt", "mcl_core:coarse_dirt", "group:hardened_clay"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = 0,
|
|
scale = 0.035,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = 1972,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
y_min = 4,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
decoration = "mcl_core:deadbush",
|
|
})
|
|
|
|
local function register_mgv6_flower(name, seed, offset, y_max)
|
|
if offset == nil then
|
|
offset = 0
|
|
end
|
|
if y_max == nil then
|
|
y_max = mcl_vars.mg_overworld_max
|
|
end
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_no_snow"},
|
|
sidelen = 16,
|
|
noise_params = {
|
|
offset = offset,
|
|
scale = 0.006,
|
|
spread = {x = 100, y = 100, z = 100},
|
|
seed = seed,
|
|
octaves = 3,
|
|
persist = 0.6
|
|
},
|
|
y_min = 1,
|
|
y_max = y_max,
|
|
decoration = "mcl_flowers:"..name,
|
|
})
|
|
end
|
|
|
|
register_mgv6_flower("tulip_red", 436)
|
|
register_mgv6_flower("tulip_orange", 536)
|
|
register_mgv6_flower("tulip_pink", 636)
|
|
register_mgv6_flower("tulip_white", 736)
|
|
register_mgv6_flower("azure_bluet", 800)
|
|
register_mgv6_flower("dandelion", 8)
|
|
-- Allium is supposed to only appear in flower forest in MC. There are no flower forests in v6.
|
|
-- We compensate by making it slightly rarer in v6.
|
|
register_mgv6_flower("allium", 0, -0.001)
|
|
--[[ Blue orchid is supposed to appear in swamplands. There are no swamplands in v6.
|
|
We emulate swamplands by limiting the height to 5 levels above sea level,
|
|
which should be close to the water. ]]
|
|
register_mgv6_flower("blue_orchid", 64500, nil, mcl_worlds.layer_to_y(67))
|
|
register_mgv6_flower("oxeye_daisy", 3490)
|
|
register_mgv6_flower("poppy", 9439)
|
|
|
|
-- Put top snow on snowy grass blocks. The v6 mapgen does not generate the top snow on its own.
|
|
minetest.register_decoration({
|
|
deco_type = "simple",
|
|
place_on = {"group:grass_block_snow"},
|
|
sidelen = 16,
|
|
fill_ratio = 11.0, -- complete coverage
|
|
y_min = 1,
|
|
y_max = mcl_vars.mg_overworld_max,
|
|
decoration = "mcl_core:snow",
|
|
})
|
|
|
|
end
|
|
register_mgv6_decorations()
|
|
|
|
local function generate_mgv6_structures()
|
|
local chunk_has_igloo = false
|
|
local struct_min, struct_max = -3, 111 --64
|
|
--except end exit portall all v6
|
|
if maxp.y >= struct_min and minp.y <= struct_max then
|
|
-- Generate structures
|
|
local pr = PcgRandom(blockseed)
|
|
perlin_structures = perlin_structures or minetest.get_perlin(329, 3, 0.6, 100)
|
|
-- Assume X and Z lengths are equal
|
|
local divlen = 5
|
|
for x0 = minp.x, maxp.x, divlen do for z0 = minp.z, maxp.z, divlen do
|
|
-- Determine amount from perlin noise
|
|
local amount = math.floor(perlin_structures:get_2d({x=x0, y=z0}) * 9)
|
|
-- Find random positions based on this random
|
|
local p, ground_y
|
|
for i=0, amount do
|
|
p = {x = pr:next(x0, x0+divlen-1), y = 0, z = pr:next(z0, z0+divlen-1)}
|
|
-- Find ground level
|
|
ground_y = nil
|
|
local nn
|
|
for y = struct_max, struct_min, -1 do
|
|
p.y = y
|
|
local checknode = minetest.get_node(p)
|
|
if checknode then
|
|
nn = checknode.name
|
|
local def = minetest.registered_nodes[nn]
|
|
if def and def.walkable then
|
|
ground_y = y
|
|
break
|
|
end
|
|
end
|
|
end
|
|
|
|
if ground_y then
|
|
p.y = ground_y+1
|
|
local nn0 = minetest.get_node(p).name
|
|
-- Check if the node can be replaced
|
|
if minetest.registered_nodes[nn0] and minetest.registered_nodes[nn0].buildable_to then
|
|
-- Igloos
|
|
if not chunk_has_igloo and (nn == "mcl_core:snowblock" or nn == "mcl_core:snow" or (minetest.get_item_group(nn, "grass_block_snow") == 1)) then
|
|
if pr:next(1, 4400) == 1 then
|
|
-- Check surface
|
|
local floor = {x=p.x+9, y=p.y-1, z=p.z+9}
|
|
local surface = minetest.find_nodes_in_area({x=p.x,y=p.y-1,z=p.z}, floor, "mcl_core:snowblock")
|
|
local surface2 = minetest.find_nodes_in_area({x=p.x,y=p.y-1,z=p.z}, floor, "mcl_core:dirt_with_grass_snow")
|
|
if #surface + #surface2 >= 63 then
|
|
mcl_structures.call_struct(p, "igloo", nil, pr)
|
|
chunk_has_igloo = true
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Fossil
|
|
if nn == "mcl_core:sandstone" or nn == "mcl_core:sand" and not chunk_has_desert_temple and ground_y > 3 then
|
|
local fossil_prob = minecraft_chunk_probability(64, minp, maxp)
|
|
|
|
if pr:next(1, fossil_prob) == 1 then
|
|
-- Spawn fossil below desert surface between layers 40 and 49
|
|
local p1 = {x=p.x, y=pr:next(mcl_worlds.layer_to_y(40), mcl_worlds.layer_to_y(49)), z=p.z}
|
|
-- Very rough check of the environment (we expect to have enough stonelike nodes).
|
|
-- Fossils may still appear partially exposed in caves, but this is O.K.
|
|
local p2 = vector.add(p1, 4)
|
|
local nodes = minetest.find_nodes_in_area(p1, p2, {"mcl_core:sandstone", "mcl_core:stone", "mcl_core:diorite", "mcl_core:andesite", "mcl_core:granite", "mcl_core:stone_with_coal", "mcl_core:dirt", "mcl_core:gravel"})
|
|
|
|
if #nodes >= 100 then -- >= 80%
|
|
mcl_structures.call_struct(p1, "fossil", nil, pr)
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Witch hut (v6)
|
|
if ground_y <= 0 and nn == "mcl_core:dirt" then
|
|
local prob = minecraft_chunk_probability(48, minp, maxp)
|
|
if pr:next(1, prob) == 1 then
|
|
|
|
local swampland = minetest.get_biome_id("Swampland")
|
|
local swampland_shore = minetest.get_biome_id("Swampland_shore")
|
|
|
|
-- Where do witches live?
|
|
-- v6: In Normal biome
|
|
if biomeinfo.get_v6_biome(p) == "Normal" then
|
|
here_be_witches = true
|
|
end
|
|
local here_be_witches = false
|
|
if here_be_witches then
|
|
|
|
local r = tostring(pr:next(0, 3) * 90) -- "0", "90", "180" or 270"
|
|
local p1 = {x=p.x-1, y=WITCH_HUT_HEIGHT+2, z=p.z-1}
|
|
local size
|
|
if r == "0" or r == "180" then
|
|
size = {x=10, y=4, z=8}
|
|
else
|
|
size = {x=8, y=4, z=10}
|
|
end
|
|
local p2 = vector.add(p1, size)
|
|
|
|
-- This checks free space at the “body” of the hut and a bit around.
|
|
-- ALL nodes must be free for the placement to succeed.
|
|
local free_nodes = minetest.find_nodes_in_area(p1, p2, {"air", "mcl_core:water_source", "mcl_flowers:waterlily"})
|
|
if #free_nodes >= ((size.x+1)*(size.y+1)*(size.z+1)) then
|
|
local place = {x=p.x, y=WITCH_HUT_HEIGHT-1, z=p.z}
|
|
|
|
-- FIXME: For some mysterious reason (black magic?) this
|
|
-- function does sometimes NOT spawn the witch hut. One can only see the
|
|
-- oak wood nodes in the water, but no hut. :-/
|
|
mcl_structures.place_structure(place,mcl_structures.registered_structures["witch_hut"],pr)
|
|
|
|
local function place_tree_if_free(pos, prev_result)
|
|
local nn = minetest.get_node(pos).name
|
|
if nn == "mcl_flowers:waterlily" or nn == "mcl_core:water_source" or nn == "mcl_core:water_flowing" or nn == "air" then
|
|
minetest.set_node(pos, {name="mcl_core:tree", param2=0})
|
|
return prev_result
|
|
else
|
|
return false
|
|
end
|
|
end
|
|
local offsets
|
|
if r == "0" then
|
|
offsets = {
|
|
{x=1, y=0, z=1},
|
|
{x=1, y=0, z=5},
|
|
{x=6, y=0, z=1},
|
|
{x=6, y=0, z=5},
|
|
}
|
|
elseif r == "180" then
|
|
offsets = {
|
|
{x=2, y=0, z=1},
|
|
{x=2, y=0, z=5},
|
|
{x=7, y=0, z=1},
|
|
{x=7, y=0, z=5},
|
|
}
|
|
elseif r == "270" then
|
|
offsets = {
|
|
{x=1, y=0, z=1},
|
|
{x=5, y=0, z=1},
|
|
{x=1, y=0, z=6},
|
|
{x=5, y=0, z=6},
|
|
}
|
|
elseif r == "90" then
|
|
offsets = {
|
|
{x=1, y=0, z=2},
|
|
{x=5, y=0, z=2},
|
|
{x=1, y=0, z=7},
|
|
{x=5, y=0, z=7},
|
|
}
|
|
end
|
|
for o=1, #offsets do
|
|
local ok = true
|
|
for y=place.y-1, place.y-64, -1 do
|
|
local tpos = vector.add(place, offsets[o])
|
|
tpos.y = y
|
|
ok = place_tree_if_free(tpos, ok)
|
|
if not ok then
|
|
break
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Ice spikes in v6
|
|
-- In other mapgens, ice spikes are generated as decorations.
|
|
if nn == "mcl_core:snowblock" then
|
|
local spike = pr:next(1,58000)
|
|
if spike < 3 then
|
|
-- Check surface
|
|
local floor = {x=p.x+4, y=p.y-1, z=p.z+4}
|
|
local surface = minetest.find_nodes_in_area({x=p.x+1,y=p.y-1,z=p.z+1}, floor, {"mcl_core:snowblock"})
|
|
-- Check for collision with spruce
|
|
local spruce_collisions = minetest.find_nodes_in_area({x=p.x+1,y=p.y+2,z=p.z+1}, {x=p.x+4, y=p.y+6, z=p.z+4}, {"mcl_core:sprucetree", "mcl_core:spruceleaves"})
|
|
|
|
if #surface >= 9 and #spruce_collisions == 0 then
|
|
mcl_structures.place_structure(p,mcl_structures.registered_structures["ice_spike_large"],pr)
|
|
end
|
|
elseif spike < 100 then
|
|
-- Check surface
|
|
local floor = {x=p.x+6, y=p.y-1, z=p.z+6}
|
|
local surface = minetest.find_nodes_in_area({x=p.x+1,y=p.y-1,z=p.z+1}, floor, {"mcl_core:snowblock", "mcl_core:dirt_with_grass_snow"})
|
|
|
|
-- Check for collision with spruce
|
|
local spruce_collisions = minetest.find_nodes_in_area({x=p.x+1,y=p.y+1,z=p.z+1}, {x=p.x+6, y=p.y+6, z=p.z+6}, {"mcl_core:sprucetree", "mcl_core:spruceleaves"})
|
|
|
|
if #surface >= 25 and #spruce_collisions == 0 then
|
|
mcl_structures.place_structure(p,mcl_structures.registered_structures["ice_spike_small"],pr)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end end
|
|
end
|
|
end
|
|
|
|
-- Generate mushrooms in caves manually.
|
|
-- only v6. minetest supports cave decos via "all_floors" flag now
|
|
local function generate_underground_mushrooms(minp, maxp, seed)
|
|
local pr_shroom = PseudoRandom(seed-24359)
|
|
-- Generate rare underground mushrooms
|
|
-- TODO: Make them appear in groups, use Perlin noise
|
|
local min, max = mcl_vars.mg_lava_overworld_max + 4, 0
|
|
if minp.y > max or maxp.y < min then
|
|
return
|
|
end
|
|
|
|
local bpos
|
|
local stone = minetest.find_nodes_in_area_under_air(minp, maxp, {"mcl_core:stone", "mcl_core:dirt", "mcl_core:mycelium", "mcl_core:podzol", "mcl_core:andesite", "mcl_core:diorite", "mcl_core:granite", "mcl_core:stone_with_coal", "mcl_core:stone_with_iron", "mcl_core:stone_with_gold"})
|
|
|
|
for n = 1, #stone do
|
|
bpos = {x = stone[n].x, y = stone[n].y + 1, z = stone[n].z }
|
|
|
|
local l = minetest.get_node_light(bpos, 0.5)
|
|
if bpos.y >= min and bpos.y <= max and l and l <= 12 and pr_shroom:next(1,1000) < 4 then
|
|
if pr_shroom:next(1,2) == 1 then
|
|
minetest.set_node(bpos, {name = "mcl_mushrooms:mushroom_brown"})
|
|
else
|
|
minetest.set_node(bpos, {name = "mcl_mushrooms:mushroom_red"})
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
-- Generate Nether decorations manually: Eternal fire, mushrooms, nether wart
|
|
-- (only v6)
|
|
local nether_wart_chance = 85
|
|
local function generate_nether_decorations(minp, maxp, seed)
|
|
local pr_nether = PseudoRandom(seed+667)
|
|
|
|
if minp.y > mcl_vars.mg_nether_max or maxp.y < mcl_vars.mg_nether_min then
|
|
return
|
|
end
|
|
|
|
minetest.log("action", "[mcl_mapgen_core] Nether decorations " .. minetest.pos_to_string(minp) .. " ... " .. minetest.pos_to_string(maxp))
|
|
|
|
-- TODO: Generate everything based on Perlin noise instead of PseudoRandom
|
|
|
|
local bpos
|
|
local rack = minetest.find_nodes_in_area_under_air(minp, maxp, {"mcl_nether:netherrack"})
|
|
local magma = minetest.find_nodes_in_area_under_air(minp, maxp, {"mcl_nether:magma"})
|
|
local ssand = minetest.find_nodes_in_area_under_air(minp, maxp, {"mcl_nether:soul_sand"})
|
|
|
|
-- Helper function to spawn “fake” decoration
|
|
local function special_deco(nodes, spawn_func)
|
|
for n = 1, #nodes do
|
|
bpos = {x = nodes[n].x, y = nodes[n].y + 1, z = nodes[n].z }
|
|
|
|
spawn_func(bpos)
|
|
end
|
|
end
|
|
-- Eternal fire on netherrack
|
|
special_deco(rack, function(bpos)
|
|
-- Eternal fire on netherrack
|
|
if pr_nether:next(1,100) <= 3 then
|
|
minetest.set_node(bpos, {name = "mcl_fire:eternal_fire"})
|
|
end
|
|
end)
|
|
|
|
-- Eternal fire on magma cubes
|
|
special_deco(magma, function(bpos)
|
|
if pr_nether:next(1,150) == 1 then
|
|
minetest.set_node(bpos, {name = "mcl_fire:eternal_fire"})
|
|
end
|
|
end)
|
|
|
|
-- Mushrooms on netherrack
|
|
-- Note: Spawned *after* the fire because of light level checks
|
|
special_deco(rack, function(bpos)
|
|
local l = minetest.get_node_light(bpos, 0.5)
|
|
if bpos.y > mcl_vars.mg_lava_nether_max + 6 and l and l <= 12 and pr_nether:next(1,1000) <= 4 then
|
|
-- TODO: Make mushrooms appear in groups, use Perlin noise
|
|
if pr_nether:next(1,2) == 1 then
|
|
minetest.set_node(bpos, {name = "mcl_mushrooms:mushroom_brown"})
|
|
else
|
|
minetest.set_node(bpos, {name = "mcl_mushrooms:mushroom_red"})
|
|
end
|
|
end
|
|
end)
|
|
|
|
-- Nether wart on soul sand
|
|
-- TODO: Spawn in Nether fortresses
|
|
special_deco(ssand, function(bpos)
|
|
if pr_nether:next(1, nether_wart_chance) == 1 then
|
|
minetest.set_node(bpos, {name = "mcl_nether:nether_wart"})
|
|
end
|
|
end)
|
|
end
|
|
|
|
local function remove_mgv6_broken_plants(minp,maxp)
|
|
--[[ Remove broken double plants caused by v6 weirdness.
|
|
v6 might break the bottom part of double plants because of how it works.
|
|
There are 3 possibilities:
|
|
1) Jungle: Top part is placed on top of a jungle tree or fern (=v6 jungle grass).
|
|
This is because the schematic might be placed even if some nodes of it
|
|
could not be placed because the destination was already occupied.
|
|
TODO: A better fix for this would be if schematics could abort placement
|
|
altogether if ANY of their nodes could not be placed.
|
|
2) Cavegen: Removes the bottom part, the upper part floats
|
|
3) Mudflow: Same as 2) ]]
|
|
|
|
local plants = minetest.find_nodes_in_area(minp, maxp, "group:double_plant")
|
|
for n = 1, #plants do
|
|
local node = vm:get_node_at(plants[n])
|
|
local is_top = minetest.get_item_group(node.name, "double_plant") == 2
|
|
if is_top then
|
|
local p_pos = area:index(plants[n].x, plants[n].y-1, plants[n].z)
|
|
if p_pos then
|
|
node = vm:get_node_at({x=plants[n].x, y=plants[n].y-1, z=plants[n].z})
|
|
local is_bottom = minetest.get_item_group(node.name, "double_plant") == 1
|
|
if not is_bottom then
|
|
p_pos = area:index(plants[n].x, plants[n].y, plants[n].z)
|
|
data[p_pos] = c_air
|
|
lvm_used = true
|
|
end
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function basic(vm, data, data2, emin, emax, area, minp, maxp, blockseed)
|
|
if not (minp.y <= mcl_vars.mg_nether_max and maxp.y >= mcl_vars.mg_nether_min) then
|
|
return
|
|
end
|
|
-- Nether block fixes:
|
|
-- * Replace water with Nether lava.
|
|
-- * Replace stone, sand dirt in v6 so the Nether works in v6.
|
|
local nodes = minetest.find_nodes_in_area(emin, emax, {"group:water"})
|
|
for _, n in pairs(nodes) do
|
|
data[area:index(n.x, n.y, n.z)] = c_nether_lava
|
|
lvm_used = true
|
|
end
|
|
nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source", "mcl_core:stone", "mcl_core:sand", "mcl_core:dirt"})
|
|
for n=1, #nodes do
|
|
local p_pos = area:index(nodes[n].x, nodes[n].y, nodes[n].z)
|
|
if data[p_pos] == c_water then
|
|
data[p_pos] = c_nether_lava
|
|
lvm_used = true
|
|
elseif data[p_pos] == c_stone then
|
|
data[p_pos] = c_netherrack
|
|
lvm_used = true
|
|
elseif data[p_pos] == c_sand or data[p_pos] == c_dirt then
|
|
data[p_pos] = c_soul_sand
|
|
lvm_used = true
|
|
end
|
|
end
|
|
end
|
|
|
|
local function end_fixes(minp,maxp)
|
|
if not ( minp.y <= mcl_vars.mg_end_max and maxp.y >= mcl_vars.mg_end_min ) then
|
|
return
|
|
end
|
|
local nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source", "mcl_core:stone", "mcl_core:sand", "mcl_core:dirt"})
|
|
if #nodes > 0 then
|
|
lvm_used = true
|
|
for _,n in pairs(nodes) do
|
|
data[area:index(n.x, n.y, n.z)] = c_air
|
|
end
|
|
end
|
|
end
|
|
|
|
local function basic_node(minp, maxp, blockseed)
|
|
if mg_name ~= "singlenode" then
|
|
-- Generate special decorations
|
|
if mg_name == "v6" then
|
|
generate_underground_mushrooms(minp, maxp, blockseed)
|
|
generate_nether_decorations(minp, maxp, blockseed)
|
|
end_fixes(minp,maxp)
|
|
remove_mgv6_broken_plants(minp,maxp,blockseed)
|
|
generate_mgv6_structures(minp, maxp, blockseed, minetest.get_mapgen_object("biomemap"))
|
|
end
|
|
end
|
|
end
|
|
|
|
mcl_mapgen_core.register_generator("mgv6-fixes", basic, basic_node, 10, true)
|