In the legacy implementation of the region file I/O (before
the chunk system), these hooks were actually used. Now, they are not
and so there is no point in maintaining them.
The RegionFile IO scheduler is now capable of taking in
a Completable<CompoundTag> for the chunk data instead of
CompoundTag. This allows writes to be scheduled without
the write value immediately.
For collisions, need to check out the new applyEffectsFromBlocks
function and see if there are any improvements we can make.
For the chunk system, we need to implement async chunk saving.
The current async unload structure will not work, as it is designed
to only handle 1 pending save at any given time.
* Change min/max section optimisations
* Correctly init dimension type
We need to initialise the field as early as possible in the constructor
to avoid problems.
Also, do not cache min/max section in EntityLookup. Note that mods
that implement worlds with variable heights will not work still,
as the entity slices expect a fixed height.
* Cache calculated height values
---------
Co-authored-by: Spottedleaf <Spottedleaf@users.noreply.github.com>
We can use a simple array lookup table by palette id when the
number of palette entries is low. This eliminates the need for
the map lookup on each entry.
It appears that this call is very expensive. We instead substitute
an exact check with setting the special colliding blocks to whether
the palette initially contains a special colliding block, and after
on block updating by whether any special colliding block was set.
If the relative distance is 0, then we would return the current
instance - which may be a mutable instance. However, Vanilla overrides
the relative function to return an immutable instance even when
the distance is zero. To ensure that this behavior is kept, we return
an immutable instance when the distance is zero.
Not all broadcast chunks are ticking in the new chunk system,
so we need to track them separately to ensure updates take place
in non-simulation range chunks.
By only iterating over chunks that are both ticking AND near players
or marked for ticking, we can reduce the number of chunks to iterate
over in higher SD settings.
Use of a map for category->count is inefficient as the key
is an enum. We can use a simple int array, which reduces
the get() and compute() calls to an array access.
