Add sub-map generators queue, fix https://git.minetest.land/MineClone2/MineClone2/issues/993 and https://git.minetest.land/MineClone2/MineClone2/issues/1060

mods/CORE/mcl_init/init.lua

@@ -46,6 +46,42 @@ local numcmax = math.max(math.floor((mapgen_limit_max - ccfmax) / chunk_size_in_
 mcl_vars.mapgen_edge_min = central_chunk_min_pos - numcmin * chunk_size_in_nodes
 mcl_vars.mapgen_edge_max = central_chunk_max_pos + numcmax * chunk_size_in_nodes
 
+local function coordinate_to_block(x)
+	return math.floor(x / mcl_vars.MAP_BLOCKSIZE)
+end
+
+local function coordinate_to_chunk(x)
+	return math.floor((coordinate_to_block(x) + central_chunk_offset) / mcl_vars.chunksize)
+end
+
+function mcl_vars.pos_to_block(pos)
+	return {
+		x = coordinate_to_block(pos.x),
+		y = coordinate_to_block(pos.y),
+		z = coordinate_to_block(pos.z)
+	}
+end
+
+function mcl_vars.pos_to_chunk(pos)
+	return {
+		x = coordinate_to_chunk(pos.x),
+		y = coordinate_to_chunk(pos.y),
+		z = coordinate_to_chunk(pos.z)
+	}
+end
+
+local k_positive = math.ceil(mcl_vars.MAX_MAP_GENERATION_LIMIT / chunk_size_in_nodes)
+local k_positive_z = k_positive * 2
+local k_positive_y = k_positive_z * k_positive_z
+
+function mcl_vars.get_chunk_number(pos) -- unsigned int
+	local c = mcl_vars.pos_to_chunk(pos)
+	return
+		(c.y + k_positive) * k_positive_y +
+		(c.z + k_positive) * k_positive_z +
+		 c.x + k_positive
+end
+
 if not superflat and not singlenode then
 	-- Normal mode
 	--[[ Realm stacking (h is for height)
@@ -91,7 +127,7 @@ else
 	mcl_vars.mg_bedrock_is_rough = false
 end
 
-mcl_vars.mg_overworld_max = 31000
+mcl_vars.mg_overworld_max = mcl_vars.mapgen_edge_max
 
 -- The Nether (around Y = -29000)
 mcl_vars.mg_nether_min = -29067 -- Carefully chosen to be at a mapchunk border

mods/CORE/mcl_util/init.lua

@@ -405,53 +405,3 @@ function mcl_util.get_object_center(obj)
 	pos.y = pos.y + (ymax - ymin) / 2.0
 	return pos
 end
-
-local get_node_emerge_queue = {}
-local function ecb_get_far_node(blockpos, action, calls_remaining, param)
-	if calls_remaining <= 0 and param then
-		minetest.log("verbose","[mcl_util] ecb done for param = "..param.." node.name="..minetest.get_node(minetest.string_to_pos(param)).name)
-		get_node_emerge_queue[param] = nil
-	end
-end
-
-function mcl_util.get_far_node(pos, force)
-	local node = minetest.get_node(pos)
-	if node.name ~= "ignore" then
-		return node
-	end
-
-	minetest.get_voxel_manip():read_from_map(pos, pos)
-	node = minetest.get_node(pos)
-	if node.name ~= "ignore" or not force then
-		return node
-	end
-
-	local blockpos = vector.multiply(vector.floor(vector.divide(pos, mcl_vars.MAP_BLOCKSIZE)), mcl_vars.MAP_BLOCKSIZE)
-	local key = minetest.pos_to_string(blockpos)
-
-	for i=1,2 do -- give engine 2 chances to emerge the data
-		if not get_node_emerge_queue[key] then
-			get_node_emerge_queue[key] = 1
-			minetest.log("verbose","[mcl_util] emerge during get_far_node("..minetest.pos_to_string(pos).."), key="..key..", blockpos="..minetest.pos_to_string(blockpos))
-			minetest.emerge_area(blockpos, vector.add(blockpos, mcl_vars.MAP_BLOCKSIZE-1), ecb_get_far_node, key)
-		end
-
-		while not get_node_emerge_queue[key] do end
-		minetest.log("verbose","[mcl_util] emerge finished for node "..minetest.pos_to_string(pos)..", key="..key..", blockpos="..minetest.pos_to_string(blockpos)..", node.name="..mcl_util.get_far_node(pos).name)
-
-		node = minetest.get_node(pos)
-		if node.name ~= "ignore" then
-			return node
-		end
-
-		minetest.get_voxel_manip():read_from_map(pos, pos)
-		node = minetest.get_node(pos)
-		if node.name ~= "ignore" or not force then
-			return node
-		end
-	end
-
-	node.name = "air" -- engine continuously returns "ignore" - probably it is a bug
-	minetest.swap_node(pos, node) -- engine continuously returns "ignore" - probably it is a bug
-	return node -- engine continuously returns "ignore" - probably it is a bug
-end

mods/MAPGEN/mcl_biomes/depends.txt

@@ -1,4 +1,5 @@
 mcl_init
+mcl_mapgen_core
 mcl_core
 mcl_worlds
 mcl_farming

mods/MAPGEN/mcl_biomes/init.lua

@@ -3967,7 +3967,7 @@ if mg_name ~= "singlenode" then
 	-- Overworld decorations for v6 are handled in mcl_mapgen_core
 
 	if deco_id_chorus_plant then
-		minetest.register_on_generated(function(minp, maxp, blockseed)
+		mcl_mapgen_core.register_generator("chorus_grow", nil, function(minp, maxp, blockseed)
 			local gennotify = minetest.get_mapgen_object("gennotify")
 			local poslist = {}
 			for _, pos in ipairs(gennotify["decoration#"..deco_id_chorus_plant] or {}) do

mods/MAPGEN/mcl_dungeons/init.lua

@@ -1,17 +1,38 @@
 -- FIXME: Chests may appear at openings
 
 local mg_name = minetest.get_mapgen_setting("mg_name")
-local pr = PseudoRandom(os.time())
 
 -- Are dungeons disabled?
-if mcl_vars.mg_dungeons == false then
+if mcl_vars.mg_dungeons == false or mg_name == "singlenode" then
 	return
 end
 
-if mg_name ~= "singlenode" then
+local min_y = math.max(mcl_vars.mg_overworld_min, mcl_vars.mg_bedrock_overworld_max) + 1
--- Get loot for dungeon chests
+local max_y = mcl_vars.mg_overworld_max - 1
-local get_loot = function()
+
-	local loottable = {
+local dungeonsizes = {
+	{ x=5, y=4, z=5},
+	{ x=5, y=4, z=7},
+	{ x=7, y=4, z=5},
+	{ x=7, y=4, z=7},
+}
+
+local dirs = {
+	{ x= 1, y=0, z= 0 },
+	{ x= 0, y=0, z= 1 },
+	{ x=-1, y=0, z= 0 },
+	{ x= 0, y=0, z=-1 },
+}
+
+local surround_vectors = {
+	{ x=-1, y=0, z=0 },
+	{ x=1, y=0, z=0 },
+	{ x=0, y=0, z=-1 },
+	{ x=0, y=0, z=1 },
+}
+
+local loottable =
+{
 	{
 		stacks_min = 1,
 		stacks_max = 3,
@@ -54,10 +75,10 @@ local get_loot = function()
 			{ itemstring = "mcl_mobitems:string", weight = 10, amount_min = 1, amount_max = 8 },
 		},
 	}
-	}
+}
 
-	-- Bonus loot for v6 mapgen: Otherwise unobtainable saplings.
+-- Bonus loot for v6 mapgen: Otherwise unobtainable saplings.
-	if mg_name == "v6" then
+if mg_name == "v6" then
 	table.insert(loottable, {
 		stacks_min = 1,
 		stacks_max = 3,
@@ -67,76 +88,27 @@ local get_loot = function()
 			{ itemstring = "", weight = 6 },
 		},
 	})
-	end
-	local items = mcl_loot.get_multi_loot(loottable, pr)
-
-	return items
 end
 
 
--- Buffer for LuaVoxelManip
+-- Calculate the number of dungeon spawn attempts
-local lvm_buffer = {}
+-- In Minecraft, there 8 dungeon spawn attempts Minecraft chunk (16*256*16 = 65536 blocks).
+-- Minetest chunks don't have this size, so scale the number accordingly.
+local attempts = math.ceil(((mcl_vars.chunksize * mcl_vars.MAP_BLOCKSIZE) ^ 3) / 8192) -- 63 = 80*80*80/8192
 
--- Below the bedrock, generate air/void
+local function ecb_spawn_dungeon(blockpos, action, calls_remaining, param)
-minetest.register_on_generated(function(minp, maxp)
+	if calls_remaining >= 1 then return end
-	if maxp.y < mcl_vars.mg_overworld_min or minp.y > mcl_vars.mg_overworld_max then
-		return
-	end
 
-	local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
+	local p1, p2, dim, pr = param.p1, param.p2, param.dim, param.pr
-	local data = vm:get_data(lvm_buffer)
+	local x, y, z = p1.x, p1.y, p1.z
-	local area = VoxelArea:new({MinEdge=emin, MaxEdge=emax})
-	local lvm_used = false
-
-	local c_air = minetest.get_content_id("air")
-	local c_cobble = minetest.get_content_id("mcl_core:cobble")
-	local c_mossycobble = minetest.get_content_id("mcl_core:mossycobble")
-
-	-- Remember spawner chest positions to set metadata later
-	local chest_posses = {}
-	local spawner_posses = {}
-
-	-- Calculate the number of dungeon spawn attempts
-	local sizevector = vector.subtract(maxp, minp)
-	sizevector = vector.add(sizevector, 1)
-	local chunksize = sizevector.x * sizevector.y * sizevector.z
-
-	-- In Minecraft, there 8 dungeon spawn attempts Minecraft chunk (16*256*16 = 65536 blocks).
-	-- Minetest chunks don't have this size, so scale the number accordingly.
-	local attempts = math.ceil(chunksize / 65536 * 8)
-
-	for a=1, attempts do
-		local x, y, z
-		local b = 7 -- buffer
-		x = math.random(minp.x+b, maxp.x-b)
-
-		local ymin = math.min(mcl_vars.mg_overworld_max, math.max(minp.y, mcl_vars.mg_bedrock_overworld_max) + 7)
-		local ymax = math.min(mcl_vars.mg_overworld_max, math.max(maxp.y, mcl_vars.mg_bedrock_overworld_max) - 4)
-
-		y = math.random(ymin, ymax)
-		z = math.random(minp.z+b, maxp.z-b)
-
-		local dungeonsizes = {
-			{ x=5, y=4, z=5},
-			{ x=5, y=4, z=7},
-			{ x=7, y=4, z=5},
-			{ x=7, y=4, z=7},
-		}
-		local dim = dungeonsizes[math.random(1, #dungeonsizes)]
 
 	-- Check floor and ceiling: Must be *completely* solid
-		local ceilingfloor_ok = true
+	local y_floor = y
-		for tx = x, x+dim.x do
+	local y_ceiling = y + dim.y + 1
-			for tz = z, z+dim.z do
+	for tx = x, x + dim.x do for tz = z, z + dim.z do
-				local floor = minetest.get_name_from_content_id(data[area:index(tx, y, tz)])
+		if not minetest.registered_nodes[mcl_mapgen_core.get_node({x = tx, y = y_floor  , z = tz}).name].walkable
-				local ceiling = minetest.get_name_from_content_id(data[area:index(tx, y+dim.y+1, tz)])
+		or not minetest.registered_nodes[mcl_mapgen_core.get_node({x = tx, y = y_ceiling, z = tz}).name].walkable then return false end
-				if (not minetest.registered_nodes[floor].walkable) or (not minetest.registered_nodes[ceiling].walkable) then
+	end end
-					ceilingfloor_ok = false
-					break
-				end
-			end
-			if not ceilingfloor_ok then break end
-		end
 
 	-- Check for air openings (2 stacked air at ground level) in wall positions
 	local openings_counter = 0
@@ -145,7 +117,6 @@ minetest.register_on_generated(function(minp, maxp)
 	-- Corners are stored because a corner-only opening needs to be increased,
 	-- so entities can get through.
 	local corners = {}
-		if ceilingfloor_ok then
 
 	local walls = {
 		-- walls along x axis (contain corners)
@@ -165,12 +136,9 @@ minetest.register_on_generated(function(minp, maxp)
 			pos.y = y+1
 
 			if openings[pos.x] == nil then openings[pos.x] = {} end
-
+			local doorname1 = mcl_mapgen_core.get_node(pos).name
-					local door1 = area:index(pos.x, pos.y, pos.z)
 			pos.y = y+2
-					local door2 = area:index(pos.x, pos.y, pos.z)
+			local doorname2 = mcl_mapgen_core.get_node(pos).name
-					local doorname1 = minetest.get_name_from_content_id(data[door1])
-					local doorname2 = minetest.get_name_from_content_id(data[door2])
 			if doorname1 == "air" and doorname2 == "air" then
 				openings_counter = openings_counter + 1
 				openings[pos.x][pos.z] = true
@@ -183,8 +151,6 @@ minetest.register_on_generated(function(minp, maxp)
 		end
 	end
 
-		end
-
 	-- If all openings are only at corners, the dungeon can't be accessed yet.
 	-- This code extends the openings of corners so they can be entered.
 	if openings_counter >= 1 and openings_counter == #corners then
@@ -216,9 +182,15 @@ minetest.register_on_generated(function(minp, maxp)
 	end
 
 	-- Check conditions. If okay, start generating
-		if ceilingfloor_ok and openings_counter >= 1 and openings_counter <= 5 then
+	if openings_counter < 1 or openings_counter > 5 then return end
+
+	minetest.log("action","[mcl_dungeons] Placing new dungeon at "..minetest.pos_to_string({x=x,y=y,z=z}))
 	-- Okay! Spawning starts!
 
+	-- Remember spawner chest positions to set metadata later
+	local chests = {}
+	local spawner_posses = {}
+
 	-- First prepare random chest positions.
 	-- Chests spawn at wall
 
@@ -232,10 +204,10 @@ minetest.register_on_generated(function(minp, maxp)
 	local lastRandom
 	local secondChance = true -- second chance is still available
 	for i=1, totalChests do
-				local r = math.random(1, totalChestSlots)
+		local r = pr:next(1, totalChestSlots)
 		if r == lastRandom and secondChance then
 			-- Oops! Same slot selected. Try again.
-					r = math.random(1, totalChestSlots)
+			r = pr:next(1, totalChestSlots)
 			secondChance = false
 		end
 		lastRandom = r
@@ -245,8 +217,11 @@ minetest.register_on_generated(function(minp, maxp)
 	local currentChest = 1
 
 	-- Calculate the mob spawner position, to be re-used for later
-			local spawner_pos = {x = x + math.ceil(dim.x/2), y = y+1, z = z + math.ceil(dim.z/2)}
+	local sp = {x = x + math.ceil(dim.x/2), y = y+1, z = z + math.ceil(dim.z/2)}
-			table.insert(spawner_posses, spawner_pos)
+	local rn = minetest.registered_nodes[mcl_mapgen_core.get_node(sp).name]
+	if rn and rn.is_ground_content then
+		table.insert(spawner_posses, sp)
+	end
 
 	-- Generate walls and floor
 	local maxx, maxy, maxz = x+dim.x+1, y+dim.y, z+dim.z+1
@@ -254,18 +229,18 @@ minetest.register_on_generated(function(minp, maxp)
 	for tx = x, maxx do
 	for tz = z, maxz do
 	for ty = y, maxy do
-						local p_pos = area:index(tx, ty, tz)
+		local p = {x = tx, y=ty, z=tz}
 
 		-- Do not overwrite nodes with is_ground_content == false (e.g. bedrock)
 		-- Exceptions: cobblestone and mossy cobblestone so neighborings dungeons nicely connect to each other
-						local name = minetest.get_name_from_content_id(data[p_pos])
+		local name = mcl_mapgen_core.get_node(p).name
 		if name == "mcl_core:cobble" or name == "mcl_core:mossycobble" or minetest.registered_nodes[name].is_ground_content then
 			-- Floor
 			if ty == y then
-								if math.random(1,4) == 1 then
+				if pr:next(1,4) == 1 then
-									data[p_pos] = c_cobble
+					minetest.swap_node(p, {name = "mcl_core:cobble"})
 				else
-									data[p_pos] = c_mossycobble
+					minetest.swap_node(p, {name = "mcl_core:mossycobble"})
 				end
 
 				-- Generate walls
@@ -277,14 +252,14 @@ minetest.register_on_generated(function(minp, maxp)
 				-- Check if it's an opening first
 				if (not openings[tx][tz]) or ty == maxy then
 					-- Place wall or ceiling
-									data[p_pos] = c_cobble
+					minetest.swap_node(p, {name = "mcl_core:cobble"})
 				elseif ty < maxy - 1 then
 					-- Normally the openings are already clear, but not if it is a corner
 					-- widening. Make sure to clear at least the bottom 2 nodes of an opening.
-									data[p_pos] = c_air
+					minetest.swap_node(p, {name = "air"})
-								elseif ty == maxy - 1 and data[p_pos] ~= c_air then
+				elseif ty == maxy - 1 and mcl_mapgen_core.get_node(p).name ~= "air" then
 					-- This allows for variation between 2-node and 3-node high openings.
-									data[p_pos] = c_cobble
+					minetest.swap_node(p, {name = "mcl_core:cobble"})
 				end
 				-- If it was an opening, the lower 3 blocks are not touched at all
 
@@ -294,49 +269,28 @@ minetest.register_on_generated(function(minp, maxp)
 
 				-- Place next chest at the wall (if it was its chosen wall slot)
 				if forChest and (currentChest < totalChests + 1) and (chestSlots[currentChest] == chestSlotCounter) then
-									table.insert(chest_posses, {x=tx, y=ty, z=tz})
 					currentChest = currentChest + 1
+					table.insert(chests, {x=tx, y=ty, z=tz})
 				else
-									data[p_pos] = c_air
+					minetest.swap_node(p, {name = "air"})
 				end
 				if forChest then
 					chestSlotCounter = chestSlotCounter + 1
 				end
 			end
 		end
+	end end end
 
-					end
+	for c=#chests, 1, -1 do
-				end
+		local pos = chests[c]
-			end
-		end
 
-		lvm_used = true
-	end
-
-	if lvm_used then
-		local chest_param2 = {}
-		-- Determine correct chest rotation (must pointi outwards)
-		for c=1, #chest_posses do
-			local cpos = chest_posses[c]
-
-			-- Check surroundings of chest to determine correct rotation
-			local surround_vectors = {
-				{ x=-1, y=0, z=0 },
-				{ x=1, y=0, z=0 },
-				{ x=0, y=0, z=-1 },
-				{ x=0, y=0, z=1 },
-			}
 		local surroundings = {}
-
 		for s=1, #surround_vectors do
 			-- Detect the 4 horizontal neighbors
-				local spos = vector.add(cpos, surround_vectors[s])
+			local spos = vector.add(pos, surround_vectors[s])
-				local wpos = vector.subtract(cpos, surround_vectors[s])
+			local wpos = vector.subtract(pos, surround_vectors[s])
-				local p_pos = area:index(spos.x, spos.y, spos.z)
+			local nodename = minetest.get_node(spos).name
-				local p_pos2 = area:index(wpos.x, wpos.y, wpos.z)
+			local nodename2 = minetest.get_node(wpos).name
-
-				local nodename = minetest.get_name_from_content_id(data[p_pos])
-				local nodename2 = minetest.get_name_from_content_id(data[p_pos2])
 			local nodedef = minetest.registered_nodes[nodename]
 			local nodedef2 = minetest.registered_nodes[nodename2]
 			-- The chest needs an open space in front of it and a walkable node (except chest) behind it
@@ -348,38 +302,22 @@ minetest.register_on_generated(function(minp, maxp)
 		local facedir
 		if #surroundings <= 0 then
 			-- Fallback if chest ended up in the middle of a room for some reason
-				facedir = math.random(0, 0)
+			facedir = pr:next(0, 0)
 		else
 			-- 1 or multiple possible open directions: Choose random facedir
-				local face_to = surroundings[math.random(1, #surroundings)]
+			local face_to = surroundings[pr:next(1, #surroundings)]
-				facedir = minetest.dir_to_facedir(vector.subtract(cpos, face_to))
+			facedir = minetest.dir_to_facedir(vector.subtract(pos, face_to))
-			end
-			chest_param2[c] = facedir
 		end
 
-		-- Finally generate the dungeons all at once (except the chests and the spawners)
+		minetest.set_node(pos, {name="mcl_chests:chest", param2=facedir})
-		vm:set_data(data)
+		local meta = minetest.get_meta(pos)
-		vm:calc_lighting()
+		mcl_loot.fill_inventory(meta:get_inventory(), "main", mcl_loot.get_multi_loot(loottable, pr))
-		vm:update_liquids()
-		vm:write_to_map()
-
-		-- Chests are placed seperately
-		for c=1, #chest_posses do
-			local cpos = chest_posses[c]
-			minetest.set_node(cpos, {name="mcl_chests:chest", param2=chest_param2[c]})
-			local meta = minetest.get_meta(cpos)
-			local inv = meta:get_inventory()
-			local items = get_loot()
-			mcl_loot.fill_inventory(inv, "main", items)
 	end
 
 	-- Mob spawners are placed seperately, too
 	-- We don't want to destroy non-ground nodes
-		for s=1, #spawner_posses do
+	for s=#spawner_posses, 1, -1 do
 		local sp = spawner_posses[s]
-			local n = minetest.get_name_from_content_id(data[area:index(sp.x,sp.y,sp.z)])
-			if minetest.registered_nodes[n].is_ground_content then
-
 		-- ... and place it and select a random mob
 		minetest.set_node(sp, {name = "mcl_mobspawners:spawner"})
 		local mobs = {
@@ -388,13 +326,27 @@ minetest.register_on_generated(function(minp, maxp)
 			"mobs_mc:spider",
 			"mobs_mc:skeleton",
 		}
-				local spawner_mob = mobs[math.random(1, #mobs)]
+		local spawner_mob = mobs[pr:next(1, #mobs)]
 
 		mcl_mobspawners.setup_spawner(sp, spawner_mob, 0, 7)
 	end
-		end
-
-	end
-
-end)
 end
+
+local function dungeons_nodes(minp, maxp, blockseed)
+	local ymin, ymax = math.max(min_y, minp.y),  math.min(max_y, maxp.y)
+	if ymax < ymin then return false end
+	local pr = PseudoRandom(blockseed)
+	for a=1, attempts do
+		local dim = dungeonsizes[pr:next(1, #dungeonsizes)]
+		local x = pr:next(minp.x, maxp.x-dim.x-2)
+		local y = pr:next(ymin  , ymax  -dim.y-2)
+		local z = pr:next(minp.z, maxp.z-dim.z-2)
+		local p1 = {x=x,y=y,z=z}
+		local p2 = {x = x+dim.x+1, y = y+dim.y+1, z = z+dim.z+1}
+		minetest.log("verbose","[mcl_dungeons] size=" ..minetest.pos_to_string(dim) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2))
+		local param = {p1=p1, p2=p2, dim=dim, pr=pr}
+		minetest.emerge_area(p1, p2, ecb_spawn_dungeon, param)
+	end
+end
+
+mcl_mapgen_core.register_generator("dungeons", nil, dungeons_nodes, 999999)

mods/MAPGEN/mcl_mapgen_core/init.lua

@@ -1,3 +1,46 @@
+mcl_mapgen_core = {}
+mcl_mapgen_core.registered_generators = {}
+
+local lvm, nodes, param2 = 0, 0, 0
+
+local generating = {} -- generating chunks
+local chunks = {} -- intervals of chunks generated
+local function add_chunk(pos)
+	local n = mcl_vars.get_chunk_number(pos) -- unsigned int
+	local prev
+	for i, d in pairs(chunks) do
+		if n <= d[2] then -- we've found it
+			if (n == d[2]) or (n >= d[1]) then return end -- already here
+			if n == d[1]-1 then -- right before:
+				if prev and (prev[2] == n-1) then
+					prev[2] = d[2]
+					table.remove(chunks, i)
+					return
+				end
+				d[1] = n
+				return
+			end
+			if prev and (prev[2] == n-1) then --join to previous
+				prev[2] = n
+				return
+			end
+			table.insert(chunks, i, {n, n}) -- insert new interval before i
+			return
+		end
+		prev = d
+	end
+	chunks[#chunks] = {n, n}
+end
+function mcl_mapgen_core.is_generated(pos)
+	local n = mcl_vars.get_chunk_number(pos) -- unsigned int
+	for i, d in pairs(chunks) do
+		if n <= d[2] then
+			return (n >= d[1])
+		end
+	end
+	return false
+end
+
 --
 -- Aliases for map generator outputs
 --
@@ -1190,12 +1233,14 @@ local perlin_structures
 local perlin_vines, perlin_vines_fine, perlin_vines_upwards, perlin_vines_length, perlin_vines_density
 local perlin_clay
 
-local function generate_clay(minp, maxp, seed, voxelmanip_data, voxelmanip_area, lvm_used)
+local function generate_clay(minp, maxp, blockseed, voxelmanip_data, voxelmanip_area, lvm_used)
 	-- TODO: Make clay generation reproducible for same seed.
 	if maxp.y < -5 or minp.y > 0 then
 		return lvm_used
 	end
 
+	local pr = PseudoRandom(blockseed)
+
 	perlin_clay = perlin_clay or minetest.get_perlin({
 		offset = 0.5,
 		scale = 0.2,
@@ -1212,18 +1257,18 @@ local function generate_clay(minp, maxp, seed, voxelmanip_data, voxelmanip_area,
 		for divx=0+1,divs-2 do
 		for divz=0+1,divs-2 do
 			-- Get position and shift it a bit randomly so the clay do not obviously appear in a grid
-			local cx = minp.x + math.floor((divx+0.5)*divlen) + math.random(-1,1)
+			local cx = minp.x + math.floor((divx+0.5)*divlen) + pr:next(-1,1)
-			local cz = minp.z + math.floor((divz+0.5)*divlen) + math.random(-1,1)
+			local cz = minp.z + math.floor((divz+0.5)*divlen) + pr:next(-1,1)
 
 			local water_pos = voxelmanip_area:index(cx, y+1, cz)
 			local waternode = voxelmanip_data[water_pos]
 			local surface_pos = voxelmanip_area:index(cx, y, cz)
 			local surfacenode = voxelmanip_data[surface_pos]
 
-			local genrnd = math.random(1, 20)
+			local genrnd = pr:next(1, 20)
 			if genrnd == 1 and perlin_clay:get_3d({x=cx,y=y,z=cz}) > 0 and waternode == c_water and
 					(surfacenode == c_dirt or minetest.get_item_group(minetest.get_name_from_content_id(surfacenode), "sand") == 1) then
-				local diamondsize = math.random(1, 3)
+				local diamondsize = pr:next(1, 3)
 				for x1 = -diamondsize, diamondsize do
 				for z1 = -(diamondsize - math.abs(x1)), diamondsize - math.abs(x1) do
 					local ccpos = voxelmanip_area:index(cx+x1, y, cz+z1)
@@ -1242,37 +1287,34 @@ local function generate_clay(minp, maxp, seed, voxelmanip_data, voxelmanip_area,
 end
 
 -- TODO: Try to use more efficient structure generating code
-local function generate_structures(minp, maxp, seed, biomemap)
+local function generate_structures(minp, maxp, blockseed, biomemap)
 	local chunk_has_desert_well = false
 	local chunk_has_desert_temple = false
 	local chunk_has_igloo = false
-	local struct_min, struct_max = -3, 64
+	local struct_min, struct_max = -3, 111 --64
+
 	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
-		local divs = (maxp.x-minp.x)/divlen+1;
+		for x0 = minp.x, maxp.x, divlen do for z0 = minp.z, maxp.z, divlen do
-		for divx=0,divs-1 do
-		for divz=0,divs-1 do
-			local x0 = minp.x + math.floor((divx+0)*divlen)
-			local z0 = minp.z + math.floor((divz+0)*divlen)
-			local x1 = minp.x + math.floor((divx+1)*divlen)
-			local z1 = minp.z + math.floor((divz+1)*divlen)
 			-- 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 pr = PseudoRandom(seed+1)
+			local p, ground_y
 			for i=0, amount do
-				local x = pr:next(x0, x1)
+				p = {x = pr:next(x0, x0+divlen-1), y = 0, z = pr:next(z0, z0+divlen-1)}
-				local z = pr:next(z0, z1)
 				-- Find ground level
-				local ground_y = nil
+				ground_y = nil
+				local nn
 				for y = struct_max, struct_min, -1 do
-					local checknode = minetest.get_node_or_nil({x=x,y=y,z=z})
+					p.y = y
+					local checknode = minetest.get_node(p)
 					if checknode then
-						local def = minetest.registered_nodes[checknode.name]
+						nn = checknode.name
+						local def = minetest.registered_nodes[nn]
 						if def and def.walkable then
 							ground_y = y
 							break
@@ -1281,21 +1323,17 @@ local function generate_structures(minp, maxp, seed, biomemap)
 				end
 
 				if ground_y then
-					local p = {x=x,y=ground_y+1,z=z}
+					p.y = ground_y+1
-					local nn = minetest.get_node(p).name
+					local nn0 = minetest.get_node(p).name
 					-- Check if the node can be replaced
-					if minetest.registered_nodes[nn] and
+					if minetest.registered_nodes[nn0] and minetest.registered_nodes[nn0].buildable_to then
-						minetest.registered_nodes[nn].buildable_to then
-						nn = minetest.get_node({x=x,y=ground_y,z=z}).name
-						local struct = false
-
 						-- Desert temples and desert wells
 						if nn == "mcl_core:sand" or (nn == "mcl_core:sandstone") then
 							if not chunk_has_desert_temple and not chunk_has_desert_well and ground_y > 3 then
 								-- Spawn desert temple
 								-- TODO: Check surface
-								if math.random(1,12000) == 1 then
+								if pr:next(1,12000) == 1 then
-									mcl_structures.call_struct(p, "desert_temple")
+									mcl_structures.call_struct(p, "desert_temple", nil, pr)
 									chunk_has_desert_temple = true
 								end
 							end
@@ -1303,11 +1341,11 @@ local function generate_structures(minp, maxp, seed, biomemap)
 								local desert_well_prob = minecraft_chunk_probability(1000, minp, maxp)
 
 								-- Spawn desert well
-								if math.random(1, desert_well_prob) == 1 then
+								if pr:next(1, desert_well_prob) == 1 then
 									-- Check surface
 									local surface = minetest.find_nodes_in_area({x=p.x,y=p.y-1,z=p.z}, {x=p.x+5, y=p.y-1, z=p.z+5}, "mcl_core:sand")
 									if #surface >= 25 then
-										mcl_structures.call_struct(p, "desert_well")
+										mcl_structures.call_struct(p, "desert_well", nil, pr)
 										chunk_has_desert_well = true
 									end
 								end
@@ -1315,13 +1353,13 @@ local function generate_structures(minp, maxp, seed, biomemap)
 
 						-- Igloos
 						elseif 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 math.random(1, 4400) == 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")
+									mcl_structures.call_struct(p, "igloo", nil, pr)
 									chunk_has_igloo = true
 								end
 							end
@@ -1331,16 +1369,16 @@ local function generate_structures(minp, maxp, seed, biomemap)
 						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 math.random(1, fossil_prob) == 1 then
+							if pr:next(1, fossil_prob) == 1 then
 								-- Spawn fossil below desert surface between layers 40 and 49
-								local p1 = {x=p.x, y=math.random(mcl_worlds.layer_to_y(40), mcl_worlds.layer_to_y(49)), z=p.z}
+								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")
+									mcl_structures.call_struct(p1, "fossil", nil, pr)
 								end
 							end
 						end
@@ -1348,7 +1386,7 @@ local function generate_structures(minp, maxp, seed, biomemap)
 						-- Witch hut
 						if ground_y <= 0 and nn == "mcl_core:dirt" then
 						local prob = minecraft_chunk_probability(48, minp, maxp)
-						if math.random(1, prob) == 1 then
+						if pr:next(1, prob) == 1 then
 
 							local swampland = minetest.get_biome_id("Swampland")
 							local swampland_shore = minetest.get_biome_id("Swampland_shore")
@@ -1370,7 +1408,7 @@ local function generate_structures(minp, maxp, seed, biomemap)
 							end
 
 							if here_be_witches then
-								local r = tostring(math.random(0, 3) * 90) -- "0", "90", "180" or 270"
+								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
@@ -1389,7 +1427,7 @@ local function generate_structures(minp, maxp, seed, biomemap)
 									-- 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.call_struct(place, "witch_hut", r)
+									mcl_structures.call_struct(place, "witch_hut", r, pr)
 
 									-- TODO: Spawn witch in or around hut when the mob sucks less.
 
@@ -1451,7 +1489,7 @@ local function generate_structures(minp, maxp, seed, biomemap)
 						-- Ice spikes in v6
 						-- In other mapgens, ice spikes are generated as decorations.
 						if mg_name == "v6" and not chunk_has_igloo and nn == "mcl_core:snowblock" then
-							local spike = math.random(1, 58000)
+							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}
@@ -1460,7 +1498,7 @@ local function generate_structures(minp, maxp, seed, biomemap)
 								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.call_struct(p, "ice_spike_large")
+									mcl_structures.call_struct(p, "ice_spike_large", nil, pr)
 								end
 							elseif spike < 100 then
 								-- Check surface
@@ -1471,7 +1509,7 @@ local function generate_structures(minp, maxp, seed, biomemap)
 								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.call_struct(p, "ice_spike_small")
+									mcl_structures.call_struct(p, "ice_spike_small", nil, pr)
 								end
 							end
 						end
@@ -1479,36 +1517,31 @@ local function generate_structures(minp, maxp, seed, biomemap)
 				end
 
 			end
-		end
+		end end
-		end
 	-- End exit portal
 	elseif	minp.y <= END_EXIT_PORTAL_POS.y and maxp.y >= END_EXIT_PORTAL_POS.y and
 		minp.x <= END_EXIT_PORTAL_POS.x and maxp.x >= END_EXIT_PORTAL_POS.x and
 		minp.z <= END_EXIT_PORTAL_POS.z and maxp.z >= END_EXIT_PORTAL_POS.z then
-		local built = false
 		for y=maxp.y, minp.y, -1 do
 			local p = {x=END_EXIT_PORTAL_POS.x, y=y, z=END_EXIT_PORTAL_POS.z}
 			if minetest.get_node(p).name == "mcl_end:end_stone" then
 				mcl_structures.call_struct(p, "end_exit_portal")
-				built = true
+				return
-				break
 			end
 		end
-		if not built then
 		mcl_structures.call_struct(END_EXIT_PORTAL_POS, "end_exit_portal")
 	end
-	end
 end
 
 -- Buffers for LuaVoxelManip
-local lvm_buffer = {}
+-- local lvm_buffer = {}
-local lvm_buffer_param2 = {}
+-- local lvm_buffer_param2 = {}
 
 -- Generate tree decorations in the bounding box. This adds:
 -- * Cocoa at jungle trees
 -- * Jungle tree vines
 -- * Oak vines in swamplands
-local function generate_tree_decorations(minp, maxp, seed, data, param2_data, area, biomemap, lvm_used)
+local function generate_tree_decorations(minp, maxp, seed, data, param2_data, area, biomemap, lvm_used, pr)
 	if maxp.y < 0 then
 		return lvm_used
 	end
@@ -1576,7 +1609,7 @@ local function generate_tree_decorations(minp, maxp, seed, data, param2_data, ar
 
 		if minetest.find_node_near(pos, 1, {"mcl_core:jungleleaves"}) then
 
-			dir = math.random(1, cocoachance)
+			dir = pr:next(1, cocoachance)
 
 			if dir == 1 then
 				pos.z = pos.z + 1
@@ -1594,7 +1627,7 @@ local function generate_tree_decorations(minp, maxp, seed, data, param2_data, ar
 			if dir < 5
 			and data[p_pos] == c_air
 			and l ~= nil and l > 12 then
-				local c = math.random(1, 3)
+				local c = pr:next(1, 3)
 				if c == 1 then
 					data[p_pos] = c_cocoa_1
 				elseif c == 2 then
@@ -1810,70 +1843,101 @@ local generate_nether_decorations = function(minp, maxp, seed)
 
 end
 
--- Below the bedrock, generate air/void
+minetest.register_on_generated(function(minp, maxp, blockseed)
-minetest.register_on_generated(function(minp, maxp, seed)
+	add_chunk(minp)
+	local p1, p2 = {x=minp.x, y=minp.y, z=minp.z}, {x=maxp.x, y=maxp.y, z=maxp.z}
+	if lvm > 0 then
+		local lvm_used, shadow = false, false
+		local lb = {} -- buffer
+		local lb2 = {} -- param2
 		local vm, emin, emax = minetest.get_mapgen_object("voxelmanip")
-	local data = vm:get_data(lvm_buffer)
+		local e1, e2 = {x=emin.x, y=emin.y, z=emin.z}, {x=emax.x, y=emax.y, z=emax.z}
-	local param2_data = vm:get_param2_data(lvm_buffer_param2)
+		local data2
-	local area = VoxelArea:new({MinEdge=emin, MaxEdge=emax})
+		local data = vm:get_data(lb)
-	local aream = VoxelArea:new({MinEdge={x=minp.x, y=0, z=minp.z}, MaxEdge={x=maxp.x, y=0, z=maxp.z}})
+		if param2 > 0 then
-	local lvm_used = false
+			data2 = vm:get_param2_data(lb2)
-	local biomemap
+		end
+		local area = VoxelArea:new({MinEdge=e1, MaxEdge=e2})
 
-	local ymin, ymax
+		for _, rec in pairs(mcl_mapgen_core.registered_generators) do
-
+			if rec.vf then
-	-- Generate basic layer-based nodes: void, bedrock, realm barrier, lava seas, etc.
+				local lvm_used0, shadow0 = rec.vf(vm, data, data2, e1, e2, area, p1, p2, blockseed)
-	-- Also perform some basic node replacements.
+				if lvm_used0 then
-
-	-- Helper function to set all nodes in the layers between min and max.
-	-- content_id: Node to set
-	-- check: optional.
-	--	If content_id, node will be set only if it is equal to check.
-	--	If function(pos_to_check, content_id_at_this_pos), will set node only if returns true.
-	-- min, max: Minimum and maximum Y levels of the layers to set
-	-- minp, maxp: minp, maxp of the on_generated
-	-- lvm_used: Set to true if any node in this on_generated has been set before.
-	--
-	-- returns true if any node was set and lvm_used otherwise
-	local function set_layers(content_id, check, min, max, minp, maxp, lvm_used)
-		if (maxp.y >= min and minp.y <= max) then
-			for y = math.max(min, minp.y), math.min(max, maxp.y) do
-				for x = minp.x, maxp.x do
-					for z = minp.z, maxp.z do
-						local p_pos = area:index(x, y, z)
-						if check then
-							if type(check) == "function" and check({x=x,y=y,z=z}, data[p_pos]) then
-								data[p_pos] = content_id
-								lvm_used = true
-							elseif check == data[p_pos] then
-								data[p_pos] = content_id
 					lvm_used = true
 				end
-						else
+				if shadow0 then
-							data[p_pos] = content_id
+					shadow = true
-							lvm_used = true
 				end
 			end
 		end
-			end
-		end
-		return lvm_used
-	end
 
-	-- The Void
+		if lvm_used then
-	lvm_used = set_layers(c_void, nil, -31000, mcl_vars.mg_nether_min-1, minp, maxp, lvm_used)
+			-- Write stuff
-	lvm_used = set_layers(c_void, nil, mcl_vars.mg_nether_max+1, mcl_vars.mg_end_min-1, minp, maxp, lvm_used)
+			vm:set_data(data)
-	lvm_used = set_layers(c_void, nil, mcl_vars.mg_end_max+1, mcl_vars.mg_realm_barrier_overworld_end_min-1, minp, maxp, lvm_used)
+			if param2 > 0 then
-	lvm_used = set_layers(c_void, nil, mcl_vars.mg_realm_barrier_overworld_end_max+1, mcl_vars.mg_overworld_min-1, minp, maxp, lvm_used)
+				vm:set_param2_data(data2)
+			end
+			vm:calc_lighting(p1, p2, shadow)
+			vm:write_to_map()
+			vm:update_liquids()
+		end
+	end
 
-	-- Realm barrier between the Overworld void and the End
+	if nodes > 0 then
-	lvm_used = set_layers(c_realm_barrier, nil, mcl_vars.mg_realm_barrier_overworld_end_min, mcl_vars.mg_realm_barrier_overworld_end_max, minp, maxp, lvm_used)
+		for _, rec in pairs(mcl_mapgen_core.registered_generators) do
+			if rec.nf then
+				rec.nf(p1, p2, blockseed)
+			end
+		end
+	end
 
-	if mg_name ~= "singlenode" then
+--	add_chunk(minp)
-		-- Bedrock
+end)
-		local bedrock_check
+
-		if mcl_vars.mg_bedrock_is_rough then
+minetest.register_on_generated=function(node_function)
-			bedrock_check = function(pos)
+	mcl_mapgen_core.register_generator("mod_"..tostring(#mcl_mapgen_core.registered_generators+1), nil, node_function)
+end
+
+function mcl_mapgen_core.register_generator(id, lvm_function, node_function, priority, needs_param2)
+	if not id then return end
+
+	local priority = priority or 5000
+
+	if lvm_function then lvm = lvm + 1 end
+	if lvm_function then nodes = nodes + 1 end
+	if needs_param2 then param2 = param2 + 1 end
+
+	local new_record = {
+		i = priority,
+		vf = lvm_function,
+		nf = node_function,
+		needs_param2 = needs_param2,
+	}
+
+	mcl_mapgen_core.registered_generators[id] = new_record
+	table.sort(
+		mcl_mapgen_core.registered_generators,
+		function(a, b)
+			return (a.i < b.i) or ((a.i == b.i) and (a.vf ~= nil) and (b.vf == nil))
+		end)
+end
+
+function mcl_mapgen_core.unregister_generator(id)
+	if not mcl_mapgen_core.registered_generators[id] then return end
+	local rec = mcl_mapgen_core.registered_generators[id]
+	mcl_mapgen_core.registered_generators[id] = nil
+	if rec.vf then lvm = lvm - 1 end
+	if rev.nf then nodes = nodes - 1 end
+	if rec.needs_param2 then param2 = param2 - 1 end
+	if rec.needs_level0 then level0 = level0 - 1 end
+end
+
+-- Generate basic layer-based nodes: void, bedrock, realm barrier, lava seas, etc.
+-- Also perform some basic node replacements.
+
+local bedrock_check
+if mcl_vars.mg_bedrock_is_rough then
+	bedrock_check = function(pos, _, pr)
 		local y = pos.y
 		-- Bedrock layers with increasing levels of roughness, until a perfecly flat bedrock later at the bottom layer
 		-- This code assumes a bedrock height of 5 layers.
@@ -1903,32 +1967,82 @@ minetest.register_on_generated(function(minp, maxp, seed)
 			return false
 		end
 
-				return math.random(1, top) <= top-1
+		return pr:next(1, top) <= top-1
+	end
+end
+
+
+-- Helper function to set all nodes in the layers between min and max.
+-- content_id: Node to set
+-- check: optional.
+--	If content_id, node will be set only if it is equal to check.
+--	If function(pos_to_check, content_id_at_this_pos), will set node only if returns true.
+-- min, max: Minimum and maximum Y levels of the layers to set
+-- minp, maxp: minp, maxp of the on_generated
+-- lvm_used: Set to true if any node in this on_generated has been set before.
+--
+-- returns true if any node was set and lvm_used otherwise
+local function set_layers(data, area, content_id, check, min, max, minp, maxp, lvm_used, pr)
+	if (maxp.y >= min and minp.y <= max) then
+		for y = math.max(min, minp.y), math.min(max, maxp.y) do
+			for x = minp.x, maxp.x do
+				for z = minp.z, maxp.z do
+					local p_pos = area:index(x, y, z)
+					if check then
+						if type(check) == "function" and check({x=x,y=y,z=z}, data[p_pos], pr) then
+							data[p_pos] = content_id
+							lvm_used = true
+						elseif check == data[p_pos] then
+							data[p_pos] = content_id
+							lvm_used = true
 						end
 					else
-			bedrock_check = nil
+						data[p_pos] = content_id
+						lvm_used = true
 					end
+				end
+			end
+		end
+	end
+	return lvm_used
+end
 
-		lvm_used = set_layers(c_bedrock, bedrock_check, mcl_vars.mg_bedrock_overworld_min, mcl_vars.mg_bedrock_overworld_max, minp, maxp, lvm_used)
+-- Below the bedrock, generate air/void
-		lvm_used = set_layers(c_bedrock, bedrock_check, mcl_vars.mg_bedrock_nether_bottom_min, mcl_vars.mg_bedrock_nether_bottom_max, minp, maxp, lvm_used)
+local function basic(vm, data, data2, emin, emax, area, minp, maxp, blockseed)
-		lvm_used = set_layers(c_bedrock, bedrock_check, mcl_vars.mg_bedrock_nether_top_min, mcl_vars.mg_bedrock_nether_top_max, minp, maxp, lvm_used)
+	local biomemap, ymin, ymax
+	local lvm_used = false
+	local pr = PseudoRandom(blockseed)
+
+	-- The Void
+	lvm_used = set_layers(data, area, c_void         , nil, mcl_vars.mapgen_edge_min                     , mcl_vars.mg_nether_min                     -1, minp, maxp, lvm_used, pr)
+	lvm_used = set_layers(data, area, c_void         , nil, mcl_vars.mg_nether_max                     +1, mcl_vars.mg_end_min                        -1, minp, maxp, lvm_used, pr)
+	lvm_used = set_layers(data, area, c_void         , nil, mcl_vars.mg_end_max                        +1, mcl_vars.mg_realm_barrier_overworld_end_min-1, minp, maxp, lvm_used, pr)
+	-- Realm barrier between the Overworld void and the End
+	lvm_used = set_layers(data, area, c_realm_barrier, nil, mcl_vars.mg_realm_barrier_overworld_end_min  , mcl_vars.mg_realm_barrier_overworld_end_max  , minp, maxp, lvm_used, pr)
+	lvm_used = set_layers(data, area, c_void         , nil, mcl_vars.mg_realm_barrier_overworld_end_max+1, mcl_vars.mg_overworld_min                  -1, minp, maxp, lvm_used, pr)
+
+	if mg_name ~= "singlenode" then
+		-- Bedrock
+		lvm_used = set_layers(data, area, c_bedrock, bedrock_check, mcl_vars.mg_bedrock_overworld_min, mcl_vars.mg_bedrock_overworld_max, minp, maxp, lvm_used, pr)
+		lvm_used = set_layers(data, area, c_bedrock, bedrock_check, mcl_vars.mg_bedrock_nether_bottom_min, mcl_vars.mg_bedrock_nether_bottom_max, minp, maxp, lvm_used, pr)
+		lvm_used = set_layers(data, area, c_bedrock, bedrock_check, mcl_vars.mg_bedrock_nether_top_min, mcl_vars.mg_bedrock_nether_top_max, minp, maxp, lvm_used, pr)
 
 		-- Flat Nether
 		if mg_name == "flat" then
-			lvm_used = set_layers(c_air, nil, mcl_vars.mg_flat_nether_floor, mcl_vars.mg_flat_nether_ceiling, minp, maxp, lvm_used)
+			lvm_used = set_layers(data, area, c_air, nil, mcl_vars.mg_flat_nether_floor, mcl_vars.mg_flat_nether_ceiling, minp, maxp, lvm_used, pr)
 		end
 
 		-- Big lava seas by replacing air below a certain height
 		if mcl_vars.mg_lava then
-			lvm_used = set_layers(c_lava, c_air, mcl_vars.mg_overworld_min, mcl_vars.mg_lava_overworld_max, emin, emax, lvm_used)
+			lvm_used = set_layers(data, area, c_lava, c_air, mcl_vars.mg_overworld_min, mcl_vars.mg_lava_overworld_max, emin, emax, lvm_used, pr)
-			lvm_used = set_layers(c_nether_lava, c_air, mcl_vars.mg_nether_min, mcl_vars.mg_lava_nether_max, emin, emax, lvm_used)
+			lvm_used = set_layers(data, area, c_nether_lava, c_air, mcl_vars.mg_nether_min, mcl_vars.mg_lava_nether_max, emin, emax, lvm_used, pr)
 		end
 
 		-- Clay, vines, cocoas
-		lvm_used = generate_clay(minp, maxp, seed, data, area, lvm_used)
+		lvm_used = generate_clay(minp, maxp, blockseed, data, area, lvm_used)
 
 		biomemap = minetest.get_mapgen_object("biomemap")
-		lvm_used = generate_tree_decorations(minp, maxp, seed, data, param2_data, area, biomemap, lvm_used)
+		lvm_used = generate_tree_decorations(minp, maxp, blockseed, data, data2, area, biomemap, lvm_used, pr)
 
 		----- Interactive block fixing section -----
 		----- The section to perform basic block overrides of the core mapgen generated world. -----
@@ -1974,26 +2088,29 @@ minetest.register_on_generated(function(minp, maxp, seed)
 				-- Set param2 (=color) of grass blocks.
 				-- Clear snowy grass blocks without snow above to ensure consistency.
 				local nodes = minetest.find_nodes_in_area(minp, maxp, {"mcl_core:dirt_with_grass", "mcl_core:dirt_with_grass_snow"})
+
+				-- Flat area at y=0 to read biome 3 times faster than 5.3.0.get_biome_data(pos).biome: 43us vs 125us per iteration:
+				local aream = VoxelArea:new({MinEdge={x=minp.x, y=0, z=minp.z}, MaxEdge={x=maxp.x, y=0, z=maxp.z}})
 				for n=1, #nodes do
-					local p_pos = area:index(nodes[n].x, nodes[n].y, nodes[n].z)
+					local n = nodes[n]
-					local p_pos_above = area:index(nodes[n].x, nodes[n].y+1, nodes[n].z)
+					local p_pos = area:index(n.x, n.y, n.z)
-					local p_pos_below = area:index(nodes[n].x, nodes[n].y-1, nodes[n].z)
+					local p_pos_above = area:index(n.x, n.y+1, n.z)
-					local b_pos = aream:index(nodes[n].x, 0, nodes[n].z)
+					local p_pos_below = area:index(n.x, n.y-1, n.z)
+					local b_pos = aream:index(n.x, 0, n.z)
 					local bn = minetest.get_biome_name(biomemap[b_pos])
 					if bn then
 						local biome = minetest.registered_biomes[bn]
-						if biome then
+						if biome and biome._mcl_biome_type then
-							if biome._mcl_biome_type then
+							data2[p_pos] = biome._mcl_palette_index
-								param2_data[p_pos] = biome._mcl_palette_index
 							lvm_used = true
 						end
 					end
-					end
 					if data[p_pos] == c_dirt_with_grass_snow and p_pos_above and data[p_pos_above] ~= c_top_snow and data[p_pos_above] ~= c_snow_block then
 						data[p_pos] = c_dirt_with_grass
 						lvm_used = true
 					end
 				end
+
 			end
 
 		-- Nether block fixes:
@@ -2025,27 +2142,28 @@ minetest.register_on_generated(function(minp, maxp, seed)
 		-- * Remove stone, sand, dirt in v6 so our End map generator works in v6.
 		-- * Generate spawn platform (End portal destination)
 		elseif emin.y <= mcl_vars.mg_end_max and emax.y >= mcl_vars.mg_end_min then
-			local nodes
+			local nodes, node
 			if mg_name == "v6" then
 				nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source", "mcl_core:stone", "mcl_core:sand", "mcl_core:dirt"})
 			else
 				nodes = minetest.find_nodes_in_area(emin, emax, {"mcl_core:water_source"})
 			end
-			for n=1, #nodes do
+			if #nodes > 0 then
-				local y = nodes[n].y
-				local p_pos = area:index(nodes[n].x, y, nodes[n].z)
-
-				if data[p_pos] == c_water or data[p_pos] == c_stone or data[p_pos] == c_dirt or data[p_pos] == c_sand then
-					data[p_pos] = c_air
 				lvm_used = true
+				for n=1, #nodes do
+					node = nodes[n]
+					data[area:index(node.x, node.y, node.z)] = c_air
 				end
-
 			end
 
 			-- Obsidian spawn platform
 			if minp.y <= mcl_vars.mg_end_platform_pos.y and maxp.y >= mcl_vars.mg_end_platform_pos.y and
 				minp.x <= mcl_vars.mg_end_platform_pos.x and maxp.x >= mcl_vars.mg_end_platform_pos.z and
 				minp.z <= mcl_vars.mg_end_platform_pos.z and maxp.z >= mcl_vars.mg_end_platform_pos.z then
+
+				local pos1 = {x = math.max(minp.x, mcl_vars.mg_end_platform_pos.x-2), y = math.max(minp.y, mcl_vars.mg_end_platform_pos.y),   z = math.max(minp.z, mcl_vars.mg_end_platform_pos.z-2)}
+				local pos2 = {x = math.min(maxp.x, mcl_vars.mg_end_platform_pos.x+2), y = math.min(maxp.y, mcl_vars.mg_end_platform_pos.y+2), z = math.min(maxp.z, mcl_vars.mg_end_platform_pos.z+2)}
+
 				for x=math.max(minp.x, mcl_vars.mg_end_platform_pos.x-2), math.min(maxp.x, mcl_vars.mg_end_platform_pos.x+2) do
 				for z=math.max(minp.z, mcl_vars.mg_end_platform_pos.z-2), math.min(maxp.z, mcl_vars.mg_end_platform_pos.z+2) do
 				for y=math.max(minp.y, mcl_vars.mg_end_platform_pos.y), math.min(maxp.y, mcl_vars.mg_end_platform_pos.y+2) do
@@ -2065,7 +2183,7 @@ minetest.register_on_generated(function(minp, maxp, seed)
 
 	-- Final hackery: Set sun light level in the End.
 	-- -26912 is at a mapchunk border.
-	local shadow
+	local shadow = true
 	if minp.y >= -26912 and maxp.y <= mcl_vars.mg_end_max then
 		vm:set_lighting({day=15, night=15})
 		lvm_used = true
@@ -2075,21 +2193,60 @@ minetest.register_on_generated(function(minp, maxp, seed)
 		lvm_used = true
 	end
 
-	-- Write stuff
-	if lvm_used then
-		vm:set_data(data)
-		vm:set_param2_data(param2_data)
-		vm:calc_lighting(nil, nil, shadow)
-		vm:write_to_map()
-		vm:update_liquids()
-	end
-
 	if mg_name ~= "singlenode" then
 		-- Generate special decorations
-		generate_underground_mushrooms(minp, maxp, seed)
+		generate_underground_mushrooms(minp, maxp, blockseed)
-		generate_nether_decorations(minp, maxp, seed)
+		generate_nether_decorations(minp, maxp, blockseed)
-		generate_structures(minp, maxp, seed, biomemap)
+		generate_structures(minp, maxp, blockseed, biomemap)
 	end
-end)
 
+	return lvm_used, shadow
+end
 
+mcl_mapgen_core.register_generator("main", basic, nil, 1, true)
+
+-- "Trivial" (actually NOT) function to just read the node and some stuff to not just return "ignore", like 5.3.0 does.
+-- p: Position, if it's wrong, {name="error"} node will return.
+-- force: optional (default: false) - Do the maximum to still read the node within us_timeout.
+-- us_timeout: optional (default: 244 = 0.000244 s = 1/80/80/80), set it at least to 3000000 to let mapgen to finish its job.
+--
+-- returns node definition, eg. {name="air"}. Unfortunately still can return {name="ignore"}.
+function mcl_mapgen_core.get_node(p, force, us_timeout)
+	-- check initial circumstances
+	if not p or not p.x or not p.y or not p.z then return {name="error"} end
+
+	-- try common way
+	local node = minetest.get_node(p)
+	if node.name ~= "ignore" then
+		return node
+	end
+
+	-- copy table to get sure it won't changed by other threads
+	local pos = {x=p.x,y=p.y,z=p.z}
+
+	-- try LVM
+	minetest.get_voxel_manip():read_from_map(pos, pos)
+	node = minetest.get_node(pos)
+	if node.name ~= "ignore" or not force then
+		return node
+	end
+
+	-- all ways failed - need to emerge (or forceload if generated)
+	local us_timeout = us_timeout or 244
+	if mcl_mapgen_core.is_generated(pos) then
+		minetest.forceload_block(pos)
+	else
+		minetest.emerge_area(pos, pos)
+	end
+
+	local t = minetest.get_us_time()
+
+	node = minetest.get_node(pos)
+
+	while (not node or node.name == "ignore") and (minetest.get_us_time() - t < us_timeout) do
+		node = minetest.get_node(pos)
+	end
+
+	return node
+	-- it still can return "ignore", LOL, even if force = true, but only after time out
+end

mods/MAPGEN/mcl_strongholds/init.lua

@@ -67,7 +67,8 @@ local init_strongholds = function()
 end
 
 -- Stronghold generation for register_on_generated.
-local generate_strongholds = function(minp, maxp)
+local generate_strongholds = function(minp, maxp, blockseed)
+	local pr = PseudoRandom(blockseed)
 	for s=1, #strongholds do
 		if not strongholds[s].generated then
 			local pos = strongholds[s].pos
@@ -80,6 +81,12 @@ local generate_strongholds = function(minp, maxp)
 				if pos.x + 6 > maxp.x then
 					pos.x = maxp.x - 7
 				end
+				if pos.y - 4 < minp.y then
+					pos.y = minp.y + 5
+				end
+				if pos.y + 4 > maxp.y then
+					pos.y = maxp.y - 5
+				end
 				if pos.z - 6 < minp.z then
 					pos.z = minp.z + 7
 				end
@@ -87,7 +94,7 @@ local generate_strongholds = function(minp, maxp)
 					pos.z = maxp.z - 7
 				end
 
-				mcl_structures.call_struct(pos, "end_portal_shrine")
+				mcl_structures.call_struct(pos, "end_portal_shrine", nil, pr)
 				strongholds[s].generated = true
 			end
 		end
@@ -96,9 +103,4 @@ end
 
 init_strongholds()
 
---[[ Note this mod depends on mcl_mapgen_core to make sure the core mapgen runs FIRST.
+mcl_mapgen_core.register_generator("strongholds", nil, generate_strongholds, 999999)
-This is important because we need this to make sure the stronghold isn't instantly
-overwritten by the core mapgen (since it uses LuaVoxelManip). ]]
-minetest.register_on_generated(function(minp, maxp, blockseed)
-	generate_strongholds(minp, maxp)
-end)

mods/MAPGEN/mcl_structures/init.lua

@@ -1,5 +1,43 @@
 local S = minetest.get_translator("mcl_structures")
 mcl_structures ={}
+local rotations = {
+	"0",
+	"90",
+	"180",
+	"270"
+}
+
+mcl_structures.minetest_place_schematic = minetest.place_schematic
+local function ecb_place(blockpos, action, calls_remaining, param)
+	if calls_remaining >= 1 then return end
+	mcl_structures.minetest_place_schematic(param.pos, param.schematic, param.rotation, param.replacements, param.force_placement, param.flags)
+	if param.after_placement_callback and param.p1 and param.p2 then
+		param.after_placement_callback(param.p1, param.p2, param.size, param.rotation, param.pr)
+	end
+end
+minetest.place_schematic = function(pos, schematic, rotation, replacements, force_placement, flags, after_placement_callback, pr)
+	local s = loadstring(minetest.serialize_schematic(schematic, "lua", {lua_use_comments = false, lua_num_indent_spaces = 0}) .. " return(schematic)")()
+	if s and s.size then
+		local x, z = s.size.x, s.size.z
+		if rotation then
+			if rotation == "random" and pr then
+				rotation = rotations[pr:next(1,#rotations)]
+			end
+			if rotation == "random" then
+				x = math.max(x, z)
+				z = x
+			elseif rotation == "90" or rotation == "270" then
+				x, z = z, x
+			end
+		end
+		local p1 = {x=pos.x    , y=pos.y           , z=pos.z    }
+		local p2 = {x=pos.x+x-1, y=pos.y+s.size.y-1, z=pos.z+z-1}
+		minetest.log("verbose","[mcl_structures] size=" ..minetest.pos_to_string(s.size) .. ", rotation=" .. tostring(rotation) .. ", emerge from "..minetest.pos_to_string(p1) .. " to " .. minetest.pos_to_string(p2))
+		local param = {pos=vector.new(pos), schematic=s, rotation=rotation, replacements=replacements, force_placement=force_placement, flags=flags, p1=p1, p2=p2, after_placement_callback = after_placement_callback, size=vector.new(s.size), pr=pr}
+		minetest.emerge_area(p1, p2, ecb_place, param)
+	end
+end
+mcl_structures.place_schematic = minetest.place_schematic -- for direct usage
 
 mcl_structures.get_struct = function(file)
 	local localfile = minetest.get_modpath("mcl_structures").."/schematics/"..file
@@ -15,10 +53,6 @@ mcl_structures.get_struct = function(file)
 	return allnode
 end
 
-local mapseed = tonumber(minetest.get_mapgen_setting("seed"))
--- Random number generator for all generated structures
-local pr = PseudoRandom(mapseed)
-
 -- Call on_construct on pos.
 -- Useful to init chests from formspec.
 local init_node_construct = function(pos)
@@ -32,16 +66,17 @@ local init_node_construct = function(pos)
 end
 
 -- The call of Struct
-mcl_structures.call_struct = function(pos, struct_style, rotation)
+mcl_structures.call_struct = function(pos, struct_style, rotation, pr)
+	minetest.log("action","[mcl_structures] call_struct " .. struct_style.." at "..minetest.pos_to_string(pos))
 	if not rotation then
 		rotation = "random"
 	end
 	if struct_style == "desert_temple" then
-		return mcl_structures.generate_desert_temple(pos, rotation)
+		return mcl_structures.generate_desert_temple(pos, rotation, pr)
 	elseif struct_style == "desert_well" then
 		return mcl_structures.generate_desert_well(pos, rotation)
 	elseif struct_style == "igloo" then
-		return mcl_structures.generate_igloo(pos, rotation)
+		return mcl_structures.generate_igloo(pos, rotation, pr)
 	elseif struct_style == "witch_hut" then
 		return mcl_structures.generate_witch_hut(pos, rotation)
 	elseif struct_style == "ice_spike_small" then
@@ -49,13 +84,13 @@ mcl_structures.call_struct = function(pos, struct_style, rotation)
 	elseif struct_style == "ice_spike_large" then
 		return mcl_structures.generate_ice_spike_large(pos, rotation)
 	elseif struct_style == "boulder" then
-		return mcl_structures.generate_boulder(pos, rotation)
+		return mcl_structures.generate_boulder(pos, rotation, pr)
 	elseif struct_style == "fossil" then
-		return mcl_structures.generate_fossil(pos, rotation)
+		return mcl_structures.generate_fossil(pos, rotation, pr)
 	elseif struct_style == "end_exit_portal" then
 		return mcl_structures.generate_end_exit_portal(pos, rotation)
 	elseif struct_style == "end_portal_shrine" then
-		return mcl_structures.generate_end_portal_shrine(pos, rotation)
+		return mcl_structures.generate_end_portal_shrine(pos, rotation, pr)
 	end
 end
 
@@ -65,12 +100,12 @@ mcl_structures.generate_desert_well = function(pos)
 	return minetest.place_schematic(newpos, path, "0", nil, true)
 end
 
-mcl_structures.generate_igloo = function(pos)
+mcl_structures.generate_igloo = function(pos, rotation, pr)
 	-- Place igloo
-	local success, rotation = mcl_structures.generate_igloo_top(pos)
+	local success, rotation = mcl_structures.generate_igloo_top(pos, pr)
 	-- Place igloo basement with 50% chance
-	local r = math.random(1,2)
+	local r = pr:next(1,2)
-	if success and r == 1 then
+	if r == 1 then
 		-- Select basement depth
 		local dim = mcl_worlds.pos_to_dimension(pos)
 		local buffer = pos.y - (mcl_vars.mg_lava_overworld_max + 10)
@@ -86,7 +121,7 @@ mcl_structures.generate_igloo = function(pos)
 		if buffer <= 19 then
 			return success
 		end
-		local depth = math.random(19, buffer)
+		local depth = pr:next(19, buffer)
 		local bpos = {x=pos.x, y=pos.y-depth, z=pos.z}
 		-- trapdoor position
 		local tpos
@@ -111,8 +146,8 @@ mcl_structures.generate_igloo = function(pos)
 			return success
 		end
 		local set_brick = function(pos)
-			local c = math.random(1, 3) -- cracked chance
+			local c = pr:next(1, 3) -- cracked chance
-			local m = math.random(1, 10) -- chance for monster egg
+			local m = pr:next(1, 10) -- chance for monster egg
 			local brick
 			if m == 1 then
 				if c == 1 then
@@ -155,28 +190,21 @@ mcl_structures.generate_igloo = function(pos)
 			minetest.set_node({x=tpos.x,y=tpos.y-y,z=tpos.z}, {name="mcl_core:ladder", param2=ladder_param2})
 		end
 		-- Place basement
-		mcl_structures.generate_igloo_basement(bpos, rotation)
+		mcl_structures.generate_igloo_basement(bpos, rotation, pr)
 	end
 	return success
 end
 
-mcl_structures.generate_igloo_top = function(pos)
+mcl_structures.generate_igloo_top = function(pos, pr)
 	-- FIXME: This spawns bookshelf instead of furnace. Fix this!
 	-- Furnace does ot work atm because apparently meta is not set. :-(
 	local newpos = {x=pos.x,y=pos.y-1,z=pos.z}
 	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_igloo_top.mts"
-	local rotation = tostring(math.random(0,3)*90)
+	local rotation = tostring(pr:next(0,3)*90)
 	return minetest.place_schematic(newpos, path, rotation, nil, true), rotation
 end
 
-mcl_structures.generate_igloo_basement = function(pos, orientation)
+local function igloo_placement_callback(p1, p2, size, orientation, pr)
-	-- TODO: Add brewing stand
-	-- TODO: Add monster eggs
-	-- TODO: Spawn villager and zombie villager
-	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_igloo_basement.mts"
-
-	local success = minetest.place_schematic(pos, path, orientation, nil, true)
-	if success then
 	local chest_offset
 	if orientation == "0" then
 		chest_offset = {x=5, y=1, z=5}
@@ -187,7 +215,7 @@ mcl_structures.generate_igloo_basement = function(pos, orientation)
 	elseif orientation == "270" then
 		chest_offset = {x=1, y=1, z=5}
 	else
-			return success
+		return
 	end
 	local size = {x=9,y=5,z=7}
 	local lootitems = mcl_loot.get_multi_loot({
@@ -212,18 +240,24 @@ mcl_structures.generate_igloo_basement = function(pos, orientation)
 		}
 	}}, pr)
 
-		local chest_pos = vector.add(pos, chest_offset)
+	local chest_pos = vector.add(p1, chest_offset)
 	init_node_construct(chest_pos)
 	local meta = minetest.get_meta(chest_pos)
 	local inv = meta:get_inventory()
 	mcl_loot.fill_inventory(inv, "main", lootitems)
-	end
-	return success
 end
 
-mcl_structures.generate_boulder = function(pos)
+mcl_structures.generate_igloo_basement = function(pos, orientation, pr)
+	-- TODO: Add brewing stand
+	-- TODO: Add monster eggs
+	-- TODO: Spawn villager and zombie villager
+	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_igloo_basement.mts"
+	mcl_structures.place_schematic(pos, path, orientation, nil, true, nil, igloo_placement_callback, pr)
+end
+
+mcl_structures.generate_boulder = function(pos, rotation, pr)
 	-- Choose between 2 boulder sizes (2×2×2 or 3×3×3)
-	local r = math.random(1, 10)
+	local r = pr:next(1, 10)
 	local path
 	if r <= 3 then
 		path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_boulder_small.mts"
@@ -235,9 +269,20 @@ mcl_structures.generate_boulder = function(pos)
 	return minetest.place_schematic(newpos, path)
 end
 
+local function hut_placement_callback(p1, p2, size, orientation, pr)
+	if not p1 or not p2 then return end
+	local legs = minetest.find_nodes_in_area(p1, p2, "mcl_core:tree")
+	for i = 1, #legs do
+		while minetest.get_item_group(mcl_mapgen_core.get_node({x=legs[i].x, y=legs[i].y-1, z=legs[i].z}, true, 333333).name, "water") ~= 0 do
+			legs[i].y = legs[i].y - 1
+			minetest.swap_node(legs[i], {name = "mcl_core:tree", param2 = 2})
+		end
+	end
+end
+
 mcl_structures.generate_witch_hut = function(pos, rotation)
 	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_witch_hut.mts"
-	return minetest.place_schematic(pos, path, rotation, nil, true)
+	mcl_structures.place_schematic(pos, path, rotation, nil, true, nil, hut_placement_callback, pr)
 end
 
 mcl_structures.generate_ice_spike_small = function(pos)
@@ -250,7 +295,7 @@ mcl_structures.generate_ice_spike_large = function(pos)
 	return minetest.place_schematic(pos, path, "random", nil, false)
 end
 
-mcl_structures.generate_fossil = function(pos)
+mcl_structures.generate_fossil = function(pos, rotation, pr)
 	-- Generates one out of 8 possible fossil pieces
 	local newpos = {x=pos.x,y=pos.y-1,z=pos.z}
 	local fossils = {
@@ -263,7 +308,7 @@ mcl_structures.generate_fossil = function(pos)
 		"mcl_structures_fossil_spine_3.mts", -- 7×4×13
 		"mcl_structures_fossil_spine_4.mts", -- 8×5×13
 	}
-	local r = math.random(1, #fossils)
+	local r = pr:next(1, #fossils)
 	local path = minetest.get_modpath("mcl_structures").."/schematics/"..fossils[r]
 	return minetest.place_schematic(newpos, path, "random", nil, true)
 end
@@ -273,24 +318,16 @@ mcl_structures.generate_end_exit_portal = function(pos)
 	return minetest.place_schematic(pos, path, "0", nil, true)
 end
 
-local generate_end_portal_shrine_no_delay = function(newpos)
+local function shrine_placement_callback(p1, p2, size, rotation, pr)
-	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_end_portal_room_simple.mts"
-	local size = {x=13, y=8, z=13}
-	local ret = minetest.place_schematic(newpos, path, "0", nil, true)
-	if ret == nil then
-		return ret
-	end
-
-	local area_start, area_end = newpos, vector.add(newpos, size)
 	-- Find and setup spawner with silverfish
-	local spawners = minetest.find_nodes_in_area(area_start, area_end, "mcl_mobspawners:spawner")
+	local spawners = minetest.find_nodes_in_area(p1, p2, "mcl_mobspawners:spawner")
 	for s=1, #spawners do
 		local meta = minetest.get_meta(spawners[s])
 		mcl_mobspawners.setup_spawner(spawners[s], "mobs_mc:silverfish")
 	end
 
 	-- Shuffle stone brick types
-	local bricks = minetest.find_nodes_in_area(area_start, area_end, "mcl_core:stonebrick")
+	local bricks = minetest.find_nodes_in_area(p1, p2, "mcl_core:stonebrick")
 	for b=1, #bricks do
 		local r_bricktype = pr:next(1, 100)
 		local r_infested = pr:next(1, 100)
@@ -317,7 +354,7 @@ local generate_end_portal_shrine_no_delay = function(newpos)
 	end
 
 	-- Also replace stairs
-	local stairs = minetest.find_nodes_in_area(area_start, area_end, {"mcl_stairs:stair_stonebrick", "mcl_stairs:stair_stonebrick_outer", "mcl_stairs:stair_stonebrick_inner"})
+	local stairs = minetest.find_nodes_in_area(p1, p2, {"mcl_stairs:stair_stonebrick", "mcl_stairs:stair_stonebrick_outer", "mcl_stairs:stair_stonebrick_inner"})
 	for s=1, #stairs do
 		local stair = minetest.get_node(stairs[s])
 		local r_type = pr:next(1, 100)
@@ -344,7 +381,7 @@ local generate_end_portal_shrine_no_delay = function(newpos)
 	end
 
 	-- Randomly add ender eyes into end portal frames, but never fill the entire frame
-	local frames = minetest.find_nodes_in_area(area_start, area_end, "mcl_portals:end_portal_frame")
+	local frames = minetest.find_nodes_in_area(p1, p2, "mcl_portals:end_portal_frame")
 	local eyes = 0
 	for f=1, #frames do
 		local r_eye = pr:next(1, 10)
@@ -357,40 +394,34 @@ local generate_end_portal_shrine_no_delay = function(newpos)
 			end
 		end
 	end
-
-	return ret
 end
 
-local function ecb_generate_end_portal_shrine(blockpos, action, calls_remaining, param)
+mcl_structures.generate_end_portal_shrine = function(pos, rotation, pr)
-	if calls_remaining <= 0 then
+	local offset = {x=6, y=4, z=6}
-		generate_end_portal_shrine_no_delay({x=param.x, y=param.y, z=param.z})
-	end
-end
-
-mcl_structures.generate_end_portal_shrine = function(pos)
-	local offset = {x=6, y=8, z=6}
 	local size = {x=13, y=8, z=13}
 	local newpos = { x = pos.x - offset.x, y = pos.y, z = pos.z - offset.z }
-	minetest.emerge_area(vector.subtract(newpos,10), vector.add(vector.add(newpos, size),10), ecb_generate_end_portal_shrine, {x=newpos.x, y=newpos.y, z=newpos.z})
+
+	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_end_portal_room_simple.mts"
+	mcl_structures.place_schematic(newpos, path, "0", nil, true, nil, shrine_placement_callback, pr)
 end
 
-mcl_structures.generate_desert_temple = function(pos)
+local function temple_placement_callback(p1, p2, size, rotation, pr)
-	-- No Generating for the temple ... Why using it ? No Change
+
-	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_desert_temple.mts"
+	-- Delete cacti leftovers:
-	local newpos = {x=pos.x,y=pos.y-12,z=pos.z}
+	local cactus_nodes = minetest.find_nodes_in_area_under_air(p1, p2, "mcl_core:cactus")
-	local size = {x=22, y=24, z=22}
+	if cactus_nodes and #cactus_nodes > 0 then
-	if newpos == nil then
+		for _, pos in pairs(cactus_nodes) do
-		return
+			local node_below = minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z})
+			if node_below and node_below.name == "mcl_core:sandstone" then
+				minetest.swap_node(pos, {name="air"})
+			end
 		end
-	local ret = minetest.place_schematic(newpos, path, "random", nil, true)
-	if ret == nil then
-		return ret
 	end
 
 	-- Find chests.
 	-- FIXME: Searching this large area just for the chets is not efficient. Need a better way to find the chests;
 	-- probably let's just infer it from newpos because the schematic always the same.
-	local chests = minetest.find_nodes_in_area({x=newpos.x-size.x, y=newpos.y, z=newpos.z-size.z}, vector.add(newpos, size), "mcl_chests:chest")
+	local chests = minetest.find_nodes_in_area(p1, p2, "mcl_chests:chest")
 
 	-- Add desert temple loot into chests
 	for c=1, #chests do
@@ -436,7 +467,7 @@ mcl_structures.generate_desert_temple = function(pos)
 	end
 
 	-- Initialize pressure plates and randomly remove up to 5 plates
-	local pplates = minetest.find_nodes_in_area({x=newpos.x-size.x, y=newpos.y, z=newpos.z-size.z}, vector.add(newpos, size), "mesecons_pressureplates:pressure_plate_stone_off")
+	local pplates = minetest.find_nodes_in_area(p1, p2, "mesecons_pressureplates:pressure_plate_stone_off")
 	local pplates_remove = 5
 	for p=1, #pplates do
 		if pplates_remove > 0 and pr:next(1, 100) >= 50 then
@@ -448,8 +479,17 @@ mcl_structures.generate_desert_temple = function(pos)
 			minetest.registered_nodes["mesecons_pressureplates:pressure_plate_stone_off"].on_construct(pplates[p])
 		end
 	end
+end
 
-	return ret
+mcl_structures.generate_desert_temple = function(pos, rotation, pr)
+	-- No Generating for the temple ... Why using it ? No Change
+	local path = minetest.get_modpath("mcl_structures").."/schematics/mcl_structures_desert_temple.mts"
+	local newpos = {x=pos.x,y=pos.y-12,z=pos.z}
+	local size = {x=22, y=24, z=22}
+	if newpos == nil then
+		return
+	end
+	minetest.place_schematic(newpos, path, "random", nil, true, nil, temple_placement_callback, pr)
 end
 
 local registered_structures = {}

mods/MAPGEN/mcl_villages/buildings.lua

@@ -4,8 +4,8 @@
 -------------------------------------------------------------------------------
 function settlements.build_schematic(vm, data, va, pos, building, replace_wall, name)
   -- get building node material for better integration to surrounding
-  local platform_material =  mcl_util.get_far_node(pos, true)
+  local platform_material =  mcl_mapgen_core.get_node(pos)
-  if not platform_material then
+  if not platform_material or (platform_material.name == "air" or platform_material.name == "ignore")  then
     return
   end
   platform_material = platform_material.name
@@ -81,12 +81,15 @@ function settlements.create_site_plan(maxp, minp, pr)
 	local possible_rotations = {"0", "90", "180", "270"}
 	-- find center of chunk
 	local center = {
-		x=maxp.x-half_map_chunk_size, 
+		x=math.floor((minp.x+maxp.x)/2), 
 		y=maxp.y, 
-		z=maxp.z-half_map_chunk_size
+		z=math.floor((minp.z+maxp.z)/2)
 	} 
 	-- find center_surface of chunk
-	local center_surface , surface_material = settlements.find_surface(center)
+	local center_surface , surface_material = settlements.find_surface(center, true)
+	local chunks = {}
+	chunks[mcl_vars.get_chunk_number(center)] = true
+
 	-- go build settlement around center
 	if not center_surface then return false end
 
@@ -114,7 +117,6 @@ function settlements.create_site_plan(maxp, minp, pr)
 	local x, z, r = center_surface.x, center_surface.z, building_all_info["hsize"]
 	-- draw j circles around center and increase radius by math.random(2,5)
 	for j = 1,20 do
-		if number_built < number_of_buildings then
 		-- set position on imaginary circle
 		for j = 0, 360, 15 do
 			local angle = j * math.pi / 180
@@ -122,7 +124,14 @@ function settlements.create_site_plan(maxp, minp, pr)
 			ptx = settlements.round(ptx, 0)
 			ptz = settlements.round(ptz, 0)
 			local pos1 = { x=ptx, y=center_surface.y+50, z=ptz}
-				local pos_surface, surface_material = settlements.find_surface(pos1)
+			local chunk_number = mcl_vars.get_chunk_number(pos1)
+			local pos_surface, surface_material
+			if chunks[chunk_number] then
+				pos_surface, surface_material = settlements.find_surface(pos1)
+			else
+				chunks[chunk_number] = true
+				pos_surface, surface_material = settlements.find_surface(pos1, true)
+			end
 			if not pos_surface then break end
 
 			local randomized_schematic_table = shuffle(settlements.schematic_table, pr)
@@ -155,8 +164,10 @@ function settlements.create_site_plan(maxp, minp, pr)
 				break
 			end
 		end
-			r = r + pr:next(2,5)
+		if number_built >= number_of_buildings then
+			break
 		end
+		r = r + pr:next(2,5)
 	end
 	settlements.debug("really ".. number_built)
 	return settlement_info

mods/MAPGEN/mcl_villages/depends.txt

@@ -1,4 +1,5 @@
 mcl_util
+mcl_mapgen_core
 mcl_core
 mcl_loot
 mcl_farming?

mods/MAPGEN/mcl_villages/foundation.lua

@@ -51,11 +51,12 @@ function settlements.terraform(settlement_info, pr)
 						settlements.ground(p, pr)
 					else
 						-- write ground
-						local p = {x=pos.x+xi, y=pos.y+yi, z=pos.z+zi}
+--						local p = {x=pos.x+xi, y=pos.y+yi, z=pos.z+zi}
-						local node = mcl_util.get_far_node(p, true)
+--						local node = mcl_mapgen_core.get_node(p)
-						if node and node.name ~= "air" then
+--						if node and node.name ~= "air" then
-							minetest.swap_node(p,{name="air"}) 
+--							minetest.swap_node(p,{name="air"}) 
-						end
+--						end
+						minetest.swap_node({x=pos.x+xi, y=pos.y+yi, z=pos.z+zi},{name="air"}) 
 					end
 				end
 			end

mods/MAPGEN/mcl_villages/init.lua

@@ -52,7 +52,7 @@ end
 --
 -- on map generation, try to build a settlement
 --
-local function build_a_settlement_no_delay(minp, maxp, blockseed)
+local function build_a_settlement(minp, maxp, blockseed)
 	local pr = PseudoRandom(blockseed)
 
 	-- fill settlement_info with buildings and their data
@@ -72,30 +72,28 @@ local function build_a_settlement_no_delay(minp, maxp, blockseed)
 	settlements.initialize_nodes(settlement_info, pr)
 end
 
-local function ecb_build_a_settlement(blockpos, action, calls_remaining, param)
+local function ecb_village(blockpos, action, calls_remaining, param)
-	if calls_remaining <= 0 then
+	if calls_remaining >= 1 then return end
-		build_a_settlement_no_delay(param.minp, param.maxp, param.blockseed)
+	local minp, maxp, blockseed = param.minp, param.maxp, param.blockseed
-	end
+	build_a_settlement(minp, maxp, blockseed)
 end
 
 -- Disable natural generation in singlenode.
 local mg_name = minetest.get_mapgen_setting("mg_name")
 if mg_name ~= "singlenode" then
-	minetest.register_on_generated(function(minp, maxp, blockseed)
+	mcl_mapgen_core.register_generator("villages", nil, function(minp, maxp, blockseed)
-		-- needed for manual and automated settlement building
-		local heightmap = minetest.get_mapgen_object("heightmap")
-
-		-- randomly try to build settlements
-		if blockseed % 77 ~= 17 then return end
-
 		-- don't build settlement underground
 		if maxp.y < 0 then return end
-
+		-- randomly try to build settlements
+		if blockseed % 77 ~= 17 then return end
+		-- needed for manual and automated settlement building
 		-- don't build settlements on (too) uneven terrain
-		local height_difference = settlements.evaluate_heightmap(minp, maxp)
+		local heightmap = minetest.get_mapgen_object("heightmap")
+		local height_difference = settlements.evaluate_heightmap()
 		if height_difference > max_height_difference then return end
-		-- we need 'minetest.after' here to exit from emerging thread we probably currently in:
+
-		minetest.after(0.1, build_a_settlement_no_delay, vector.new(minp), vector.new(maxp), blockseed)
+		local param={minp=vector.new(minp), maxp=vector.new(maxp), blockseed=blockseed}
+		minetest.emerge_area(minp, maxp, ecb_village, param)
 	end)
 end
 -- manually place villages
@@ -108,7 +106,7 @@ if minetest.is_creative_enabled("") then
 			if not pointed_thing.under then return end
 			local minp = vector.subtract(	pointed_thing.under, half_map_chunk_size)
 		        local maxp = vector.add(	pointed_thing.under, half_map_chunk_size)
-			build_a_settlement_no_delay(minp, maxp, math.random(0,32767))
+			build_a_settlement(minp, maxp, math.random(0,32767))
 		end
 	})
 end

mods/MAPGEN/mcl_villages/utils.lua

@@ -45,31 +45,27 @@ end
 -- function to find surface block y coordinate
 -- returns surface postion
 -------------------------------------------------------------------------------
-function settlements.find_surface(pos)
+function settlements.find_surface(pos, wait)
 	local p6 = vector.new(pos)
 	local cnt = 0
-	local itter -- count up or down
+	local itter = 1 -- count up or down
 	local cnt_max = 200
 	-- check, in which direction to look for surface
-	local surface_node = mcl_util.get_far_node(p6, true)
+	local surface_node
-	if surface_node and string.find(surface_node.name,"air") then
+	if wait then
-		itter = -1
+		surface_node = mcl_mapgen_core.get_node(p6, true, 10000000)
 	else
-		itter = 1
+		surface_node = mcl_mapgen_core.get_node(p6)
+	end
+	if surface_node.name=="air" or surface_node.name=="ignore" then
+		itter = -1
 	end
 	-- go through nodes an find surface
 	while cnt < cnt_max do
-		cnt = cnt+1
-		surface_node = mcl_util.get_far_node(p6, true)
-		if surface_node.name == "ignore" then
-			settlements.debug("find_surface1: nil or ignore")
-			return nil
-		end
-
 		-- Check Surface_node and Node above
 		--
 		if settlements.surface_mat[surface_node.name] then
-			local surface_node_plus_1 = mcl_util.get_far_node({ x=p6.x, y=p6.y+1, z=p6.z}, true)
+			local surface_node_plus_1 = mcl_mapgen_core.get_node({ x=p6.x, y=p6.y+1, z=p6.z})
 			if surface_node_plus_1 and surface_node and
 				(string.find(surface_node_plus_1.name,"air") or
 				string.find(surface_node_plus_1.name,"snow") or
@@ -93,6 +89,8 @@ function settlements.find_surface(pos)
 			settlements.debug("find_surface4: y<0")
 			return nil
 		end
+		cnt = cnt+1
+		surface_node = mcl_mapgen_core.get_node(p6)
 	end
 	settlements.debug("find_surface5: cnt_max overflow")
 	return nil
@@ -241,7 +239,7 @@ function settlements.initialize_nodes(settlement_info, pr)
 			for xi = 0,width do
 				for zi = 0,depth do
 					local ptemp = {x=p.x+xi, y=p.y+yi, z=p.z+zi}
-					local node = mcl_util.get_far_node(ptemp, true)
+					local node = mcl_mapgen_core.get_node(ptemp)
 					if node.name == "mcl_furnaces:furnace" or
 						node.name == "mcl_chests:chest" or
 						node.name == "mcl_anvils:anvil" then
@@ -282,17 +280,13 @@ function settlements.evaluate_heightmap()
 	for j = 1 , 40, 1 do
 		for i = square_start, square_end, 1 do
 			-- skip buggy heightmaps, return high value
-      if heightmap[i] == -31000 or
+			if heightmap[i] == -31000 or heightmap[i] == 31000 then
-      heightmap[i] == 31000
-      then
 				return max_height_difference + 1
 			end
-      if heightmap[i] < min_y
+			if heightmap[i] < min_y then
-      then
 				min_y = heightmap[i]
 			end
-      if heightmap[i] > max_y
+			if heightmap[i] > max_y then
-      then
 				max_y = heightmap[i]
 			end
 		end
@@ -303,8 +297,7 @@ function settlements.evaluate_heightmap()
 	-- return the difference between highest and lowest pos in chunk
 	local height_diff = max_y - min_y
 	-- filter buggy heightmaps
-  if height_diff <= 1 
+	if height_diff <= 1 then
-  then
 		return max_height_difference + 1
 	end
 	-- debug info

mods/MAPGEN/tsm_railcorridors/depends.txt

@@ -1,6 +1,7 @@
 mcl_init
 mcl_worlds
 mcl_core
+mcl_mapgen_core
 mcl_loot
 mcl_tnt
 mcl_farming

mods/MAPGEN/tsm_railcorridors/init.lua

@@ -1089,7 +1089,7 @@ local function create_corridor_system(main_cave_coords)
 end
 
 -- The rail corridor algorithm starts here
-minetest.register_on_generated(function(minp, maxp, blockseed)
+mcl_mapgen_core.register_generator("railcorridors", nil, function(minp, maxp, blockseed, _pr)
 	-- We re-init the randomizer for every mapchunk as we start generating in the middle of each mapchunk.
 	-- We can't use the mapgen seed as this would make the algorithm depending on the order the mapchunk generate.
 	InitRandomizer(blockseed)
@@ -1115,4 +1115,4 @@ minetest.register_on_generated(function(minp, maxp, blockseed)
 			end
 		end
 	end
-end)
+end, 10)