mtcontrib/biome_lib
1
0
Fork 1
mirror of https://github.com/mt-mods/biome_lib.git synced 2025-06-28 22:36:44 +02:00
Code Issues Releases Wiki Activity

Compare commits

base: mtcontrib:20200603-1302
Branches Tags
mtcontrib:master mtcontrib:mapgen_deco mtcontrib:extra-map-checks mtcontrib:non_mtg
mtcontrib:2021-04-23-2 mtcontrib:2021-04-23-1 mtcontrib:2021-04-20-1 mtcontrib:2021-04-16-2 mtcontrib:2021-04-16-1 mtcontrib:2021-04-14-1 mtcontrib:2021-04-09-1 mtcontrib:2021-04-08-2 mtcontrib:2021-04-08-1 mtcontrib:2021-04-07-5 mtcontrib:2021-04-07-2 mtcontrib:2021-04-07-1 mtcontrib:2021-03-25-1 mtcontrib:20200603-1302 mtcontrib:2021-01-30 mtcontrib:2019-05-22 mtcontrib:2018-11-26 mtcontrib:20181109 mtcontrib:2018-11-09
...
compare: mtcontrib:2021-04-09-1
Branches Tags
mtcontrib:master mtcontrib:mapgen_deco mtcontrib:extra-map-checks mtcontrib:non_mtg
mtcontrib:2021-04-23-2 mtcontrib:2021-04-23-1 mtcontrib:2021-04-20-1 mtcontrib:2021-04-16-2 mtcontrib:2021-04-16-1 mtcontrib:2021-04-14-1 mtcontrib:2021-04-09-1 mtcontrib:2021-04-08-2 mtcontrib:2021-04-08-1 mtcontrib:2021-04-07-5 mtcontrib:2021-04-07-2 mtcontrib:2021-04-07-1 mtcontrib:2021-03-25-1 mtcontrib:20200603-1302 mtcontrib:2021-01-30 mtcontrib:2019-05-22 mtcontrib:2018-11-26 mtcontrib:20181109 mtcontrib:2018-11-09

37 Commits
20200603-1 ... 2021-04-09

Author SHA1 Message Date
Vanessa Dannenberg
d06ab90e01 allow re-check-log entries to time out gradually rather than 
having to go all at once.  This purges the log sooner than before,
but without damaging the mapgen results.
 2021-04-09 13:26:42 -04:00
Vanessa Dannenberg
ba46e6c05e Report the mod's progress and ETA 
while purging the mapblock log at shutdown
 2021-04-09 12:38:09 -04:00
Vanessa Dannenberg
ed0b23677d fix typo 2021-04-08 08:09:59 -04:00
Vanessa Dannenberg
3b35fc67c6 Periodically re-trigger the mapblock queue code if it's idle, 
to give old, deferrred blocks a chance to time-out.  Needed
because if players aren't currently creating new terrain,
old blocks would never get processed, causing the block log
to only grow rather than eventually run dry (which could result
in very long shutdown times).
 2021-04-08 06:33:43 -04:00
Vanessa Dannenberg
eabc053c05 If a block has to be re-checked, renew its timestamp 2021-04-07 09:12:57 -04:00
Vanessa Dannenberg
dd650da443 Allow old blocks to time-out after a while 
(default 5 minutes).

Rationale: if a block is old enough, there's a very high probability
that the engine's done screwing around with its neighbors, so it's safe
to process.
 2021-04-07 07:41:48 -04:00
Vanessa Dannenberg
0a34e3c7af rename debug variable and option for consistency 
make global so it can be changed while running
 2021-04-07 07:41:32 -04:00
Vanessa Dannenberg
07c2b1d9d4 move all settings at the top of the code 
(some were scattered here and there)
 2021-04-07 07:13:53 -04:00
Vanessa Dannenberg
1dc0febd8c print a message when the queue goes idle. 2021-04-07 05:26:31 -04:00
Vanessa Dannenberg
50f921a85a implement variable log levels 
so that one need not see all the spammy stuff
if the only things of interest are e.g. warnings
 2021-04-07 05:16:11 -04:00
Vanessa Dannenberg
6009f261c2 make sure that any block about to be scanned is definitely loaded (in 
case the engine has unloaded the block because the player wandered off
for too long)
 2021-04-07 04:55:57 -04:00
Vanessa Dannenberg
531577afcf rather than copy the re-check log back into the block log when it comes 
time to run through it, just use it in-place, copying its entries back
to the main block log if they have to be skipped again (essentially
using the re-check list and the end of the block log as a double buffer)
 2021-04-07 01:44:31 -04:00
Vanessa Dannenberg
e346fd599f rather than rearranging the block log to deal with blocks that can't be 
populated yet, move those blocks to a separate list, and replay that
list whenever new mapblocks come in.  That way the main block list can
run dry and allow the block populate routines to go idle.

Thanks to Warr1024 for the idea!
 2021-04-06 16:09:50 -04:00
Vanessa Dannenberg
212024a9b4 tiny optimization 2021-04-06 13:38:43 -04:00
Vanessa Dannenberg
1d2593f022 if the block list is empty, don't try to start another batch of actions. 2021-04-06 13:08:43 -04:00
Vanessa Dannenberg
3bc8737e2d make sure the target mapblock and all 8 of its corner neighbors have 
been generated before populating the block (else move the target block
the end of the queue)

Thanks to Warr1024 for this idea!
 2021-04-06 12:47:05 -04:00
Vanessa Dannenberg
0ea4cb3848 don't bother checking dtime during globalstep 
it's enough to rely in the run ratio.
 2021-04-06 10:00:16 -04:00
Vanessa Dannenberg
bef0a0d87e oops, forgot to allow for no-air-check blocks 2021-04-06 04:19:57 -04:00
Vanessa Dannenberg
89ca62e492 added a bunch of debugging info 2021-04-06 03:20:14 -04:00
Vanessa Dannenberg
a325c2ccd8 rewrote block queue handlers to reduce code duplication 
and improve lag management

minetest.conf settings added:

biome_lib_dtime_limit:

Maximum lag allowed, in seconds.  Default 0.5s.  Larger values allow for
more lag, but make map updates run a bit faster.

biome_lib_queue_run_ratio:

If positive, this is the approximate number of globalstep ticks to skip
between map updates. If negative, it becomes the positive number of map
updates to run per globalstep tick before lag is checked.  No minimum
value, maximum +100.  Default: -100 (that is, 100 updates per globalstep
tick, with none intentionally skipped).  Use positive numbers for slow
machines or biome_lib-using mods that tend to cause lag, and negative
values for fast machines and mods.
 2021-04-06 03:20:12 -04:00
Vanessa Dannenberg
8ecb401309 fix a couple of missing = signs 2021-04-05 12:44:21 -04:00
Vanessa Dannenberg
9ed4858518 take the integer of that last division I added 
always round up.  otherwise it'll break the `for` loop
if a mod supplies a value not divisible by 25 :-)
 2021-04-01 09:02:41 -04:00
Vanessa Dannenberg
26dbbb5a67 since we split to mapblocks now, 
biome.max_count as received from mods has to be scaled appropriately
as mods expect this value to be relative to the usual
chunk size of 80x80 = 6400 nodes' horizontal area.
 2021-04-01 08:32:45 -04:00
Vanessa Dannenberg
ec0a0f0c3b add some debugging messages 2021-04-01 07:18:28 -04:00
Vanessa Dannenberg
e92361675f remove the old-plantslib-api compat thing 2021-04-01 06:24:09 -04:00
Vanessa Dannenberg
7f1fec6ae0 add compatibility for games other than minetest_game 2021-04-01 05:47:22 -04:00
Vanessa Dannenberg
f569bb1fbd fix outdated "plantlife" message 
and some redundancy
 2021-04-01 05:03:29 -04:00
Vanessa Dannenberg
f2a807b814 make debug mode a proper minetest.conf setting 2021-04-01 05:02:07 -04:00
Vanessa Dannenberg
9b7705c380 move the "registered N actions on M surfaces" message to debug 2021-04-01 04:59:57 -04:00
Vanessa Dannenberg
c9f6235815 Add a function to print active/pending block counts to debug 2021-04-01 04:50:03 -04:00
Vanessa Dannenberg
ddd88613e0 trim some blank lines 2021-04-01 04:34:07 -04:00
Vanessa Dannenberg
27cd07cb36 Fix overlap in the split-to-blocks feature 2021-04-01 04:33:53 -04:00
Vanessa Dannenberg
ac8738d837 use mod.conf instead of depends.txt 2021-03-29 19:56:09 -04:00
Vanessa Dannenberg
0005af6022 fix my name 2021-03-29 19:53:26 -04:00
Vanessa Dannenberg
228296411e split generated map chunks into mapblock-sized pieces as they're logged 
to reduce lag/latency at a tiny cost of overall throughput.
 2021-03-29 05:19:52 -04:00
Vanessa Dannenberg
353ca0cbd4 optimize some blocklist/actionlist checks 2021-03-28 23:10:31 -04:00
Vanessa Dannenberg
d65c72d48b don't need the old non-air-above find nodes call anymore 
only very old minetest engine lacks the air-above api call
 2021-03-25 19:27:38 -04:00
7 changed files with 357 additions and 172 deletions
Expand all files Collapse all files

52
API.txt
View File

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

2
README.md
View File

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

3
depends.txt
View File

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

6
growth.lua
View File

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

444
init.lua
View File

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

1
mod.conf
View File

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

21
search_functions.lua
View File

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