add remapped patches as a testsoftspoon

1 files changed, 644 insertions, 0 deletions

diff --git a/patch-remap/mache-vineflower/net/minecraft/server/level/ServerChunkCache.java.patch b/patch-remap/mache-vineflower/net/minecraft/server/level/ServerChunkCache.java.patch
new file mode 100644
index 0000000000..1f70a0e9ed
--- /dev/null
+++ b/patch-remap/mache-vineflower/net/minecraft/server/level/ServerChunkCache.java.patch
@@ -0,0 +1,644 @@
+--- a/net/minecraft/server/level/ServerChunkCache.java
++++ b/net/minecraft/server/level/ServerChunkCache.java
+@@ -7,10 +7,11 @@
+ import java.io.File;
+ import java.io.IOException;
+ import java.util.Arrays;
++import java.util.Iterator;
+ import java.util.List;
++import java.util.Objects;
+ import java.util.Optional;
+ import java.util.concurrent.CompletableFuture;
+-import java.util.concurrent.CompletionStage;
+ import java.util.concurrent.Executor;
+ import java.util.function.BooleanSupplier;
+ import java.util.function.Consumer;
+@@ -27,9 +28,9 @@
+ import net.minecraft.world.entity.Entity;
+ import net.minecraft.world.entity.ai.village.poi.PoiManager;
+ import net.minecraft.world.level.ChunkPos;
++import net.minecraft.world.level.EnumSkyBlock;
+ import net.minecraft.world.level.GameRules;
+ import net.minecraft.world.level.Level;
+-import net.minecraft.world.level.LightLayer;
+ import net.minecraft.world.level.LocalMobCapCalculator;
+ import net.minecraft.world.level.NaturalSpawner;
+ import net.minecraft.world.level.chunk.ChunkAccess;
+@@ -47,6 +48,7 @@
+ import net.minecraft.world.level.storage.LevelStorageSource;
+ 
+ public class ServerChunkCache extends ChunkSource {
++
+     private static final List<ChunkStatus> CHUNK_STATUSES = ChunkStatus.getStatusList();
+     private final DistanceManager distanceManager;
+     final ServerLevel level;
+@@ -56,8 +58,8 @@
+     public final ChunkMap chunkMap;
+     private final DimensionDataStorage dataStorage;
+     private long lastInhabitedUpdate;
+-    private boolean spawnEnemies = true;
+-    private boolean spawnFriendlies = true;
++    public boolean spawnEnemies = true;
++    public boolean spawnFriendlies = true;
+     private static final int CACHE_SIZE = 4;
+     private final long[] lastChunkPos = new long[4];
+     private final ChunkStatus[] lastChunkStatus = new ChunkStatus[4];
+@@ -66,47 +68,31 @@
+     @VisibleForDebug
+     private NaturalSpawner.SpawnState lastSpawnState;
+ 
+-    public ServerChunkCache(
+-        ServerLevel level,
+-        LevelStorageSource.LevelStorageAccess levelStorageAccess,
+-        DataFixer fixerUpper,
+-        StructureTemplateManager structureManager,
+-        Executor dispatcher,
+-        ChunkGenerator generator,
+-        int viewDistance,
+-        int simulationDistance,
+-        boolean sync,
+-        ChunkProgressListener progressListener,
+-        ChunkStatusUpdateListener chunkStatusListener,
+-        Supplier<DimensionDataStorage> overworldDataStorage
+-    ) {
++    public ServerChunkCache(ServerLevel level, LevelStorageSource.LevelStorageAccess levelStorageAccess, DataFixer fixerUpper, StructureTemplateManager structureManager, Executor dispatcher, ChunkGenerator generator, int viewDistance, int simulationDistance, boolean sync, ChunkProgressListener progressListener, ChunkStatusUpdateListener chunkStatusListener, Supplier<DimensionDataStorage> overworldDataStorage) {
+         this.level = level;
+         this.mainThreadProcessor = new ServerChunkCache.MainThreadExecutor(level);
+         this.mainThread = Thread.currentThread();
+         File file = levelStorageAccess.getDimensionPath(level.dimension()).resolve("data").toFile();
++
+         file.mkdirs();
+         this.dataStorage = new DimensionDataStorage(file, fixerUpper);
+-        this.chunkMap = new ChunkMap(
+-            level,
+-            levelStorageAccess,
+-            fixerUpper,
+-            structureManager,
+-            dispatcher,
+-            this.mainThreadProcessor,
+-            this,
+-            generator,
+-            progressListener,
+-            chunkStatusListener,
+-            overworldDataStorage,
+-            viewDistance,
+-            sync
+-        );
++        this.chunkMap = new ChunkMap(level, levelStorageAccess, fixerUpper, structureManager, dispatcher, this.mainThreadProcessor, this, generator, progressListener, chunkStatusListener, overworldDataStorage, viewDistance, sync);
+         this.lightEngine = this.chunkMap.getLightEngine();
+         this.distanceManager = this.chunkMap.getDistanceManager();
+         this.distanceManager.updateSimulationDistance(simulationDistance);
+         this.clearCache();
+     }
+ 
++    // CraftBukkit start - properly implement isChunkLoaded
++    public boolean isChunkLoaded(int chunkX, int chunkZ) {
++        ChunkHolder chunk = this.chunkMap.getUpdatingChunkIfPresent(ChunkPos.asLong(chunkX, chunkZ));
++        if (chunk == null) {
++            return false;
++        }
++        return chunk.getFullChunkNow() != null;
++    }
++    // CraftBukkit end
++
+     @Override
+     public ThreadedLevelLightEngine getLightEngine() {
+         return this.lightEngine;
+@@ -121,51 +107,59 @@
+         return this.chunkMap.getTickingGenerated();
+     }
+ 
+-    private void storeInCache(long chunkPos, ChunkAccess chunk, ChunkStatus chunkStatus) {
+-        for (int i = 3; i > 0; i--) {
+-            this.lastChunkPos[i] = this.lastChunkPos[i - 1];
+-            this.lastChunkStatus[i] = this.lastChunkStatus[i - 1];
+-            this.lastChunk[i] = this.lastChunk[i - 1];
++    private void storeInCache(long chunkPos, ChunkAccess ichunkaccess, ChunkStatus chunk) {
++        for (int j = 3; j > 0; --j) {
++            this.lastChunkPos[j] = this.lastChunkPos[j - 1];
++            this.lastChunkStatus[j] = this.lastChunkStatus[j - 1];
++            this.lastChunk[j] = this.lastChunk[j - 1];
+         }
+ 
+         this.lastChunkPos[0] = chunkPos;
+-        this.lastChunkStatus[0] = chunkStatus;
+-        this.lastChunk[0] = chunk;
++        this.lastChunkStatus[0] = chunk;
++        this.lastChunk[0] = ichunkaccess;
+     }
+ 
+     @Nullable
+     @Override
+     public ChunkAccess getChunk(int chunkX, int chunkZ, ChunkStatus requiredStatus, boolean load) {
+         if (Thread.currentThread() != this.mainThread) {
+-            return CompletableFuture.<ChunkAccess>supplyAsync(() -> this.getChunk(chunkX, chunkZ, requiredStatus, load), this.mainThreadProcessor).join();
++            return (ChunkAccess) CompletableFuture.supplyAsync(() -> {
++                return this.getChunk(chunkX, chunkZ, requiredStatus, load);
++            }, this.mainThreadProcessor).join();
+         } else {
+-            ProfilerFiller profiler = this.level.getProfiler();
+-            profiler.incrementCounter("getChunk");
+-            long _long = ChunkPos.asLong(chunkX, chunkZ);
++            ProfilerFiller gameprofilerfiller = this.level.getProfiler();
+ 
+-            for (int i = 0; i < 4; i++) {
+-                if (_long == this.lastChunkPos[i] && requiredStatus == this.lastChunkStatus[i]) {
+-                    ChunkAccess chunkAccess = this.lastChunk[i];
+-                    if (chunkAccess != null || !load) {
+-                        return chunkAccess;
++            gameprofilerfiller.incrementCounter("getChunk");
++            long k = ChunkPos.asLong(chunkX, chunkZ);
++
++            ChunkAccess ichunkaccess;
++
++            for (int l = 0; l < 4; ++l) {
++                if (k == this.lastChunkPos[l] && requiredStatus == this.lastChunkStatus[l]) {
++                    ichunkaccess = this.lastChunk[l];
++                    if (ichunkaccess != null) { // CraftBukkit - the chunk can become accessible in the meantime TODO for non-null chunks it might also make sense to check that the chunk's state hasn't changed in the meantime
++                        return ichunkaccess;
+                     }
+                 }
+             }
+ 
+-            profiler.incrementCounter("getChunkCacheMiss");
+-            CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> chunkFutureMainThread = this.getChunkFutureMainThread(
+-                chunkX, chunkZ, requiredStatus, load
+-            );
+-            this.mainThreadProcessor.managedBlock(chunkFutureMainThread::isDone);
+-            ChunkAccess chunkAccess = chunkFutureMainThread.join().map(chunkAccess1 -> (ChunkAccess)chunkAccess1, chunkLoadingFailure -> {
++            gameprofilerfiller.incrementCounter("getChunkCacheMiss");
++            CompletableFuture<Either<ChunkAccess, ChunkHolder.Failure>> completablefuture = this.getChunkFutureMainThread(chunkX, chunkZ, requiredStatus, load);
++            ServerChunkCache.MainThreadExecutor chunkproviderserver_b = this.mainThreadProcessor;
++
++            Objects.requireNonNull(completablefuture);
++            chunkproviderserver_b.managedBlock(completablefuture::isDone);
++            ichunkaccess = (ChunkAccess) ((Either) completablefuture.join()).map((ichunkaccess1) -> {
++                return ichunkaccess1;
++            }, (playerchunk_failure) -> {
+                 if (load) {
+-                    throw (IllegalStateException)Util.pauseInIde(new IllegalStateException("Chunk not there when requested: " + chunkLoadingFailure));
++                    throw (IllegalStateException) Util.pauseInIde(new IllegalStateException("Chunk not there when requested: " + playerchunk_failure));
+                 } else {
+                     return null;
+                 }
+             });
+-            this.storeInCache(_long, chunkAccess, requiredStatus);
+-            return chunkAccess;
++            this.storeInCache(k, ichunkaccess, requiredStatus);
++            return ichunkaccess;
+         }
+     }
+ 
+@@ -176,28 +170,32 @@
+             return null;
+         } else {
+             this.level.getProfiler().incrementCounter("getChunkNow");
+-            long _long = ChunkPos.asLong(chunkX, chunkZ);
++            long k = ChunkPos.asLong(chunkX, chunkZ);
+ 
+-            for (int i = 0; i < 4; i++) {
+-                if (_long == this.lastChunkPos[i] && this.lastChunkStatus[i] == ChunkStatus.FULL) {
+-                    ChunkAccess chunkAccess = this.lastChunk[i];
+-                    return chunkAccess instanceof LevelChunk ? (LevelChunk)chunkAccess : null;
++            for (int l = 0; l < 4; ++l) {
++                if (k == this.lastChunkPos[l] && this.lastChunkStatus[l] == ChunkStatus.FULL) {
++                    ChunkAccess ichunkaccess = this.lastChunk[l];
++
++                    return ichunkaccess instanceof LevelChunk ? (LevelChunk) ichunkaccess : null;
+                 }
+             }
+ 
+-            ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(_long);
+-            if (visibleChunkIfPresent == null) {
++            ChunkHolder playerchunk = this.getVisibleChunkIfPresent(k);
++
++            if (playerchunk == null) {
+                 return null;
+             } else {
+-                Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure> either = visibleChunkIfPresent.getFutureIfPresent(ChunkStatus.FULL).getNow(null);
++                Either<ChunkAccess, ChunkHolder.Failure> either = (Either) playerchunk.getFutureIfPresent(ChunkStatus.FULL).getNow(null); // CraftBukkit - decompile error
++
+                 if (either == null) {
+                     return null;
+                 } else {
+-                    ChunkAccess chunkAccess1 = either.left().orElse(null);
+-                    if (chunkAccess1 != null) {
+-                        this.storeInCache(_long, chunkAccess1, ChunkStatus.FULL);
+-                        if (chunkAccess1 instanceof LevelChunk) {
+-                            return (LevelChunk)chunkAccess1;
++                    ChunkAccess ichunkaccess1 = (ChunkAccess) either.left().orElse(null); // CraftBukkit - decompile error
++
++                    if (ichunkaccess1 != null) {
++                        this.storeInCache(k, ichunkaccess1, ChunkStatus.FULL);
++                        if (ichunkaccess1 instanceof LevelChunk) {
++                            return (LevelChunk) ichunkaccess1;
+                         }
+                     }
+ 
+@@ -209,85 +207,99 @@
+ 
+     private void clearCache() {
+         Arrays.fill(this.lastChunkPos, ChunkPos.INVALID_CHUNK_POS);
+-        Arrays.fill(this.lastChunkStatus, null);
+-        Arrays.fill(this.lastChunk, null);
++        Arrays.fill(this.lastChunkStatus, (Object) null);
++        Arrays.fill(this.lastChunk, (Object) null);
+     }
+ 
+-    public CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getChunkFuture(int x, int y, ChunkStatus chunkStatus, boolean load) {
+-        boolean flag = Thread.currentThread() == this.mainThread;
+-        CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> chunkFutureMainThread;
+-        if (flag) {
+-            chunkFutureMainThread = this.getChunkFutureMainThread(x, y, chunkStatus, load);
+-            this.mainThreadProcessor.managedBlock(chunkFutureMainThread::isDone);
++    public CompletableFuture<Either<ChunkAccess, ChunkHolder.Failure>> getChunkFuture(int x, int y, ChunkStatus chunkStatus, boolean load) {
++        boolean flag1 = Thread.currentThread() == this.mainThread;
++        CompletableFuture completablefuture;
++
++        if (flag1) {
++            completablefuture = this.getChunkFutureMainThread(x, y, chunkStatus, load);
++            ServerChunkCache.MainThreadExecutor chunkproviderserver_b = this.mainThreadProcessor;
++
++            Objects.requireNonNull(completablefuture);
++            chunkproviderserver_b.managedBlock(completablefuture::isDone);
+         } else {
+-            chunkFutureMainThread = CompletableFuture.<CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>>>supplyAsync(
+-                    () -> this.getChunkFutureMainThread(x, y, chunkStatus, load), this.mainThreadProcessor
+-                )
+-                .thenCompose(completableFuture -> (CompletionStage<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>>)completableFuture);
++            completablefuture = CompletableFuture.supplyAsync(() -> {
++                return this.getChunkFutureMainThread(x, y, chunkStatus, load);
++            }, this.mainThreadProcessor).thenCompose((completablefuture1) -> {
++                return completablefuture1;
++            });
+         }
+ 
+-        return chunkFutureMainThread;
++        return completablefuture;
+     }
+ 
+-    private CompletableFuture<Either<ChunkAccess, ChunkHolder.ChunkLoadingFailure>> getChunkFutureMainThread(
+-        int x, int y, ChunkStatus chunkStatus, boolean load
+-    ) {
+-        ChunkPos chunkPos = new ChunkPos(x, y);
+-        long l = chunkPos.toLong();
+-        int i = ChunkLevel.byStatus(chunkStatus);
+-        ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(l);
+-        if (load) {
+-            this.distanceManager.addTicket(TicketType.UNKNOWN, chunkPos, i, chunkPos);
+-            if (this.chunkAbsent(visibleChunkIfPresent, i)) {
+-                ProfilerFiller profiler = this.level.getProfiler();
+-                profiler.push("chunkLoad");
++    private CompletableFuture<Either<ChunkAccess, ChunkHolder.Failure>> getChunkFutureMainThread(int x, int y, ChunkStatus chunkStatus, boolean load) {
++        ChunkPos chunkcoordintpair = new ChunkPos(x, y);
++        long k = chunkcoordintpair.toLong();
++        int l = ChunkLevel.byStatus(chunkStatus);
++        ChunkHolder playerchunk = this.getVisibleChunkIfPresent(k);
++
++        // CraftBukkit start - don't add new ticket for currently unloading chunk
++        boolean currentlyUnloading = false;
++        if (playerchunk != null) {
++            FullChunkStatus oldChunkState = ChunkLevel.fullStatus(playerchunk.oldTicketLevel);
++            FullChunkStatus currentChunkState = ChunkLevel.fullStatus(playerchunk.getTicketLevel());
++            currentlyUnloading = (oldChunkState.isOrAfter(FullChunkStatus.FULL) && !currentChunkState.isOrAfter(FullChunkStatus.FULL));
++        }
++        if (load && !currentlyUnloading) {
++            // CraftBukkit end
++            this.distanceManager.addTicket(TicketType.UNKNOWN, chunkcoordintpair, l, chunkcoordintpair);
++            if (this.chunkAbsent(playerchunk, l)) {
++                ProfilerFiller gameprofilerfiller = this.level.getProfiler();
++
++                gameprofilerfiller.push("chunkLoad");
+                 this.runDistanceManagerUpdates();
+-                visibleChunkIfPresent = this.getVisibleChunkIfPresent(l);
+-                profiler.pop();
+-                if (this.chunkAbsent(visibleChunkIfPresent, i)) {
+-                    throw (IllegalStateException)Util.pauseInIde(new IllegalStateException("No chunk holder after ticket has been added"));
++                playerchunk = this.getVisibleChunkIfPresent(k);
++                gameprofilerfiller.pop();
++                if (this.chunkAbsent(playerchunk, l)) {
++                    throw (IllegalStateException) Util.pauseInIde(new IllegalStateException("No chunk holder after ticket has been added"));
+                 }
+             }
+         }
+ 
+-        return this.chunkAbsent(visibleChunkIfPresent, i)
+-            ? ChunkHolder.UNLOADED_CHUNK_FUTURE
+-            : visibleChunkIfPresent.getOrScheduleFuture(chunkStatus, this.chunkMap);
++        return this.chunkAbsent(playerchunk, l) ? ChunkHolder.UNLOADED_CHUNK_FUTURE : playerchunk.getOrScheduleFuture(chunkStatus, this.chunkMap);
+     }
+ 
+     private boolean chunkAbsent(@Nullable ChunkHolder chunkHolder, int status) {
+-        return chunkHolder == null || chunkHolder.getTicketLevel() > status;
++        return chunkHolder == null || chunkHolder.oldTicketLevel > status; // CraftBukkit using oldTicketLevel for isLoaded checks
+     }
+ 
+     @Override
+     public boolean hasChunk(int x, int z) {
+-        ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(new ChunkPos(x, z).toLong());
+-        int i = ChunkLevel.byStatus(ChunkStatus.FULL);
+-        return !this.chunkAbsent(visibleChunkIfPresent, i);
++        ChunkHolder playerchunk = this.getVisibleChunkIfPresent((new ChunkPos(x, z)).toLong());
++        int k = ChunkLevel.byStatus(ChunkStatus.FULL);
++
++        return !this.chunkAbsent(playerchunk, k);
+     }
+ 
+     @Nullable
+     @Override
+     public LightChunk getChunkForLighting(int chunkX, int chunkZ) {
+-        long _long = ChunkPos.asLong(chunkX, chunkZ);
+-        ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(_long);
+-        if (visibleChunkIfPresent == null) {
++        long k = ChunkPos.asLong(chunkX, chunkZ);
++        ChunkHolder playerchunk = this.getVisibleChunkIfPresent(k);
++
++        if (playerchunk == null) {
+             return null;
+         } else {
+-            int i = CHUNK_STATUSES.size() - 1;
++            int l = ServerChunkCache.CHUNK_STATUSES.size() - 1;
+ 
+             while (true) {
+-                ChunkStatus chunkStatus = CHUNK_STATUSES.get(i);
+-                Optional<ChunkAccess> optional = visibleChunkIfPresent.getFutureIfPresentUnchecked(chunkStatus).getNow(ChunkHolder.UNLOADED_CHUNK).left();
++                ChunkStatus chunkstatus = (ChunkStatus) ServerChunkCache.CHUNK_STATUSES.get(l);
++                Optional<ChunkAccess> optional = ((Either) playerchunk.getFutureIfPresentUnchecked(chunkstatus).getNow(ChunkHolder.UNLOADED_CHUNK)).left();
++
+                 if (optional.isPresent()) {
+-                    return optional.get();
++                    return (LightChunk) optional.get();
+                 }
+ 
+-                if (chunkStatus == ChunkStatus.INITIALIZE_LIGHT.getParent()) {
++                if (chunkstatus == ChunkStatus.INITIALIZE_LIGHT.getParent()) {
+                     return null;
+                 }
+ 
+-                i--;
++                --l;
+             }
+         }
+     }
+@@ -304,6 +316,7 @@
+     boolean runDistanceManagerUpdates() {
+         boolean flag = this.distanceManager.runAllUpdates(this.chunkMap);
+         boolean flag1 = this.chunkMap.promoteChunkMap();
++
+         if (!flag && !flag1) {
+             return false;
+         } else {
+@@ -313,13 +326,15 @@
+     }
+ 
+     public boolean isPositionTicking(long chunkPos) {
+-        ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(chunkPos);
+-        if (visibleChunkIfPresent == null) {
++        ChunkHolder playerchunk = this.getVisibleChunkIfPresent(chunkPos);
++
++        if (playerchunk == null) {
+             return false;
+         } else if (!this.level.shouldTickBlocksAt(chunkPos)) {
+             return false;
+         } else {
+-            Either<LevelChunk, ChunkHolder.ChunkLoadingFailure> either = visibleChunkIfPresent.getTickingChunkFuture().getNow(null);
++            Either<LevelChunk, ChunkHolder.Failure> either = (Either) playerchunk.getTickingChunkFuture().getNow(null); // CraftBukkit - decompile error
++
+             return either != null && either.left().isPresent();
+         }
+     }
+@@ -331,11 +346,31 @@
+ 
+     @Override
+     public void close() throws IOException {
+-        this.save(true);
++        // CraftBukkit start
++        close(true);
++    }
++
++    public void close(boolean save) throws IOException {
++        if (save) {
++            this.save(true);
++        }
++        // CraftBukkit end
+         this.lightEngine.close();
+         this.chunkMap.close();
+     }
+ 
++    // CraftBukkit start - modelled on below
++    public void purgeUnload() {
++        this.level.getProfiler().push("purge");
++        this.distanceManager.purgeStaleTickets();
++        this.runDistanceManagerUpdates();
++        this.level.getProfiler().popPush("unload");
++        this.chunkMap.tick(() -> true);
++        this.level.getProfiler().pop();
++        this.clearCache();
++    }
++    // CraftBukkit end
++
+     @Override
+     public void tick(BooleanSupplier hasTimeLeft, boolean tickChunks) {
+         this.level.getProfiler().push("purge");
+@@ -354,68 +389,80 @@
+     }
+ 
+     private void tickChunks() {
+-        long gameTime = this.level.getGameTime();
+-        long l = gameTime - this.lastInhabitedUpdate;
+-        this.lastInhabitedUpdate = gameTime;
++        long i = this.level.getGameTime();
++        long j = i - this.lastInhabitedUpdate;
++
++        this.lastInhabitedUpdate = i;
+         if (!this.level.isDebug()) {
+-            ProfilerFiller profiler = this.level.getProfiler();
+-            profiler.push("pollingChunks");
+-            profiler.push("filteringLoadedChunks");
+-            List<ServerChunkCache.ChunkAndHolder> list = Lists.newArrayListWithCapacity(this.chunkMap.size());
++            ProfilerFiller gameprofilerfiller = this.level.getProfiler();
+ 
+-            for (ChunkHolder chunkHolder : this.chunkMap.getChunks()) {
+-                LevelChunk tickingChunk = chunkHolder.getTickingChunk();
+-                if (tickingChunk != null) {
+-                    list.add(new ServerChunkCache.ChunkAndHolder(tickingChunk, chunkHolder));
++            gameprofilerfiller.push("pollingChunks");
++            gameprofilerfiller.push("filteringLoadedChunks");
++            List<ServerChunkCache.a> list = Lists.newArrayListWithCapacity(this.chunkMap.size());
++            Iterator iterator = this.chunkMap.getChunks().iterator();
++
++            while (iterator.hasNext()) {
++                ChunkHolder playerchunk = (ChunkHolder) iterator.next();
++                LevelChunk chunk = playerchunk.getTickingChunk();
++
++                if (chunk != null) {
++                    list.add(new ServerChunkCache.a(chunk, playerchunk));
+                 }
+             }
+ 
+             if (this.level.getServer().tickRateManager().runsNormally()) {
+-                profiler.popPush("naturalSpawnCount");
+-                int naturalSpawnChunkCount = this.distanceManager.getNaturalSpawnChunkCount();
+-                NaturalSpawner.SpawnState spawnState = NaturalSpawner.createState(
+-                    naturalSpawnChunkCount, this.level.getAllEntities(), this::getFullChunk, new LocalMobCapCalculator(this.chunkMap)
+-                );
+-                this.lastSpawnState = spawnState;
+-                profiler.popPush("spawnAndTick");
+-                boolean _boolean = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING);
++                gameprofilerfiller.popPush("naturalSpawnCount");
++                int k = this.distanceManager.getNaturalSpawnChunkCount();
++                NaturalSpawner.SpawnState spawnercreature_d = NaturalSpawner.createState(k, this.level.getAllEntities(), this::getFullChunk, new LocalMobCapCalculator(this.chunkMap));
++
++                this.lastSpawnState = spawnercreature_d;
++                gameprofilerfiller.popPush("spawnAndTick");
++                boolean flag = this.level.getGameRules().getBoolean(GameRules.RULE_DOMOBSPAWNING) && !this.level.players().isEmpty(); // CraftBukkit
++
+                 Util.shuffle(list, this.level.random);
+-                int _int = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING);
+-                boolean flag = this.level.getLevelData().getGameTime() % 400L == 0L;
++                int l = this.level.getGameRules().getInt(GameRules.RULE_RANDOMTICKING);
++                boolean flag1 = this.level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) != 0L && this.level.getLevelData().getGameTime() % this.level.ticksPerSpawnCategory.getLong(org.bukkit.entity.SpawnCategory.ANIMAL) == 0L; // CraftBukkit
++                Iterator iterator1 = list.iterator();
+ 
+-                for (ServerChunkCache.ChunkAndHolder chunkAndHolder : list) {
+-                    LevelChunk levelChunk = chunkAndHolder.chunk;
+-                    ChunkPos pos = levelChunk.getPos();
+-                    if (this.level.isNaturalSpawningAllowed(pos) && this.chunkMap.anyPlayerCloseEnoughForSpawning(pos)) {
+-                        levelChunk.incrementInhabitedTime(l);
+-                        if (_boolean && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(pos)) {
+-                            NaturalSpawner.spawnForChunk(this.level, levelChunk, spawnState, this.spawnFriendlies, this.spawnEnemies, flag);
++                while (iterator1.hasNext()) {
++                    ServerChunkCache.a chunkproviderserver_a = (ServerChunkCache.a) iterator1.next();
++                    LevelChunk chunk1 = chunkproviderserver_a.chunk;
++                    ChunkPos chunkcoordintpair = chunk1.getPos();
++
++                    if (this.level.isNaturalSpawningAllowed(chunkcoordintpair) && this.chunkMap.anyPlayerCloseEnoughForSpawning(chunkcoordintpair)) {
++                        chunk1.incrementInhabitedTime(j);
++                        if (flag && (this.spawnEnemies || this.spawnFriendlies) && this.level.getWorldBorder().isWithinBounds(chunkcoordintpair)) {
++                            NaturalSpawner.spawnForChunk(this.level, chunk1, spawnercreature_d, this.spawnFriendlies, this.spawnEnemies, flag1);
+                         }
+ 
+-                        if (this.level.shouldTickBlocksAt(pos.toLong())) {
+-                            this.level.tickChunk(levelChunk, _int);
++                        if (this.level.shouldTickBlocksAt(chunkcoordintpair.toLong())) {
++                            this.level.tickChunk(chunk1, l);
+                         }
+                     }
+                 }
+ 
+-                profiler.popPush("customSpawners");
+-                if (_boolean) {
++                gameprofilerfiller.popPush("customSpawners");
++                if (flag) {
+                     this.level.tickCustomSpawners(this.spawnEnemies, this.spawnFriendlies);
+                 }
+             }
+ 
+-            profiler.popPush("broadcast");
+-            list.forEach(chunkAndHolder1 -> chunkAndHolder1.holder.broadcastChanges(chunkAndHolder1.chunk));
+-            profiler.pop();
+-            profiler.pop();
++            gameprofilerfiller.popPush("broadcast");
++            list.forEach((chunkproviderserver_a1) -> {
++                chunkproviderserver_a1.holder.broadcastChanges(chunkproviderserver_a1.chunk);
++            });
++            gameprofilerfiller.pop();
++            gameprofilerfiller.pop();
+         }
+     }
+ 
+-    private void getFullChunk(long chunkPos, Consumer<LevelChunk> fullChunkGetter) {
+-        ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(chunkPos);
+-        if (visibleChunkIfPresent != null) {
+-            visibleChunkIfPresent.getFullChunkFuture().getNow(ChunkHolder.UNLOADED_LEVEL_CHUNK).left().ifPresent(fullChunkGetter);
++    private void getFullChunk(long chunkPos, Consumer<LevelChunk> consumer) {
++        ChunkHolder playerchunk = this.getVisibleChunkIfPresent(chunkPos);
++
++        if (playerchunk != null) {
++            ((Either) playerchunk.getFullChunkFuture().getNow(ChunkHolder.UNLOADED_LEVEL_CHUNK)).left().ifPresent(consumer);
+         }
++
+     }
+ 
+     @Override
+@@ -447,20 +494,24 @@
+ 
+     public void blockChanged(BlockPos pos) {
+         int i = SectionPos.blockToSectionCoord(pos.getX());
+-        int i1 = SectionPos.blockToSectionCoord(pos.getZ());
+-        ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(ChunkPos.asLong(i, i1));
+-        if (visibleChunkIfPresent != null) {
+-            visibleChunkIfPresent.blockChanged(pos);
++        int j = SectionPos.blockToSectionCoord(pos.getZ());
++        ChunkHolder playerchunk = this.getVisibleChunkIfPresent(ChunkPos.asLong(i, j));
++
++        if (playerchunk != null) {
++            playerchunk.blockChanged(pos);
+         }
++
+     }
+ 
+     @Override
+-    public void onLightUpdate(LightLayer type, SectionPos pos) {
++    public void onLightUpdate(EnumSkyBlock type, SectionPos pos) {
+         this.mainThreadProcessor.execute(() -> {
+-            ChunkHolder visibleChunkIfPresent = this.getVisibleChunkIfPresent(pos.chunk().toLong());
+-            if (visibleChunkIfPresent != null) {
+-                visibleChunkIfPresent.sectionLightChanged(type, pos.y());
++            ChunkHolder playerchunk = this.getVisibleChunkIfPresent(pos.chunk().toLong());
++
++            if (playerchunk != null) {
++                playerchunk.sectionLightChanged(type, pos.y());
+             }
++
+         });
+     }
+ 
+@@ -481,6 +532,7 @@
+         if (!player.isRemoved()) {
+             this.chunkMap.move(player);
+         }
++
+     }
+ 
+     public void removeEntity(Entity entity) {
+@@ -539,12 +591,10 @@
+         this.distanceManager.removeTicketsOnClosing();
+     }
+ 
+-    static record ChunkAndHolder(LevelChunk chunk, ChunkHolder holder) {
+-    }
++    private final class MainThreadExecutor extends BlockableEventLoop<Runnable> {
+ 
+-    final class MainThreadExecutor extends BlockableEventLoop<Runnable> {
+-        MainThreadExecutor(Level level) {
+-            super("Chunk source main thread executor for " + level.dimension().location());
++        MainThreadExecutor(Level world) {
++            super("Chunk source main thread executor for " + world.dimension().location());
+         }
+ 
+         @Override
+@@ -574,13 +624,23 @@
+         }
+ 
+         @Override
++        // CraftBukkit start - process pending Chunk loadCallback() and unloadCallback() after each run task
+         public boolean pollTask() {
++        try {
+             if (ServerChunkCache.this.runDistanceManagerUpdates()) {
+                 return true;
+             } else {
+                 ServerChunkCache.this.lightEngine.tryScheduleUpdate();
+                 return super.pollTask();
+             }
++        } finally {
++            chunkMap.callbackExecutor.run();
+         }
++        // CraftBukkit end
++        }
+     }
++
++    private static record a(LevelChunk chunk, ChunkHolder holder) {
++
++    }
+ }