leaves now call `minetest.check_for_falling` at their position when
decomposing into air. this fixes an error where falling nodes would be
left floating above decomposing leaves once said leaves disappeared.
saplings can now replace alive leaves when growing (and other nodes can
easily be added in the future).
previously, instead of saplings, it was accidentally the case that
alive leaves growth worked like this when growing out of sapling,
instead of actual sapling growth.
make growing leaves turn into alive leaves if they should do so.
previously, this didn't happen for leaves that exceeded their max
distance from supporting node.
saplings now only check for groups, not specific nodes, when determining
whether they are supported. the previously checked nodes are now in the
new group that's being checked.
make sure that the node at the placed position is actually a decomposing
leaves variant before doing anything else. (this may not be the case,
since a node may start falling immediately after being placed.)
make decomposing leaves no longer traverse nodes that don't affect their
decomposition rate, when determining said rate. this means that they're
only affected by nodes that either touch them directly, or touch nodes
that affect them.
leaves now have a higher chance of turning into dirt, the higher they're
piled within the node. full stacks (taking up an entire node) always
turn into dirt.
decomposing leaves now stack in layers, each one 1/4 of a node in
height.
currently this doesn't affect their behaviour, beyond making them stack
when placed or landing.
using the new falling node hooks provided by `bg_api`, add alternative
versions of existing stoneworking recipes, where instead of pummeling, a
stoney node must fall onto the input nodes with sufficient force.
note that since the only currently existing stoney node that can fall,
loose cobblestone, is unobtainable without cheats, so are these recipes.
make the position passed to callbacks be the position where the
falling_node entity landed, rather than the position it tries to land
on/in.
note that if the node it lands on has its `paramtype2` set to
`"leveled"` then this new position might be empty after a landing.
modify the builtin `falling_node` entity to make it possible for mods to
register callbacks to be called when they land and turn into a node.
also register such a callback that checks if the landed node has an
entry `after_landing`, and if so calls that.
loose nodes are now automatically registrered when their settled
counterparts are. also rewrite a small amount of wrapper code and node
registration to work with this.
the api function `blockgame.register_node` will now emit events before
and after registering a node, allowing for other code to react to and
affect node registration.
make the wrapper `blockgame.register_node` make reasonable assumptions
that make node registration more convenient.
change other code to take advantage of that change.
also remove the `blockgame.reg_simple_node` utility since it's now
redundant.
rewrite some node registration code, removing the so far unused loose
nodes, and putting in place some data that outlines how they might be
implemented in the future.
create `bg_api_fall` mod, and move files `falling_node.lua` and `loose_node.lua` to there from `bg_api`.
update dependencies in other mods to account for this change.
