If a block has to be re-checked, renew its timestamp

(default 5 minutes).

Rationale: if a block is old enough, there's a very high probability
that the engine's done screwing around with its neighbors, so it's safe
to process.

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)

init.lua

@@ -4,39 +4,42 @@
 -- Splizard's snow mod.
 --
 
+biome_lib = {}
+
+-- Boilerplate to support localized strings if intllib mod is installed.
+local S
+if minetest.global_exists("intllib") then
+	if intllib.make_gettext_pair then
+		S = intllib.make_gettext_pair()
+	else
+		S = intllib.Getter()
+	end
+else
+	S = function(s) return s end
+end
+biome_lib.intllib = S
+
 -- 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.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")
 
-biome_lib.total_no_aircheck_calls = 0
-
-biome_lib.queue_run_ratio = tonumber(minetest.settings:get("biome_lib_queue_run_ratio")) or 100
-
 local function tableize(s)
 	return string.split(string.trim(string.gsub(s, " ", "")))
 end
 
-local c1 minetest.settings:get("biome_lib_default_grow_through_nodes")
+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
@@ -46,7 +49,7 @@ else
 	biome_lib.default_grow_through_nodes["default:snow"] = true
 end
 
-local c2 minetest.settings:get("biome_lib_default_water_nodes")
+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
@@ -67,27 +70,16 @@ biome_lib.default_wet_surfaces = c3 and tableize(c3) or {"default:dirt", "defaul
 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"}
 
--- Boilerplate to support localized strings if intllib mod is installed.
-local S
-if minetest.global_exists("intllib") then
-	if intllib.make_gettext_pair then
-		S = intllib.make_gettext_pair()
-	else
-		S = intllib.Getter()
-	end
-else
-	S = function(s) return s end
-end
-biome_lib.intllib = S
+biome_lib.debug_log_level = tonumber(minetest.settings:get("biome_lib_debug_log_level")) or 0
 
-local DEBUG = minetest.settings:get_bool("biome_lib_debug", false)
+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)
 
-function biome_lib:dbg(msg)
-	if DEBUG then
-		print("[Biome Lib] "..msg)
-		minetest.log("verbose", "[Biome Lib] "..msg)
-	end
-end
+-- timer runs in microseconds, but I want the user to supply a time in seconds
+biome_lib.block_timeout = (tonumber(minetest.settings:get("biome_lib_block_timeout")) or 300) * 1000000
+
+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
 
@@ -106,7 +98,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
@@ -119,6 +110,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})
 
@@ -160,7 +159,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
@@ -189,17 +188,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
@@ -208,7 +207,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
@@ -218,12 +217,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
@@ -232,7 +231,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
@@ -242,7 +241,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
@@ -330,7 +329,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)
 
@@ -351,10 +351,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
@@ -393,13 +393,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
@@ -409,114 +412,147 @@ 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 log read-out/mapgen spawner
+
+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
+
+	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
+
+function biome_lib.generate_block(shutting_down)
+
+	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
 
--- Primary mapgen spawner, for mods that can work with air checking enabled on
--- a surface during the initial map read stage.
+	local blocklog = biome_lib.run_block_recheck_list
+	  and biome_lib.block_recheck_list
+	  or biome_lib.block_log
 
-function biome_lib:generate_block_with_air_checking()
-	if not biome_lib.blocklist_aircheck[1] then
+	if not blocklog[1] then return end
+
+	local minp =		blocklog[1][1]
+	local maxp =		blocklog[1][2]
+	local airflag = 	blocklog[1][3]
+	local pos_hash = 	minetest.hash_node_position(minp)
+
+	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
-	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 -- read it into the block cache
-		biome_lib.surface_nodes_aircheck.blockhash =
-			minetest.find_nodes_in_area_under_air(minp, maxp, biome_lib.surfaceslist_aircheck)
-		biome_lib.actioncount_aircheck.blockhash = 1
-
 		else
-		if biome_lib.actionslist_aircheck[biome_lib.actioncount_aircheck.blockhash] 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
+			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
-			table.remove(biome_lib.blocklist_aircheck, 1)
-			biome_lib.surface_nodes_aircheck.blockhash = nil
-			biome_lib.actioncount_aircheck.blockhash = nil
+		-- 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
-	end
-end
-
--- Secondary mapgen spawner, for mods that require disabling of
--- checking for air during the initial map read stage.
-
-function biome_lib:generate_block_no_aircheck()
-	if not biome_lib.blocklist_no_aircheck[1] then
-		return
-	end
-
-	local minp =		biome_lib.blocklist_no_aircheck[1][1]
-	local maxp =		biome_lib.blocklist_no_aircheck[1][2]
-
-	local blockhash =	minetest.hash_node_position(minp)
-
-	if not biome_lib.surface_nodes_no_aircheck.blockhash then
-		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.actionslist_no_aircheck[biome_lib.actioncount_no_aircheck.blockhash] 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
-			table.remove(biome_lib.blocklist_no_aircheck, 1)
-			biome_lib.surface_nodes_no_aircheck.blockhash = nil
-			biome_lib.actioncount_no_aircheck.blockhash = nil
+			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)
 
@@ -524,26 +560,21 @@ end)
 -- 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)
 
@@ -737,29 +768,28 @@ function biome_lib:get_nodedef_field(nodename, fieldname)
 	return minetest.registered_nodes[nodename][fieldname]
 end
 
-if DEBUG then
-	biome_lib.last_count_air = 0
-	biome_lib.last_count_no_air = 0
+if biome_lib.debug_log_level >= 3 then
+	biome_lib.last_count = 0
 
-	function biome_lib.show_pending_block_counts()
-		if biome_lib.last_count_air ~= #biome_lib.blocklist_aircheck
-			or biome_lib.last_count_no_air ~= #biome_lib.blocklist_no_aircheck then
-			biome_lib:dbg(string.format("Pending block counts,  air: %-7i no-air: %i",
-				#biome_lib.blocklist_aircheck, #biome_lib.blocklist_no_aircheck))
-
-			biome_lib.last_count_air = #biome_lib.blocklist_aircheck
-			biome_lib.last_count_no_air = #biome_lib.blocklist_no_aircheck
+	function biome_lib.show_pending_block_count()
+		if biome_lib.last_count ~= #biome_lib.block_log then
+			biome_lib.dbg("Pending block count: "..(#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
+			biome_lib.dbg("Mapblock queue only contains blocks that can't yet be processed.",  3)
+			biome_lib.dbg("Idling the queue until new mapblocks show up.",  3)
+			biome_lib.queue_idle_flag = true
 		end
-		minetest.after(1, biome_lib.show_pending_block_counts)
+		minetest.after(1, biome_lib.show_pending_block_count)
 	end
 
-	biome_lib.show_pending_block_counts()
+	biome_lib.show_pending_block_count()
+end
 
 minetest.after(0, function()
-		print("Registered a total of "..(#biome_lib.surfaceslist_aircheck)+(#biome_lib.surfaceslist_no_aircheck).." surface types to be evaluated, spread")
-		print("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)
 
-end
-
-print("[Biome Lib] Loaded")
+biome_lib.dbg("[Biome Lib] Loaded", 0)

search_functions.lua

@@ -56,6 +56,7 @@ end
 -- split into individual mapblocks to reduce lag
 
 minetest.register_on_generated(function(minp, maxp, blockseed)
+	local timestamp = minetest.get_us_time()
 	for x = 0, 4 do
 		local minx = minp.x + x*16
 		for y = 0, 4 do
@@ -65,10 +66,10 @@ minetest.register_on_generated(function(minp, maxp, blockseed)
 
 				local bmin = {x=minx, y=miny, z=minz}
 				local bmax = {x=minx + 15, y=miny + 15, z=minz + 15}
-
-				biome_lib.blocklist_aircheck[#biome_lib.blocklist_aircheck + 1] = { bmin, bmax }
-				biome_lib.blocklist_no_aircheck[#biome_lib.blocklist_no_aircheck + 1] = { bmin, bmax }
+				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)