fix typo

to give old, deferrred blocks a chance to time-out.  Needed
because if players aren't currently creating new terrain,
old blocks would never get processed, causing the block log
to only grow rather than eventually run dry (which could result
in very long shutdown times).

API.txt

@@ -446,12 +446,22 @@ question is already loaded, or false if not.
 
 
 =====
-dbg(string)
+dbg(string, level)
 
 This is a simple debug output function which takes one string parameter.  It
 just checks if DEBUG is true and outputs the phrase "[Plantlife] " followed by
 the supplied string, via the print() function, if so.
 
+'level' is a number that, if supplied, dictates the lowest 'biome_lib_debug'
+can be set to in minetest.conf for this message to be displayed.  Both the
+default log level and the default message level are 0, thus always showing the
+supplied message.
+
+Although it's not set in stone, a good practice is to use a level of 0 (or
+just omit the value) for anything that generally important enough that it
+ought always be shown, 1 for errors, 2 for warnings, 3 for info, 4 for verbose
+spammy stuff.
+
 =====
 biome_lib:generate_tree(pos, treemodel)
 biome_lib:grow_tree(pos, treemodel)
@@ -588,3 +598,43 @@ And this particular one is mapped slightly differently from the others:
 
 (Note the +150 and +50 offsets)
 
+
+==================
+Default game nodes
+==================
+
+Although this project was intended to be used with minetest_game, it can be
+configured to work with something else instead.  All you need to do is provide
+the names of the nodes in your game you want biome_lib's internals to use.
+
+Put these settings in your game's minetest.conf (or your client's own config,
+if desired).  You'll need to set all of them.
+
+biome_lib_default_grow_through_nodes
+	Comma-separated list of things that a spawned node is allowed to grow
+	through.  Air is always added to whatever you specify.
+	Default:  air, default:snow
+
+biome_lib_default_water_nodes
+	Comma-separated list of nodes that should be treated as water for the sake
+	of looking for neighboring "wet" ground.
+	Default: default:water_source, default:water_flowing,
+		default:river_water_source, default:river_water_flowing
+
+biome_lib_default_wet_surfaces
+	Comma-separated list of nodes that should be considered "wet" if one of
+	the aforementioned water nodes is nearby.
+	Default: default:dirt, default:dirt_with_grass, default:sand
+
+biome_lib_default_grow_nodes
+	Comma-separated list of nodes that something must be sitting on to be
+	able to actively change from one thing to another (such as a sapling
+	growing into a tree), to be used for ALL growable nodes, if the calling
+	mod doesn't provide its own lists.
+	Default: "default:dirt_with_grass"
+
+biome_lib_default_ground_nodes
+	Comma-separated list of nodes to use as the "root" of something that can
+	gradually climb up a wall, to be used for ALL such nodes, if the calling
+	mod doesn't provide its own lists.
+	Default: "default:dirt_with_grass"

README.md

@@ -12,7 +12,7 @@ Both mapgen-based spawning and ABM-based spawning is supported. Growing code is
 
 It is primarily intended for mapgen v6, but it should work fine when used with mapgen v7.
 
-**Dependencies**: default from minetest_game
+**Dependencies:** nothing, but if you don't use `minetest_game`, you'll need to supply some settings (see API.txt).
 
 **Recommends**: [Plantlife Modpack](https://github.com/minetest-mods/plantlife_modpack), 
 [More Trees](https://github.com/minetest-mods/moretrees)

depends.txt

@@ -1,3 +0,0 @@
-default
-intllib?
-

growth.lua

@@ -20,8 +20,8 @@ function biome_lib:grow_plants(opts)
 	local options = opts
 
 	options.height_limit = options.height_limit or 5
-	options.ground_nodes = options.ground_nodes or { "default:dirt_with_grass" }
-	options.grow_nodes = options.grow_nodes or { "default:dirt_with_grass" }
+	options.ground_nodes = options.ground_nodes or biome_lib.default_ground_nodes
+	options.grow_nodes = options.grow_nodes or biome_lib.default_grow_nodes
 	options.seed_diff = options.seed_diff or 0
 
 	local n
@@ -55,7 +55,7 @@ function biome_lib:grow_plants(opts)
 			if options.need_wall and options.verticals_list then
 				walldir = biome_lib:find_adjacent_wall(p_top, options.verticals_list, options.choose_random_wall)
 			end
-			if (n_top.name == "air" or n_top.name == "default:snow")
+			if biome_lib.default_grow_through_nodes[n_top.name]
 			  and (not options.need_wall or (options.need_wall and walldir)) then
 				if options.grow_vertically and walldir then
 					if biome_lib:search_downward(pos, options.height_limit, options.ground_nodes) then

init.lua

@@ -1,36 +1,10 @@
--- Biome library mod by Vanessa Ezekowitz
+-- Biome library mod by VanessaE
 --
 -- I got the temperature map idea from "hmmmm", values used for it came from
 -- Splizard's snow mod.
 --
 
--- Various settings - most of these probably won't need to be changed
-
 biome_lib = {}
-biome_lib.air = {name = "air"}
-
-plantslib = setmetatable({}, { __index=function(t,k) print("Use of deprecated function:", k) return biome_lib[k] end })
-
-biome_lib.blocklist_aircheck = {}
-biome_lib.blocklist_no_aircheck = {}
-
-biome_lib.surface_nodes_aircheck = {}
-biome_lib.surface_nodes_no_aircheck = {}
-
-biome_lib.surfaceslist_aircheck = {}
-biome_lib.surfaceslist_no_aircheck = {}
-
-biome_lib.actioncount_aircheck = {}
-biome_lib.actioncount_no_aircheck = {}
-
-biome_lib.actionslist_aircheck = {}
-biome_lib.actionslist_no_aircheck = {}
-
-biome_lib.modpath = minetest.get_modpath("biome_lib")
-
-biome_lib.total_no_aircheck_calls = 0
-
-biome_lib.queue_run_ratio = tonumber(minetest.settings:get("biome_lib_queue_run_ratio")) or 100
 
 -- Boilerplate to support localized strings if intllib mod is installed.
 local S
@@ -45,16 +19,75 @@ else
 end
 biome_lib.intllib = S
 
-local DEBUG = false --... except if you want to spam the console with debugging info :-)
+-- Various settings - most of these probably won't need to be changed
 
-function biome_lib:dbg(msg)
-	if DEBUG then
-		print("[Plantlife] "..msg)
-		minetest.log("verbose", "[Plantlife] "..msg)
-	end
+biome_lib.air = {name = "air"}
+
+biome_lib.block_log = {}
+biome_lib.block_recheck_list = {}
+biome_lib.run_block_recheck_list = false
+
+biome_lib.actionslist_aircheck = {}
+biome_lib.actionslist_no_aircheck = {}
+
+biome_lib.surfaceslist_aircheck = {}
+biome_lib.surfaceslist_no_aircheck = {}
+
+biome_lib.modpath = minetest.get_modpath("biome_lib")
+
+local function tableize(s)
+	return string.split(string.trim(string.gsub(s, " ", "")))
 end
 
-biome_lib.plantlife_seed_diff = 329	-- needs to be global so other mods can see it
+local c1 = minetest.settings:get("biome_lib_default_grow_through_nodes")
+biome_lib.default_grow_through_nodes = {["air"] = true}
+if c1 then
+	for _, i in ipairs(tableize(c1)) do
+		biome_lib.default_grow_through_nodes[i] = true
+	end
+else
+	biome_lib.default_grow_through_nodes["default:snow"] = true
+end
+
+local c2 = minetest.settings:get("biome_lib_default_water_nodes")
+biome_lib.default_water_nodes = {}
+if c2 then
+	for _, i in ipairs(tableize(c2)) do
+		biome_lib.default_water_nodes[i] = true
+	end
+else
+	biome_lib.default_water_nodes["default:water_source"] = true
+	biome_lib.default_water_nodes["default:water_flowing"] = true
+	biome_lib.default_water_nodes["default:river_water_source"] = true
+	biome_lib.default_water_nodes["default:river_water_flowing"] = true
+end
+
+local c3 = minetest.settings:get("biome_lib_default_wet_surfaces")
+local c4 = minetest.settings:get("biome_lib_default_ground_nodes")
+local c5 = minetest.settings:get("biome_lib_default_grow_nodes")
+
+biome_lib.default_wet_surfaces = c3 and tableize(c3) or {"default:dirt", "default:dirt_with_grass", "default:sand"}
+biome_lib.default_ground_nodes = c4 and tableize(c4) or {"default:dirt_with_grass"}
+biome_lib.default_grow_nodes =   c5 and tableize(c5) or {"default:dirt_with_grass"}
+
+biome_lib.debug_log_level = tonumber(minetest.settings:get("biome_lib_debug_log_level")) or 0
+
+local rr = tonumber(minetest.settings:get("biome_lib_queue_run_ratio")) or -100
+biome_lib.queue_run_ratio = 100 - rr
+biome_lib.entries_per_step = math.max(-rr, 1)
+
+-- the timer that manages the block timeout is in microseconds, but the timer
+-- that manages the queue wakeup call has to be in seconds, and works best if
+-- it takes a little longer than the block timeout interval.
+
+local t = tonumber(minetest.settings:get("biome_lib_block_timeout")) or 300
+
+biome_lib.block_timeout = t * 1000000
+biome_lib.block_queue_wakeup_time = t * 1.1
+
+local time_speed = tonumber(minetest.settings:get("time_speed"))
+
+biome_lib.plantlife_seed_diff = 329 -- needs to be global so other mods can see it
 
 local perlin_octaves = 3
 local perlin_persistence = 0.6
@@ -71,7 +104,6 @@ local humidity_persistence = 0.5
 local humidity_scale = 250
 
 local time_scale = 1
-local time_speed = tonumber(minetest.settings:get("time_speed"))
 
 if time_speed and time_speed > 0 then
 	time_scale = 72 / time_speed
@@ -84,6 +116,14 @@ biome_lib.perlin_humidity = PerlinNoise(humidity_seeddiff, humidity_octaves, hum
 
 -- Local functions
 
+function biome_lib.dbg(msg, level)
+	local l = tonumber(level) or 0
+	if biome_lib.debug_log_level >= l then
+		print("[Biome Lib] "..msg)
+		minetest.log("verbose", "[Biome Lib] "..msg)
+	end
+end
+
 local function get_biome_data(pos, perlin_fertile)
 	local fertility = perlin_fertile:get_2d({x=pos.x, y=pos.z})
 
@@ -125,7 +165,7 @@ function biome_lib:set_defaults(biome)
 	biome.near_nodes_size = biome.near_nodes_size or 0
 	biome.near_nodes_count = biome.near_nodes_count or 1
 	biome.rarity = biome.rarity or 50
-	biome.max_count = biome.max_count or 5
+	biome.max_count = biome.max_count or 125
 	if biome.check_air ~= false then biome.check_air = true end
 
 -- specific to abm spawner
@@ -154,17 +194,17 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 	if type(nodes_or_function_or_model) == "string"
 	  and string.find(nodes_or_function_or_model, ":")
 	  and not minetest.registered_nodes[nodes_or_function_or_model] then
-		biome_lib:dbg("Warning: Ignored registration for undefined spawn node: "..dump(nodes_or_function_or_model))
+		biome_lib.dbg("Warning: Ignored registration for undefined spawn node: "..dump(nodes_or_function_or_model), 2)
 		return
 	end
 
 	if type(nodes_or_function_or_model) == "string"
 	  and not string.find(nodes_or_function_or_model, ":") then
-		biome_lib:dbg("Warning: Registered function call using deprecated string method: "..dump(nodes_or_function_or_model))
+		biome_lib.dbg("Warning: Registered function call using deprecated string method: "..dump(nodes_or_function_or_model), 2)
 	end
 
 	if biomedef.check_air == false then 
-		biome_lib:dbg("Register no-air-check mapgen hook: "..dump(nodes_or_function_or_model))
+		biome_lib.dbg("Register no-air-check mapgen hook: "..dump(nodes_or_function_or_model), 3)
 		biome_lib.actionslist_no_aircheck[#biome_lib.actionslist_no_aircheck + 1] = { biomedef, nodes_or_function_or_model }
 		local s = biomedef.surface
 		if type(s) == "string" then
@@ -173,7 +213,7 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 					biome_lib.surfaceslist_no_aircheck[#biome_lib.surfaceslist_no_aircheck + 1] = s
 				end
 			else
-				biome_lib:dbg("Warning: Ignored no-air-check registration for undefined surface node: "..dump(s))
+				biome_lib.dbg("Warning: Ignored no-air-check registration for undefined surface node: "..dump(s), 2)
 			end
 		else
 			for i = 1, #biomedef.surface do
@@ -183,12 +223,12 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 						biome_lib.surfaceslist_no_aircheck[#biome_lib.surfaceslist_no_aircheck + 1] = s
 					end
 				else
-					biome_lib:dbg("Warning: Ignored no-air-check registration for undefined surface node: "..dump(s))
+					biome_lib.dbg("Warning: Ignored no-air-check registration for undefined surface node: "..dump(s), 2)
 				end
 			end
 		end
 	else
-		biome_lib:dbg("Register with-air-checking mapgen hook: "..dump(nodes_or_function_or_model))
+		biome_lib.dbg("Register with-air-checking mapgen hook: "..dump(nodes_or_function_or_model), 3)
 		biome_lib.actionslist_aircheck[#biome_lib.actionslist_aircheck + 1] = { biomedef, nodes_or_function_or_model }
 		local s = biomedef.surface
 		if type(s) == "string" then
@@ -197,7 +237,7 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 					biome_lib.surfaceslist_aircheck[#biome_lib.surfaceslist_aircheck + 1] = s
 				end
 			else
-				biome_lib:dbg("Warning: Ignored with-air-checking registration for undefined surface node: "..dump(s))
+				biome_lib.dbg("Warning: Ignored with-air-checking registration for undefined surface node: "..dump(s), 2)
 			end
 		else
 			for i = 1, #biomedef.surface do
@@ -207,7 +247,7 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 						biome_lib.surfaceslist_aircheck[#biome_lib.surfaceslist_aircheck + 1] = s
 					end
 				else
-					biome_lib:dbg("Warning: Ignored with-air-checking registration for undefined surface node: "..dump(s))
+					biome_lib.dbg("Warning: Ignored with-air-checking registration for undefined surface node: "..dump(s), 2)
 				end
 			end
 		end
@@ -295,7 +335,8 @@ local function populate_single_surface(biome, pos, perlin_fertile_area, checkair
 	return true
 end
 
-function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes, checkair)
+function biome_lib.populate_surfaces(biome, nodes_or_function_or_model, snodes, checkair)
+	local items_added = 0
 
 	biome_lib:set_defaults(biome)
 
@@ -316,10 +357,10 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 	local num_in_biome_nodes = #in_biome_nodes
 
 	if num_in_biome_nodes == 0 then
-		return
+		return 0
 	end
 
-	for i = 1, math.min(biome.max_count, num_in_biome_nodes) do
+	for i = 1, math.min(math.ceil(biome.max_count/25), num_in_biome_nodes) do
 		local tries = 0
 		local spawned = false
 		while tries < 2 and not spawned do
@@ -358,13 +399,16 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 				if objtype == "table" then
 					if nodes_or_function_or_model.axiom then
 						biome_lib:generate_tree(p_top, nodes_or_function_or_model)
+						biome_lib.dbg("An L-tree was spawned at "..minetest.pos_to_string(p_top), 4)
 						spawned = true
 					else
 						local fdir = nil
 						if biome.random_facedir then
 							fdir = math.random(biome.random_facedir[1], biome.random_facedir[2])
 						end
-						minetest.swap_node(p_top, { name = nodes_or_function_or_model[math.random(#nodes_or_function_or_model)], param2 = fdir })
+						local n=nodes_or_function_or_model[math.random(#nodes_or_function_or_model)]
+						minetest.swap_node(p_top, { name = n, param2 = fdir })
+						biome_lib.dbg("Node \""..n.."\" was randomly picked from a list and placed at "..minetest.pos_to_string(p_top), 4)
 						spawned = true
 					end
 				elseif objtype == "string" and
@@ -374,163 +418,188 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 						fdir = math.random(biome.random_facedir[1], biome.random_facedir[2])
 					end
 					minetest.swap_node(p_top, { name = nodes_or_function_or_model, param2 = fdir })
+					biome_lib.dbg("Node \""..nodes_or_function_or_model.."\" was placed at "..minetest.pos_to_string(p_top), 4)
 					spawned = true
 				elseif objtype == "function" then
 					nodes_or_function_or_model(pos)
+					biome_lib.dbg("A function was run on surface node at "..minetest.pos_to_string(pos), 4)
 					spawned = true
 				elseif objtype == "string" and pcall(loadstring(("return %s(...)"):
 					format(nodes_or_function_or_model)),pos) then
 					spawned = true
+					biome_lib.dbg("An obsolete string-specified function was run on surface node at "..minetest.pos_to_string(p_top), 4)
 				else
-					biome_lib:dbg("Warning: Ignored invalid definition for object "..dump(nodes_or_function_or_model).." that was pointed at {"..dump(pos).."}")
+					biome_lib.dbg("Warning: Ignored invalid definition for object "..dump(nodes_or_function_or_model).." that was pointed at {"..dump(pos).."}", 2)
 				end
 			else
 				tries = tries + 1
 			end
 		end
+		if spawned then items_added = items_added + 1 end
 	end
+	return items_added
 end
 
--- Primary mapgen spawner, for mods that can work with air checking enabled on
--- a surface during the initial map read stage.
+-- Primary log read-out/mapgen spawner
 
-function biome_lib:generate_block_with_air_checking()
-	if #biome_lib.blocklist_aircheck == 0 then
-		return
-	end
+local function confirm_block_surroundings(p)
+	local n=minetest.get_node_or_nil(p)
+	if not n or n.name == "ignore" then return false end
 
-	local minp =		biome_lib.blocklist_aircheck[1][1]
-	local maxp =		biome_lib.blocklist_aircheck[1][2]
-
-	-- use the block hash as a unique key into the surface nodes
-	-- tables, so that we can write the tables thread-safely.
-
-	local blockhash =	minetest.hash_node_position(minp)
-
-	if not biome_lib.surface_nodes_aircheck.blockhash then
-
-		if type(minetest.find_nodes_in_area_under_air) == "function" then -- use newer API call
-			biome_lib.surface_nodes_aircheck.blockhash =
-				minetest.find_nodes_in_area_under_air(minp, maxp, biome_lib.surfaceslist_aircheck)
-		else
-			local search_area = minetest.find_nodes_in_area(minp, maxp, biome_lib.surfaceslist_aircheck)
-
-			-- search the generated block for air-bounded surfaces the slow way.
-
-			biome_lib.surface_nodes_aircheck.blockhash = {}
-
-			for i = 1, #search_area do
-			local pos = search_area[i]
-				local p_top = { x=pos.x, y=pos.y+1, z=pos.z }
-				if minetest.get_node(p_top).name == "air" then
-					biome_lib.surface_nodes_aircheck.blockhash[#biome_lib.surface_nodes_aircheck.blockhash + 1] = pos
-				end
-			end
-		end
-		biome_lib.actioncount_aircheck.blockhash = 1
-
-	else
-		if biome_lib.actioncount_aircheck.blockhash <= #biome_lib.actionslist_aircheck then
-			-- [1] is biome, [2] is node/function/model
-			biome_lib:populate_surfaces(
-				biome_lib.actionslist_aircheck[biome_lib.actioncount_aircheck.blockhash][1],
-				biome_lib.actionslist_aircheck[biome_lib.actioncount_aircheck.blockhash][2],
-				biome_lib.surface_nodes_aircheck.blockhash, true)
-			biome_lib.actioncount_aircheck.blockhash = biome_lib.actioncount_aircheck.blockhash + 1
-		else
-			if biome_lib.surface_nodes_aircheck.blockhash then
-				table.remove(biome_lib.blocklist_aircheck, 1)
-				biome_lib.surface_nodes_aircheck.blockhash = nil
+	for x = -32,32,64 do -- step of 64 causes it to only check the 8 corner blocks
+		for y = -32,32,64 do
+			for z = -32,32,64 do
+				local n=minetest.get_node_or_nil({x=p.x + x, y=p.y + y, z=p.z + z})
+				if not n or n.name == "ignore" then return false end
 			end
 		end
 	end
+	return true
 end
 
--- Secondary mapgen spawner, for mods that require disabling of
--- checking for air during the initial map read stage.
+function biome_lib.generate_block(shutting_down)
 
-function biome_lib:generate_block_no_aircheck()
-	if #biome_lib.blocklist_no_aircheck == 0 then
-		return
+	if shutting_down then
+		if #biome_lib.block_recheck_list > 0 then
+			for i = 1, #biome_lib.block_recheck_list do
+				biome_lib.block_log[#biome_lib.block_log + 1] = biome_lib.block_recheck_list[i]
+			end
+			biome_lib.block_recheck_list = {}
+		end
+		biome_lib.run_block_recheck_list = false
+	else
+		if biome_lib.run_block_recheck_list
+		  and not biome_lib.block_recheck_list[1] then
+				biome_lib.run_block_recheck_list = false
+		end
 	end
 
-	local minp =		biome_lib.blocklist_no_aircheck[1][1]
-	local maxp =		biome_lib.blocklist_no_aircheck[1][2]
+	local blocklog = biome_lib.run_block_recheck_list
+	  and biome_lib.block_recheck_list
+	  or biome_lib.block_log
 
-	local blockhash =	minetest.hash_node_position(minp)
+	if not blocklog[1] then return end
 
-	if not biome_lib.surface_nodes_no_aircheck.blockhash then
+	local minp =		blocklog[1][1]
+	local maxp =		blocklog[1][2]
+	local airflag = 	blocklog[1][3]
+	local pos_hash = 	minetest.hash_node_position(minp)
 
-		-- directly read the block to be searched into the chunk cache
-
-		biome_lib.surface_nodes_no_aircheck.blockhash =
-			minetest.find_nodes_in_area(minp, maxp, biome_lib.surfaceslist_no_aircheck)
-		biome_lib.actioncount_no_aircheck.blockhash = 1
-
-	else
-		if biome_lib.actioncount_no_aircheck.blockhash <= #biome_lib.actionslist_no_aircheck then
-			biome_lib:populate_surfaces(
-				biome_lib.actionslist_no_aircheck[biome_lib.actioncount_no_aircheck.blockhash][1],
-				biome_lib.actionslist_no_aircheck[biome_lib.actioncount_no_aircheck.blockhash][2],
-				biome_lib.surface_nodes_no_aircheck.blockhash, false)
-			biome_lib.actioncount_no_aircheck.blockhash = biome_lib.actioncount_no_aircheck.blockhash + 1
-		else
-			if biome_lib.surface_nodes_no_aircheck.blockhash then
-				table.remove(biome_lib.blocklist_no_aircheck, 1)
-				biome_lib.surface_nodes_no_aircheck.blockhash = nil
+	if not biome_lib.pos_hash then -- we need to read the maplock and get the surfaces list
+		local now = minetest.get_us_time()
+		biome_lib.pos_hash = {}
+		minetest.load_area(minp)
+		if not confirm_block_surroundings(minp)
+		  and not shutting_down
+		  and (blocklog[1][4] + biome_lib.block_timeout) > now then -- if any neighbors appear not to be loaded and the block hasn't expired yet, defer it
+			blocklog[1][4] = now -- reset the timer, give this block more time to "cook"
+			if biome_lib.run_block_recheck_list then
+				biome_lib.block_log[#biome_lib.block_log + 1] = table.copy(biome_lib.block_recheck_list[1])
+				table.remove(biome_lib.block_recheck_list, 1)
+			else
+				biome_lib.block_recheck_list[#biome_lib.block_recheck_list + 1] = table.copy(biome_lib.block_log[1])
+				table.remove(biome_lib.block_log, 1)
 			end
+			biome_lib.pos_hash = nil
+				biome_lib.dbg("Mapblock at "..minetest.pos_to_string(minp)..
+					" had a neighbor not fully emerged, skipped it for now.", 4)
+			return
+		else
+			biome_lib.pos_hash.surface_node_list = airflag
+				and minetest.find_nodes_in_area_under_air(minp, maxp, biome_lib.surfaceslist_aircheck)
+				or minetest.find_nodes_in_area(minp, maxp, biome_lib.surfaceslist_no_aircheck)
+			biome_lib.pos_hash.action_index = 1
+			if #biome_lib.pos_hash.surface_node_list > 0 then
+				biome_lib.dbg("Mapblock at "..minetest.pos_to_string(minp)..
+					" has "..#biome_lib.pos_hash.surface_node_list..
+					" surface nodes to work on (airflag="..dump(airflag)..")", 4)
+			end
+		end
+	elseif not (airflag and biome_lib.actionslist_aircheck[biome_lib.pos_hash.action_index])
+	  and not (not airflag and biome_lib.actionslist_no_aircheck[biome_lib.pos_hash.action_index]) then
+		-- the block is finished, remove it
+		if #biome_lib.pos_hash.surface_node_list > 0 then
+			biome_lib.dbg("Deleted mapblock "..minetest.pos_to_string(minp).." from the block log", 4)
+		end
+		table.remove(blocklog, 1)
+		biome_lib.pos_hash = nil
+	else
+		-- below, [1] is biome, [2] is the thing to be added
+		local added = 0
+		if airflag then
+			if biome_lib.actionslist_aircheck[biome_lib.pos_hash.action_index] then
+				added = biome_lib.populate_surfaces(
+							biome_lib.actionslist_aircheck[biome_lib.pos_hash.action_index][1],
+							biome_lib.actionslist_aircheck[biome_lib.pos_hash.action_index][2],
+							biome_lib.pos_hash.surface_node_list, true)
+				biome_lib.pos_hash.action_index = biome_lib.pos_hash.action_index + 1
+			end
+		else
+			if biome_lib.actionslist_no_aircheck[biome_lib.pos_hash.action_index] then
+				added = biome_lib.populate_surfaces(
+							biome_lib.actionslist_no_aircheck[biome_lib.pos_hash.action_index][1],
+							biome_lib.actionslist_no_aircheck[biome_lib.pos_hash.action_index][2],
+							biome_lib.pos_hash.surface_node_list, false)
+				biome_lib.pos_hash.action_index = biome_lib.pos_hash.action_index + 1
+			end
+		end
+		if added > 0 then
+			biome_lib.dbg("biome_lib.populate_surfaces ran on mapblock at "..
+				minetest.pos_to_string(minp)..".  Entry #"..
+				(biome_lib.pos_hash.action_index-1).." added "..added.." items.", 4)
 		end
 	end
 end
 
 -- "Play" them back, populating them with new stuff in the process
 
-local step_duration = tonumber(minetest.settings:get("dedicated_server_step"))
 minetest.register_globalstep(function(dtime)
-	if dtime >= step_duration + 0.1 -- don't attempt to populate if lag is already too high
-			or math.random(100) > biome_lib.queue_run_ratio
-			or (#biome_lib.blocklist_aircheck == 0 and #biome_lib.blocklist_no_aircheck == 0) then
-		return
-	end
+	if not biome_lib.block_log[1] then return end -- the block log is empty
 
-	biome_lib.globalstep_start_time = minetest.get_us_time()
-	biome_lib.globalstep_runtime = 0
-	while (#biome_lib.blocklist_aircheck > 0 or #biome_lib.blocklist_no_aircheck > 0)
-	  and biome_lib.globalstep_runtime < 200000 do  -- 0.2 seconds, in uS.
-		if #biome_lib.blocklist_aircheck > 0 then
-			biome_lib:generate_block_with_air_checking()
-		end
-		if #biome_lib.blocklist_no_aircheck > 0 then
-			biome_lib:generate_block_no_aircheck()
-		end
-		biome_lib.globalstep_runtime = minetest.get_us_time() - biome_lib.globalstep_start_time
+	if math.random(100) > biome_lib.queue_run_ratio then return end
+	for s = 1, biome_lib.entries_per_step do
+		biome_lib.generate_block()
 	end
 end)
 
+-- Periodically wake-up the queue to give old blocks a chance to time-out
+-- if the player isn't currently exploring (i.e. they're just playing in one area)
+
+function biome_lib.wake_up_queue()
+	if #biome_lib.block_recheck_list > 0
+	  and #biome_lib.block_log == 0 then
+		-- we move the second element and not the first because we can't be
+		-- sure if the recheck list's first item is the one currently acted upon
+		-- (else it'd be the first item in the main block log)
+		biome_lib.block_log = table.copy(biome_lib.block_recheck_list)
+		biome_lib.block_recheck_list = {}
+		biome_lib.queue_idle_flag = false
+		biome_lib.dbg("Woke-up the map queue to give old blocks a chance to time-out.", 3)
+	end
+	minetest.after(biome_lib.block_queue_wakeup_time, biome_lib.wake_up_queue)
+end
+
+biome_lib.wake_up_queue()
+
 -- Play out the entire log all at once on shutdown
 -- to prevent unpopulated map areas
 
 minetest.register_on_shutdown(function()
-	if #biome_lib.blocklist_aircheck == 0 then
+	if #biome_lib.block_log + #biome_lib.block_recheck_list == 0 then
 		return
 	end
 
-	print("[biome_lib] Stand by, playing out the rest of the aircheck mapblock log")
-	print("(there are "..#biome_lib.blocklist_aircheck.." entries)...")
-	while #biome_lib.blocklist_aircheck > 0 do
-		biome_lib:generate_block_with_air_checking(0.1)
-	end
-end)
-
-minetest.register_on_shutdown(function()
-	if #biome_lib.blocklist_aircheck == 0 then
-		return
+	biome_lib.dbg("[biome_lib] Stand by, playing out the rest of the mapblock log", 0)
+	biome_lib.dbg("(there are "..(#biome_lib.block_log + #biome_lib.block_recheck_list).." entries)...", 0)
+	while #biome_lib.block_log > 0 do
+		biome_lib.generate_block(true)
 	end
 
-	print("[biome_lib] Stand by, playing out the rest of the no-aircheck mapblock log")
-	print("(there are "..#biome_lib.blocklist_no_aircheck.." entries)...")
-	while #biome_lib.blocklist_no_aircheck > 0 do
-		biome_lib:generate_block_no_aircheck(0.1)
+	if #biome_lib.block_recheck_list > 0 then
+		biome_lib.block_log = table.copy(biome_lib.block_recheck_list)
+		while #biome_lib.block_log > 0 do
+			biome_lib.generate_block(true)
+		end
 	end
 end)
 
@@ -639,11 +708,11 @@ function biome_lib:spawn_on_surfaces(sd,sp,sr,sc,ss,sa)
 
 			local currentsurface = minetest.get_node(pos).name
 
-			if currentsurface == "default:water_source" and
+			if biome_lib.default_water_nodes[currentsurface] and
 					#minetest.find_nodes_in_area(
 						{x=pos.x, y=pos.y-biome.depth_max-1, z=pos.z},
 						vector.new(pos),
-						{"default:dirt", "default:dirt_with_grass", "default:sand"}
+						biome_lib.default_wet_surfaces
 					) == 0 then
 				return -- On water but no ground nearby
 			end
@@ -704,12 +773,9 @@ function biome_lib:replace_object(pos, replacement, grow_function, walldir, seed
 	end
 end
 
-
 dofile(biome_lib.modpath .. "/search_functions.lua")
 assert(loadfile(biome_lib.modpath .. "/growth.lua"))(time_scale)
 
-
-
 -- Check for infinite stacks
 
 if minetest.get_modpath("unified_inventory") or not minetest.settings:get_bool("creative_mode") then
@@ -727,10 +793,34 @@ function biome_lib:get_nodedef_field(nodename, fieldname)
 	return minetest.registered_nodes[nodename][fieldname]
 end
 
-print("[Biome Lib] Loaded")
+if biome_lib.debug_log_level >= 3 then
+	biome_lib.last_count = 0
+
+	function biome_lib.show_pending_block_count()
+		if biome_lib.last_count ~= #biome_lib.block_log then
+			biome_lib.dbg(string.format("Pending block counts - ready to process: %-8icurrently deferred: %i",
+				#biome_lib.block_log, #biome_lib.block_recheck_list), 3)
+			biome_lib.last_count = #biome_lib.block_log
+			biome_lib.queue_idle_flag = false
+		elseif not biome_lib.queue_idle_flag then
+			if #biome_lib.block_recheck_list > 0 then
+				biome_lib.dbg("Mapblock queue only contains blocks that can't yet be processed.",  3)
+				biome_lib.dbg("Idling the queue until new blocks arrive or the next wake-up call occurs.",  3)
+			else
+				biome_lib.dbg("Mapblock queue has run dry.",  3)
+				biome_lib.dbg("Idling the queue until new blocks arrive.",  3)
+			end
+			biome_lib.queue_idle_flag = true
+		end
+		minetest.after(1, biome_lib.show_pending_block_count)
+	end
+
+	biome_lib.show_pending_block_count()
+end
 
 minetest.after(0, function()
-	print("[Biome Lib] Registered a total of "..(#biome_lib.surfaceslist_aircheck)+(#biome_lib.surfaceslist_no_aircheck).." surface types to be evaluated, spread")
-	print("[Biome Lib] across "..#biome_lib.actionslist_aircheck.." actions with air-checking and "..#biome_lib.actionslist_no_aircheck.." actions without.")
+	biome_lib.dbg("Registered a total of "..(#biome_lib.surfaceslist_aircheck)+(#biome_lib.surfaceslist_no_aircheck).." surface types to be evaluated, spread", 0)
+	biome_lib.dbg("across "..#biome_lib.actionslist_aircheck.." actions with air-checking and "..#biome_lib.actionslist_no_aircheck.." actions without.", 0)
 end)
 
+biome_lib.dbg("[Biome Lib] Loaded", 0)

mod.conf

@@ -1,2 +1,3 @@
 name = biome_lib
 min_minetest_version = 5.2.0
+optional_depends = default, intllib

search_functions.lua

@@ -52,9 +52,24 @@ function biome_lib:find_open_side(pos)
 	return nil
 end
 
--- "Record" the chunks being generated by the core mapgen
+-- "Record" the map chunks being generated by the core mapgen,
+-- split into individual mapblocks to reduce lag
 
 minetest.register_on_generated(function(minp, maxp, blockseed)
-	biome_lib.blocklist_aircheck[#biome_lib.blocklist_aircheck + 1] = { minp, maxp }
-	biome_lib.blocklist_no_aircheck[#biome_lib.blocklist_no_aircheck + 1] = { minp, maxp }
+	local timestamp = minetest.get_us_time()
+	for x = 0, 4 do
+		local minx = minp.x + x*16
+		for y = 0, 4 do
+			local miny = minp.y + y*16
+			for z = 0, 4 do
+				local minz = minp.z + z*16
+
+				local bmin = {x=minx, y=miny, z=minz}
+				local bmax = {x=minx + 15, y=miny + 15, z=minz + 15}
+				biome_lib.block_log[#biome_lib.block_log + 1] = { bmin, bmax, true, timestamp }
+				biome_lib.block_log[#biome_lib.block_log + 1] = { bmin, bmax, false, timestamp }
+			end
+		end
+	end
+	biome_lib.run_block_recheck_list = true
 end)