5.27.19 - commit.1

gradle.properties

@@ -3,7 +3,7 @@ org.gradle.jvmargs=-Xmx2G
 
 # Mod properties
 mod_id=modernfix
-version=5.27.18-build.1
+version=5.27.19-build.1
 
 # Minecraft/Fabric
 minecraft_version=26.2

src/main/java/org/embeddedt/modernfix/annotation/FeatureLevel.java

@@ -0,0 +1,9 @@
+package org.embeddedt.modernfix.annotation;
+
+public enum FeatureLevel {
+    GA, BETA;
+
+    public boolean isAtLeast(FeatureLevel required) {
+        return this.ordinal() >= required.ordinal();
+    }
+}

src/main/java/org/embeddedt/modernfix/annotation/RequiresFeatureLevel.java

@@ -0,0 +1,12 @@
+package org.embeddedt.modernfix.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+@Retention(RetentionPolicy.CLASS)
+@Target({ElementType.TYPE, ElementType.PACKAGE})
+public @interface RequiresFeatureLevel {
+    FeatureLevel value() default FeatureLevel.GA;
+}

src/main/java/org/embeddedt/modernfix/annotation/RequiresMod.java

@@ -8,7 +8,7 @@
 /**
  * Marks a mixin class as requiring a specific mod to be present (or absent with ! prefix).
  */
-@Target(ElementType.TYPE)
+@Target({ElementType.TYPE, ElementType.PACKAGE})
 @Retention(RetentionPolicy.RUNTIME)
 public @interface RequiresMod {
     String value();

src/main/java/org/embeddedt/modernfix/common/mixin/bugfix/missing_block_entities/LevelChunkMixin.java

@@ -85,12 +85,9 @@ private void makeBlockEntityIfNotExists(BlockState state, BlockPos.MutableBlockP
         }
 
         BlockEntity blockEntity = this.getBlockEntity(pos.immutable(), LevelChunk.EntityCreationType.IMMEDIATE);
-        String blockName = state.getBlock().toString();
-        if (blockEntity != null) {
-            ModernFix.LOGGER.warn("Created missing block entity for {} at {}", blockName, pos.toShortString());
-        } else {
-            ModernFix.LOGGER.error("Block entity is missing for {} at {}, but could not be created", blockName, pos.toShortString());
+        if (blockEntity != null && ModernFix.LOGGER.isDebugEnabled()) {
+            String blockName = state.getBlock().toString();
+            ModernFix.LOGGER.debug("Created missing block entity for {} at {}", blockName, pos.toShortString());
         }
     }
 }
-

src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_strongholds/ChunkGeneratorMixin.java

@@ -2,10 +2,13 @@
 
 import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
 import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.sugar.Share;
+import com.llamalad7.mixinextras.sugar.ref.LocalRef;
+import net.minecraft.TracingExecutor;
 import net.minecraft.core.Holder;
-import net.minecraft.core.RegistryAccess;
 import net.minecraft.nbt.*;
 import net.minecraft.resources.RegistryOps;
+import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.Util;
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.biome.BiomeSource;
@@ -17,6 +20,8 @@
 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.Redirect;
 
 import java.lang.ref.SoftReference;
 import java.nio.charset.StandardCharsets;
@@ -29,6 +34,8 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 @Mixin(ChunkGeneratorStructureState.class)
 public class ChunkGeneratorMixin implements IChunkGenerator {
@@ -41,22 +48,23 @@ public class ChunkGeneratorMixin implements IChunkGenerator {
     private BiomeSource biomeSource;
 
     private Path mfix$dimensionPath;
-    private RegistryAccess.Frozen mfix$registryAccess;
+    private MinecraftServer mfix$server;
     private SoftReference<Map<String, List<ChunkPos>>> mfix$cachedPositions = new SoftReference<>(null);
 
     private static final String CACHE_FILENAME = "mfix_stronghold_cache_v2.nbt";
 
     @Override
-    public void mfix$setStrongholdCachePath(Path cachePath, RegistryAccess.Frozen registryAccess) {
+    public void mfix$setStrongholdCachePath(Path cachePath, MinecraftServer server) {
         this.mfix$dimensionPath = cachePath;
-        this.mfix$registryAccess = registryAccess;
+        this.mfix$server = server;
     }
 
     @WrapMethod(method = "generateRingPositions")
     private CompletableFuture<List<ChunkPos>> modernfix$cacheRingPositions(Holder<StructureSet> structureSet,
                                                                           ConcentricRingsStructurePlacement placement,
-                                                                          Operation<CompletableFuture<List<ChunkPos>>> original) {
-        if (this.mfix$registryAccess == null || this.mfix$dimensionPath == null) {
+                                                                          Operation<CompletableFuture<List<ChunkPos>>> original,
+                                                                          @Share("threadPool") LocalRef<TracingExecutor> threadPoolRef) {
+        if (this.mfix$server == null || this.mfix$dimensionPath == null) {
             return original.call(structureSet, placement);
         }
 
@@ -69,14 +77,34 @@ public class ChunkGeneratorMixin implements IChunkGenerator {
             return CompletableFuture.completedFuture(List.copyOf(cached));
         }
 
-        return original.call(structureSet, placement).thenApplyAsync(positions -> {
-            mfix$writeToCache(cacheKey, positions);
-            return positions;
-        }, Util.ioPool());
+        var server = this.mfix$server;
+        ExecutorService strongholdPool = Executors.newFixedThreadPool(Math.max(1, Runtime.getRuntime().availableProcessors() - 2));
+        threadPoolRef.set(new TracingExecutor(strongholdPool));
+        try {
+            return original.call(structureSet, placement).thenApplyAsync(positions -> {
+                if (server.isRunning()) {
+                    mfix$writeToCache(cacheKey, positions);
+                }
+                return positions;
+            }, Util.ioPool());
+        } finally {
+            strongholdPool.shutdown();
+        }
+    }
+
+    /**
+     * @author embeddedt
+     * @reason Ring position calculation is often not required for initial chunk generation, but the tasks still occupy
+     * CPU time on the main worker pool and prevent higher priority work from progressing. To fix this we use a
+     * dedicated pool.
+     */
+    @Redirect(method = "generateRingPositions", at = @At(value = "INVOKE", target = "Lnet/minecraft/util/Util;backgroundExecutor()Lnet/minecraft/TracingExecutor;"))
+    private TracingExecutor useDedicatedService(@Share("threadPool") LocalRef<TracingExecutor> threadPoolRef) {
+        return threadPoolRef.get();
     }
 
     private String mfix$makeCacheKey(ConcentricRingsStructurePlacement placement) {
-        RegistryOps<Tag> ops = RegistryOps.create(NbtOps.INSTANCE, this.mfix$registryAccess);
+        RegistryOps<Tag> ops = RegistryOps.create(NbtOps.INSTANCE, this.mfix$server.registryAccess());
         String placementKey = ConcentricRingsStructurePlacement.CODEC.codec().encodeStart(ops, placement)
                 .result().map(Tag::toString).orElse(null);
         String biomeSourceKey = BiomeSource.CODEC.encodeStart(ops, this.biomeSource)

src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_strongholds/ConcentricRingsStructurePlacementMixin.java

@@ -0,0 +1,83 @@
+package org.embeddedt.modernfix.common.mixin.perf.cache_strongholds;
+
+import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
+import net.minecraft.world.level.levelgen.structure.placement.ConcentricRingsStructurePlacement;
+import org.embeddedt.modernfix.annotation.FeatureLevel;
+import org.embeddedt.modernfix.annotation.RequiresFeatureLevel;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.Unique;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+@Mixin(ConcentricRingsStructurePlacement.class)
+@RequiresFeatureLevel(FeatureLevel.BETA)
+public class ConcentricRingsStructurePlacementMixin {
+
+    @Shadow @Final private int distance;
+    @Shadow @Final private int spread;
+    @Shadow @Final private int count;
+
+    @Unique private static final int MFIX_MAX_BIOME_SNAP_SECTIONS_PER_AXIS = 7;
+    @Unique private static final double MFIX_MAX_ROUNDING_ERROR = Math.sqrt(2.0) * 0.5;
+    @Unique private static final double MFIX_MAX_BIOME_SNAP_ERROR = MFIX_MAX_BIOME_SNAP_SECTIONS_PER_AXIS * Math.sqrt(2.0);
+    @Unique private static final double MFIX_MAX_POSITION_ERROR = MFIX_MAX_ROUNDING_ERROR + MFIX_MAX_BIOME_SNAP_ERROR;
+
+    @Unique private long mfix$innerRadiusSq;
+    @Unique private long mfix$outerRadiusSq;
+
+    @Inject(
+        method = "<init>(Lnet/minecraft/core/Vec3i;Lnet/minecraft/world/level/levelgen/structure/placement/StructurePlacement$FrequencyReductionMethod;FILjava/util/Optional;IIILnet/minecraft/core/HolderSet;)V",
+        at = @At("RETURN")
+    )
+    private void mfix$computeRadiusBounds(CallbackInfo ci) {
+        double maxNoise = this.distance * 1.25;
+
+        double minDist = 4.0 * this.distance - maxNoise;
+        double safeInnerRadius = minDist - MFIX_MAX_POSITION_ERROR;
+        this.mfix$innerRadiusSq = (long)Math.max(0.0, Math.floor(safeInnerRadius * safeInnerRadius));
+
+        if (this.spread == 0) {
+            this.mfix$outerRadiusSq = Long.MAX_VALUE;
+            return;
+        }
+
+        int maxCircle = this.mfix$computeMaxCircleIndex();
+        double maxDist = 4.0 * this.distance + (double)this.distance * maxCircle * 6.0 + maxNoise;
+        double safeOuterRadius = maxDist + MFIX_MAX_POSITION_ERROR;
+        this.mfix$outerRadiusSq = (long)Math.ceil(safeOuterRadius * safeOuterRadius);
+    }
+
+    @Unique
+    private int mfix$computeMaxCircleIndex() {
+        int ringSpread = this.spread;
+        int total = 0;
+        int circle = 0;
+
+        while (total + ringSpread < this.count) {
+            total += ringSpread;
+            circle++;
+            ringSpread += 2 * ringSpread / (circle + 1);
+            ringSpread = Math.min(ringSpread, this.count - total);
+        }
+
+        return circle;
+    }
+
+    /**
+     * @author embeddedt, GPT-5.3-Codex
+     * @reason Avoid calling getRingPositionsFor() when we know the current chunk lies outside the region where
+     * concentric placement can even happen.
+     */
+    @Inject(method = "isPlacementChunk", at = @At("HEAD"), cancellable = true)
+    private void mfix$earlyRejectByRadius(ChunkGeneratorStructureState structureState, int x, int z,
+                                          CallbackInfoReturnable<Boolean> cir) {
+        long distSq = (long)x * x + (long)z * z;
+        if (distSq < this.mfix$innerRadiusSq || distSq > this.mfix$outerRadiusSq) {
+            cir.setReturnValue(false);
+        }
+    }
+}

src/main/java/org/embeddedt/modernfix/common/mixin/perf/cache_strongholds/ServerLevelMixin.java

@@ -24,7 +24,7 @@ private void setCachePath(ChunkGeneratorStructureState instance, Operation<Void>
                                      @Local(ordinal = 0, argsOnly = true) LevelStorageSource.LevelStorageAccess levelStorageAccess,
                                      @Local(ordinal = 0, argsOnly = true) ResourceKey<Level> dimension,
                                      @Local(ordinal = 0, argsOnly = true) MinecraftServer server) {
-        ((IChunkGenerator)instance).mfix$setStrongholdCachePath(levelStorageAccess.getDimensionPath(dimension), server.registryAccess());
+        ((IChunkGenerator)instance).mfix$setStrongholdCachePath(levelStorageAccess.getDimensionPath(dimension), server);
         original.call(instance);
     }
 }

src/main/java/org/embeddedt/modernfix/common/mixin/perf/compact_entity_models/package-info.java

@@ -0,0 +1,5 @@
+@RequiresFeatureLevel(FeatureLevel.BETA)
+package org.embeddedt.modernfix.common.mixin.perf.compact_entity_models;
+
+import org.embeddedt.modernfix.annotation.FeatureLevel;
+import org.embeddedt.modernfix.annotation.RequiresFeatureLevel;

src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_languages/ClientLanguageMixin.java

@@ -50,4 +50,4 @@ private static Map<String, String> modifyLanguageMap(Map<String, String> storage
         List<Resource> collected = Objects.requireNonNullElse(usedResources.get(), List.of());
         return DynamicLanguageMap.forVanillaData(storage, collected);
     }
-}
+}

src/main/java/org/embeddedt/modernfix/common/mixin/perf/dynamic_languages/package-info.java

@@ -0,0 +1,5 @@
+@RequiresFeatureLevel(FeatureLevel.BETA)
+package org.embeddedt.modernfix.common.mixin.perf.dynamic_languages;
+
+import org.embeddedt.modernfix.annotation.FeatureLevel;
+import org.embeddedt.modernfix.annotation.RequiresFeatureLevel;

src/main/java/org/embeddedt/modernfix/common/mixin/perf/faster_item_rendering/package-info.java

@@ -0,0 +1,5 @@
+@RequiresFeatureLevel(FeatureLevel.BETA)
+package org.embeddedt.modernfix.common.mixin.perf.faster_item_rendering;
+
+import org.embeddedt.modernfix.annotation.FeatureLevel;
+import org.embeddedt.modernfix.annotation.RequiresFeatureLevel;

src/main/java/org/embeddedt/modernfix/common/mixin/perf/release_protochunks/ChunkHolderMixin.java

@@ -3,7 +3,6 @@
 import net.minecraft.server.level.ChunkHolder;
 import net.minecraft.server.level.ChunkLevel;
 import net.minecraft.server.level.ChunkMap;
-import net.minecraft.server.level.FullChunkStatus;
 import net.minecraft.server.level.GenerationChunkHolder;
 import net.minecraft.world.level.ChunkPos;
 import org.embeddedt.modernfix.duck.release_protochunks.IClearableChunkHolder;
@@ -64,7 +63,7 @@ private void markForSuspensionOnDemotion(ChunkMap chunkMap, Executor executor, C
     }
 
     private void mfix$markAsNeedingProtoChunkDrop() {
-        if (!ChunkLevel.fullStatus(this.ticketLevel).isOrAfter(FullChunkStatus.FULL)
+        if (this.ticketLevel >= LOWEST_DROPPABLE_TICKET_LEVEL
                 && ChunkLevel.isLoaded(this.ticketLevel)) {
             // Register for suspension check when chain completes.
             var map = ((ISuspendedHolderTrackingChunkMap)this.playerProvider);
@@ -75,4 +74,4 @@ private void markForSuspensionOnDemotion(ChunkMap chunkMap, Executor executor, C
             }, map.mfix$getMainThreadExecutor());
         }
     }
-}
+}

src/main/java/org/embeddedt/modernfix/common/mixin/perf/release_protochunks/ChunkMapMixin.java

@@ -5,7 +5,6 @@
 import net.minecraft.server.level.ChunkHolder;
 import net.minecraft.server.level.ChunkLevel;
 import net.minecraft.server.level.ChunkMap;
-import net.minecraft.server.level.FullChunkStatus;
 import net.minecraft.util.thread.BlockableEventLoop;
 import net.minecraft.world.level.ChunkPos;
 import org.embeddedt.modernfix.duck.release_protochunks.IClearableChunkHolder;
@@ -62,7 +61,7 @@ private void dropProtoChunks(BooleanSupplier hasMoreTime, CallbackInfo ci) {
             long pos = entry.getLongKey();
             ChunkHolder holder = this.updatingChunkMap.get(pos);
             if (holder == null
-                    || ChunkLevel.fullStatus(holder.getTicketLevel()).isOrAfter(FullChunkStatus.FULL)
+                    || holder.getTicketLevel() < IClearableChunkHolder.LOWEST_DROPPABLE_TICKET_LEVEL
                     || !ChunkLevel.isLoaded(holder.getTicketLevel())
             ) {
                 dropIterator.remove();
@@ -103,4 +102,4 @@ private void dropProtoChunks(BooleanSupplier hasMoreTime, CallbackInfo ci) {
     public Executor mfix$getMainThreadExecutor() {
         return this.mainThreadExecutor;
     }
-}
+}

src/main/java/org/embeddedt/modernfix/common/mixin/perf/release_protochunks/ImposterProtoChunkMixin.java

@@ -0,0 +1,33 @@
+package org.embeddedt.modernfix.common.mixin.perf.release_protochunks;
+
+import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
+import com.llamalad7.mixinextras.sugar.Local;
+import net.minecraft.core.BlockPos;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.chunk.ImposterProtoChunk;
+import org.embeddedt.modernfix.ModernFix;
+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;
+
+@Mixin(ImposterProtoChunk.class)
+public class ImposterProtoChunkMixin {
+    @Shadow
+    @Final
+    private boolean allowWrites;
+
+    /**
+     * @author embeddedt
+     * @reason Hide live BlockEntity instances from worldgen through ImposterProtoChunk wrappers.
+     */
+    @ModifyExpressionValue(method = "getBlockEntity", at = @At(value = "INVOKE", target = "Lnet/minecraft/world/level/chunk/LevelChunk;getBlockEntity(Lnet/minecraft/core/BlockPos;)Lnet/minecraft/world/level/block/entity/BlockEntity;"))
+    private BlockEntity avoidLeakingLiveBE(BlockEntity original, @Local(ordinal = 0, argsOnly = true) BlockPos pos) {
+        if (!this.allowWrites && original != null && original.getLevel() != null) {
+            ModernFix.LOGGER.debug("Blocked accessing the main level BlockEntity at {} from the ImposterProtoChunk wrapper, as this is unsafe during worldgen.", pos, new Exception("Stacktrace"));
+            return null;
+        } else {
+            return original;
+        }
+    }
+}