add minimum minetest version key for contentdb

(if no surface list is given, just grow on anything)

API.txt

@@ -72,6 +72,7 @@ biome = {
 	---- most likely want to use at least some of these to limit how and
 	---- where your objects are spawned.
 
+	label = string,		-- set this to identify the ABM for Minetest's profiler
 	avoid_nodes = {table},	-- same meaning as savoid, above
 	avoid_radius = num,	-- same as sradius
 	seed_diff = num,	-- The Perlin seed difference value passed to the
@@ -342,14 +343,18 @@ into something else over time.  This function has no return value, and accepts
 a biome definition table as the only parameter.  These are defined like so:
 
 options = {
-	grow_plant = "string", -- Name of the node to be grown into something
+	label = string,		-- set this to identify the ABM for Minetest's
-						-- else.  This value is passed to the ABM as the
+						-- profiler.  If not set, biome_lib will set it to 
-						-- "nodenames" parameter, so it is the plants
+						-- "biome_lib grow_plants(): " appended with the node
-						-- themselves that are the ABM trigger, rather than
+						-- in grow_plant (or the first item if it's a table)
+	grow_plant = "string" or {table}, -- Name(s) of the node(s) to be grown
+						-- into something else.  This value is passed to the
+						-- ABM as the "nodenames" parameter, so the plants
+						-- themselves are the ABM trigger, rather than
 						-- the ground they spawned on.  A plant will only grow
-						-- if the node above it is air.  Can also be a table,
+						-- if the node above it is air.  If you use a table,
-						-- but note that all nodes referenced therein will be
+						-- note that all nodes referenced therein will be
-						-- grown into the same object.
+						-- grown into the same final object.
 	grow_delay = num,	-- Passed as the ABM "interval" parameter, as with
 						-- spawning.
 	grow_chance = num,	-- Passed as the ABM "chance" parameter.

growth.lua

@@ -0,0 +1,90 @@
+local time_scale = ...
+
+-- The growing ABM
+
+function biome_lib.check_surface(name, nodes)
+	if not nodes then return true end
+	if type(nodes) == "string" then return nodes == name end
+	if nodes.set and nodes[name] then
+		return true
+	else
+		for _, n in ipairs(nodes) do
+			if name == n then return true end
+		end
+	end
+	return false
+end
+
+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.seed_diff = options.seed_diff or 0
+
+	local n
+
+	if type(options.grow_plant) == "table" then
+		n = "multi: "..options.grow_plant[1]..", ..."
+	else
+		n = options.grow_plant
+	end
+
+	options.label = options.label or "biome_lib grow_plants(): "..n
+
+	if options.grow_delay*time_scale >= 1 then
+		options.interval = options.grow_delay*time_scale
+	else
+		options.interval = 1
+	end
+
+	minetest.register_abm({
+		nodenames = { options.grow_plant },
+		interval = options.interval,
+		chance = options.grow_chance,
+		label = options.label,
+		action = function(pos, node, active_object_count, active_object_count_wider)
+			local p_top = {x=pos.x, y=pos.y+1, z=pos.z}
+			local p_bot = {x=pos.x, y=pos.y-1, z=pos.z}
+			local n_top = minetest.get_node(p_top)
+			local n_bot = minetest.get_node(p_bot)
+			local root_node = minetest.get_node({x=pos.x, y=pos.y-options.height_limit, z=pos.z})
+			local walldir = nil
+			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")
+			  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
+						minetest.swap_node(p_top, { name = options.grow_plant, param2 = walldir})
+					end
+
+				elseif biome_lib.check_surface(n_bot.name, options.grow_nodes) then
+					if not options.grow_result and not options.grow_function then
+						minetest.swap_node(pos, biome_lib.air)
+
+					else
+						biome_lib:replace_object(pos, options.grow_result, options.grow_function, options.facedir, options.seed_diff)
+					end
+				end
+			end
+		end
+	})
+end
+
+
+-- spawn_tree() on generate is routed through here so that other mods can hook
+-- into it.
+
+function biome_lib:generate_tree(pos, nodes_or_function_or_model)
+	minetest.spawn_tree(pos, nodes_or_function_or_model)
+end
+
+-- and this one's for the call used in the growing code
+
+function biome_lib:grow_tree(pos, nodes_or_function_or_model)
+	minetest.spawn_tree(pos, nodes_or_function_or_model)
+end

init.lua

@@ -84,6 +84,22 @@ biome_lib.perlin_humidity = PerlinNoise(humidity_seeddiff, humidity_octaves, hum
 
 -- Local functions
 
+local function get_biome_data(pos, perlin_fertile)
+	local fertility = perlin_fertile:get_2d({x=pos.x, y=pos.z})
+
+	if type(minetest.get_biome_data) == "function" then
+		local data = minetest.get_biome_data(pos)
+		if data then
+			return fertility, data.heat / 100, data.humidity / 100
+		end
+	end
+
+	local temperature = biome_lib.perlin_temperature:get2d({x=pos.x, y=pos.z})
+	local humidity = biome_lib.perlin_humidity:get2d({x=pos.x+150, y=pos.z+50})
+
+	return fertility, temperature, humidity
+end
+
 function biome_lib:is_node_loaded(node_pos)
 	local n = minetest.get_node_or_nil(node_pos)
 	if (not n) or (n.name == "ignore") then
@@ -198,21 +214,27 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 	end
 end
 
-function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes, checkair)
+-- Function to check whether a position matches the given biome definition
+-- Returns true when the surface can be populated
 
-	biome_lib:set_defaults(biome)
+local function populate_single_surface(biome, pos, perlin_fertile_area, checkair)
-
-	-- filter stage 1 - find nodes from the supplied surfaces that are within the current biome.
-
-	local in_biome_nodes = {}
-	local perlin_fertile_area = minetest.get_perlin(biome.seed_diff, perlin_octaves, perlin_persistence, perlin_scale)
-
-	for i = 1, #snodes do
-		local pos = snodes[i]
 	local p_top = { x = pos.x, y = pos.y + 1, z = pos.z }
-		local noise1 = perlin_fertile_area:get2d({x=pos.x, y=pos.z})
+
-		local noise2 = biome_lib.perlin_temperature:get2d({x=pos.x, y=pos.z})
+	if math.random(1, 100) <= biome.rarity then
-		local noise3 = biome_lib.perlin_humidity:get2d({x=pos.x+150, y=pos.z+50})
+		return
+	end
+
+	local fertility, temperature, humidity = get_biome_data(pos, perlin_fertile_area)
+
+	local pos_biome_ok = pos.y >= biome.min_elevation and pos.y <= biome.max_elevation
+		and fertility > biome.plantlife_limit
+		and temperature <= biome.temp_min and temperature >= biome.temp_max
+		and humidity <= biome.humidity_min and humidity >= biome.humidity_max
+	
+	if not pos_biome_ok then
+		return -- Y position mismatch, outside of biome
+	end
+
 	local biome_surfaces_string = dump(biome.surface)
 	local surface_ok = false
 
@@ -231,24 +253,60 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 				end
 			end
 		end
-		elseif not string.find(biome_surfaces_string, minetest.get_node({ x = pos.x, y = pos.y-biome.depth-1, z = pos.z }).name) then
+	elseif not string.find(biome_surfaces_string,
+			minetest.get_node({ x = pos.x, y = pos.y-biome.depth-1, z = pos.z }).name) then
 		surface_ok = true
 	end
 	
-		if surface_ok
+	if not surface_ok then
-		  and pos.y >= biome.min_elevation
+		return -- Surface does not match the given node group/name
-		  and pos.y <= biome.max_elevation
+	end
-		  and noise1 > biome.plantlife_limit
+
-		  and noise2 <= biome.temp_min
+	if checkair and minetest.get_node(p_top).name ~= "air" then
-		  and noise2 >= biome.temp_max
+		return
-		  and noise3 <= biome.humidity_min
+	end
-		  and noise3 >= biome.humidity_max
+
-		  and (not checkair or minetest.get_node(p_top).name == "air")
+	if biome.below_nodes and
-		  and (not biome.ncount or #(minetest.find_nodes_in_area({x=pos.x-1, y=pos.y, z=pos.z-1}, {x=pos.x+1, y=pos.y, z=pos.z+1}, biome.neighbors)) > biome.ncount)
+			not string.find(dump(biome.below_nodes),
-		  and (not biome.near_nodes or #(minetest.find_nodes_in_area({x=pos.x-biome.near_nodes_size, y=pos.y-biome.near_nodes_vertical, z=pos.z-biome.near_nodes_size}, {x=pos.x+biome.near_nodes_size, y=pos.y+biome.near_nodes_vertical, z=pos.z+biome.near_nodes_size}, biome.near_nodes)) >= biome.near_nodes_count)
+				minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name
-		  and math.random(1,100) > biome.rarity
+			) then
-		  and (not biome.below_nodes or string.find(dump(biome.below_nodes), minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name) )
+		return -- Node below does not match
-		  then
+	end
+
+	if biome.ncount and
+			#minetest.find_nodes_in_area(
+				{x=pos.x-1, y=pos.y, z=pos.z-1},
+				{x=pos.x+1, y=pos.y, z=pos.z+1},
+				biome.neighbors
+			) <= biome.ncount then
+		return -- Not enough similar biome nodes around
+	end
+
+	if biome.near_nodes and
+			#minetest.find_nodes_in_area(
+				{x=pos.x-biome.near_nodes_size, y=pos.y-biome.near_nodes_vertical, z=pos.z-biome.near_nodes_size},
+				{x=pos.x+biome.near_nodes_size, y=pos.y+biome.near_nodes_vertical, z=pos.z+biome.near_nodes_size}, 
+				biome.near_nodes
+			) < biome.near_nodes_count then
+		return -- Long distance neighbours do not match
+	end
+
+	-- Position fits into given biome
+	return true
+end
+
+function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes, checkair)
+
+	biome_lib:set_defaults(biome)
+
+	-- filter stage 1 - find nodes from the supplied surfaces that are within the current biome.
+
+	local in_biome_nodes = {}
+	local perlin_fertile_area = minetest.get_perlin(biome.seed_diff, perlin_octaves, perlin_persistence, perlin_scale)
+
+	for i = 1, #snodes do
+		local pos = vector.new(snodes[i])
+		if populate_single_surface(biome, pos, perlin_fertile_area, checkair) then
 			in_biome_nodes[#in_biome_nodes + 1] = pos
 		end
 	end
@@ -257,7 +315,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
+	if num_in_biome_nodes == 0 then
+		return
+	end
+
 	for i = 1, math.min(biome.max_count, num_in_biome_nodes) do
 		local tries = 0
 		local spawned = false
@@ -268,7 +329,9 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 			end
 			local p_top = { x = pos.x, y = pos.y + 1, z = pos.z }
 
-				if not (biome.avoid_nodes and biome.avoid_radius and minetest.find_node_near(p_top, biome.avoid_radius + math.random(-1.5,2), biome.avoid_nodes)) then
+			if not (biome.avoid_nodes and biome.avoid_radius
+					and minetest.find_node_near(p_top, biome.avoid_radius
+					+ math.random(-1.5,2), biome.avoid_nodes)) then
 				if biome.delete_above then
 					minetest.swap_node(p_top, biome_lib.air)
 					minetest.swap_node({x=p_top.x, y=p_top.y+1, z=p_top.z}, biome_lib.air)
@@ -326,14 +389,15 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 			end
 		end
 	end
-	end
 end
 
 -- Primary mapgen spawner, for mods that can work with air checking enabled on
 -- a surface during the initial map read stage.
 
 function biome_lib:generate_block_with_air_checking()
-	if #biome_lib.blocklist_aircheck > 0 then
+	if #biome_lib.blocklist_aircheck == 0 then
+		return
+	end
 
 	local minp =		biome_lib.blocklist_aircheck[1][1]
 	local maxp =		biome_lib.blocklist_aircheck[1][2]
@@ -380,14 +444,15 @@ function biome_lib:generate_block_with_air_checking()
 			end
 		end
 	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 #biome_lib.blocklist_no_aircheck > 0 then
+	if #biome_lib.blocklist_no_aircheck == 0 then
+		return
+	end
 
 	local minp =		biome_lib.blocklist_no_aircheck[1][1]
 	local maxp =		biome_lib.blocklist_no_aircheck[1][2]
@@ -416,25 +481,18 @@ function biome_lib:generate_block_no_aircheck()
 			end
 		end
 	end
-	end
 end
 
--- "Record" the chunks being generated by the core mapgen
-
-minetest.register_on_generated(function(minp, maxp, blockseed)
-	biome_lib.blocklist_aircheck[#biome_lib.blocklist_aircheck + 1] = { minp, maxp }
-end)
-
-minetest.register_on_generated(function(minp, maxp, blockseed)
-	biome_lib.blocklist_no_aircheck[#biome_lib.blocklist_no_aircheck + 1] = { minp, maxp }
-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 < 0.2    -- don't attempt to populate if lag is already too high
+	if dtime >= step_duration + 0.1 -- don't attempt to populate if lag is already too high
-	  and math.random(100) <= biome_lib.queue_run_ratio
+			or math.random(100) > biome_lib.queue_run_ratio
-	  and (#biome_lib.blocklist_aircheck > 0 or #biome_lib.blocklist_no_aircheck > 0) then
+			or (#biome_lib.blocklist_aircheck == 0 and #biome_lib.blocklist_no_aircheck == 0) then
+		return
+	end
+
 	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)
@@ -447,31 +505,32 @@ minetest.register_globalstep(function(dtime)
 		end
 		biome_lib.globalstep_runtime = minetest.get_us_time() - biome_lib.globalstep_start_time
 	end
-	end
 end)
 
 -- 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.blocklist_aircheck == 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 true do
+	while #biome_lib.blocklist_aircheck > 0 do
 		biome_lib:generate_block_with_air_checking(0.1)
-			if #biome_lib.blocklist_aircheck == 0 then return end
-		end
 	end
 end)
 
 minetest.register_on_shutdown(function()
-	if #biome_lib.blocklist_no_aircheck > 0 then
+	if #biome_lib.blocklist_aircheck == 0 then
+		return
+	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 true do
+	while #biome_lib.blocklist_no_aircheck > 0 do
 		biome_lib:generate_block_no_aircheck(0.1)
-			if #biome_lib.blocklist_no_aircheck == 0 then return end
-		end
 	end
 end)
 
@@ -501,44 +560,94 @@ function biome_lib:spawn_on_surfaces(sd,sp,sr,sc,ss,sa)
 	biome_lib:set_defaults(biome)
 	biome.spawn_plants_count = #(biome.spawn_plants)
 
+	local n
+	if type(biome.spawn_plants) == "table" then
+		n = "random: "..biome.spawn_plants[1]..", ..."
+	else
+		n = biome.spawn_plants
+	end
+	biome.label = biome.label or "biome_lib spawn_on_surfaces(): "..n
+
 	minetest.register_abm({
 		nodenames = biome.spawn_surfaces,
 		interval = biome.interval,
 		chance = biome.spawn_chance,
 		neighbors = biome.neighbors,
+		label = biome.label,
 		action = function(pos, node, active_object_count, active_object_count_wider)
 			local p_top = { x = pos.x, y = pos.y + 1, z = pos.z }	
 			local n_top = minetest.get_node(p_top)
 			local perlin_fertile_area = minetest.get_perlin(biome.seed_diff, perlin_octaves, perlin_persistence, perlin_scale)
-			local noise1 = perlin_fertile_area:get2d({x=p_top.x, y=p_top.z})
+
-			local noise2 = biome_lib.perlin_temperature:get2d({x=p_top.x, y=p_top.z})
+			local fertility, temperature, humidity = get_biome_data(pos, perlin_fertile_area)
-			local noise3 = biome_lib.perlin_humidity:get2d({x=p_top.x+150, y=p_top.z+50})
+
-			if noise1 > biome.plantlife_limit 
+			local pos_biome_ok = pos.y >= biome.min_elevation and pos.y <= biome.max_elevation
-			  and noise2 <= biome.temp_min
+				and fertility > biome.plantlife_limit
-			  and noise2 >= biome.temp_max
+				and temperature <= biome.temp_min and temperature >= biome.temp_max
-			  and noise3 <= biome.humidity_min
+				and humidity <= biome.humidity_min and humidity >= biome.humidity_max
-			  and noise3 >= biome.humidity_max
+				and biome_lib:is_node_loaded(p_top)
-			  and biome_lib:is_node_loaded(p_top) then
+
+			if not pos_biome_ok then
+				return -- Outside of biome
+			end
+
 			local n_light = minetest.get_node_light(p_top, nil)
-				if not (biome.avoid_nodes and biome.avoid_radius and minetest.find_node_near(p_top, biome.avoid_radius + math.random(-1.5,2), biome.avoid_nodes))
+			if n_light < biome.light_min or n_light > biome.light_max then
-				  and n_light >= biome.light_min
+				return -- Too dark or too bright
-				  and n_light <= biome.light_max
+			end
-				  and (not(biome.neighbors and biome.ncount) or #(minetest.find_nodes_in_area({x=pos.x-1, y=pos.y, z=pos.z-1}, {x=pos.x+1, y=pos.y, z=pos.z+1}, biome.neighbors)) > biome.ncount )
+
-				  and (not(biome.near_nodes and biome.near_nodes_count and biome.near_nodes_size) or #(minetest.find_nodes_in_area({x=pos.x-biome.near_nodes_size, y=pos.y-biome.near_nodes_vertical, z=pos.z-biome.near_nodes_size}, {x=pos.x+biome.near_nodes_size, y=pos.y+biome.near_nodes_vertical, z=pos.z+biome.near_nodes_size}, biome.near_nodes)) >= biome.near_nodes_count)
+			if biome.avoid_nodes and biome.avoid_radius and minetest.find_node_near(
-				  and (not(biome.air_count and biome.air_size) or #(minetest.find_nodes_in_area({x=p_top.x-biome.air_size, y=p_top.y, z=p_top.z-biome.air_size}, {x=p_top.x+biome.air_size, y=p_top.y, z=p_top.z+biome.air_size}, "air")) >= biome.air_count)
+					p_top, biome.avoid_radius + math.random(-1.5,2), biome.avoid_nodes) then
-				  and pos.y >= biome.min_elevation
+				return -- Nodes to avoid are nearby
-				  and pos.y <= biome.max_elevation
+			end
-				  then
+
+			if biome.neighbors and biome.ncount and
+					#minetest.find_nodes_in_area(
+						{x=pos.x-1, y=pos.y, z=pos.z-1},
+						{x=pos.x+1, y=pos.y, z=pos.z+1},
+						biome.neighbors
+					) <= biome.ncount then
+				return -- Near neighbour nodes are not present
+			end
+
+			local NEAR_DST = biome.near_nodes_size
+			if biome.near_nodes and biome.near_nodes_count and biome.near_nodes_size and
+					#minetest.find_nodes_in_area(
+						{x=pos.x-NEAR_DST, y=pos.y-biome.near_nodes_vertical, z=pos.z-NEAR_DST},
+						{x=pos.x+NEAR_DST, y=pos.y+biome.near_nodes_vertical, z=pos.z+NEAR_DST},
+						biome.near_nodes
+					) < biome.near_nodes_count then
+				return -- Far neighbour nodes are not present
+			end
+
+			if (biome.air_count and biome.air_size) and
+					#minetest.find_nodes_in_area(
+						{x=p_top.x-biome.air_size, y=p_top.y, z=p_top.z-biome.air_size},
+						{x=p_top.x+biome.air_size, y=p_top.y, z=p_top.z+biome.air_size},
+						"air"
+					) < biome.air_count then
+				return -- Not enough air
+			end
+
 			local walldir = biome_lib:find_adjacent_wall(p_top, biome.verticals_list, biome.choose_random_wall)
 			if biome.alt_wallnode and walldir then
 				if n_top.name == "air" then
 					minetest.swap_node(p_top, { name = biome.alt_wallnode, param2 = walldir })
 				end
-					else
+				return
+			end
+
 			local currentsurface = minetest.get_node(pos).name
-						if currentsurface ~= "default:water_source"
+
-						  or (currentsurface == "default:water_source" and #(minetest.find_nodes_in_area({x=pos.x, y=pos.y-biome.depth_max-1, z=pos.z}, {x=pos.x, y=pos.y, z=pos.z}, {"default:dirt", "default:dirt_with_grass", "default:sand"})) > 0 )
+			if currentsurface == "default:water_source" and
-						  then
+					#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"}
+					) == 0 then
+				return -- On water but no ground nearby
+			end
+
 			local rnd = math.random(1, biome.spawn_plants_count)
 			local plant_to_spawn = biome.spawn_plants[rnd]
 			local fdir = biome.facedir
@@ -565,64 +674,6 @@ function biome_lib:spawn_on_surfaces(sd,sp,sr,sc,ss,sa)
 				end
 			end
 		end
-					end
-				end
-			end
-		end
-	})
-end
-
--- The growing ABM
-
-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.seed_diff = options.seed_diff or 0
-
-	if options.grow_delay*time_scale >= 1 then
-		options.interval = options.grow_delay*time_scale
-	else
-		options.interval = 1
-	end
-
-	minetest.register_abm({
-		nodenames = { options.grow_plant },
-		interval = options.interval,
-		chance = options.grow_chance,
-		action = function(pos, node, active_object_count, active_object_count_wider)
-			local p_top = {x=pos.x, y=pos.y+1, z=pos.z}
-			local p_bot = {x=pos.x, y=pos.y-1, z=pos.z}
-			local n_top = minetest.get_node(p_top)
-			local n_bot = minetest.get_node(p_bot)
-			local root_node = minetest.get_node({x=pos.x, y=pos.y-options.height_limit, z=pos.z})
-			local walldir = nil
-			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")
-			  and (not options.need_wall or (options.need_wall and walldir)) then
-				-- corner case for changing short junglegrass
-				-- to dry shrub in desert
-				if n_bot.name == options.dry_early_node and options.grow_plant == "junglegrass:short" then
-					minetest.swap_node(pos, { name = "default:dry_shrub" })
-
-				elseif options.grow_vertically and walldir then
-					if biome_lib:search_downward(pos, options.height_limit, options.ground_nodes) then
-						minetest.swap_node(p_top, { name = options.grow_plant, param2 = walldir})
-					end
-
-				elseif not options.grow_result and not options.grow_function then
-					minetest.swap_node(pos, biome_lib.air)
-
-				else
-					biome_lib:replace_object(pos, options.grow_result, options.grow_function, options.facedir, options.seed_diff)
-				end
-			end
-		end
 	})
 end
 
@@ -637,15 +688,13 @@ function biome_lib:replace_object(pos, replacement, grow_function, walldir, seed
 		return
 	elseif growtype == "function" then
 		local perlin_fertile_area = minetest.get_perlin(seeddiff, perlin_octaves, perlin_persistence, perlin_scale)
-		local noise1 = perlin_fertile_area:get2d({x=pos.x, y=pos.z})
+		local fertility, temperature, _ = get_biome_data(pos, perlin_fertile_area)
-		local noise2 = biome_lib.perlin_temperature:get2d({x=pos.x, y=pos.z})
+		grow_function(pos, fertility, temperature, walldir)
-		grow_function(pos,noise1,noise2,walldir)
 		return
 	elseif growtype == "string" then
 		local perlin_fertile_area = minetest.get_perlin(seeddiff, perlin_octaves, perlin_persistence, perlin_scale)
-		local noise1 = perlin_fertile_area:get2d({x=pos.x, y=pos.z})
+		local fertility, temperature, _ = get_biome_data(pos, perlin_fertile_area)
-		local noise2 = biome_lib.perlin_temperature:get2d({x=pos.x, y=pos.z})
+		assert(loadstring(grow_function.."(...)"))(pos, fertility, temperature, walldir)
-		assert(loadstring(grow_function.."(...)"))(pos,noise1,noise2,walldir)
 		return
 	elseif growtype == "nil" then
 		minetest.swap_node(pos, { name = replacement, param2 = walldir})
@@ -655,71 +704,11 @@ function biome_lib:replace_object(pos, replacement, grow_function, walldir, seed
 	end
 end
 
--- function to decide if a node has a wall that's in verticals_list{}
--- returns wall direction of valid node, or nil if invalid.
 
-function biome_lib:find_adjacent_wall(pos, verticals, randomflag)
+dofile(biome_lib.modpath .. "/search_functions.lua")
-	local verts = dump(verticals)
+assert(loadfile(biome_lib.modpath .. "/growth.lua"))(time_scale)
-	if randomflag then
-		local walltab = {}
 
-		if string.find(verts, minetest.get_node({ x=pos.x-1, y=pos.y, z=pos.z   }).name) then walltab[#walltab + 1] = 3 end
-		if string.find(verts, minetest.get_node({ x=pos.x+1, y=pos.y, z=pos.z   }).name) then walltab[#walltab + 1] = 2 end
-		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z-1 }).name) then walltab[#walltab + 1] = 5 end
-		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z+1 }).name) then walltab[#walltab + 1] = 4 end
 
-		if #walltab > 0 then return walltab[math.random(1, #walltab)] end
-
-	else
-		if string.find(verts, minetest.get_node({ x=pos.x-1, y=pos.y, z=pos.z   }).name) then return 3 end
-		if string.find(verts, minetest.get_node({ x=pos.x+1, y=pos.y, z=pos.z   }).name) then return 2 end
-		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z-1 }).name) then return 5 end
-		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z+1 }).name) then return 4 end
-	end
-	return nil
-end
-
--- Function to search downward from the given position, looking for the first
--- node that matches the ground table.  Returns the new position, or nil if
--- height limit is exceeded before finding it.
-
-function biome_lib:search_downward(pos, heightlimit, ground)
-	for i = 0, heightlimit do
-		if string.find(dump(ground), minetest.get_node({x=pos.x, y=pos.y-i, z = pos.z}).name) then
-			return {x=pos.x, y=pos.y-i, z = pos.z}
-		end
-	end
-	return false
-end
-
-function biome_lib:find_open_side(pos)
-	if minetest.get_node({ x=pos.x-1, y=pos.y, z=pos.z }).name == "air" then
-		return {newpos = { x=pos.x-1, y=pos.y, z=pos.z }, facedir = 2}
-	end
-	if minetest.get_node({ x=pos.x+1, y=pos.y, z=pos.z }).name == "air" then
-		return {newpos = { x=pos.x+1, y=pos.y, z=pos.z }, facedir = 3}
-	end
-	if minetest.get_node({ x=pos.x, y=pos.y, z=pos.z-1 }).name == "air" then
-		return {newpos = { x=pos.x, y=pos.y, z=pos.z-1 }, facedir = 4}
-	end
-	if minetest.get_node({ x=pos.x, y=pos.y, z=pos.z+1 }).name == "air" then
-		return {newpos = { x=pos.x, y=pos.y, z=pos.z+1 }, facedir = 5}
-	end
-	return nil
-end
-
--- spawn_tree() on generate is routed through here so that other mods can hook
--- into it.
-
-function biome_lib:generate_tree(pos, nodes_or_function_or_model)
-	minetest.spawn_tree(pos, nodes_or_function_or_model)
-end
-
--- and this one's for the call used in the growing code
-
-function biome_lib:grow_tree(pos, nodes_or_function_or_model)
-	minetest.spawn_tree(pos, nodes_or_function_or_model)
-end
 
 -- Check for infinite stacks
 

mod.conf

@@ -1 +1,2 @@
 name = biome_lib
+min_minetest_version = 5.2.0

search_functions.lua

@@ -0,0 +1,60 @@
+
+-- function to decide if a node has a wall that's in verticals_list{}
+-- returns wall direction of valid node, or nil if invalid.
+
+function biome_lib:find_adjacent_wall(pos, verticals, randomflag)
+	local verts = dump(verticals)
+	if randomflag then
+		local walltab = {}
+		
+		if string.find(verts, minetest.get_node({ x=pos.x-1, y=pos.y, z=pos.z   }).name) then walltab[#walltab + 1] = 3 end
+		if string.find(verts, minetest.get_node({ x=pos.x+1, y=pos.y, z=pos.z   }).name) then walltab[#walltab + 1] = 2 end
+		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z-1 }).name) then walltab[#walltab + 1] = 5 end
+		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z+1 }).name) then walltab[#walltab + 1] = 4 end
+
+		if #walltab > 0 then return walltab[math.random(1, #walltab)] end
+
+	else
+		if string.find(verts, minetest.get_node({ x=pos.x-1, y=pos.y, z=pos.z   }).name) then return 3 end
+		if string.find(verts, minetest.get_node({ x=pos.x+1, y=pos.y, z=pos.z   }).name) then return 2 end
+		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z-1 }).name) then return 5 end
+		if string.find(verts, minetest.get_node({ x=pos.x  , y=pos.y, z=pos.z+1 }).name) then return 4 end
+	end
+	return nil
+end
+
+-- Function to search downward from the given position, looking for the first
+-- node that matches the ground table.  Returns the new position, or nil if
+-- height limit is exceeded before finding it.
+
+function biome_lib:search_downward(pos, heightlimit, ground)
+	for i = 0, heightlimit do
+		if string.find(dump(ground), minetest.get_node({x=pos.x, y=pos.y-i, z = pos.z}).name) then
+			return {x=pos.x, y=pos.y-i, z = pos.z}
+		end
+	end
+	return false
+end
+
+function biome_lib:find_open_side(pos)
+	if minetest.get_node({ x=pos.x-1, y=pos.y, z=pos.z }).name == "air" then
+		return {newpos = { x=pos.x-1, y=pos.y, z=pos.z }, facedir = 2}
+	end
+	if minetest.get_node({ x=pos.x+1, y=pos.y, z=pos.z }).name == "air" then
+		return {newpos = { x=pos.x+1, y=pos.y, z=pos.z }, facedir = 3}
+	end
+	if minetest.get_node({ x=pos.x, y=pos.y, z=pos.z-1 }).name == "air" then
+		return {newpos = { x=pos.x, y=pos.y, z=pos.z-1 }, facedir = 4}
+	end
+	if minetest.get_node({ x=pos.x, y=pos.y, z=pos.z+1 }).name == "air" then
+		return {newpos = { x=pos.x, y=pos.y, z=pos.z+1 }, facedir = 5}
+	end
+	return nil
+end
+
+-- "Record" the chunks being generated by the core mapgen
+
+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 }
+end)