don't need the old non-air-above find nodes call anymore

only very old minetest engine lacks the air-above api call

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
@@ -238,7 +239,7 @@ biome = {
 	---- Everything else is optional, but you'll definitely want to use
 	---- some of these other fields to limit where and under what
 	---- conditions the objects are spawned.
-	
+
 	below_nodes = {table}, -- List of nodes that must be below the target
 						-- node.  Useful in snow biomes to keep objects from
 						-- spawning in snow that's on the wrong surface for
@@ -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.
@@ -481,6 +486,12 @@ Set this to true if you want the mod to spam your console with debug info :-)
 
 	plantlife_debug = false
 
+To slow down the playback of the queue (e.g. for really slow machines where
+the 0.2 second max limiter isn't enough), set:
+
+	biome_lib_queue_run_ratio = <some value 1 to 100>
+
+Default is 100 (basically percent of maximum runtime)
 
 ======================
 Fertile Ground Mapping

LICENSE

@@ -0,0 +1,600 @@
+License for code: LGPL 3.0
+License for media and all other assets:  CC-by-SA 4.0
+
+###############################################################################
+
+                   GNU LESSER GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+
+  This version of the GNU Lesser General Public License incorporates
+the terms and conditions of version 3 of the GNU General Public
+License, supplemented by the additional permissions listed below.
+
+  0. Additional Definitions.
+
+  As used herein, "this License" refers to version 3 of the GNU Lesser
+General Public License, and the "GNU GPL" refers to version 3 of the GNU
+General Public License.
+
+  "The Library" refers to a covered work governed by this License,
+other than an Application or a Combined Work as defined below.
+
+  An "Application" is any work that makes use of an interface provided
+by the Library, but which is not otherwise based on the Library.
+Defining a subclass of a class defined by the Library is deemed a mode
+of using an interface provided by the Library.
+
+  A "Combined Work" is a work produced by combining or linking an
+Application with the Library.  The particular version of the Library
+with which the Combined Work was made is also called the "Linked
+Version".
+
+  The "Minimal Corresponding Source" for a Combined Work means the
+Corresponding Source for the Combined Work, excluding any source code
+for portions of the Combined Work that, considered in isolation, are
+based on the Application, and not on the Linked Version.
+
+  The "Corresponding Application Code" for a Combined Work means the
+object code and/or source code for the Application, including any data
+and utility programs needed for reproducing the Combined Work from the
+Application, but excluding the System Libraries of the Combined Work.
+
+  1. Exception to Section 3 of the GNU GPL.
+
+  You may convey a covered work under sections 3 and 4 of this License
+without being bound by section 3 of the GNU GPL.
+
+  2. Conveying Modified Versions.
+
+  If you modify a copy of the Library, and, in your modifications, a
+facility refers to a function or data to be supplied by an Application
+that uses the facility (other than as an argument passed when the
+facility is invoked), then you may convey a copy of the modified
+version:
+
+   a) under this License, provided that you make a good faith effort to
+   ensure that, in the event an Application does not supply the
+   function or data, the facility still operates, and performs
+   whatever part of its purpose remains meaningful, or
+
+   b) under the GNU GPL, with none of the additional permissions of
+   this License applicable to that copy.
+
+  3. Object Code Incorporating Material from Library Header Files.
+
+  The object code form of an Application may incorporate material from
+a header file that is part of the Library.  You may convey such object
+code under terms of your choice, provided that, if the incorporated
+material is not limited to numerical parameters, data structure
+layouts and accessors, or small macros, inline functions and templates
+(ten or fewer lines in length), you do both of the following:
+
+   a) Give prominent notice with each copy of the object code that the
+   Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the object code with a copy of the GNU GPL and this license
+   document.
+
+  4. Combined Works.
+
+  You may convey a Combined Work under terms of your choice that,
+taken together, effectively do not restrict modification of the
+portions of the Library contained in the Combined Work and reverse
+engineering for debugging such modifications, if you also do each of
+the following:
+
+   a) Give prominent notice with each copy of the Combined Work that
+   the Library is used in it and that the Library and its use are
+   covered by this License.
+
+   b) Accompany the Combined Work with a copy of the GNU GPL and this license
+   document.
+
+   c) For a Combined Work that displays copyright notices during
+   execution, include the copyright notice for the Library among
+   these notices, as well as a reference directing the user to the
+   copies of the GNU GPL and this license document.
+
+   d) Do one of the following:
+
+       0) Convey the Minimal Corresponding Source under the terms of this
+       License, and the Corresponding Application Code in a form
+       suitable for, and under terms that permit, the user to
+       recombine or relink the Application with a modified version of
+       the Linked Version to produce a modified Combined Work, in the
+       manner specified by section 6 of the GNU GPL for conveying
+       Corresponding Source.
+
+       1) Use a suitable shared library mechanism for linking with the
+       Library.  A suitable mechanism is one that (a) uses at run time
+       a copy of the Library already present on the user's computer
+       system, and (b) will operate properly with a modified version
+       of the Library that is interface-compatible with the Linked
+       Version.
+
+   e) Provide Installation Information, but only if you would otherwise
+   be required to provide such information under section 6 of the
+   GNU GPL, and only to the extent that such information is
+   necessary to install and execute a modified version of the
+   Combined Work produced by recombining or relinking the
+   Application with a modified version of the Linked Version. (If
+   you use option 4d0, the Installation Information must accompany
+   the Minimal Corresponding Source and Corresponding Application
+   Code. If you use option 4d1, you must provide the Installation
+   Information in the manner specified by section 6 of the GNU GPL
+   for conveying Corresponding Source.)
+
+  5. Combined Libraries.
+
+  You may place library facilities that are a work based on the
+Library side by side in a single library together with other library
+facilities that are not Applications and are not covered by this
+License, and convey such a combined library under terms of your
+choice, if you do both of the following:
+
+   a) Accompany the combined library with a copy of the same work based
+   on the Library, uncombined with any other library facilities,
+   conveyed under the terms of this License.
+
+   b) Give prominent notice with the combined library that part of it
+   is a work based on the Library, and explaining where to find the
+   accompanying uncombined form of the same work.
+
+  6. Revised Versions of the GNU Lesser General Public License.
+
+  The Free Software Foundation may publish revised and/or new versions
+of the GNU Lesser General Public License from time to time. Such new
+versions will be similar in spirit to the present version, but may
+differ in detail to address new problems or concerns.
+
+  Each version is given a distinguishing version number. If the
+Library as you received it specifies that a certain numbered version
+of the GNU Lesser General Public License "or any later version"
+applies to it, you have the option of following the terms and
+conditions either of that published version or of any later version
+published by the Free Software Foundation. If the Library as you
+received it does not specify a version number of the GNU Lesser
+General Public License, you may choose any version of the GNU Lesser
+General Public License ever published by the Free Software Foundation.
+
+  If the Library as you received it specifies that a proxy can decide
+whether future versions of the GNU Lesser General Public License shall
+apply, that proxy's public statement of acceptance of any version is
+permanent authorization for you to choose that version for the
+Library.
+
+###############################################################################
+
+Attribution-ShareAlike 4.0 International
+
+=======================================================================
+
+Creative Commons Corporation ("Creative Commons") is not a law firm and
+does not provide legal services or legal advice. Distribution of
+Creative Commons public licenses does not create a lawyer-client or
+other relationship. Creative Commons makes its licenses and related
+information available on an "as-is" basis. Creative Commons gives no
+warranties regarding its licenses, any material licensed under their
+terms and conditions, or any related information. Creative Commons
+disclaims all liability for damages resulting from their use to the
+fullest extent possible.
+
+Using Creative Commons Public Licenses
+
+Creative Commons public licenses provide a standard set of terms and
+conditions that creators and other rights holders may use to share
+original works of authorship and other material subject to copyright
+and certain other rights specified in the public license below. The
+following considerations are for informational purposes only, are not
+exhaustive, and do not form part of our licenses.
+
+     Considerations for licensors: Our public licenses are
+     intended for use by those authorized to give the public
+     permission to use material in ways otherwise restricted by
+     copyright and certain other rights. Our licenses are
+     irrevocable. Licensors should read and understand the terms
+     and conditions of the license they choose before applying it.
+     Licensors should also secure all rights necessary before
+     applying our licenses so that the public can reuse the
+     material as expected. Licensors should clearly mark any
+     material not subject to the license. This includes other CC-
+     licensed material, or material used under an exception or
+     limitation to copyright. More considerations for licensors:
+	wiki.creativecommons.org/Considerations_for_licensors
+
+     Considerations for the public: By using one of our public
+     licenses, a licensor grants the public permission to use the
+     licensed material under specified terms and conditions. If
+     the licensor's permission is not necessary for any reason--for
+     example, because of any applicable exception or limitation to
+     copyright--then that use is not regulated by the license. Our
+     licenses grant only permissions under copyright and certain
+     other rights that a licensor has authority to grant. Use of
+     the licensed material may still be restricted for other
+     reasons, including because others have copyright or other
+     rights in the material. A licensor may make special requests,
+     such as asking that all changes be marked or described.
+     Although not required by our licenses, you are encouraged to
+     respect those requests where reasonable. More considerations
+     for the public: 
+	wiki.creativecommons.org/Considerations_for_licensees
+
+=======================================================================
+
+Creative Commons Attribution-ShareAlike 4.0 International Public
+License
+
+By exercising the Licensed Rights (defined below), You accept and agree
+to be bound by the terms and conditions of this Creative Commons
+Attribution-ShareAlike 4.0 International Public License ("Public
+License"). To the extent this Public License may be interpreted as a
+contract, You are granted the Licensed Rights in consideration of Your
+acceptance of these terms and conditions, and the Licensor grants You
+such rights in consideration of benefits the Licensor receives from
+making the Licensed Material available under these terms and
+conditions.
+
+
+Section 1 -- Definitions.
+
+  a. Adapted Material means material subject to Copyright and Similar
+     Rights that is derived from or based upon the Licensed Material
+     and in which the Licensed Material is translated, altered,
+     arranged, transformed, or otherwise modified in a manner requiring
+     permission under the Copyright and Similar Rights held by the
+     Licensor. For purposes of this Public License, where the Licensed
+     Material is a musical work, performance, or sound recording,
+     Adapted Material is always produced where the Licensed Material is
+     synched in timed relation with a moving image.
+
+  b. Adapter's License means the license You apply to Your Copyright
+     and Similar Rights in Your contributions to Adapted Material in
+     accordance with the terms and conditions of this Public License.
+
+  c. BY-SA Compatible License means a license listed at
+     creativecommons.org/compatiblelicenses, approved by Creative
+     Commons as essentially the equivalent of this Public License.
+
+  d. Copyright and Similar Rights means copyright and/or similar rights
+     closely related to copyright including, without limitation,
+     performance, broadcast, sound recording, and Sui Generis Database
+     Rights, without regard to how the rights are labeled or
+     categorized. For purposes of this Public License, the rights
+     specified in Section 2(b)(1)-(2) are not Copyright and Similar
+     Rights.
+
+  e. Effective Technological Measures means those measures that, in the
+     absence of proper authority, may not be circumvented under laws
+     fulfilling obligations under Article 11 of the WIPO Copyright
+     Treaty adopted on December 20, 1996, and/or similar international
+     agreements.
+
+  f. Exceptions and Limitations means fair use, fair dealing, and/or
+     any other exception or limitation to Copyright and Similar Rights
+     that applies to Your use of the Licensed Material.
+
+  g. License Elements means the license attributes listed in the name
+     of a Creative Commons Public License. The License Elements of this
+     Public License are Attribution and ShareAlike.
+
+  h. Licensed Material means the artistic or literary work, database,
+     or other material to which the Licensor applied this Public
+     License.
+
+  i. Licensed Rights means the rights granted to You subject to the
+     terms and conditions of this Public License, which are limited to
+     all Copyright and Similar Rights that apply to Your use of the
+     Licensed Material and that the Licensor has authority to license.
+
+  j. Licensor means the individual(s) or entity(ies) granting rights
+     under this Public License.
+
+  k. Share means to provide material to the public by any means or
+     process that requires permission under the Licensed Rights, such
+     as reproduction, public display, public performance, distribution,
+     dissemination, communication, or importation, and to make material
+     available to the public including in ways that members of the
+     public may access the material from a place and at a time
+     individually chosen by them.
+
+  l. Sui Generis Database Rights means rights other than copyright
+     resulting from Directive 96/9/EC of the European Parliament and of
+     the Council of 11 March 1996 on the legal protection of databases,
+     as amended and/or succeeded, as well as other essentially
+     equivalent rights anywhere in the world.
+
+  m. You means the individual or entity exercising the Licensed Rights
+     under this Public License. Your has a corresponding meaning.
+
+
+Section 2 -- Scope.
+
+  a. License grant.
+
+       1. Subject to the terms and conditions of this Public License,
+          the Licensor hereby grants You a worldwide, royalty-free,
+          non-sublicensable, non-exclusive, irrevocable license to
+          exercise the Licensed Rights in the Licensed Material to:
+
+            a. reproduce and Share the Licensed Material, in whole or
+               in part; and
+
+            b. produce, reproduce, and Share Adapted Material.
+
+       2. Exceptions and Limitations. For the avoidance of doubt, where
+          Exceptions and Limitations apply to Your use, this Public
+          License does not apply, and You do not need to comply with
+          its terms and conditions.
+
+       3. Term. The term of this Public License is specified in Section
+          6(a).
+
+       4. Media and formats; technical modifications allowed. The
+          Licensor authorizes You to exercise the Licensed Rights in
+          all media and formats whether now known or hereafter created,
+          and to make technical modifications necessary to do so. The
+          Licensor waives and/or agrees not to assert any right or
+          authority to forbid You from making technical modifications
+          necessary to exercise the Licensed Rights, including
+          technical modifications necessary to circumvent Effective
+          Technological Measures. For purposes of this Public License,
+          simply making modifications authorized by this Section 2(a)
+          (4) never produces Adapted Material.
+
+       5. Downstream recipients.
+
+            a. Offer from the Licensor -- Licensed Material. Every
+               recipient of the Licensed Material automatically
+               receives an offer from the Licensor to exercise the
+               Licensed Rights under the terms and conditions of this
+               Public License.
+
+            b. Additional offer from the Licensor -- Adapted Material.
+               Every recipient of Adapted Material from You
+               automatically receives an offer from the Licensor to
+               exercise the Licensed Rights in the Adapted Material
+               under the conditions of the Adapter's License You apply.
+
+            c. No downstream restrictions. You may not offer or impose
+               any additional or different terms or conditions on, or
+               apply any Effective Technological Measures to, the
+               Licensed Material if doing so restricts exercise of the
+               Licensed Rights by any recipient of the Licensed
+               Material.
+
+       6. No endorsement. Nothing in this Public License constitutes or
+          may be construed as permission to assert or imply that You
+          are, or that Your use of the Licensed Material is, connected
+          with, or sponsored, endorsed, or granted official status by,
+          the Licensor or others designated to receive attribution as
+          provided in Section 3(a)(1)(A)(i).
+
+  b. Other rights.
+
+       1. Moral rights, such as the right of integrity, are not
+          licensed under this Public License, nor are publicity,
+          privacy, and/or other similar personality rights; however, to
+          the extent possible, the Licensor waives and/or agrees not to
+          assert any such rights held by the Licensor to the limited
+          extent necessary to allow You to exercise the Licensed
+          Rights, but not otherwise.
+
+       2. Patent and trademark rights are not licensed under this
+          Public License.
+
+       3. To the extent possible, the Licensor waives any right to
+          collect royalties from You for the exercise of the Licensed
+          Rights, whether directly or through a collecting society
+          under any voluntary or waivable statutory or compulsory
+          licensing scheme. In all other cases the Licensor expressly
+          reserves any right to collect such royalties.
+
+
+Section 3 -- License Conditions.
+
+Your exercise of the Licensed Rights is expressly made subject to the
+following conditions.
+
+  a. Attribution.
+
+       1. If You Share the Licensed Material (including in modified
+          form), You must:
+
+            a. retain the following if it is supplied by the Licensor
+               with the Licensed Material:
+
+                 i. identification of the creator(s) of the Licensed
+                    Material and any others designated to receive
+                    attribution, in any reasonable manner requested by
+                    the Licensor (including by pseudonym if
+                    designated);
+
+                ii. a copyright notice;
+
+               iii. a notice that refers to this Public License;
+
+                iv. a notice that refers to the disclaimer of
+                    warranties;
+
+                 v. a URI or hyperlink to the Licensed Material to the
+                    extent reasonably practicable;
+
+            b. indicate if You modified the Licensed Material and
+               retain an indication of any previous modifications; and
+
+            c. indicate the Licensed Material is licensed under this
+               Public License, and include the text of, or the URI or
+               hyperlink to, this Public License.
+
+       2. You may satisfy the conditions in Section 3(a)(1) in any
+          reasonable manner based on the medium, means, and context in
+          which You Share the Licensed Material. For example, it may be
+          reasonable to satisfy the conditions by providing a URI or
+          hyperlink to a resource that includes the required
+          information.
+
+       3. If requested by the Licensor, You must remove any of the
+          information required by Section 3(a)(1)(A) to the extent
+          reasonably practicable.
+
+  b. ShareAlike.
+
+     In addition to the conditions in Section 3(a), if You Share
+     Adapted Material You produce, the following conditions also apply.
+
+       1. The Adapter's License You apply must be a Creative Commons
+          license with the same License Elements, this version or
+          later, or a BY-SA Compatible License.
+
+       2. You must include the text of, or the URI or hyperlink to, the
+          Adapter's License You apply. You may satisfy this condition
+          in any reasonable manner based on the medium, means, and
+          context in which You Share Adapted Material.
+
+       3. You may not offer or impose any additional or different terms
+          or conditions on, or apply any Effective Technological
+          Measures to, Adapted Material that restrict exercise of the
+          rights granted under the Adapter's License You apply.
+
+
+Section 4 -- Sui Generis Database Rights.
+
+Where the Licensed Rights include Sui Generis Database Rights that
+apply to Your use of the Licensed Material:
+
+  a. for the avoidance of doubt, Section 2(a)(1) grants You the right
+     to extract, reuse, reproduce, and Share all or a substantial
+     portion of the contents of the database;
+
+  b. if You include all or a substantial portion of the database
+     contents in a database in which You have Sui Generis Database
+     Rights, then the database in which You have Sui Generis Database
+     Rights (but not its individual contents) is Adapted Material,
+
+     including for purposes of Section 3(b); and
+  c. You must comply with the conditions in Section 3(a) if You Share
+     all or a substantial portion of the contents of the database.
+
+For the avoidance of doubt, this Section 4 supplements and does not
+replace Your obligations under this Public License where the Licensed
+Rights include other Copyright and Similar Rights.
+
+
+Section 5 -- Disclaimer of Warranties and Limitation of Liability.
+
+  a. UNLESS OTHERWISE SEPARATELY UNDERTAKEN BY THE LICENSOR, TO THE
+     EXTENT POSSIBLE, THE LICENSOR OFFERS THE LICENSED MATERIAL AS-IS
+     AND AS-AVAILABLE, AND MAKES NO REPRESENTATIONS OR WARRANTIES OF
+     ANY KIND CONCERNING THE LICENSED MATERIAL, WHETHER EXPRESS,
+     IMPLIED, STATUTORY, OR OTHER. THIS INCLUDES, WITHOUT LIMITATION,
+     WARRANTIES OF TITLE, MERCHANTABILITY, FITNESS FOR A PARTICULAR
+     PURPOSE, NON-INFRINGEMENT, ABSENCE OF LATENT OR OTHER DEFECTS,
+     ACCURACY, OR THE PRESENCE OR ABSENCE OF ERRORS, WHETHER OR NOT
+     KNOWN OR DISCOVERABLE. WHERE DISCLAIMERS OF WARRANTIES ARE NOT
+     ALLOWED IN FULL OR IN PART, THIS DISCLAIMER MAY NOT APPLY TO YOU.
+
+  b. TO THE EXTENT POSSIBLE, IN NO EVENT WILL THE LICENSOR BE LIABLE
+     TO YOU ON ANY LEGAL THEORY (INCLUDING, WITHOUT LIMITATION,
+     NEGLIGENCE) OR OTHERWISE FOR ANY DIRECT, SPECIAL, INDIRECT,
+     INCIDENTAL, CONSEQUENTIAL, PUNITIVE, EXEMPLARY, OR OTHER LOSSES,
+     COSTS, EXPENSES, OR DAMAGES ARISING OUT OF THIS PUBLIC LICENSE OR
+     USE OF THE LICENSED MATERIAL, EVEN IF THE LICENSOR HAS BEEN
+     ADVISED OF THE POSSIBILITY OF SUCH LOSSES, COSTS, EXPENSES, OR
+     DAMAGES. WHERE A LIMITATION OF LIABILITY IS NOT ALLOWED IN FULL OR
+     IN PART, THIS LIMITATION MAY NOT APPLY TO YOU.
+
+  c. The disclaimer of warranties and limitation of liability provided
+     above shall be interpreted in a manner that, to the extent
+     possible, most closely approximates an absolute disclaimer and
+     waiver of all liability.
+
+
+Section 6 -- Term and Termination.
+
+  a. This Public License applies for the term of the Copyright and
+     Similar Rights licensed here. However, if You fail to comply with
+     this Public License, then Your rights under this Public License
+     terminate automatically.
+
+  b. Where Your right to use the Licensed Material has terminated under
+     Section 6(a), it reinstates:
+
+       1. automatically as of the date the violation is cured, provided
+          it is cured within 30 days of Your discovery of the
+          violation; or
+
+       2. upon express reinstatement by the Licensor.
+
+     For the avoidance of doubt, this Section 6(b) does not affect any
+     right the Licensor may have to seek remedies for Your violations
+     of this Public License.
+
+  c. For the avoidance of doubt, the Licensor may also offer the
+     Licensed Material under separate terms or conditions or stop
+     distributing the Licensed Material at any time; however, doing so
+     will not terminate this Public License.
+
+  d. Sections 1, 5, 6, 7, and 8 survive termination of this Public
+     License.
+
+
+Section 7 -- Other Terms and Conditions.
+
+  a. The Licensor shall not be bound by any additional or different
+     terms or conditions communicated by You unless expressly agreed.
+
+  b. Any arrangements, understandings, or agreements regarding the
+     Licensed Material not stated herein are separate from and
+     independent of the terms and conditions of this Public License.
+
+
+Section 8 -- Interpretation.
+
+  a. For the avoidance of doubt, this Public License does not, and
+     shall not be interpreted to, reduce, limit, restrict, or impose
+     conditions on any use of the Licensed Material that could lawfully
+     be made without permission under this Public License.
+
+  b. To the extent possible, if any provision of this Public License is
+     deemed unenforceable, it shall be automatically reformed to the
+     minimum extent necessary to make it enforceable. If the provision
+     cannot be reformed, it shall be severed from this Public License
+     without affecting the enforceability of the remaining terms and
+     conditions.
+
+  c. No term or condition of this Public License will be waived and no
+     failure to comply consented to unless expressly agreed to by the
+     Licensor.
+
+  d. Nothing in this Public License constitutes or may be interpreted
+     as a limitation upon, or waiver of, any privileges and immunities
+     that apply to the Licensor or You, including from the legal
+     processes of any jurisdiction or authority.
+
+
+=======================================================================
+
+Creative Commons is not a party to its public
+licenses. Notwithstanding, Creative Commons may elect to apply one of
+its public licenses to material it publishes and in those instances
+will be considered the “Licensor.” The text of the Creative Commons
+public licenses is dedicated to the public domain under the CC0 Public
+Domain Dedication. Except for the limited purpose of indicating that
+material is shared under a Creative Commons public license or as
+otherwise permitted by the Creative Commons policies published at
+creativecommons.org/policies, Creative Commons does not authorize the
+use of the trademark "Creative Commons" or any other trademark or logo
+of Creative Commons without its prior written consent including,
+without limitation, in connection with any unauthorized modifications
+to any of its public licenses or any other arrangements,
+understandings, or agreements concerning use of licensed material. For
+the avoidance of doubt, this paragraph does not form part of the
+public licenses.
+
+Creative Commons may be contacted at creativecommons.org.

README.md

@@ -17,8 +17,6 @@ It is primarily intended for mapgen v6, but it should work fine when used with m
 **Recommends**: [Plantlife Modpack](https://github.com/minetest-mods/plantlife_modpack), 
 [More Trees](https://github.com/minetest-mods/moretrees)
 
-**License**: WTFPL
-
 **API**: This mod supplies a small number of very powerful functions. They are, briefly:
 
 * biome_lib:register_generate_plant()

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

@@ -1,6 +1,4 @@
--- Plantlife library mod by Vanessa Ezekowitz
+-- Biome library mod by Vanessa Ezekowitz
---
--- License:  WTFPL
 --
 -- I got the temperature map idea from "hmmmm", values used for it came from
 -- Splizard's snow mod.
@@ -9,6 +7,7 @@
 -- 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 })
 
@@ -31,10 +30,16 @@ 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
-if minetest.get_modpath("intllib") then
+if minetest.global_exists("intllib") then
-	S = intllib.Getter()
+	if intllib.make_gettext_pair then
+		S = intllib.make_gettext_pair()
+	else
+		S = intllib.Getter()
+	end
 else
 	S = function(s) return s end
 end
@@ -44,7 +49,7 @@ local DEBUG = false --... except if you want to spam the console with debugging
 
 function biome_lib:dbg(msg)
 	if DEBUG then
-		minetest.log("info", "[Plantlife] "..msg)
+		print("[Plantlife] "..msg)
 		minetest.log("verbose", "[Plantlife] "..msg)
 	end
 end
@@ -66,7 +71,7 @@ local humidity_persistence = 0.5
 local humidity_scale = 250
 
 local time_scale = 1
-local time_speed = tonumber(minetest.setting_get("time_speed"))
+local time_speed = tonumber(minetest.settings:get("time_speed"))
 
 if time_speed and time_speed > 0 then
 	time_scale = 72 / time_speed
@@ -79,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
@@ -142,7 +163,7 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 		biome_lib:dbg("Warning: Registered function call using deprecated string method: "..dump(nodes_or_function_or_model))
 	end
 
-	if biomedef.check_air == false then
+	if biomedef.check_air == false then 
 		biome_lib:dbg("Register no-air-check mapgen hook: "..dump(nodes_or_function_or_model))
 		biome_lib.actionslist_no_aircheck[#biome_lib.actionslist_no_aircheck + 1] = { biomedef, nodes_or_function_or_model }
 		local s = biomedef.surface
@@ -193,6 +214,87 @@ function biome_lib:register_generate_plant(biomedef, nodes_or_function_or_model)
 	end
 end
 
+-- Function to check whether a position matches the given biome definition
+-- Returns true when the surface can be populated
+
+local function populate_single_surface(biome, pos, perlin_fertile_area, checkair)
+	local p_top = { x = pos.x, y = pos.y + 1, z = pos.z }
+
+	if math.random(1, 100) <= biome.rarity then
+		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
+
+	if not biome.depth then
+		local dest_node = minetest.get_node(pos)
+		if string.find(biome_surfaces_string, dest_node.name) then
+			surface_ok = true
+		else
+			if string.find(biome_surfaces_string, "group:") then
+				for j = 1, #biome.surface do
+					if string.find(biome.surface[j], "^group:") 
+					  and minetest.get_item_group(dest_node.name, biome.surface[j]) then
+						surface_ok = true
+						break
+					end
+				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
+		surface_ok = true
+	end
+	
+	if not surface_ok then
+		return -- Surface does not match the given node group/name
+	end
+
+	if checkair and minetest.get_node(p_top).name ~= "air" then
+		return
+	end
+
+	if biome.below_nodes and
+			not string.find(dump(biome.below_nodes),
+				minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name
+			) then
+		return -- Node below does not match
+	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)
@@ -203,47 +305,8 @@ function biome_lib:populate_surfaces(biome, nodes_or_function_or_model, snodes,
 	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 pos = vector.new(snodes[i])
-		local p_top = { x = pos.x, y = pos.y + 1, z = pos.z }
+		if populate_single_surface(biome, pos, perlin_fertile_area, checkair) then
-		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})
-		local noise3 = biome_lib.perlin_humidity:get2d({x=pos.x+150, y=pos.z+50})
-		local biome_surfaces_string = dump(biome.surface)
-		local surface_ok = false
-
-		if not biome.depth then
-			local dest_node = minetest.get_node(pos)
-			if string.find(biome_surfaces_string, dest_node.name) then
-				surface_ok = true
-			else
-				if string.find(biome_surfaces_string, "group:") then
-					for j = 1, #biome.surface do
-						if string.find(biome.surface[j], "^group:")
-						  and minetest.get_item_group(dest_node.name, biome.surface[j]) then
-							surface_ok = true
-							break
-						end
-					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
-			surface_ok = true
-		end
-
-		if surface_ok
-		  and (not checkair or minetest.get_node(p_top).name == "air")
-		  and pos.y >= biome.min_elevation
-		  and pos.y <= biome.max_elevation
-		  and noise1 > biome.plantlife_limit
-		  and noise2 <= biome.temp_min
-		  and noise2 >= biome.temp_max
-		  and noise3 <= biome.humidity_min
-		  and noise3 >= biome.humidity_max
-		  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)
-		  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)
-		  and math.random(1,100) > biome.rarity
-		  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) )
-		  then
 			in_biome_nodes[#in_biome_nodes + 1] = pos
 		end
 	end
@@ -252,73 +315,77 @@ 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
-		for i = 1, math.min(biome.max_count, num_in_biome_nodes) do
+		return
-			local tries = 0
+	end
-			local spawned = false
+
-			while tries < 2 and not spawned do
+	for i = 1, math.min(biome.max_count, num_in_biome_nodes) do
-				local pos = in_biome_nodes[math.random(1, num_in_biome_nodes)]
+		local tries = 0
-				if biome.spawn_replace_node then
+		local spawned = false
-					pos.y = pos.y-1
+		while tries < 2 and not spawned do
+			local pos = in_biome_nodes[math.random(1, num_in_biome_nodes)]
+			if biome.spawn_replace_node then
+				pos.y = pos.y-1
+			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 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)
 				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 biome.delete_above_surround then
-					if biome.delete_above then
+					minetest.swap_node({x=p_top.x-1, y=p_top.y, z=p_top.z}, biome_lib.air)
-						minetest.remove_node(p_top)
+					minetest.swap_node({x=p_top.x+1, y=p_top.y, z=p_top.z}, biome_lib.air)
-						minetest.remove_node({x=p_top.x, y=p_top.y+1, z=p_top.z})
+					minetest.swap_node({x=p_top.x,   y=p_top.y, z=p_top.z-1}, biome_lib.air)
-					end
+					minetest.swap_node({x=p_top.x,   y=p_top.y, z=p_top.z+1}, biome_lib.air)
 
-					if biome.delete_above_surround then
+					minetest.swap_node({x=p_top.x-1, y=p_top.y+1, z=p_top.z}, biome_lib.air)
-						minetest.remove_node({x=p_top.x-1, y=p_top.y, z=p_top.z})
+					minetest.swap_node({x=p_top.x+1, y=p_top.y+1, z=p_top.z}, biome_lib.air)
-						minetest.remove_node({x=p_top.x+1, y=p_top.y, z=p_top.z})
+					minetest.swap_node({x=p_top.x,   y=p_top.y+1, z=p_top.z-1}, biome_lib.air)
-						minetest.remove_node({x=p_top.x,   y=p_top.y, z=p_top.z-1})
+					minetest.swap_node({x=p_top.x,   y=p_top.y+1, z=p_top.z+1}, biome_lib.air)
-						minetest.remove_node({x=p_top.x,   y=p_top.y, z=p_top.z+1})
+				end
 
-						minetest.remove_node({x=p_top.x-1, y=p_top.y+1, z=p_top.z})
+				if biome.spawn_replace_node then
-						minetest.remove_node({x=p_top.x+1, y=p_top.y+1, z=p_top.z})
+					minetest.swap_node(pos, biome_lib.air)
-						minetest.remove_node({x=p_top.x,   y=p_top.y+1, z=p_top.z-1})
+				end
-						minetest.remove_node({x=p_top.x,   y=p_top.y+1, z=p_top.z+1})
-					end
 
-					if biome.spawn_replace_node then
+				local objtype = type(nodes_or_function_or_model)
-						minetest.remove_node(pos)
-					end
 
-					local objtype = type(nodes_or_function_or_model)
+				if objtype == "table" then
-
+					if nodes_or_function_or_model.axiom then
-					if objtype == "table" then
+						biome_lib:generate_tree(p_top, nodes_or_function_or_model)
-						if nodes_or_function_or_model.axiom then
+						spawned = true
-							biome_lib:generate_tree(p_top, nodes_or_function_or_model)
+					else
-							spawned = true
-						else
-							local fdir = nil
-							if biome.random_facedir then
-								fdir = math.random(biome.random_facedir[1], biome.random_facedir[2])
-							end
-							minetest.set_node(p_top, { name = nodes_or_function_or_model[math.random(#nodes_or_function_or_model)], param2 = fdir })
-							spawned = true
-						end
-					elseif objtype == "string" and
-					  minetest.registered_nodes[nodes_or_function_or_model] then
 						local fdir = nil
 						if biome.random_facedir then
 							fdir = math.random(biome.random_facedir[1], biome.random_facedir[2])
 						end
-						minetest.set_node(p_top, { name = nodes_or_function_or_model, param2 = fdir })
+						minetest.swap_node(p_top, { name = nodes_or_function_or_model[math.random(#nodes_or_function_or_model)], param2 = fdir })
 						spawned = true
-					elseif objtype == "function" then
-						nodes_or_function_or_model(pos)
-						spawned = true
-					elseif objtype == "string" and pcall(loadstring(("return %s(...)"):
-						format(nodes_or_function_or_model)),pos) then
-						spawned = true
-					else
-						biome_lib:dbg("Warning: Ignored invalid definition for object "..dump(nodes_or_function_or_model).." that was pointed at {"..dump(pos).."}")
 					end
+				elseif objtype == "string" and
+				  minetest.registered_nodes[nodes_or_function_or_model] then
+					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, param2 = fdir })
+					spawned = true
+				elseif objtype == "function" then
+					nodes_or_function_or_model(pos)
+					spawned = true
+				elseif objtype == "string" and pcall(loadstring(("return %s(...)"):
+					format(nodes_or_function_or_model)),pos) then
+					spawned = true
 				else
-					tries = tries + 1
+					biome_lib:dbg("Warning: Ignored invalid definition for object "..dump(nodes_or_function_or_model).." that was pointed at {"..dump(pos).."}")
 				end
+			else
+				tries = tries + 1
 			end
 		end
 	end
@@ -328,51 +395,35 @@ end
 -- 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 minp =		biome_lib.blocklist_aircheck[1][1]
-		local maxp =		biome_lib.blocklist_aircheck[1][2]
+	local maxp =		biome_lib.blocklist_aircheck[1][2]
 
-		-- use the block hash as a unique key into the surface nodes
+	-- use the block hash as a unique key into the surface nodes
-		-- tables, so that we can write the tables thread-safely.
+	-- tables, so that we can write the tables thread-safely.
 
-		local blockhash =	minetest.hash_node_position(minp)
+	local blockhash =	minetest.hash_node_position(minp)
 
-		if not biome_lib.surface_nodes_aircheck.blockhash then
+	if not biome_lib.surface_nodes_aircheck.blockhash then
-
+		biome_lib.surface_nodes_aircheck.blockhash =
-			if type(minetest.find_nodes_in_area_under_air) == "function" then -- use newer API call
+			minetest.find_nodes_in_area_under_air(minp, maxp, biome_lib.surfaceslist_aircheck)
-				biome_lib.surface_nodes_aircheck.blockhash =
+		biome_lib.actioncount_aircheck.blockhash = 1
-					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.actioncount_aircheck.blockhash <= #biome_lib.actionslist_aircheck then
+			if biome_lib.surface_nodes_aircheck.blockhash then
-				-- [1] is biome, [2] is node/function/model
+				table.remove(biome_lib.blocklist_aircheck, 1)
-				biome_lib:populate_surfaces(
+				biome_lib.surface_nodes_aircheck.blockhash = nil
-					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
-				end
 			end
 		end
 	end
@@ -382,65 +433,60 @@ end
 -- 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 minp =		biome_lib.blocklist_no_aircheck[1][1]
-		local maxp =		biome_lib.blocklist_no_aircheck[1][2]
+	local maxp =		biome_lib.blocklist_no_aircheck[1][2]
 
-		local blockhash =	minetest.hash_node_position(minp)
+	local blockhash =	minetest.hash_node_position(minp)
 
-		if not biome_lib.surface_nodes_no_aircheck.blockhash then
+	if not biome_lib.surface_nodes_no_aircheck.blockhash then
 
-			-- directly read the block to be searched into the chunk cache
+		-- directly read the block to be searched into the chunk cache
 
-			biome_lib.surface_nodes_no_aircheck.blockhash =
+		biome_lib.surface_nodes_no_aircheck.blockhash =
-				minetest.find_nodes_in_area(minp, maxp, biome_lib.surfaceslist_no_aircheck)
+			minetest.find_nodes_in_area(minp, maxp, biome_lib.surfaceslist_no_aircheck)
-			biome_lib.actioncount_no_aircheck.blockhash = 1
+		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.actioncount_no_aircheck.blockhash <= #biome_lib.actionslist_no_aircheck then
+			if biome_lib.surface_nodes_no_aircheck.blockhash then
-				biome_lib:populate_surfaces(
+				table.remove(biome_lib.blocklist_no_aircheck, 1)
-					biome_lib.actionslist_no_aircheck[biome_lib.actioncount_no_aircheck.blockhash][1],
+				biome_lib.surface_nodes_no_aircheck.blockhash = nil
-					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
-				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 and    -- 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
-	  (#biome_lib.blocklist_aircheck > 0 or #biome_lib.blocklist_no_aircheck > 0) then
+			or math.random(100) > biome_lib.queue_run_ratio
-		biome_lib.globalstep_start_time = minetest.get_us_time()
+			or (#biome_lib.blocklist_aircheck == 0 and #biome_lib.blocklist_no_aircheck == 0) then
-		biome_lib.globalstep_runtime = 0
+		return
-		while (#biome_lib.blocklist_aircheck > 0 or #biome_lib.blocklist_no_aircheck > 0)
+	end
-		  and biome_lib.globalstep_runtime < 200000 do  -- 0.2 seconds, in uS.
+
-			if #biome_lib.blocklist_aircheck > 0 then
+	biome_lib.globalstep_start_time = minetest.get_us_time()
-				biome_lib:generate_block_with_air_checking()
+	biome_lib.globalstep_runtime = 0
-			end
+	while (#biome_lib.blocklist_aircheck > 0 or #biome_lib.blocklist_no_aircheck > 0)
-			if #biome_lib.blocklist_no_aircheck > 0 then
+	  and biome_lib.globalstep_runtime < 200000 do  -- 0.2 seconds, in uS.
-				biome_lib:generate_block_no_aircheck()
+		if #biome_lib.blocklist_aircheck > 0 then
-			end
+			biome_lib:generate_block_with_air_checking()
-			biome_lib.globalstep_runtime = minetest.get_us_time() - biome_lib.globalstep_start_time
 		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
 	end
 end)
 
@@ -448,20 +494,26 @@ end)
 -- to prevent unpopulated map areas
 
 minetest.register_on_shutdown(function()
-	minetest.log("action", "[biome_lib] Stand by, playing out the rest of the aircheck mapblock log")
+	if #biome_lib.blocklist_aircheck == 0 then
-	minetest.log("action", "(there are "..#biome_lib.blocklist_aircheck.." entries)...")
+		return
-	while true do
+	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)
-		if #biome_lib.blocklist_aircheck == 0 then return end
 	end
 end)
 
 minetest.register_on_shutdown(function()
-	minetest.log("action", "[biome_lib] Stand by, playing out the rest of the no-aircheck mapblock log")
+	if #biome_lib.blocklist_aircheck == 0 then
-	minetest.log("action", "(there are "..#biome_lib.blocklist_aircheck.." entries)...")
+		return
-	while true do
+	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.blocklist_no_aircheck == 0 then return end
 	end
 end)
 
@@ -491,125 +543,117 @@ 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 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 noise3 = biome_lib.perlin_humidity:get2d({x=p_top.x+150, y=p_top.z+50})
-			if noise1 > biome.plantlife_limit
-			  and noise2 <= biome.temp_min
-			  and noise2 >= biome.temp_max
-			  and noise3 <= biome.humidity_min
-			  and noise3 >= biome.humidity_max
-			  and biome_lib:is_node_loaded(p_top) then
-				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))
-				  and n_light >= biome.light_min
-				  and n_light <= biome.light_max
-				  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)
-				  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)
-				  and pos.y >= biome.min_elevation
-				  and pos.y <= biome.max_elevation
-				  then
-					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.set_node(p_top, { name = biome.alt_wallnode, param2 = walldir })
-						end
-					else
-						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 )
-						  then
-							local rnd = math.random(1, biome.spawn_plants_count)
-							local plant_to_spawn = biome.spawn_plants[rnd]
-							local fdir = biome.facedir
-							if biome.random_facedir then
-								fdir = math.random(biome.random_facedir[1],biome.random_facedir[2])
-							end
-							if type(biome.spawn_plants) == "string" then
-								assert(loadstring(biome.spawn_plants.."(...)"))(pos)
-							elseif not biome.spawn_on_side and not biome.spawn_on_bottom and not biome.spawn_replace_node then
-								if n_top.name == "air" then
-									minetest.set_node(p_top, { name = plant_to_spawn, param2 = fdir })
-								end
-							elseif biome.spawn_replace_node then
-								minetest.set_node(pos, { name = plant_to_spawn, param2 = fdir })
 
-							elseif biome.spawn_on_side then
+			local fertility, temperature, humidity = get_biome_data(pos, perlin_fertile_area)
-								local onside = biome_lib:find_open_side(pos)
+
-								if onside then
+			local pos_biome_ok = pos.y >= biome.min_elevation and pos.y <= biome.max_elevation
-									minetest.set_node(onside.newpos, { name = plant_to_spawn, param2 = onside.facedir })
+				and fertility > biome.plantlife_limit
-								end
+				and temperature <= biome.temp_min and temperature >= biome.temp_max
-							elseif biome.spawn_on_bottom then
+				and humidity <= biome.humidity_min and humidity >= biome.humidity_max
-								if minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
+				and biome_lib:is_node_loaded(p_top)
-									minetest.set_node({x=pos.x, y=pos.y-1, z=pos.z}, { name = plant_to_spawn, param2 = fdir} )
+
-								end
+			if not pos_biome_ok then
-							end
+				return -- Outside of biome
-						end
+			end
-					end
+
+			local n_light = minetest.get_node_light(p_top, nil)
+			if n_light < biome.light_min or n_light > biome.light_max then
+				return -- Too dark or too bright
+			end
+
+			if 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
+				return -- Nodes to avoid are nearby
+			end
+
+			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
+				return
 			end
-		end
-	})
-end
 
--- The growing ABM
+			local currentsurface = minetest.get_node(pos).name
 
-function biome_lib:grow_plants(opts)
+			if currentsurface == "default:water_source" and
-
+					#minetest.find_nodes_in_area(
-	local options = opts
+						{x=pos.x, y=pos.y-biome.depth_max-1, z=pos.z},
-
+						vector.new(pos),
-	options.height_limit = options.height_limit or 5
+						{"default:dirt", "default:dirt_with_grass", "default:sand"}
-	options.ground_nodes = options.ground_nodes or { "default:dirt_with_grass" }
+					) == 0 then
-	options.grow_nodes = options.grow_nodes or { "default:dirt_with_grass" }
+				return -- On water but no ground nearby
-	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.set_node(pos, { name = "default:dry_shrub" })
 
-				elseif options.grow_vertically and walldir then
+			local rnd = math.random(1, biome.spawn_plants_count)
-					if biome_lib:search_downward(pos, options.height_limit, options.ground_nodes) then
+			local plant_to_spawn = biome.spawn_plants[rnd]
-						minetest.set_node(p_top, { name = options.grow_plant, param2 = walldir})
+			local fdir = biome.facedir
-					end
+			if biome.random_facedir then
+				fdir = math.random(biome.random_facedir[1],biome.random_facedir[2])
+			end
+			if type(biome.spawn_plants) == "string" then
+				assert(loadstring(biome.spawn_plants.."(...)"))(pos)
+			elseif not biome.spawn_on_side and not biome.spawn_on_bottom and not biome.spawn_replace_node then
+				if n_top.name == "air" then
+					minetest.swap_node(p_top, { name = plant_to_spawn, param2 = fdir })
+				end
+			elseif biome.spawn_replace_node then
+				minetest.swap_node(pos, { name = plant_to_spawn, param2 = fdir })
 
-				elseif not options.grow_result and not options.grow_function then
+			elseif biome.spawn_on_side then
-					minetest.remove_node(pos)
+				local onside = biome_lib:find_open_side(pos)
-
+				if onside then
-				else
+					minetest.swap_node(onside.newpos, { name = plant_to_spawn, param2 = onside.facedir })
-					biome_lib:replace_object(pos, options.grow_result, options.grow_function, options.facedir, options.seed_diff)
+				end
+			elseif biome.spawn_on_bottom then
+				if minetest.get_node({x=pos.x, y=pos.y-1, z=pos.z}).name == "air" then
+					minetest.swap_node({x=pos.x, y=pos.y-1, z=pos.z}, { name = plant_to_spawn, param2 = fdir} )
 				end
 			end
 		end
@@ -622,98 +666,36 @@ end
 function biome_lib:replace_object(pos, replacement, grow_function, walldir, seeddiff)
 	local growtype = type(grow_function)
 	if growtype == "table" then
-		minetest.remove_node(pos)
+		minetest.swap_node(pos, biome_lib.air)
 		biome_lib:grow_tree(pos, grow_function)
 		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.set_node(pos, { name = replacement, param2 = walldir})
+		minetest.swap_node(pos, { name = replacement, param2 = walldir})
 		return
 	elseif growtype ~= "nil" and growtype ~= "string" and growtype ~= "table" then
 		error("Invalid grow function "..dump(grow_function).." used on object at ("..dump(pos)..")")
 	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
 
-if minetest.get_modpath("unified_inventory") or not minetest.setting_getbool("creative_mode") then
+if minetest.get_modpath("unified_inventory") or not minetest.settings:get_bool("creative_mode") then
 	biome_lib.expect_infinite_stacks = false
 else
 	biome_lib.expect_infinite_stacks = true
@@ -728,10 +710,10 @@ function biome_lib:get_nodedef_field(nodename, fieldname)
 	return minetest.registered_nodes[nodename][fieldname]
 end
 
-minetest.log("action", "[Biome Lib] Loaded")
+print("[Biome Lib] Loaded")
 
 minetest.after(0, function()
-	minetest.log("action", "[Biome Lib] Registered a total of "..(#biome_lib.surfaceslist_aircheck)+(#biome_lib.surfaceslist_no_aircheck).." surface types to be evaluated, spread")
+	print("[Biome Lib] Registered a total of "..(#biome_lib.surfaceslist_aircheck)+(#biome_lib.surfaceslist_no_aircheck).." surface types to be evaluated, spread")
-	minetest.log("action", "[Biome Lib] across "..#biome_lib.actionslist_aircheck.." actions with air-checking and "..#biome_lib.actionslist_no_aircheck.." actions without.")
+	print("[Biome Lib] across "..#biome_lib.actionslist_aircheck.." actions with air-checking and "..#biome_lib.actionslist_no_aircheck.." actions without.")
 end)
 

locale/ru.txt

@@ -0,0 +1,5 @@
+# Translation by inpos
+
+someone = кто-то 
+Sorry, %s owns that spot. = Извините, но %s уже является владельцем этой точки.
+[Plantlife Library] Loaded = [Plantlife Library] Загружена

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)