From da6e9dc0754cacae13c9a7d10e022fb3105f03ea Mon Sep 17 00:00:00 2001 From: embeddedt <42941056+embeddedt@users.noreply.github.com> Date: Thu, 27 Apr 2023 20:48:53 -0400 Subject: [PATCH 1/5] Port two chunk system patches from Paper --- .../core/config/ModernFixEarlyConfig.java | 1 + .../modernfix/duck/IPaperChunkHolder.java | 5 ++ .../paper_chunk_patches/ChunkHolderMixin.java | 61 +++++++++++++++++++ .../paper_chunk_patches/ChunkMapMixin.java | 59 ++++++++++++++++++ src/main/resources/modernfix.mixins.json | 2 + 5 files changed, 128 insertions(+) create mode 100644 src/main/java/org/embeddedt/modernfix/duck/IPaperChunkHolder.java create mode 100644 src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java create mode 100644 src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java diff --git a/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java b/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java index 08bbeb4b..8ce7c38b 100644 --- a/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java +++ b/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java @@ -70,6 +70,7 @@ public class ModernFixEarlyConfig { this.addMixinRule("perf.dynamic_structure_manager", true); this.addMixinRule("bugfix.mc218112", true); this.addMixinRule("bugfix.chunk_deadlock", true); + this.addMixinRule("bugfix.chunk_not_unloading", true); this.addMixinRule("bugfix.chunk_deadlock.valhesia", modPresent("valhelsia_structures")); this.addMixinRule("bugfix.tf_cme_on_load", modPresent("twilightforest")); this.addMixinRule("bugfix.refinedstorage", modPresent("refinedstorage")); diff --git a/src/main/java/org/embeddedt/modernfix/duck/IPaperChunkHolder.java b/src/main/java/org/embeddedt/modernfix/duck/IPaperChunkHolder.java new file mode 100644 index 00000000..0d83c721 --- /dev/null +++ b/src/main/java/org/embeddedt/modernfix/duck/IPaperChunkHolder.java @@ -0,0 +1,5 @@ +package org.embeddedt.modernfix.duck; + +public interface IPaperChunkHolder { + boolean mfix$canAdvanceStatus(); +} diff --git a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java new file mode 100644 index 00000000..796097d6 --- /dev/null +++ b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java @@ -0,0 +1,61 @@ +package org.embeddedt.modernfix.mixin.bugfix.paper_chunk_patches; + +import com.mojang.datafixers.util.Either; +import net.minecraft.server.level.ChunkHolder; +import net.minecraft.world.level.chunk.ChunkAccess; +import net.minecraft.world.level.chunk.ChunkStatus; +import org.embeddedt.modernfix.duck.IPaperChunkHolder; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +import java.util.List; +import java.util.concurrent.CompletableFuture; + +@Mixin(ChunkHolder.class) +public abstract class ChunkHolderMixin implements IPaperChunkHolder { + + @Shadow public abstract CompletableFuture> getFutureIfPresentUnchecked(ChunkStatus arg); + + @Shadow @Final private static List CHUNK_STATUSES; + + public ChunkStatus mfix$getChunkHolderStatus() { + for (ChunkStatus curr = ChunkStatus.FULL, next = curr.getParent(); curr != next; curr = next, next = next.getParent()) { + CompletableFuture> future = this.getFutureIfPresentUnchecked(curr); + Either either = future.getNow(null); + if (either == null || !either.left().isPresent()) { + continue; + } + return curr; + } + + return null; + } + + public ChunkAccess mfix$getAvailableChunkNow() { + // TODO can we just getStatusFuture(EMPTY)? + for (ChunkStatus curr = ChunkStatus.FULL, next = curr.getParent(); curr != next; curr = next, next = next.getParent()) { + CompletableFuture> future = this.getFutureIfPresentUnchecked(curr); + Either either = future.getNow(null); + if (either == null || !either.left().isPresent()) { + continue; + } + return either.left().get(); + } + return null; + } + + public static ChunkStatus mfix$getNextStatus(ChunkStatus status) { + if (status == ChunkStatus.FULL) { + return status; + } + return CHUNK_STATUSES.get(status.getIndex() + 1); + } + + @Override + public boolean mfix$canAdvanceStatus() { + ChunkStatus status = mfix$getChunkHolderStatus(); + ChunkAccess chunk = mfix$getAvailableChunkNow(); + return chunk != null && (status == null || chunk.getStatus().isOrAfter(mfix$getNextStatus(status))); + } +} diff --git a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java new file mode 100644 index 00000000..aed16d3f --- /dev/null +++ b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java @@ -0,0 +1,59 @@ +package org.embeddedt.modernfix.mixin.bugfix.paper_chunk_patches; + +import net.minecraft.server.MinecraftServer; +import net.minecraft.server.level.ChunkHolder; +import net.minecraft.server.level.ChunkMap; +import net.minecraft.util.thread.BlockableEventLoop; +import net.minecraftforge.fml.server.ServerLifecycleHooks; +import org.embeddedt.modernfix.duck.IPaperChunkHolder; +import org.spongepowered.asm.mixin.Final; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; +import org.spongepowered.asm.mixin.injection.At; +import org.spongepowered.asm.mixin.injection.Inject; +import org.spongepowered.asm.mixin.injection.ModifyArg; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; + +import java.util.concurrent.Executor; + + +@Mixin(ChunkMap.class) +public class ChunkMapMixin { + @Shadow @Final private BlockableEventLoop mainThreadExecutor; + + private Executor mainInvokingExecutor; + + @Inject(method = "", at = @At("RETURN"), cancellable = true) + private void setup(CallbackInfo ci) { + this.mainInvokingExecutor = (runnable) -> { + if(ServerLifecycleHooks.getCurrentServer().isSameThread()) + runnable.run(); + else + this.mainThreadExecutor.execute(runnable); + }; + } + + + /* https://github.com/PaperMC/Paper/blob/ver/1.17.1/patches/server/0752-Fix-chunks-refusing-to-unload-at-low-TPS.patch */ + @ModifyArg(method = "unpackTicks", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenApplyAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"), index = 1) + private Executor useMainThreadExecutor(Executor executor) { + return this.mainThreadExecutor; + } + + /* https://github.com/PaperMC/Paper/blob/master/patches/removed/1.19.2-legacy-chunksystem/0482-Improve-Chunk-Status-Transition-Speed.patch */ + @ModifyArg(method = "getEntityTickingRangeFuture", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenApplyAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"), index = 1) + private Executor useMainInvokingExecutor(Executor executor) { + return this.mainInvokingExecutor; + } + + @ModifyArg(method = "scheduleChunkGeneration", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenComposeAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"), index = 1) + private Executor skipWorkerIfPossible(Executor executor, ChunkHolder chunkHolder) { + return (runnable) -> { + if(((IPaperChunkHolder)chunkHolder).mfix$canAdvanceStatus()) { + this.mainInvokingExecutor.execute(runnable); + return; + } + executor.execute(runnable); + }; + } +} diff --git a/src/main/resources/modernfix.mixins.json b/src/main/resources/modernfix.mixins.json index ddd419c7..f57416aa 100644 --- a/src/main/resources/modernfix.mixins.json +++ b/src/main/resources/modernfix.mixins.json @@ -9,6 +9,8 @@ "core.BootstrapMixin", "bugfix.edge_chunk_not_saved.ChunkManagerMixin", "bugfix.starlight_emptiness.StarLightEngineMixin", + "bugfix.paper_chunk_patches.ChunkMapMixin", + "bugfix.paper_chunk_patches.ChunkHolderMixin", "perf.dynamic_structure_manager.StructureManagerMixin", "bugfix.tf_cme_on_load.TwilightForestModMixin", "bugfix.refinedstorage.te_bug.ItemExternalStorageProviderMixin", From a0ceaa4dacd0b35aa28c36b56963f26e04e209d1 Mon Sep 17 00:00:00 2001 From: embeddedt <42941056+embeddedt@users.noreply.github.com> Date: Thu, 27 Apr 2023 21:36:32 -0400 Subject: [PATCH 2/5] Fix patches being nonfunctional --- .../core/config/ModernFixEarlyConfig.java | 2 +- .../paper_chunk_patches/ChunkHolderMixin.java | 2 +- .../paper_chunk_patches/ChunkMapMixin.java | 16 ++++++++++++---- 3 files changed, 14 insertions(+), 6 deletions(-) diff --git a/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java b/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java index 8ce7c38b..c954f1b5 100644 --- a/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java +++ b/src/main/java/org/embeddedt/modernfix/core/config/ModernFixEarlyConfig.java @@ -70,7 +70,7 @@ public class ModernFixEarlyConfig { this.addMixinRule("perf.dynamic_structure_manager", true); this.addMixinRule("bugfix.mc218112", true); this.addMixinRule("bugfix.chunk_deadlock", true); - this.addMixinRule("bugfix.chunk_not_unloading", true); + this.addMixinRule("bugfix.paper_chunk_patches", true); this.addMixinRule("bugfix.chunk_deadlock.valhesia", modPresent("valhelsia_structures")); this.addMixinRule("bugfix.tf_cme_on_load", modPresent("twilightforest")); this.addMixinRule("bugfix.refinedstorage", modPresent("refinedstorage")); diff --git a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java index 796097d6..0a51f6d7 100644 --- a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java +++ b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkHolderMixin.java @@ -45,7 +45,7 @@ public abstract class ChunkHolderMixin implements IPaperChunkHolder { return null; } - public static ChunkStatus mfix$getNextStatus(ChunkStatus status) { + private static ChunkStatus mfix$getNextStatus(ChunkStatus status) { if (status == ChunkStatus.FULL) { return status; } diff --git a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java index aed16d3f..15f9dd38 100644 --- a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java +++ b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java @@ -1,9 +1,11 @@ package org.embeddedt.modernfix.mixin.bugfix.paper_chunk_patches; +import com.mojang.datafixers.util.Either; import net.minecraft.server.MinecraftServer; import net.minecraft.server.level.ChunkHolder; import net.minecraft.server.level.ChunkMap; import net.minecraft.util.thread.BlockableEventLoop; +import net.minecraft.world.level.chunk.ChunkAccess; import net.minecraftforge.fml.server.ServerLifecycleHooks; import org.embeddedt.modernfix.duck.IPaperChunkHolder; import org.spongepowered.asm.mixin.Final; @@ -12,9 +14,13 @@ import org.spongepowered.asm.mixin.Shadow; import org.spongepowered.asm.mixin.injection.At; import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.ModifyArg; +import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import java.util.List; +import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; +import java.util.function.Function; @Mixin(ChunkMap.class) @@ -46,14 +52,16 @@ public class ChunkMapMixin { return this.mainInvokingExecutor; } - @ModifyArg(method = "scheduleChunkGeneration", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenComposeAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;"), index = 1) - private Executor skipWorkerIfPossible(Executor executor, ChunkHolder chunkHolder) { - return (runnable) -> { - if(((IPaperChunkHolder)chunkHolder).mfix$canAdvanceStatus()) { + @SuppressWarnings({"rawtypes", "unchecked"}) + @Redirect(method = "scheduleChunkGeneration", at = @At(value = "INVOKE", target = "Ljava/util/concurrent/CompletableFuture;thenComposeAsync(Ljava/util/function/Function;Ljava/util/concurrent/Executor;)Ljava/util/concurrent/CompletableFuture;")) + private CompletableFuture skipWorkerIfPossible(CompletableFuture inputFuture, Function function, Executor executor, ChunkHolder holder) { + Executor targetExecutor = (runnable) -> { + if(((IPaperChunkHolder)holder).mfix$canAdvanceStatus()) { this.mainInvokingExecutor.execute(runnable); return; } executor.execute(runnable); }; + return inputFuture.thenComposeAsync(function, targetExecutor); } } From 006c487b8674f4a4ca41db320dd08e6d882ad914 Mon Sep 17 00:00:00 2001 From: embeddedt <42941056+embeddedt@users.noreply.github.com> Date: Fri, 28 Apr 2023 09:53:43 -0400 Subject: [PATCH 3/5] Optimize SortedArraySet.removeIf --- .../SortedArraySetMixin.java | 51 +++++++++++++++++++ src/main/resources/modernfix.mixins.json | 1 + 2 files changed, 52 insertions(+) create mode 100644 src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/SortedArraySetMixin.java diff --git a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/SortedArraySetMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/SortedArraySetMixin.java new file mode 100644 index 00000000..ea9e9167 --- /dev/null +++ b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/SortedArraySetMixin.java @@ -0,0 +1,51 @@ +package org.embeddedt.modernfix.mixin.bugfix.paper_chunk_patches; + +import net.minecraft.util.SortedArraySet; +import org.spongepowered.asm.mixin.Mixin; +import org.spongepowered.asm.mixin.Shadow; + +import java.util.AbstractSet; +import java.util.Arrays; +import java.util.function.Predicate; + +@Mixin(SortedArraySet.class) +public abstract class SortedArraySetMixin extends AbstractSet { + @Shadow private int size; + + @Shadow private T[] contents; + + // Paper start - optimise removeIf + @Override + public boolean removeIf(Predicate filter) { + // prev. impl used an iterator, which could be n^2 and creates garbage + int i = 0, len = this.size; + T[] backingArray = this.contents; + + for (;;) { + if (i >= len) { + return false; + } + if (!filter.test(backingArray[i])) { + ++i; + continue; + } + break; + } + + // we only want to write back to backingArray if we really need to + + int lastIndex = i; // this is where new elements are shifted to + + for (; i < len; ++i) { + T curr = backingArray[i]; + if (!filter.test(curr)) { // if test throws we're screwed + backingArray[lastIndex++] = curr; + } + } + + // cleanup end + Arrays.fill(backingArray, lastIndex, len, null); + this.size = lastIndex; + return true; + } +} diff --git a/src/main/resources/modernfix.mixins.json b/src/main/resources/modernfix.mixins.json index f57416aa..a9af9c66 100644 --- a/src/main/resources/modernfix.mixins.json +++ b/src/main/resources/modernfix.mixins.json @@ -11,6 +11,7 @@ "bugfix.starlight_emptiness.StarLightEngineMixin", "bugfix.paper_chunk_patches.ChunkMapMixin", "bugfix.paper_chunk_patches.ChunkHolderMixin", + "bugfix.paper_chunk_patches.SortedArraySetMixin", "perf.dynamic_structure_manager.StructureManagerMixin", "bugfix.tf_cme_on_load.TwilightForestModMixin", "bugfix.refinedstorage.te_bug.ItemExternalStorageProviderMixin", From f85d19340b5c3c354053141b832fb8adc4cf8fe3 Mon Sep 17 00:00:00 2001 From: embeddedt <42941056+embeddedt@users.noreply.github.com> Date: Fri, 28 Apr 2023 10:51:58 -0400 Subject: [PATCH 4/5] Fix closing font textures that were cached Fixes #64 --- .../LegacyUnicodeBitmapsProviderMixin.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/main/java/org/embeddedt/modernfix/mixin/perf/faster_font_loading/LegacyUnicodeBitmapsProviderMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/perf/faster_font_loading/LegacyUnicodeBitmapsProviderMixin.java index beb327b7..53dfe159 100644 --- a/src/main/java/org/embeddedt/modernfix/mixin/perf/faster_font_loading/LegacyUnicodeBitmapsProviderMixin.java +++ b/src/main/java/org/embeddedt/modernfix/mixin/perf/faster_font_loading/LegacyUnicodeBitmapsProviderMixin.java @@ -43,6 +43,11 @@ public abstract class LegacyUnicodeBitmapsProviderMixin { return image; } + @Redirect(method = "", at = @At(value = "INVOKE", target = "Lcom/mojang/blaze3d/platform/NativeImage;close()V")) + private void skipCloseNativeImage(NativeImage image) { + /* we can't close here, as the image has been stored for use later */ + } + @Inject(method = "", at = @At("RETURN")) private void clearLocation(CallbackInfo ci) { currentCharIdx = null; From 066471df331685e4d31d3fd6eda778926e38349c Mon Sep 17 00:00:00 2001 From: embeddedt <42941056+embeddedt@users.noreply.github.com> Date: Fri, 28 Apr 2023 13:05:42 -0400 Subject: [PATCH 5/5] Port Paper's chunk turbocharger from 1.17/1.18 With these changes 1.18 worlds can load on 400MB as well --- .../paper_chunk_patches/ChunkMapMixin.java | 54 +++++++++++++++++-- .../resources/META-INF/accesstransformer.cfg | 2 + 2 files changed, 53 insertions(+), 3 deletions(-) diff --git a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java index 5ecfe981..231a070e 100644 --- a/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java +++ b/src/main/java/org/embeddedt/modernfix/mixin/bugfix/paper_chunk_patches/ChunkMapMixin.java @@ -2,10 +2,13 @@ package org.embeddedt.modernfix.mixin.bugfix.paper_chunk_patches; import com.mojang.datafixers.util.Either; import net.minecraft.server.MinecraftServer; -import net.minecraft.server.level.ChunkHolder; -import net.minecraft.server.level.ChunkMap; +import net.minecraft.server.level.*; +import net.minecraft.server.level.progress.ChunkProgressListener; import net.minecraft.util.thread.BlockableEventLoop; +import net.minecraft.world.level.ChunkPos; import net.minecraft.world.level.chunk.ChunkAccess; +import net.minecraft.world.level.chunk.ChunkStatus; +import net.minecraft.world.level.levelgen.structure.templatesystem.StructureManager; import net.minecraftforge.server.ServerLifecycleHooks; import org.embeddedt.modernfix.duck.IPaperChunkHolder; import org.spongepowered.asm.mixin.Final; @@ -16,17 +19,30 @@ import org.spongepowered.asm.mixin.injection.Inject; import org.spongepowered.asm.mixin.injection.ModifyArg; import org.spongepowered.asm.mixin.injection.Redirect; import org.spongepowered.asm.mixin.injection.callback.CallbackInfo; +import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable; import java.util.List; +import java.util.Optional; import java.util.concurrent.CompletableFuture; import java.util.concurrent.Executor; import java.util.function.Function; @Mixin(ChunkMap.class) -public class ChunkMapMixin { +public abstract class ChunkMapMixin { @Shadow @Final private BlockableEventLoop mainThreadExecutor; + @Shadow @Final private ChunkMap.DistanceManager distanceManager; + + @Shadow protected abstract CompletableFuture> protoChunkToFullChunk(ChunkHolder arg); + + @Shadow @Final private ServerLevel level; + @Shadow @Final private StructureManager structureManager; + @Shadow @Final private ThreadedLevelLightEngine lightEngine; + @Shadow @Final private ChunkProgressListener progressListener; + + @Shadow protected abstract CompletableFuture> scheduleChunkGeneration(ChunkHolder chunkHolder, ChunkStatus chunkStatus); + private Executor mainInvokingExecutor; @Inject(method = "", at = @At("RETURN"), cancellable = true) @@ -64,4 +80,36 @@ public class ChunkMapMixin { }; return inputFuture.thenComposeAsync(function, targetExecutor); } + + /** + * @author embeddedt + * @reason revert 1.17 chunk system changes, significantly reduces time and RAM needed to load chunks + */ + @Inject(method = "schedule", at = @At("HEAD"), cancellable = true) + private void useLegacySchedulingLogic(ChunkHolder holder, ChunkStatus requiredStatus, CallbackInfoReturnable>> cir) { + if(requiredStatus != ChunkStatus.EMPTY) { + ChunkPos chunkpos = holder.getPos(); + CompletableFuture> future = holder.getOrScheduleFuture(requiredStatus.getParent(), (ChunkMap)(Object)this); + cir.setReturnValue(future.thenComposeAsync((either) -> { + Optional optional = either.left(); + if(!optional.isPresent()) + return CompletableFuture.completedFuture(either); + + if (requiredStatus == ChunkStatus.LIGHT) { + this.distanceManager.addTicket(TicketType.LIGHT, chunkpos, 33 + ChunkStatus.getDistance(ChunkStatus.LIGHT), chunkpos); + } + + // from original method + if (optional.get().getStatus().isOrAfter(requiredStatus)) { + CompletableFuture> completablefuture = requiredStatus.load(this.level, this.structureManager, this.lightEngine, (arg2) -> { + return this.protoChunkToFullChunk(holder); + }, (ChunkAccess)optional.get()); + this.progressListener.onStatusChange(chunkpos, requiredStatus); + return completablefuture; + } else { + return this.scheduleChunkGeneration(holder, requiredStatus); + } + }, this.mainThreadExecutor).thenComposeAsync(CompletableFuture::completedFuture, this.mainThreadExecutor)); + } + } } diff --git a/src/main/resources/META-INF/accesstransformer.cfg b/src/main/resources/META-INF/accesstransformer.cfg index c1e448c8..56e08703 100644 --- a/src/main/resources/META-INF/accesstransformer.cfg +++ b/src/main/resources/META-INF/accesstransformer.cfg @@ -26,3 +26,5 @@ public net.minecraft.world.level.block.state.BlockBehaviour$Properties f_60888_ public net.minecraft.server.level.ServerChunkCache$MainThreadExecutor public net.minecraft.nbt.CompoundTag (Ljava/util/Map;)V # public net.minecraft.client.renderer.texture.TextureAtlasSprite (Lnet/minecraft/client/renderer/texture/TextureAtlas;Lnet/minecraft/client/renderer/texture/TextureAtlasSprite$Info;IIIIILcom/mojang/blaze3d/platform/NativeImage;)V # +public net.minecraft.server.level.DistanceManager m_140792_(Lnet/minecraft/server/level/TicketType;Lnet/minecraft/world/level/ChunkPos;ILjava/lang/Object;)V # addTicket +public net.minecraft.server.level.ChunkMap$DistanceManager \ No newline at end of file