new: implements FabricMC/fabric#4541

ishland · ishland · commit 0a04fdc6b1c9 · 2025-04-25T00:11:00.000+08:00
diff --git a/build.gradle b/build.gradle
@@ -80,10 +80,12 @@ configure (allprojects - project(":tests")) {
 
         [
                 "fabric-networking-api-v1",
-                "fabric-lifecycle-events-v1",
+//                "fabric-lifecycle-events-v1",
         ].forEach {
             modCompileOnly(fabricApi.module(it, "${project.fabric_version}"))
         }
+
+        modCompileOnly("com.github.FabricMC.fabric:fabric-lifecycle-events-v1:c814733d8423a4464332bc4d15b3e6a190fcbcfe")
     }
 
     loom {
diff --git a/c2me-base/src/main/java/com/ishland/c2me/base/common/config/LateModStatuses.java b/c2me-base/src/main/java/com/ishland/c2me/base/common/config/LateModStatuses.java
@@ -0,0 +1,33 @@
+package com.ishland.c2me.base.common.config;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class LateModStatuses {
+
+    private static final Logger LOGGER = LoggerFactory.getLogger(ModStatuses.class);
+    public static final boolean fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE = isAvailable0_fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE();
+
+    private static boolean isAvailable0_fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE() {
+        if (!ModStatuses.fabric_lifecycle_events_v1) {
+            LOGGER.info("Fabric Lifecycle Events (v1) not found, skipping compat");
+            return false;
+        }
+        Class<?> clazzServerChunkEvents;
+        try {
+            clazzServerChunkEvents = Class.forName("net.fabricmc.fabric.api.event.lifecycle.v1.ServerChunkEvents");
+        } catch (ClassNotFoundException e) {
+            LOGGER.warn("net.fabricmc.fabric.api.event.lifecycle.v1.ServerChunkEvents not found, but fabric-loader claims fabric-lifecycle-events-v1 is present, outdated fabric-api?", e);
+            return false;
+        }
+        try {
+            clazzServerChunkEvents.getField("CHUNK_LEVEL_TYPE_CHANGE");
+        } catch (NoSuchFieldException e) {
+            LOGGER.warn("Lnet/fabricmc/fabric/api/event/lifecycle/v1/ServerChunkEvents;CHUNK_LEVEL_TYPE_CHANGE:Lnet/fabricmc/fabric/api/event/Event; not found, outdated fabric-api?", e);
+            return false;
+        }
+
+        return true;
+    }
+
+}
diff --git a/c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/fapi/IArrayBackedEvent.java b/c2me-base/src/main/java/com/ishland/c2me/base/mixin/access/fapi/IArrayBackedEvent.java
@@ -0,0 +1,12 @@
+package com.ishland.c2me.base.mixin.access.fapi;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(targets = "net.fabricmc.fabric.impl.base.event.ArrayBackedEvent", remap = false)
+public interface IArrayBackedEvent<T> {
+
+    @Accessor("handlers")
+    T[] c2me$getHandlers();
+
+}
diff --git a/c2me-base/src/main/resources/c2me-base.mixins.json b/c2me-base/src/main/resources/c2me-base.mixins.json
@@ -55,6 +55,7 @@
     "access.IXoroshiro128PlusPlusRandom",
     "access.IXoroshiro128PlusPlusRandomDeriver",
     "access.IXoroshiro128PlusPlusRandomImpl",
+    "access.fapi.IArrayBackedEvent",
     "instrumentation.MixinServerChunkManager",
     "report.MixinDedicatedServerWatchdog",
     "scheduler.MixinThreadedAnvilChunkStorage",
diff --git a/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/fapi/LifecycleEventInvoker.java b/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/fapi/LifecycleEventInvoker.java
@@ -1,27 +1,65 @@
 package com.ishland.c2me.rewrites.chunksystem.common.fapi;
 
+import com.ishland.c2me.base.mixin.access.fapi.IArrayBackedEvent;
 import net.fabricmc.fabric.api.event.lifecycle.v1.ServerChunkEvents;
+import net.minecraft.server.world.ChunkLevelType;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.world.chunk.WorldChunk;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 public class LifecycleEventInvoker {
 
+    private static final Logger LOGGER = LoggerFactory.getLogger(LifecycleEventInvoker.class);
+
     public static void invokeChunkLoaded(ServerWorld world, WorldChunk chunk, boolean newChunk) {
         try {
             ServerChunkEvents.CHUNK_LOAD.invoker().onChunkLoad(world, chunk);
             if (newChunk) {
                 ServerChunkEvents.CHUNK_GENERATE.invoker().onChunkGenerate(world, chunk);
             }
         } catch (Throwable t) {
-            t.printStackTrace();
+            LOGGER.error("Failed to invoke chunk load event (world={}, pos={}, newChunk={})", world, chunk.getPos(), newChunk, t);
         }
     }
 
     public static void invokeChunkUnload(ServerWorld world, WorldChunk chunk) {
         try {
             ServerChunkEvents.CHUNK_UNLOAD.invoker().onChunkUnload(world, chunk);
         } catch (Throwable t) {
-            t.printStackTrace();
+            LOGGER.error("Failed to invoke chunk unload event (world={}, pos={})", world, chunk.getPos(), t);
+        }
+    }
+
+    private static boolean cachedNeedsInvokeChunkLevelTypeChange = false;
+
+    public static boolean needsInvokeChunkLevelTypeChange() {
+        if (cachedNeedsInvokeChunkLevelTypeChange) return true;
+        try {
+            if (ServerChunkEvents.CHUNK_LEVEL_TYPE_CHANGE instanceof IArrayBackedEvent<?> accessor0) {
+                IArrayBackedEvent<ServerChunkEvents.LevelTypeChange> accessor = (IArrayBackedEvent<ServerChunkEvents.LevelTypeChange>) accessor0;
+                if (accessor.c2me$getHandlers().length > 0) {
+                    cachedNeedsInvokeChunkLevelTypeChange = true;
+                    return true;
+                }
+            } else {
+                LOGGER.warn("Unexpected Event implementation of ServerChunkEvents.CHUNK_LEVEL_TYPE_CHANGE: {}", ServerChunkEvents.CHUNK_LEVEL_TYPE_CHANGE.getClass().getName());
+                cachedNeedsInvokeChunkLevelTypeChange = true;
+                return true;
+            }
+            return false;
+        } catch (Throwable t) {
+            LOGGER.error("Failed to check if chunk level type change event is needed", t);
+            cachedNeedsInvokeChunkLevelTypeChange = true;
+            return true;
+        }
+    }
+
+    public static void invokeChunkLevelTypeChange(ServerWorld world, WorldChunk chunk, ChunkLevelType oldLevelType, ChunkLevelType newLevelType) {
+        try {
+            ServerChunkEvents.CHUNK_LEVEL_TYPE_CHANGE.invoker().onChunkLevelTypeChange(world, chunk, oldLevelType, newLevelType);
+        } catch (Throwable t) {
+            LOGGER.error("Failed to invoke chunk level type change event (world={}, pos={}, oldLevelType={}, newLevelType={})", world, chunk.getPos(), oldLevelType, newLevelType, t);
         }
     }
 
diff --git a/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/statuses/ServerAccessible.java b/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/statuses/ServerAccessible.java
@@ -1,6 +1,7 @@
 package com.ishland.c2me.rewrites.chunksystem.common.statuses;
 
 import com.google.common.base.Preconditions;
+import com.ishland.c2me.base.common.config.LateModStatuses;
 import com.ishland.c2me.base.common.config.ModStatuses;
 import com.ishland.c2me.base.common.threadstate.ThreadInstrumentation;
 import com.ishland.c2me.base.mixin.access.IThreadedAnvilChunkStorage;
@@ -16,6 +17,7 @@
 import net.minecraft.entity.EntityType;
 import net.minecraft.entity.SpawnReason;
 import net.minecraft.nbt.NbtCompound;
+import net.minecraft.server.world.ChunkLevelType;
 import net.minecraft.server.world.ServerWorld;
 import net.minecraft.world.chunk.Chunk;
 import net.minecraft.world.chunk.ChunkStatus;
@@ -58,6 +60,10 @@ public CompletionStage<Void> upgradeToThis(ChunkLoadingContext context, Cancella
                     }
                 }
 
+                if (LateModStatuses.fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE) {
+                    LifecycleEventInvoker.invokeChunkLevelTypeChange(serverWorld, worldChunk, ChunkLevelType.INACCESSIBLE, ChunkLevelType.FULL);
+                }
+
                 ((IThreadedAnvilChunkStorage) context.tacs()).getCurrentChunkHolders().put(context.holder().getKey().toLong(), context.holder().getUserData().get());
                 ((IThreadedAnvilChunkStorage) context.tacs()).setChunkHolderListDirty(true);
             }
@@ -88,12 +94,18 @@ public CompletionStage<Void> downgradeFromThis(ChunkLoadingContext context, Canc
             ((IThreadedAnvilChunkStorage) context.tacs()).getCurrentChunkHolders().remove(context.holder().getKey().toLong());
             ((IThreadedAnvilChunkStorage) context.tacs()).setChunkHolderListDirty(true);
             final WorldChunk worldChunk = (WorldChunk) chunk;
+            ServerWorld serverWorld = ((IThreadedAnvilChunkStorage) context.tacs()).getWorld();
 //            worldChunk.setLoadedToWorld(false);
 //            worldChunk.removeChunkTickSchedulers(((IThreadedAnvilChunkStorage) context.tacs()).getWorld());
+
+            if (LateModStatuses.fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE) {
+                LifecycleEventInvoker.invokeChunkLevelTypeChange(serverWorld, worldChunk, ChunkLevelType.FULL, ChunkLevelType.INACCESSIBLE);
+            }
+            LithiumChunkStatusTrackerInvoker.invokeOnChunkInaccessible(((IThreadedAnvilChunkStorage) context.tacs()).getWorld(), context.holder().getKey());
+
             worldChunk.setLevelTypeProvider(null);
             worldChunk.setUnsavedListener(pos -> {
             });
-            LithiumChunkStatusTrackerInvoker.invokeOnChunkInaccessible(((IThreadedAnvilChunkStorage) context.tacs()).getWorld(), context.holder().getKey());
             context.holder().getItem().set(new ChunkState(state.protoChunk(), state.protoChunk(), ChunkStatus.FULL));
         }, ((IThreadedAnvilChunkStorage) context.tacs()).getMainThreadExecutor());
     }
diff --git a/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/statuses/ServerBlockTicking.java b/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/statuses/ServerBlockTicking.java
@@ -1,6 +1,7 @@
 package com.ishland.c2me.rewrites.chunksystem.common.statuses;
 
 import com.google.common.base.Suppliers;
+import com.ishland.c2me.base.common.config.LateModStatuses;
 import com.ishland.c2me.base.common.threadstate.ThreadInstrumentation;
 import com.ishland.c2me.base.mixin.access.IThreadedAnvilChunkStorage;
 import com.ishland.c2me.rewrites.chunksystem.common.ChunkLoadingContext;
@@ -9,6 +10,7 @@
 import com.ishland.c2me.rewrites.chunksystem.common.NewChunkHolderVanillaInterface;
 import com.ishland.c2me.rewrites.chunksystem.common.NewChunkStatus;
 import com.ishland.c2me.rewrites.chunksystem.common.ducks.WorldChunkExtension;
+import com.ishland.c2me.rewrites.chunksystem.common.fapi.LifecycleEventInvoker;
 import com.ishland.c2me.rewrites.chunksystem.common.quirks.FlowableFluidUtils;
 import com.ishland.c2me.rewrites.chunksystem.common.threadstate.ChunkTaskWork;
 import com.ishland.flowsched.scheduler.Cancellable;
@@ -19,6 +21,8 @@
 import net.minecraft.block.BlockState;
 import net.minecraft.fluid.FlowableFluid;
 import net.minecraft.fluid.FluidState;
+import net.minecraft.server.world.ChunkLevelType;
+import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.world.ChunkRegion;
@@ -64,11 +68,15 @@ public CompletionStage<Void> upgradeToThis(ChunkLoadingContext context, Cancella
         return CompletableFuture.runAsync(() -> {
             try (var ignored = ThreadInstrumentation.getCurrent().begin(new ChunkTaskWork(context, this, true))) {
                 final WorldChunk chunk = (WorldChunk) context.holder().getItem().get().chunk();
-                chunk.runPostProcessing(((IThreadedAnvilChunkStorage) context.tacs()).getWorld());
-                ((IThreadedAnvilChunkStorage) context.tacs()).getWorld().disableTickSchedulers(chunk);
+                ServerWorld serverWorld = ((IThreadedAnvilChunkStorage) context.tacs()).getWorld();
+                chunk.runPostProcessing(serverWorld);
+                serverWorld.disableTickSchedulers(chunk);
                 sendChunkToPlayer(context);
                 ((IThreadedAnvilChunkStorage) context.tacs()).getTotalChunksLoadedCount().incrementAndGet(); // never decremented in vanilla
                 ((WorldChunkExtension) chunk).c2me$setBlockTicking(true);
+                if (LateModStatuses.fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE) {
+                    LifecycleEventInvoker.invokeChunkLevelTypeChange(serverWorld, chunk, ChunkLevelType.FULL, ChunkLevelType.BLOCK_TICKING);
+                }
             }
         }, ((IThreadedAnvilChunkStorage) context.tacs()).getMainThreadExecutor());
     }
@@ -117,8 +125,14 @@ private static void sendChunkToPlayer(ChunkLoadingContext context) {
 
     @Override
     public CompletionStage<Void> downgradeFromThis(ChunkLoadingContext context, Cancellable cancellable) {
+        ServerWorld serverWorld = ((IThreadedAnvilChunkStorage) context.tacs()).getWorld();
         final WorldChunk chunk = (WorldChunk) context.holder().getItem().get().chunk();
         ((WorldChunkExtension) chunk).c2me$setBlockTicking(false);
+        if (LateModStatuses.fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE && LifecycleEventInvoker.needsInvokeChunkLevelTypeChange()) {
+            return CompletableFuture.runAsync(() -> {
+                LifecycleEventInvoker.invokeChunkLevelTypeChange(serverWorld, chunk, ChunkLevelType.BLOCK_TICKING, ChunkLevelType.FULL);
+            }, ((IThreadedAnvilChunkStorage) context.tacs()).getMainThreadExecutor());
+        }
         return CompletableFuture.completedStage(null);
         // TODO check if syncing is needed
     }
diff --git a/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/statuses/ServerEntityTicking.java b/c2me-rewrites-chunk-system/src/main/java/com/ishland/c2me/rewrites/chunksystem/common/statuses/ServerEntityTicking.java
@@ -1,13 +1,19 @@
 package com.ishland.c2me.rewrites.chunksystem.common.statuses;
 
+import com.ishland.c2me.base.common.config.LateModStatuses;
+import com.ishland.c2me.base.mixin.access.IThreadedAnvilChunkStorage;
 import com.ishland.c2me.rewrites.chunksystem.common.ChunkLoadingContext;
 import com.ishland.c2me.rewrites.chunksystem.common.ChunkState;
 import com.ishland.c2me.rewrites.chunksystem.common.NewChunkStatus;
+import com.ishland.c2me.rewrites.chunksystem.common.fapi.LifecycleEventInvoker;
 import com.ishland.flowsched.scheduler.Cancellable;
 import com.ishland.flowsched.scheduler.ItemHolder;
 import com.ishland.flowsched.scheduler.KeyStatusPair;
+import net.minecraft.server.world.ChunkLevelType;
+import net.minecraft.server.world.ServerWorld;
 import net.minecraft.util.math.ChunkPos;
 import net.minecraft.world.chunk.ChunkStatus;
+import net.minecraft.world.chunk.WorldChunk;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.CompletionStage;
@@ -35,11 +41,25 @@ public ServerEntityTicking(int ordinal) {
 
     @Override
     public CompletionStage<Void> upgradeToThis(ChunkLoadingContext context, Cancellable cancellable) {
+        if (LateModStatuses.fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE && LifecycleEventInvoker.needsInvokeChunkLevelTypeChange()) {
+            return CompletableFuture.runAsync(() -> {
+                ServerWorld serverWorld = ((IThreadedAnvilChunkStorage) context.tacs()).getWorld();
+                final WorldChunk chunk = (WorldChunk) context.holder().getItem().get().chunk();
+                LifecycleEventInvoker.invokeChunkLevelTypeChange(serverWorld, chunk, ChunkLevelType.BLOCK_TICKING, ChunkLevelType.ENTITY_TICKING);
+            }, ((IThreadedAnvilChunkStorage) context.tacs()).getMainThreadExecutor());
+        }
         return CompletableFuture.completedStage(null);
     }
 
     @Override
     public CompletionStage<Void> downgradeFromThis(ChunkLoadingContext context, Cancellable cancellable) {
+        if (LateModStatuses.fabric_lifecycle_events_v1_CHUNK_LEVEL_TYPE_CHANGE && LifecycleEventInvoker.needsInvokeChunkLevelTypeChange()) {
+            return CompletableFuture.runAsync(() -> {
+                ServerWorld serverWorld = ((IThreadedAnvilChunkStorage) context.tacs()).getWorld();
+                final WorldChunk chunk = (WorldChunk) context.holder().getItem().get().chunk();
+                LifecycleEventInvoker.invokeChunkLevelTypeChange(serverWorld, chunk, ChunkLevelType.ENTITY_TICKING, ChunkLevelType.BLOCK_TICKING);
+            }, ((IThreadedAnvilChunkStorage) context.tacs()).getMainThreadExecutor());
+        }
         return CompletableFuture.completedStage(null);
     }
 

Original file line number	Diff line number	Diff line change
`@@ -80,10 +80,12 @@ configure (allprojects - project(":tests")) {`
`80`	`80`
`81`	`81`	`[`
`82`	`82`	`"fabric-networking-api-v1",`
`83`		`- "fabric-lifecycle-events-v1",`
	`83`	`+// "fabric-lifecycle-events-v1",`
`84`	`84`	`].forEach {`
`85`	`85`	`modCompileOnly(fabricApi.module(it, "${project.fabric_version}"))`
`86`	`86`	`}`
	`87`	`+`
	`88`	`+ modCompileOnly("com.github.FabricMC.fabric:fabric-lifecycle-events-v1:c814733d8423a4464332bc4d15b3e6a190fcbcfe")`
`87`	`89`	`}`
`88`	`90`
`89`	`91`	`loom {`