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.
leaves that aren't in contact with living logs, or are not in contact
with any supported leaves, or are too far away from living logs, will
now die and fall down.
make `flood_fill` able to be interrupted if its callback returns false;
the meaning that was previously indicated by this return value is now
indicated by nil instead.
update code that uses this function to account for this change.
pummeling definition tables now has lists of item id:s and groups, the
same way e.g. ABM:s do, that determine what items are involved in a
recipe.
update existing (in-use) pummel recipes to make use of this.
create api functions `any`, `every`, and `underride`.
`any` and `every` checks if a condition is true for any and every item
in a table, respectively.
`underride` returns a table that defaults to a provided table, for
items that aren't specified in the other provided table.
