24w20a, disable reset_chunk, relight, and chunk load events

gnembon · gnembon · commit c4f8c865205b · 2024-05-15T23:13:40.000+02:00
diff --git a/gradle.properties b/gradle.properties
@@ -3,7 +3,7 @@ org.gradle.jvmargs=-Xmx1G
 
 # Fabric Properties
 	# check https://fabricmc.net/develop/
-	minecraft_version=24w18a
+	minecraft_version=24w20a
 	loader_version=0.15.11
 	jsr305_version=3.0.2
 	fabric_version=0.97.8+1.20.6
diff --git a/src/main/java/carpet/fakes/ChunkHolderInterface.java b/src/main/java/carpet/fakes/ChunkHolderInterface.java
@@ -9,5 +9,5 @@
 
 public interface ChunkHolderInterface
 {
-    CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos chpos, BlockableEventLoop<Runnable> executor, ServerLevel world);
+    //CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos chpos, BlockableEventLoop<Runnable> executor, ServerLevel world);
 }
diff --git a/src/main/java/carpet/fakes/ThreadedAnvilChunkStorageInterface.java b/src/main/java/carpet/fakes/ThreadedAnvilChunkStorageInterface.java
@@ -7,11 +7,11 @@
 
 public interface ThreadedAnvilChunkStorageInterface
 {
-    Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks);
+    //Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks);
 
-    void relightChunk(ChunkPos pos);
+    //void relightChunk(ChunkPos pos);
 
-    void releaseRelightTicket(ChunkPos pos);
+    //void releaseRelightTicket(ChunkPos pos);
 
-    Iterable<ChunkHolder> getChunksCM();
+    //Iterable<ChunkHolder> getChunksCM();
 }
diff --git a/src/main/java/carpet/mixins/AbstractArrowMixin.java b/src/main/java/carpet/mixins/AbstractArrowMixin.java
@@ -20,8 +20,8 @@ public abstract class AbstractArrowMixin extends Entity
     private TrajectoryLogHelper logHelper;
     public AbstractArrowMixin(EntityType<?> entityType_1, Level world_1) { super(entityType_1, world_1); }
 
-    @Inject(method = "<init>(Lnet/minecraft/world/entity/EntityType;Lnet/minecraft/world/level/Level;Lnet/minecraft/world/item/ItemStack;Lnet/minecraft/world/item/ItemStack;)V", at = @At("RETURN"))
-    private void addLogger(final EntityType entityType, final Level level, final ItemStack itemStack, final ItemStack weapon, final CallbackInfo ci)
+    @Inject(method = "<init>(Lnet/minecraft/world/entity/EntityType;DDDLnet/minecraft/world/level/Level;Lnet/minecraft/world/item/ItemStack;Lnet/minecraft/world/item/ItemStack;)V", at = @At("RETURN"))
+    private void addLogger(final EntityType entityType, final double x, final double y, final double z, final Level level, final ItemStack itemStack, final ItemStack weapon, final CallbackInfo ci)
     {
         if (LoggerRegistry.__projectiles && !level.isClientSide)
             logHelper = new TrajectoryLogHelper("projectiles");
diff --git a/src/main/java/carpet/mixins/ChunkHolder_scarpetChunkCreationMixin.java b/src/main/java/carpet/mixins/ChunkHolder_scarpetChunkCreationMixin.java
@@ -21,10 +21,11 @@
 @Mixin(ChunkHolder.class)
 public abstract class ChunkHolder_scarpetChunkCreationMixin implements ChunkHolderInterface
 {
-    @Shadow protected abstract void updateChunkToSave(CompletableFuture<? extends ChunkResult<? extends ChunkAccess>> newChunkFuture, String type);
+    //@Shadow protected abstract void updateChunkToSave(CompletableFuture<? extends ChunkResult<? extends ChunkAccess>> newChunkFuture, String type);
 
-    @Shadow @Final private AtomicReferenceArray<CompletableFuture<ChunkResult<ChunkAccess>>> futures;
+    //@Shadow @Final private AtomicReferenceArray<CompletableFuture<ChunkResult<ChunkAccess>>> futures;
 
+    /*
     @Override
     public CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos chpos, BlockableEventLoop<Runnable> executor, ServerLevel world)
     {
@@ -37,4 +38,5 @@ public CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos
         futures.set(i, completableFuture2);
         return completableFuture2;
     }
+     */
 }
diff --git a/src/main/java/carpet/mixins/ChunkMap_scarpetChunkCreationMixin.java b/src/main/java/carpet/mixins/ChunkMap_scarpetChunkCreationMixin.java
@@ -19,6 +19,7 @@
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.TickTask;
 import net.minecraft.server.level.ChunkHolder;
+import net.minecraft.server.level.ChunkLevel;
 import net.minecraft.server.level.ChunkMap;
 import net.minecraft.server.level.ChunkMap.DistanceManager;
 import net.minecraft.server.level.ChunkResult;
@@ -64,10 +65,6 @@ public abstract class ChunkMap_scarpetChunkCreationMixin implements ThreadedAnvi
     @Final
     private ServerLevel level;
 
-    @Shadow
-    @Final
-    private LongSet entitiesInLevel;
-
     @Shadow
     @Final
     private Long2ObjectLinkedOpenHashMap<ChunkHolder> updatingChunkMap;
@@ -111,6 +108,10 @@ public abstract class ChunkMap_scarpetChunkCreationMixin implements ThreadedAnvi
 
     // in protoChunkToFullChunk
     // fancier version of the one below, ensuring that the event is triggered when the chunk is actually loaded.
+
+    /*
+
+
     @Inject(method = "method_17227", at = @At("HEAD"), remap = false)
     private void onChunkGeneratedStart(ChunkHolder chunkHolder, ChunkAccess chunkAccess, CallbackInfoReturnable<ChunkAccess> cir)
     {
@@ -146,6 +147,8 @@ private void onChunkGeneratedEnd(ChunkHolder chunkHolder, ChunkAccess chunk, Cal
         }
     }
 
+     */
+
     /* simple but a version that doesn't guarantee that the chunk is actually loaded
     @Inject(method = "convertToFullChunk", at = @At("HEAD"))
     private void onChunkGeneratedEnd(ChunkHolder chunkHolder, CallbackInfoReturnable<CompletableFuture<ChunkResult<ChunkAccess>>> cir)
@@ -167,7 +170,7 @@ private void onChunkGeneratedEnd(ChunkHolder chunkHolder, CallbackInfoReturnable
     @Unique
     private void addTicket(ChunkPos pos, ChunkStatus status)
     {  // UNKNOWN
-        this.distanceManager.addTicket(TicketType.UNKNOWN, pos, 33 + ChunkStatus.getDistance(status), pos);
+        this.distanceManager.addTicket(TicketType.UNKNOWN, pos, 33 + ChunkLevel.byStatus(status), pos);
     }
 
     @Unique
@@ -176,6 +179,8 @@ private void addTicket(ChunkPos pos)
         this.addTicket(pos, ChunkStatus.EMPTY);
     }
 
+
+    /*
     @Unique
     private void addRelightTicket(ChunkPos pos)
     {
@@ -190,7 +195,7 @@ public void releaseRelightTicket(ChunkPos pos)
                 () -> "release relight ticket " + pos
         ));
     }
-
+     */
     @Unique
     private void tickTicketManager()
     {
@@ -214,6 +219,8 @@ private Set<ChunkPos> getExistingChunks(Set<ChunkPos> requestedChunks)
         return ret;
     }
 
+
+    /*
     @Unique
     private Set<ChunkPos> loadExistingChunksFromDisk(Set<ChunkPos> requestedChunks)
     {
@@ -329,6 +336,8 @@ public void relightChunk(ChunkPos pos)
         this.waitFor(lightFuture);
     }
 
+    /*
+
     @Override
     public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunksList)
     {
@@ -385,7 +394,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks
         {
             ChunkAccess chunk = this.getCurrentChunk(pos);
 
-            if (chunk.getStatus().isOrAfter(ChunkStatus.LIGHT.getParent()))
+            if (chunk.getPersistedStatus().isOrAfter(ChunkStatus.LIGHT.getParent()))
             {
                 affectedNeighbors.add(chunk);
             }
@@ -399,7 +408,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks
 
             // remove entities
             long longPos = pos.toLong();
-            if (this.entitiesInLevel.contains(longPos) && chunk instanceof LevelChunk)
+            if (chunk instanceof LevelChunk)
             {
                 ((SimpleEntityLookupInterface<Entity>) ((ServerWorldInterface) level).getEntityLookupCMPublic()).getChunkEntities(pos).forEach(entity -> {
                     if (!(entity instanceof Player))
@@ -415,7 +424,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks
                 ((LevelChunk) chunk).setLoaded(false);
             }
 
-            if (this.entitiesInLevel.remove(pos.toLong()) && chunk instanceof LevelChunk)
+            if (chunk instanceof LevelChunk)
             {
                 this.level.unload((LevelChunk) chunk); // block entities only
             }
@@ -450,7 +459,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks
         // Also, this is needed to ensure chunks are saved to disk
 
         Map<ChunkPos, ChunkStatus> targetGenerationStatus = affectedChunks.stream().collect(
-                Collectors.toMap(ChunkAccess::getPos, ChunkAccess::getStatus)
+                Collectors.toMap(ChunkAccess::getPos, ChunkAccess::getPersistedStatus)
         );
 
         for (Entry<ChunkPos, ChunkStatus> entry : targetGenerationStatus.entrySet())
@@ -548,9 +557,13 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks
         return report;
     }
 
+
+
     @Override
     public Iterable<ChunkHolder> getChunksCM()
     {
         return getChunks();
     }
+
+     */
 }
diff --git a/src/main/java/carpet/mixins/LevelRenderer_scarpetRenderMixin.java b/src/main/java/carpet/mixins/LevelRenderer_scarpetRenderMixin.java
@@ -4,6 +4,7 @@
 import carpet.script.utils.ShapesRenderer;
 import com.mojang.blaze3d.vertex.PoseStack;
 import net.minecraft.client.Camera;
+import net.minecraft.client.DeltaTracker;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.renderer.GameRenderer;
 import net.minecraft.client.renderer.LevelRenderer;
@@ -36,14 +37,14 @@ private void addRenderers(Minecraft minecraft, EntityRenderDispatcher entityRend
             //target = "Lnet/minecraft/client/render/BufferBuilderStorage;getEntityVertexConsumers()Lnet/minecraft/client/render/VertexConsumerProvider$Immediate;", shift = At.Shift.AFTER
             //target = "Lnet/minecraft/client/render/WorldRenderer;renderChunkDebugInfo(Lnet/minecraft/client/render/Camera;)V", shift = At.Shift.AFTER // before return
     ))
-    private void renderScarpetThings(float tickDelta, long limitTime, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, LightTexture lightmapTextureManager, Matrix4f modelViewMatrix, Matrix4f matrix4f, CallbackInfo ci)
+    private void renderScarpetThings(final DeltaTracker deltaTracker, final boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, LightTexture lightmapTextureManager, Matrix4f modelViewMatrix, Matrix4f matrix4f, CallbackInfo ci)
     {
         // in normal circumstances we want to render shapes at the very end so it appears correctly behind stuff.
         // we might actually not need to play with render hooks here.
         //if (!FabricAPIHooks.WORLD_RENDER_EVENTS && CarpetClient.shapes != null )
         if (CarpetClient.shapes != null)
         {
-            CarpetClient.shapes.render(modelViewMatrix, camera, tickDelta);
+            CarpetClient.shapes.render(modelViewMatrix, camera, deltaTracker.getGameTimeDeltaPartialTick(false));
         }
     }
 }
diff --git a/src/main/java/carpet/mixins/PlayerList_scarpetEventsMixin.java b/src/main/java/carpet/mixins/PlayerList_scarpetEventsMixin.java
@@ -7,6 +7,7 @@
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.server.level.ServerPlayer;
 import net.minecraft.server.players.PlayerList;
+import net.minecraft.world.entity.Entity;
 import org.spongepowered.asm.mixin.Final;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -24,9 +25,9 @@ public class PlayerList_scarpetEventsMixin
     @Shadow @Final private MinecraftServer server;
 
     @Inject(method = "respawn", at = @At("HEAD"))
-    private void onRespawn(ServerPlayer player, boolean olive, CallbackInfoReturnable<ServerPlayer> cir)
+    private void onResp(ServerPlayer serverPlayer, boolean olive, Entity.RemovalReason removalReason, CallbackInfoReturnable<ServerPlayer> cir)
     {
-        PLAYER_RESPAWNS.onPlayerEvent(player);
+        PLAYER_RESPAWNS.onPlayerEvent(serverPlayer);
     }
 
     @Inject(method = "broadcastChatMessage(Lnet/minecraft/network/chat/PlayerChatMessage;Lnet/minecraft/server/level/ServerPlayer;Lnet/minecraft/network/chat/ChatType$Bound;)V",
@@ -44,7 +45,7 @@ private void cancellableChatMessageEvent(PlayerChatMessage message, ServerPlayer
             value = "INVOKE",
             target = "Lnet/minecraft/server/level/ServerPlayer;initInventoryMenu()V"
     ))
-    private void invalidatePreviousInstance(ServerPlayer player, boolean alive, CallbackInfoReturnable<ServerPlayer> cir)
+    private void invalidatePreviousInstance(ServerPlayer player, boolean alive, Entity.RemovalReason removalReason, CallbackInfoReturnable<ServerPlayer> cir)
     {
         ((ServerPlayerInterface)player).invalidateEntityObjectReference();
     }
diff --git a/src/main/java/carpet/mixins/ServerPlayer_scarpetEventMixin.java b/src/main/java/carpet/mixins/ServerPlayer_scarpetEventMixin.java
@@ -14,6 +14,7 @@
 import net.minecraft.world.entity.Entity;
 import net.minecraft.world.entity.player.Player;
 import net.minecraft.world.level.Level;
+import net.minecraft.world.level.portal.DimensionTransition;
 import net.minecraft.world.phys.Vec3;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -96,18 +97,20 @@ private void setSneakingConditionally(ServerPlayer serverPlayerEntity, boolean s
     private ResourceKey<Level> previousDimension;
 
     @Inject(method = "changeDimension", at = @At("HEAD"))
-    private void logPreviousCoordinates(ServerLevel serverWorld, CallbackInfoReturnable<Entity> cir)
+    private void logPreviousCoordinates(DimensionTransitionSupplier serverWorld, CallbackInfoReturnable<Entity> cir)
     {
         previousLocation = position();
         previousDimension = level().dimension();  //dimension type
     }
 
     @Inject(method = "changeDimension", at = @At("RETURN"))
-    private void atChangeDimension(ServerLevel destination, CallbackInfoReturnable<Entity> cir)
+    private void atChangeDimension(DimensionTransitionSupplier destinationP, CallbackInfoReturnable<Entity> cir)
     {
         if (PLAYER_CHANGES_DIMENSION.isNeeded())
         {
             ServerPlayer player = (ServerPlayer) (Object)this;
+            DimensionTransition destinationTransition = destinationP.get();
+            ServerLevel destination = destinationTransition.newDimension();
             Vec3 to = null;
             if (!wonGame || previousDimension != Level.END || destination.dimension() != Level.OVERWORLD)
             {
diff --git a/src/main/java/carpet/patches/EntityPlayerMPFake.java b/src/main/java/carpet/patches/EntityPlayerMPFake.java
@@ -213,7 +213,7 @@ protected void checkFallDamage(double y, boolean onGround, BlockState state, Blo
     }
 
     @Override
-    public Entity changeDimension(ServerLevel serverLevel)
+    public Entity changeDimension(DimensionTransitionSupplier serverLevel)
     {
         super.changeDimension(serverLevel);
         if (wonGame) {
diff --git a/src/main/java/carpet/script/api/Auxiliary.java b/src/main/java/carpet/script/api/Auxiliary.java
@@ -804,13 +804,17 @@ else if (!interactable && targetBlock == null)
 
         expression.addContextFunction("relight", -1, (c, t, lv) ->
         {
+            return Value.NULL;
+            /*
             CarpetContext cc = (CarpetContext) c;
             BlockArgument locator = BlockArgument.findIn(cc, lv, 0);
             BlockPos pos = locator.block.getPos();
             ServerLevel world = cc.level();
             Vanilla.ChunkMap_relightChunk(world.getChunkSource().chunkMap, new ChunkPos(pos));
             WorldTools.forceChunkUpdate(pos, world);
             return Value.TRUE;
+
+             */
         });
 
         // Should this be deprecated for system_info('source_dimension')?
diff --git a/src/main/java/carpet/script/api/WorldAccess.java b/src/main/java/carpet/script/api/WorldAccess.java
@@ -637,7 +637,7 @@ else if (!("any".equals(statusString)))
                 forceLoad = lv.get(blockArgument.offset).getBoolean();
             }
             ChunkAccess chunk = ((CarpetContext) c).level().getChunk(pos.getX() >> 4, pos.getZ() >> 4, ChunkStatus.EMPTY, forceLoad);
-            return chunk == null ? Value.NULL : ValueConversions.of(BuiltInRegistries.CHUNK_STATUS.getKey(chunk.getStatus()));
+            return chunk == null ? Value.NULL : ValueConversions.of(BuiltInRegistries.CHUNK_STATUS.getKey(chunk.getPersistedStatus()));
         });
 
         expression.addContextFunction("chunk_tickets", -1, (c, t, lv) ->
@@ -921,7 +921,7 @@ else if (item instanceof TridentItem || item instanceof SwordItem)
                     damageAmount = 2;
                 }
                 final int finalDamageAmount = damageAmount;
-                tool.hurtAndBreak(damageAmount, world, null, () ->  { if (finalDamageAmount > 0) toolBroke.setTrue(); } );
+                tool.hurtAndBreak(damageAmount, world, null, (i) ->  { if (finalDamageAmount > 0) toolBroke.setTrue(); } );
                 if (!isUsingEffectiveTool)
                 {
                     dropLoot = false;
@@ -1586,6 +1586,8 @@ LivingEntity getIndirectSourceEntity()
         // todo maybe enable chunk blending?
         expression.addContextFunction("reset_chunk", -1, (c, t, lv) ->
         {
+            return Value.NULL;
+            /*
             CarpetContext cc = (CarpetContext) c;
             List<ChunkPos> requestedChunks = new ArrayList<>();
             if (lv.size() == 1)
@@ -1643,6 +1645,8 @@ LivingEntity getIndirectSourceEntity()
                 )));
             });
             return result[0];
+
+             */
         });
 
         expression.addContextFunction("inhabited_time", -1, (c, t, lv) ->
diff --git a/src/main/java/carpet/script/external/Vanilla.java b/src/main/java/carpet/script/external/Vanilla.java
@@ -100,12 +100,12 @@ public static void MinecraftServer_forceTick(MinecraftServer server, BooleanSupp
 
     public static void ChunkMap_relightChunk(ChunkMap chunkMap, ChunkPos pos)
     {
-        ((ThreadedAnvilChunkStorageInterface) chunkMap).relightChunk(pos);
+        //((ThreadedAnvilChunkStorageInterface) chunkMap).relightChunk(pos);
     }
 
     public static Map<String, Integer> ChunkMap_regenerateChunkRegion(ChunkMap chunkMap, List<ChunkPos> requestedChunks)
     {
-        return ((ThreadedAnvilChunkStorageInterface) chunkMap).regenerateChunkRegion(requestedChunks);
+        return Map.of(); //return ((ThreadedAnvilChunkStorageInterface) chunkMap).regenerateChunkRegion(requestedChunks);
     }
 
     public static List<Collection<ItemStack>> Ingredient_getRecipeStacks(Ingredient ingredient)

Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@`
`9`	`9`
`10`	`10`	`public interface ChunkHolderInterface`
`11`	`11`	`{`
`12`		`- CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos chpos, BlockableEventLoop<Runnable> executor, ServerLevel world);`
	`12`	`+ //CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos chpos, BlockableEventLoop<Runnable> executor, ServerLevel world);`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -7,11 +7,11 @@`
`7`	`7`
`8`	`8`	`public interface ThreadedAnvilChunkStorageInterface`
`9`	`9`	`{`
`10`		`- Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks);`
	`10`	`+ //Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks);`
`11`	`11`
`12`		`- void relightChunk(ChunkPos pos);`
	`12`	`+ //void relightChunk(ChunkPos pos);`
`13`	`13`
`14`		`- void releaseRelightTicket(ChunkPos pos);`
	`14`	`+ //void releaseRelightTicket(ChunkPos pos);`
`15`	`15`
`16`		`- Iterable<ChunkHolder> getChunksCM();`
	`16`	`+ //Iterable<ChunkHolder> getChunksCM();`
`17`	`17`	`}`
Original file line number	Diff line number	Diff line change
`@@ -21,10 +21,11 @@`
`21`	`21`	`@Mixin(ChunkHolder.class)`
`22`	`22`	`public abstract class ChunkHolder_scarpetChunkCreationMixin implements ChunkHolderInterface`
`23`	`23`	`{`
`24`		`- @Shadow protected abstract void updateChunkToSave(CompletableFuture<? extends ChunkResult<? extends ChunkAccess>> newChunkFuture, String type);`
	`24`	`+ //@Shadow protected abstract void updateChunkToSave(CompletableFuture<? extends ChunkResult<? extends ChunkAccess>> newChunkFuture, String type);`
`25`	`25`
`26`		`- @Shadow @Final private AtomicReferenceArray<CompletableFuture<ChunkResult<ChunkAccess>>> futures;`
	`26`	`+ //@Shadow @Final private AtomicReferenceArray<CompletableFuture<ChunkResult<ChunkAccess>>> futures;`
`27`	`27`
	`28`	`+ /*`
`28`	`29`	`@Override`
`29`	`30`	`public CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos chpos, BlockableEventLoop<Runnable> executor, ServerLevel world)`
`30`	`31`	`{`
`@@ -37,4 +38,5 @@ public CompletableFuture<ChunkResult<ChunkAccess>> setDefaultProtoChunk(ChunkPos`
`37`	`38`	`futures.set(i, completableFuture2);`
`38`	`39`	`return completableFuture2;`
`39`	`40`	`}`
	`41`	`+ */`
`40`	`42`	`}`
Original file line number	Diff line number	Diff line change
`@@ -19,6 +19,7 @@`
`19`	`19`	`import net.minecraft.server.MinecraftServer;`
`20`	`20`	`import net.minecraft.server.TickTask;`
`21`	`21`	`import net.minecraft.server.level.ChunkHolder;`
	`22`	`+import net.minecraft.server.level.ChunkLevel;`
`22`	`23`	`import net.minecraft.server.level.ChunkMap;`
`23`	`24`	`import net.minecraft.server.level.ChunkMap.DistanceManager;`
`24`	`25`	`import net.minecraft.server.level.ChunkResult;`
`@@ -64,10 +65,6 @@ public abstract class ChunkMap_scarpetChunkCreationMixin implements ThreadedAnvi`
`64`	`65`	`@Final`
`65`	`66`	`private ServerLevel level;`
`66`	`67`
`67`		`- @Shadow`
`68`		`- @Final`
`69`		`- private LongSet entitiesInLevel;`
`70`		`-`
`71`	`68`	`@Shadow`
`72`	`69`	`@Final`
`73`	`70`	`private Long2ObjectLinkedOpenHashMap<ChunkHolder> updatingChunkMap;`
`@@ -111,6 +108,10 @@ public abstract class ChunkMap_scarpetChunkCreationMixin implements ThreadedAnvi`
`111`	`108`
`112`	`109`	`// in protoChunkToFullChunk`
`113`	`110`	`// fancier version of the one below, ensuring that the event is triggered when the chunk is actually loaded.`
	`111`	`+`
	`112`	`+ /*`
	`113`	`+`
	`114`	`+`
`114`	`115`	`@Inject(method = "method_17227", at = @At("HEAD"), remap = false)`
`115`	`116`	`private void onChunkGeneratedStart(ChunkHolder chunkHolder, ChunkAccess chunkAccess, CallbackInfoReturnable<ChunkAccess> cir)`
`116`	`117`	`{`
`@@ -146,6 +147,8 @@ private void onChunkGeneratedEnd(ChunkHolder chunkHolder, ChunkAccess chunk, Cal`
`146`	`147`	`}`
`147`	`148`	`}`
`148`	`149`
	`150`	`+ */`
	`151`	`+`
`149`	`152`	`/* simple but a version that doesn't guarantee that the chunk is actually loaded`
`150`	`153`	`@Inject(method = "convertToFullChunk", at = @At("HEAD"))`
`151`	`154`	`private void onChunkGeneratedEnd(ChunkHolder chunkHolder, CallbackInfoReturnable<CompletableFuture<ChunkResult<ChunkAccess>>> cir)`
`@@ -167,7 +170,7 @@ private void onChunkGeneratedEnd(ChunkHolder chunkHolder, CallbackInfoReturnable`
`167`	`170`	`@Unique`
`168`	`171`	`private void addTicket(ChunkPos pos, ChunkStatus status)`
`169`	`172`	`{ // UNKNOWN`
`170`		`- this.distanceManager.addTicket(TicketType.UNKNOWN, pos, 33 + ChunkStatus.getDistance(status), pos);`
	`173`	`+ this.distanceManager.addTicket(TicketType.UNKNOWN, pos, 33 + ChunkLevel.byStatus(status), pos);`
`171`	`174`	`}`
`172`	`175`
`173`	`176`	`@Unique`
`@@ -176,6 +179,8 @@ private void addTicket(ChunkPos pos)`
`176`	`179`	`this.addTicket(pos, ChunkStatus.EMPTY);`
`177`	`180`	`}`
`178`	`181`
	`182`	`+`
	`183`	`+ /*`
`179`	`184`	`@Unique`
`180`	`185`	`private void addRelightTicket(ChunkPos pos)`
`181`	`186`	`{`
`@@ -190,7 +195,7 @@ public void releaseRelightTicket(ChunkPos pos)`
`190`	`195`	`() -> "release relight ticket " + pos`
`191`	`196`	`));`
`192`	`197`	`}`
`193`		`-`
	`198`	`+ */`
`194`	`199`	`@Unique`
`195`	`200`	`private void tickTicketManager()`
`196`	`201`	`{`
`@@ -214,6 +219,8 @@ private Set<ChunkPos> getExistingChunks(Set<ChunkPos> requestedChunks)`
`214`	`219`	`return ret;`
`215`	`220`	`}`
`216`	`221`
	`222`	`+`
	`223`	`+ /*`
`217`	`224`	`@Unique`
`218`	`225`	`private Set<ChunkPos> loadExistingChunksFromDisk(Set<ChunkPos> requestedChunks)`
`219`	`226`	`{`
`@@ -329,6 +336,8 @@ public void relightChunk(ChunkPos pos)`
`329`	`336`	`this.waitFor(lightFuture);`
`330`	`337`	`}`
`331`	`338`
	`339`	`+ /*`
	`340`	`+`
`332`	`341`	`@Override`
`333`	`342`	`public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunksList)`
`334`	`343`	`{`
`@@ -385,7 +394,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks`
`385`	`394`	`{`
`386`	`395`	`ChunkAccess chunk = this.getCurrentChunk(pos);`
`387`	`396`
`388`		`- if (chunk.getStatus().isOrAfter(ChunkStatus.LIGHT.getParent()))`
	`397`	`+ if (chunk.getPersistedStatus().isOrAfter(ChunkStatus.LIGHT.getParent()))`
`389`	`398`	`{`
`390`	`399`	`affectedNeighbors.add(chunk);`
`391`	`400`	`}`
`@@ -399,7 +408,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks`
`399`	`408`
`400`	`409`	`// remove entities`
`401`	`410`	`long longPos = pos.toLong();`
`402`		`- if (this.entitiesInLevel.contains(longPos) && chunk instanceof LevelChunk)`
	`411`	`+ if (chunk instanceof LevelChunk)`
`403`	`412`	`{`
`404`	`413`	`((SimpleEntityLookupInterface<Entity>) ((ServerWorldInterface) level).getEntityLookupCMPublic()).getChunkEntities(pos).forEach(entity -> {`
`405`	`414`	`if (!(entity instanceof Player))`
`@@ -415,7 +424,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks`
`415`	`424`	`((LevelChunk) chunk).setLoaded(false);`
`416`	`425`	`}`
`417`	`426`
`418`		`- if (this.entitiesInLevel.remove(pos.toLong()) && chunk instanceof LevelChunk)`
	`427`	`+ if (chunk instanceof LevelChunk)`
`419`	`428`	`{`
`420`	`429`	`this.level.unload((LevelChunk) chunk); // block entities only`
`421`	`430`	`}`
`@@ -450,7 +459,7 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks`
`450`	`459`	`// Also, this is needed to ensure chunks are saved to disk`
`451`	`460`
`452`	`461`	`Map<ChunkPos, ChunkStatus> targetGenerationStatus = affectedChunks.stream().collect(`
`453`		`- Collectors.toMap(ChunkAccess::getPos, ChunkAccess::getStatus)`
	`462`	`+ Collectors.toMap(ChunkAccess::getPos, ChunkAccess::getPersistedStatus)`
`454`	`463`	`);`
`455`	`464`
`456`	`465`	`for (Entry<ChunkPos, ChunkStatus> entry : targetGenerationStatus.entrySet())`
`@@ -548,9 +557,13 @@ public Map<String, Integer> regenerateChunkRegion(List<ChunkPos> requestedChunks`
`548`	`557`	`return report;`
`549`	`558`	`}`
`550`	`559`
	`560`	`+`
	`561`	`+`
`551`	`562`	`@Override`
`552`	`563`	`public Iterable<ChunkHolder> getChunksCM()`
`553`	`564`	`{`
`554`	`565`	`return getChunks();`
`555`	`566`	`}`
	`567`	`+`
	`568`	`+ */`
`556`	`569`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,7 @@`
`4`	`4`	`import carpet.script.utils.ShapesRenderer;`
`5`	`5`	`import com.mojang.blaze3d.vertex.PoseStack;`
`6`	`6`	`import net.minecraft.client.Camera;`
	`7`	`+import net.minecraft.client.DeltaTracker;`
`7`	`8`	`import net.minecraft.client.Minecraft;`
`8`	`9`	`import net.minecraft.client.renderer.GameRenderer;`
`9`	`10`	`import net.minecraft.client.renderer.LevelRenderer;`
`@@ -36,14 +37,14 @@ private void addRenderers(Minecraft minecraft, EntityRenderDispatcher entityRend`
`36`	`37`	`//target = "Lnet/minecraft/client/render/BufferBuilderStorage;getEntityVertexConsumers()Lnet/minecraft/client/render/VertexConsumerProvider$Immediate;", shift = At.Shift.AFTER`
`37`	`38`	`//target = "Lnet/minecraft/client/render/WorldRenderer;renderChunkDebugInfo(Lnet/minecraft/client/render/Camera;)V", shift = At.Shift.AFTER // before return`
`38`	`39`	`))`
`39`		`- private void renderScarpetThings(float tickDelta, long limitTime, boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, LightTexture lightmapTextureManager, Matrix4f modelViewMatrix, Matrix4f matrix4f, CallbackInfo ci)`
	`40`	`+ private void renderScarpetThings(final DeltaTracker deltaTracker, final boolean renderBlockOutline, Camera camera, GameRenderer gameRenderer, LightTexture lightmapTextureManager, Matrix4f modelViewMatrix, Matrix4f matrix4f, CallbackInfo ci)`
`40`	`41`	`{`
`41`	`42`	`// in normal circumstances we want to render shapes at the very end so it appears correctly behind stuff.`
`42`	`43`	`// we might actually not need to play with render hooks here.`
`43`	`44`	`//if (!FabricAPIHooks.WORLD_RENDER_EVENTS && CarpetClient.shapes != null )`
`44`	`45`	`if (CarpetClient.shapes != null)`
`45`	`46`	`{`
`46`		`- CarpetClient.shapes.render(modelViewMatrix, camera, tickDelta);`
	`47`	`+ CarpetClient.shapes.render(modelViewMatrix, camera, deltaTracker.getGameTimeDeltaPartialTick(false));`
`47`	`48`	`}`
`48`	`49`	`}`
`49`	`50`	`}`
Original file line number	Diff line number	Diff line change
`@@ -14,6 +14,7 @@`
`14`	`14`	`import net.minecraft.world.entity.Entity;`
`15`	`15`	`import net.minecraft.world.entity.player.Player;`
`16`	`16`	`import net.minecraft.world.level.Level;`
	`17`	`+import net.minecraft.world.level.portal.DimensionTransition;`
`17`	`18`	`import net.minecraft.world.phys.Vec3;`
`18`	`19`	`import org.spongepowered.asm.mixin.Mixin;`
`19`	`20`	`import org.spongepowered.asm.mixin.Shadow;`
`@@ -96,18 +97,20 @@ private void setSneakingConditionally(ServerPlayer serverPlayerEntity, boolean s`
`96`	`97`	`private ResourceKey<Level> previousDimension;`
`97`	`98`
`98`	`99`	`@Inject(method = "changeDimension", at = @At("HEAD"))`
`99`		`- private void logPreviousCoordinates(ServerLevel serverWorld, CallbackInfoReturnable<Entity> cir)`
	`100`	`+ private void logPreviousCoordinates(DimensionTransitionSupplier serverWorld, CallbackInfoReturnable<Entity> cir)`
`100`	`101`	`{`
`101`	`102`	`previousLocation = position();`
`102`	`103`	`previousDimension = level().dimension(); //dimension type`
`103`	`104`	`}`
`104`	`105`
`105`	`106`	`@Inject(method = "changeDimension", at = @At("RETURN"))`
`106`		`- private void atChangeDimension(ServerLevel destination, CallbackInfoReturnable<Entity> cir)`
	`107`	`+ private void atChangeDimension(DimensionTransitionSupplier destinationP, CallbackInfoReturnable<Entity> cir)`
`107`	`108`	`{`
`108`	`109`	`if (PLAYER_CHANGES_DIMENSION.isNeeded())`
`109`	`110`	`{`
`110`	`111`	`ServerPlayer player = (ServerPlayer) (Object)this;`
	`112`	`+ DimensionTransition destinationTransition = destinationP.get();`
	`113`	`+ ServerLevel destination = destinationTransition.newDimension();`
`111`	`114`	`Vec3 to = null;`
`112`	`115`	`if (!wonGame \|\| previousDimension != Level.END \|\| destination.dimension() != Level.OVERWORLD)`
`113`	`116`	`{`
Original file line number	Diff line number	Diff line change
`@@ -213,7 +213,7 @@ protected void checkFallDamage(double y, boolean onGround, BlockState state, Blo`
`213`	`213`	`}`
`214`	`214`
`215`	`215`	`@Override`
`216`		`- public Entity changeDimension(ServerLevel serverLevel)`
	`216`	`+ public Entity changeDimension(DimensionTransitionSupplier serverLevel)`
`217`	`217`	`{`
`218`	`218`	`super.changeDimension(serverLevel);`
`219`	`219`	`if (wonGame) {`
Original file line number	Diff line number	Diff line change
`@@ -100,12 +100,12 @@ public static void MinecraftServer_forceTick(MinecraftServer server, BooleanSupp`
`100`	`100`
`101`	`101`	`public static void ChunkMap_relightChunk(ChunkMap chunkMap, ChunkPos pos)`
`102`	`102`	`{`
`103`		`- ((ThreadedAnvilChunkStorageInterface) chunkMap).relightChunk(pos);`
	`103`	`+ //((ThreadedAnvilChunkStorageInterface) chunkMap).relightChunk(pos);`
`104`	`104`	`}`
`105`	`105`
`106`	`106`	`public static Map<String, Integer> ChunkMap_regenerateChunkRegion(ChunkMap chunkMap, List<ChunkPos> requestedChunks)`
`107`	`107`	`{`
`108`		`- return ((ThreadedAnvilChunkStorageInterface) chunkMap).regenerateChunkRegion(requestedChunks);`
	`108`	`+ return Map.of(); //return ((ThreadedAnvilChunkStorageInterface) chunkMap).regenerateChunkRegion(requestedChunks);`
`109`	`109`	`}`
`110`	`110`
`111`	`111`	`public static List<Collection<ItemStack>> Ingredient_getRecipeStacks(Ingredient ingredient)`