Keep native structures out of static object cells

Vanilla structure and feature placement now runs through the bounded
worldgen access with a protected-position predicate, so a jigsaw piece
or an imported feature can read a static object's blocks but never
overwrite them, and never schedules a tick or block entity there.
Dimensions without static objects keep the plain level as before.

adapters/modded-common/src/main/java/art/arcane/iris/modded/ModdedImportedFeatureStage.java

@@ -25,6 +25,7 @@ import art.arcane.iris.engine.object.IrisBiome;
 import art.arcane.iris.engine.object.IrisBiomeCustom;
 import art.arcane.iris.engine.object.IrisDecorationStep;
 import art.arcane.iris.engine.object.IrisImportedFeatureControl;
+import art.arcane.iris.engine.object.IrisStaticObjectLayer;
 import art.arcane.iris.util.project.context.IrisContext;
 import it.unimi.dsi.fastutil.ints.IntArraySet;
 import it.unimi.dsi.fastutil.ints.IntSet;
@@ -43,6 +44,7 @@ import net.minecraft.world.level.biome.FeatureSorter;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.LevelChunkSection;
 import net.minecraft.world.level.levelgen.RandomSupport;
+import net.minecraft.world.level.levelgen.Heightmap;
 import net.minecraft.world.level.levelgen.WorldgenRandom;
 import net.minecraft.world.level.levelgen.XoroshiroRandomSource;
 import net.minecraft.world.level.levelgen.placement.PlacedFeature;
@@ -321,13 +323,20 @@ final class ModdedImportedFeatureStage {
         WorldgenRandom random = new WorldgenRandom(new XoroshiroRandomSource(RandomSupport.generateUniqueSeed()));
         long decorationSeed = random.setDecorationSeed(level.getSeed(), origin.getX(), origin.getZ());
         Set<Holder<Biome>> chunkBiomes = chunkBiomes(level, sectionPos, table);
+        IrisStaticObjectLayer staticObjects = engine.getDimension().getStaticObjectLayer(engine.getData());
+        int staticMinY = engine.getMinHeight();
+        WorldGenLevel placementLevel = staticObjects.isEmpty() ? level : ModdedNativeStructureWorldgenAccess.create(
+                level, centerPos,
+                (x, z) -> level.getHeight(Heightmap.Types.WORLD_SURFACE_WG, x, z),
+                (x, z) -> level.getHeight(Heightmap.Types.OCEAN_FLOOR_WG, x, z),
+                position -> staticObjects.contains(position.getX(), position.getY() - staticMinY, position.getZ()));
 
         try {
             for (int stepIndex = 0; stepIndex < steps.size(); stepIndex++) {
                 if (!table.control().shouldGenerateStep(IrisDecorationStep.byOrdinal(stepIndex))) {
                     continue;
                 }
-                placeStep(level, table, steps.get(stepIndex), featureRegistry, chunkBiomes, owner,
+                placeStep(placementLevel, table, steps.get(stepIndex), featureRegistry, chunkBiomes, owner,
                         random, decorationSeed, origin, stepIndex);
             }
         } catch (Throwable error) {

adapters/modded-common/src/main/java/art/arcane/iris/modded/ModdedNativeStructureStage.java

@@ -25,6 +25,7 @@ import art.arcane.iris.engine.framework.NativeStructureOwnershipRecord;
 import art.arcane.iris.engine.framework.NativeStructureStartPlan;
 import art.arcane.iris.engine.object.IrisMaterialPalette;
 import art.arcane.iris.engine.object.IrisNativeStructureDecision;
+import art.arcane.iris.engine.object.IrisStaticObjectLayer;
 import art.arcane.iris.nativegen.NativeStructureGenerationException;
 import art.arcane.iris.nativegen.NativeStructureLocatePersistence;
 import art.arcane.iris.nativegen.NativeStructureLocateResults;
@@ -365,9 +366,14 @@ final class ModdedNativeStructureStage {
                     "heightmap priming", nativeStructureBatchContext(placementGroups),
                     chunkPos.x(), chunkPos.z(), error);
         }
+        IrisStaticObjectLayer staticObjects = current.getDimension().getStaticObjectLayer(current.getData());
+        int staticMinY = current.getMinHeight();
+        WorldGenLevel boundedWorld = staticObjects.isEmpty() ? world : ModdedNativeStructureWorldgenAccess.create(
+                world, chunkPos, worldgenSurfaceHeight(current, world.getMinY()), worldgenFloorHeight(current, world.getMinY()),
+                position -> staticObjects.contains(position.getX(), position.getY() - staticMinY, position.getZ()));
         try {
             NativeStructureVegetationClearer.clearIntersectingVegetation(
-                    world, chunk, area, vegetationTargets);
+                    boundedWorld, chunk, area, vegetationTargets);
         } catch (Throwable error) {
             throw NativeStructureGenerationException.failure(
                     "vegetation cleanup", nativeStructureBatchContext(placementGroups),
@@ -376,7 +382,7 @@ final class ModdedNativeStructureStage {
         NativeStructureSurfaceFitter.VacuumFoundationPlan vacuumFoundationPlan;
         try {
             vacuumFoundationPlan = NativeStructureSurfaceFitter.prepareSurfaceStructures(
-                    world, area, terrainTargets,
+                    boundedWorld, area, terrainTargets,
                     (x, z) -> current.getHeight(x, z, true) + current.getMinHeight());
         } catch (Throwable error) {
             throw NativeStructureGenerationException.failure(
@@ -385,7 +391,7 @@ final class ModdedNativeStructureStage {
         }
         try {
             NativeStructurePostProcessor.prepareTerrain(
-                    world, area, terrainTargets, this::resolvePaletteBlock);
+                    boundedWorld, area, terrainTargets, this::resolvePaletteBlock);
         } catch (Throwable error) {
             throw NativeStructureGenerationException.failure(
                     "terrain preparation", nativeStructureBatchContext(placementGroups),
@@ -395,7 +401,7 @@ final class ModdedNativeStructureStage {
             random.setFeatureSeed(decorationSeed, group.featureIndex(), group.step());
             try {
                 for (NativePlacement placement : group.placements()) {
-                    placeVanillaStructure(world, structureManager, random, area, chunkPos,
+                    placeVanillaStructure(boundedWorld, structureManager, random, area, chunkPos,
                             group.structureId(), placement.start(), placement.decision());
                 }
             } catch (Throwable error) {
@@ -405,7 +411,7 @@ final class ModdedNativeStructureStage {
         }
         try {
             NativeStructureSurfaceFitter.repairVacuumFoundations(
-                    world, area, vacuumFoundationPlan);
+                    boundedWorld, area, vacuumFoundationPlan);
         } catch (Throwable error) {
             throw NativeStructureGenerationException.failure(
                     "foundation repair", nativeStructureBatchContext(placementGroups),
@@ -436,11 +442,8 @@ final class ModdedNativeStructureStage {
                                        String structureId, StructureStart start,
                                        IrisNativeStructureDecision decision) {
         Engine current = generator.engine();
-        int runtimeMinY = world.getMinY();
-        WorldGenLevel boundedWorld = ModdedNativeStructureWorldgenAccess.create(
-                world, chunkPos,
-                worldgenSurfaceHeight(current, runtimeMinY),
-                worldgenFloorHeight(current, runtimeMinY));
+        WorldGenLevel boundedWorld = world instanceof ModdedNativeStructureWorldgenAccess ? world : ModdedNativeStructureWorldgenAccess.create(
+                world, chunkPos, worldgenSurfaceHeight(current, world.getMinY()), worldgenFloorHeight(current, world.getMinY()), position -> false);
         world.setCurrentlyGenerating(() -> "Iris native structure " + structureId);
         try {
             NativeStructurePostProcessor.place(

adapters/modded-common/src/main/java/art/arcane/iris/modded/ModdedNativeStructureWorldgenAccess.java

@@ -63,6 +63,7 @@ final class ModdedNativeStructureWorldgenAccess implements WorldGenLevel {
     private final ChunkPos generationCenter;
     private final IntBinaryOperator surfaceFirstFreeY;
     private final IntBinaryOperator floorFirstFreeY;
+    private final Predicate<BlockPos> protectedPosition;
     private final Holder<Biome> fallbackBiome;
     private final BiomeManager biomeManager;
     private final AABB generationBounds;
@@ -79,6 +80,8 @@ final class ModdedNativeStructureWorldgenAccess implements WorldGenLevel {
                 boundary.surfaceFirstFreeY(), "Native structure world access requires a surface resolver");
         this.floorFirstFreeY = Objects.requireNonNull(
                 boundary.floorFirstFreeY(), "Native structure world access requires an ocean-floor resolver");
+        this.protectedPosition = Objects.requireNonNull(
+                boundary.protectedPosition(), "World access requires a protected-position predicate");
         BlockPos biomeSample = generationCenter.getMiddleBlockPosition(delegate.getSeaLevel());
         this.fallbackBiome = delegate.getBiome(biomeSample);
         this.biomeManager = delegate.getBiomeManager().withDifferentSource(this);
@@ -98,9 +101,10 @@ final class ModdedNativeStructureWorldgenAccess implements WorldGenLevel {
 
     static ModdedNativeStructureWorldgenAccess create(WorldGenLevel delegate, ChunkPos generationCenter,
                                                 IntBinaryOperator surfaceFirstFreeY,
-                                                IntBinaryOperator floorFirstFreeY) {
+                                                IntBinaryOperator floorFirstFreeY,
+                                                Predicate<BlockPos> protectedPosition) {
         return new ModdedNativeStructureWorldgenAccess(delegate, new Boundary(
-                generationCenter, surfaceFirstFreeY, floorFirstFreeY));
+                generationCenter, surfaceFirstFreeY, floorFirstFreeY, protectedPosition));
     }
 
     @Override
@@ -350,13 +354,13 @@ final class ModdedNativeStructureWorldgenAccess implements WorldGenLevel {
 
     @Override
     public BlockEntity getBlockEntity(BlockPos position) {
-        return isReadable(position) ? delegate.getBlockEntity(position) : null;
+        return isWritable(position) ? delegate.getBlockEntity(position) : null;
     }
 
     @Override
     public <T extends BlockEntity> Optional<T> getBlockEntity(
             BlockPos position, BlockEntityType<T> type) {
-        return isReadable(position) ? delegate.getBlockEntity(position, type) : Optional.empty();
+        return isWritable(position) ? delegate.getBlockEntity(position, type) : Optional.empty();
     }
 
     @Override
@@ -430,7 +434,7 @@ final class ModdedNativeStructureWorldgenAccess implements WorldGenLevel {
     }
 
     private boolean isWritable(BlockPos position) {
-        return isReadable(position);
+        return isReadable(position) && !protectedPosition.test(position);
     }
 
     private boolean isWritableNeighbourhood(BlockPos position) {
@@ -521,7 +525,8 @@ final class ModdedNativeStructureWorldgenAccess implements WorldGenLevel {
 
     private record Boundary(ChunkPos generationCenter,
                             IntBinaryOperator surfaceFirstFreeY,
-                            IntBinaryOperator floorFirstFreeY) {
+                            IntBinaryOperator floorFirstFreeY,
+                            Predicate<BlockPos> protectedPosition) {
     }
 
     private static final class BoundedTickAccess<T> implements LevelTickAccess<T> {