Instead of using limited-lifetime particles that need to be
refreshed, use sprite entities, which never need to be replaced
as long as they stay loaded.
There was a short "glitch" when replacing the particles where
they could appear twice, or be absent, for a frame or two. If
we're taking the screenshot at insanely high resolution/AA, which
the automation in this mod enables, we may have fractional FPS,
and the time window when the particles are in an invalid state
may expand to the point where it's impossible to capture a
screenshot with the correct smoke particles.
Making the smoke particles stable this way makes it possible to
reliably capture a screenshot with correct smoke particles at
insanely high quality / low framerate.
This allows us to remove a compatibility hack that risked creating
memory leaks on the server side. There may be other
simplifications possible that aren't known yet (e.g. with
formspec handling)
CDB now used WebP for thumbnails, de facto requiring that users of
the site actually support the format, so since it's already
mandatory, take advantage of it. WebP compresses notably better
than JPEG for comparable quality, so we can make the NodeCore CDB
page and screenshots load faster.
Since cdbrelease fixes the game title now, for players who have
a dev repo installed alongside the official game, display a
distinctly "DEV" title in the title bar when the game is selected
on the game bar to make it distinguishable.
If the fix for this gets merged, it will cause IDs to
just keep increasing until they wrap around, which
would eat up memory. Detect this before it
becomes critical, and disable the pooling hack
permanently (for this session) in that case.
Just hold the zoom button for a couple of seconds
(gives the player a chance to take screenshots with
the fixed zoom level) and then progressive zoom will
kick in automatically as long as zoom and no other
input control is held down.
This also prevents problems with the sneak/aux
causing unwanted movement while zooming.
Spontaneous node falling was intended to serve two
purposes originally:
- Prevent falling nodes from remaining nonsensically
suspended indefinitely from bad mapgen.
- Add a bit of tension to the game, back when it was
envisioned as more "hardcore" in more traditional
a sense.
The feature no longer fits with the tone and themes
of the game today. Sudden cave-ins caused by the
"sound/vibrations" of players disturbing an area are
largely indifferent to most players, confusing to
some, and very much hated by a few.
Instead of using variadics, hard-code array accesses for the
expected arity of door_operate_core, throwing away any
"future-proofing" that variadics were supposed to offer.
This is because in Lua 5.1, the length of arrays that contain
nil values anywhere in the sequence is apparently undefined, and
implementations are free to return the position of any value that
is followd by a nil, so length of {1, nil, 3} could be 1 or 3.
PUC lua seems to generally return 3, but LuaJIT takes more
liberties here (presumably exploiting UB for optimizations).
The problem arises when trying to unpack({1, nil, 3}) and LuaJIT
sees the length as 1 so return only <1>, instead of <1, nil, 3>.
This means that calling nodecore.door_operate(pos, ni, dir),
which was INTENDED for this API (it would look up node for you if
you didn't provide one) could result in the dir param being
lost due to packing the args into an array to defer them, and then
that array getting only partially unpacked.
Reference to WONTFIX bug where LuaJIT claims this is allowed UB:
https://github.com/LuaJIT/LuaJIT/issues/527
The solution for now is to stop relying on unpack (which is sort
of easy in its own way since I never really liked it). In the
specific case of nodecore.door_operate in particular, adding
more positional args (it already has 3) would be bad for other
reasons (should switch to a named passing style).
Deprecate the old APIs that used to close over the
metadata about valid node rotations. Now expose
this data in the node definition, and use a generic
non-closure function to handle the callback.
nodedef.spindata contains:
qty = number of allowed rotations total
cycle = table keyed on current param2 and valued with
next param2 for next rotation
equiv = table keyed by each possible param2 (24 keys)
and valued with canonical equivalent for that param2
Note that these are separate from the existing
recipes used elsewhere out of necessity. Lode
also anneals faster when carried (it's exposed
to more air cooling).
The inability to make solid white surfaces
has been a significant limitation to in-game
artistic expression for a while; this is an
inexpensive fix for that.
It shouldn't consume the whole tool, but
should wear it. Without having groups to
use, just wear the tool based on whichever
group is most "lenient" in terms of uses.
- Prevent them from interfering with each other if
one machine is used to host the game in "Host
Server" non-dedicated mode and another is used
to actually join to take the screenshot.
- Multiple player YCTIWY things shouldn't happen
anymore.
- Rebuild alpha image on demand from updated release image and
some filters and masks.
- Don't bother including the "release" screenshot in the alpha
edition listing, since it's sort of redundant and makes the
CDB page layout look a bit crappier on most screen sizes.
Players can use sneak and/or aux1 for far-zooming, so they can
far-zoom while treading water in an ocean to look at distant
islands, instead of using the aux1=climb down hack, which causes
all sorts of weird issues with other features that try to detect
movement controls
Add a centrifugal/centripetal component to door
conveyance when it's on the vertical axis, to
help prevent gravity from immediately undoing
the work.
- Items propelled by the bottom of a door are
also pushed outward.
- Items propelled by the top a door are also
pulled inward, landing atop where the door was.
There IS actually a mechanism to detect it,
though I'm not exactly sure how to use it.
Players need an opportunity to discover that
method and prove whether or not it can be
exploited to make a proper machine.
Door recursion is now always:
- Breadth-first, so paths with fewer door-to-door
interactions always "win".
- Random-ordered within each depth layer, so
there are are no biases in door operation order.
Looking into the possibility of making everything
overridable for game-logic purposes by group, it
turned out to be a bit of a nightmare. Also, instead
of overriding them at the "heuristic" layer, it's
probably better to simply allow overriding at the
specific game logic level, e.g. so that multiple
systems that use the same source data for heuristic
purposes can have differing behavior.
