content

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/DatapackStructureStateFilter.java

@@ -1,7 +1,10 @@
 package art.arcane.iris.core.nms.v26_2_R1;
 
 import art.arcane.iris.core.datapack.DatapackStructureScopeIndex;
+import art.arcane.iris.engine.framework.NativeStructureFrequencyScale;
+import art.arcane.iris.engine.object.IrisImportedStructureControl;
 import net.minecraft.core.Holder;
+import net.minecraft.core.HolderOwner;
 import net.minecraft.core.Vec3i;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
@@ -30,6 +33,21 @@ final class DatapackStructureStateFilter {
             DatapackStructureScopeIndex scopeIndex,
             Set<String> declaredSources
     ) {
+        return filter(structureSets, scopeIndex, declaredSources, new IrisImportedStructureControl());
+    }
+
+    static Selection filter(
+            List<Holder<StructureSet>> structureSets,
+            DatapackStructureScopeIndex scopeIndex,
+            Set<String> declaredSources,
+            IrisImportedStructureControl importedStructures
+    ) {
+        if (scopeIndex.isEmpty()) {
+            return new Selection(
+                    scaleFrequencyOverrides(structureSets, importedStructures),
+                    0,
+                    0);
+        }
         Map<String, Holder<StructureSet>> holdersByKey = new HashMap<>();
         for (Holder<StructureSet> holder : structureSets) {
             String key = structureSetKey(holder);
@@ -64,7 +82,7 @@ final class DatapackStructureStateFilter {
             filteredSets.add(scopedHolder);
         }
         return new Selection(
-                List.copyOf(filteredSets),
+                scaleFrequencyOverrides(List.copyOf(filteredSets), importedStructures),
                 retainedManagedSets,
                 excludedManagedSets);
     }
@@ -138,7 +156,8 @@ final class DatapackStructureStateFilter {
                 scopedByIdentity.put(holder, holder);
                 return holder;
             }
-            Holder<StructureSet> scoped = Holder.direct(new StructureSet(entries, placement));
+            Holder<StructureSet> scoped = replacementHolder(
+                    holder, new StructureSet(entries, placement));
             scopedByIdentity.put(holder, scoped);
             return scoped;
         } finally {
@@ -193,12 +212,138 @@ final class DatapackStructureStateFilter {
         if (scopedTarget == currentZone.get().otherSet()) {
             return placement;
         }
-        return copyPlacement(placement, scopedZone);
+        return copyPlacement(placement, scopedZone, 1D);
+    }
+
+    private static List<Holder<StructureSet>> scaleFrequencyOverrides(
+            List<Holder<StructureSet>> structureSets,
+            IrisImportedStructureControl importedStructures
+    ) {
+        if (!importedStructures.hasFrequencyOverrides()) {
+            return structureSets;
+        }
+        Map<String, Holder<StructureSet>> holdersByKey = new HashMap<>();
+        for (Holder<StructureSet> holder : structureSets) {
+            String key = structureSetKey(holder);
+            if (key != null) {
+                holdersByKey.putIfAbsent(key, holder);
+            }
+        }
+        Map<Holder<StructureSet>, Holder<StructureSet>> scaledByIdentity = new IdentityHashMap<>();
+        List<Holder<StructureSet>> scaledSets = new ArrayList<>(structureSets.size());
+        boolean changed = false;
+        for (Holder<StructureSet> holder : structureSets) {
+            Holder<StructureSet> scaled = scaleFrequencyHolder(
+                    holder, importedStructures, holdersByKey, scaledByIdentity);
+            scaledSets.add(scaled);
+            changed |= scaled != holder;
+        }
+        return changed ? List.copyOf(scaledSets) : structureSets;
+    }
+
+    private static Holder<StructureSet> scaleFrequencyHolder(
+            Holder<StructureSet> holder,
+            IrisImportedStructureControl importedStructures,
+            Map<String, Holder<StructureSet>> holdersByKey,
+            Map<Holder<StructureSet>, Holder<StructureSet>> scaledByIdentity
+    ) {
+        if (scaledByIdentity.containsKey(holder)) {
+            return scaledByIdentity.get(holder);
+        }
+        if (!dependsOnFrequencyOverride(holder, importedStructures, holdersByKey)) {
+            scaledByIdentity.put(holder, holder);
+            return holder;
+        }
+
+        ResourceKey<StructureSet> holderKey = structureSetResourceKey(holder).orElseThrow(() ->
+                new IllegalStateException(
+                        "An affected native structure-set exclusion graph has an unkeyed holder"));
+        ReboundStructureSetHolder scaledHolder = new ReboundStructureSetHolder(holderKey);
+        scaledByIdentity.put(holder, scaledHolder);
+
+        StructureSet originalSet = holder.value();
+        StructurePlacement originalPlacement = originalSet.placement();
+        Optional<StructurePlacement.ExclusionZone> originalZone = exclusionZone(originalPlacement);
+        Optional<StructurePlacement.ExclusionZone> scaledZone = originalZone;
+        if (originalZone.isPresent()) {
+            Holder<StructureSet> target = canonicalHolder(
+                    originalZone.get().otherSet(), holdersByKey);
+            Holder<StructureSet> scaledTarget = scaleFrequencyHolder(
+                    target, importedStructures, holdersByKey, scaledByIdentity);
+            if (scaledTarget != originalZone.get().otherSet()) {
+                scaledZone = Optional.of(new StructurePlacement.ExclusionZone(
+                        scaledTarget, originalZone.get().chunkCount()));
+            }
+        }
+
+        double multiplier = importedStructures.frequencyMultiplier(structureSetKey(holder));
+        StructurePlacement scaledPlacement = multiplier == 1D && scaledZone.equals(originalZone)
+                ? originalPlacement
+                : copyPlacement(originalPlacement, scaledZone, multiplier);
+        scaledHolder.bind(new StructureSet(originalSet.structures(), scaledPlacement));
+        return scaledHolder;
+    }
+
+    private static boolean dependsOnFrequencyOverride(
+            Holder<StructureSet> holder,
+            IrisImportedStructureControl importedStructures,
+            Map<String, Holder<StructureSet>> holdersByKey
+    ) {
+        Set<Holder<StructureSet>> visited = Collections.newSetFromMap(new IdentityHashMap<>());
+        Holder<StructureSet> current = holder;
+        while (visited.add(current)) {
+            if (importedStructures.frequencyMultiplier(structureSetKey(current)) != 1D) {
+                return true;
+            }
+            Optional<StructurePlacement.ExclusionZone> zone =
+                    exclusionZone(current.value().placement());
+            if (zone.isEmpty()) {
+                return false;
+            }
+            current = canonicalHolder(zone.get().otherSet(), holdersByKey);
+        }
+        return false;
+    }
+
+    private static Holder<StructureSet> canonicalHolder(
+            Holder<StructureSet> holder,
+            Map<String, Holder<StructureSet>> holdersByKey
+    ) {
+        String key = structureSetKey(holder);
+        return key == null ? holder : holdersByKey.getOrDefault(key, holder);
+    }
+
+    private static Holder<StructureSet> replacementHolder(
+            Holder<StructureSet> original,
+            StructureSet replacement
+    ) {
+        Optional<ResourceKey<StructureSet>> key = structureSetResourceKey(original);
+        if (key.isEmpty()) {
+            return Holder.direct(replacement);
+        }
+        ReboundStructureSetHolder holder = new ReboundStructureSetHolder(key.get());
+        holder.bind(replacement);
+        return holder;
+    }
+
+    private static Optional<ResourceKey<StructureSet>> structureSetResourceKey(
+            Holder<StructureSet> holder
+    ) {
+        Optional<ResourceKey<StructureSet>> key = holder.unwrapKey();
+        if (key.isPresent()) {
+            return key;
+        }
+        if (holder.value().placement()
+                instanceof ChunkGeneratorStructureState.KeyedRandomSpreadStructurePlacement keyedPlacement) {
+            return Optional.of(keyedPlacement.key);
+        }
+        return Optional.empty();
     }
 
     private static StructurePlacement copyPlacement(
             StructurePlacement placement,
-            Optional<StructurePlacement.ExclusionZone> exclusionZone
+            Optional<StructurePlacement.ExclusionZone> exclusionZone,
+            double frequencyMultiplier
     ) {
         Vec3i locateOffset = (Vec3i) declaredFieldValue(
                 StructurePlacement.class, placement, Vec3i.class);
@@ -212,34 +357,47 @@ final class DatapackStructureStateFilter {
         int salt = (int) declaredFieldValue(
                 StructurePlacement.class, placement, int.class);
 
-        if (placement instanceof ChunkGeneratorStructureState.KeyedRandomSpreadStructurePlacement keyedPlacement) {
+        if (placement.getClass()
+                == ChunkGeneratorStructureState.KeyedRandomSpreadStructurePlacement.class) {
+            ChunkGeneratorStructureState.KeyedRandomSpreadStructurePlacement keyedPlacement =
+                    (ChunkGeneratorStructureState.KeyedRandomSpreadStructurePlacement) placement;
+            NativeStructureFrequencyScale scale = NativeStructureFrequencyScale.randomSpread(
+                    frequency, keyedPlacement.spacing(), keyedPlacement.separation(), frequencyMultiplier);
             return new ChunkGeneratorStructureState.KeyedRandomSpreadStructurePlacement(
                     keyedPlacement.key,
                     locateOffset,
                     frequencyReductionMethod,
-                    frequency,
+                    scale.frequency(),
                     salt,
                     exclusionZone,
-                    keyedPlacement.spacing(),
+                    scale.spacing(),
                     keyedPlacement.separation(),
                     keyedPlacement.spreadType());
         }
-        if (placement instanceof RandomSpreadStructurePlacement randomSpread) {
+        if (placement.getClass() == RandomSpreadStructurePlacement.class) {
+            RandomSpreadStructurePlacement randomSpread =
+                    (RandomSpreadStructurePlacement) placement;
+            NativeStructureFrequencyScale scale = NativeStructureFrequencyScale.randomSpread(
+                    frequency, randomSpread.spacing(), randomSpread.separation(), frequencyMultiplier);
             return new RandomSpreadStructurePlacement(
                     locateOffset,
                     frequencyReductionMethod,
-                    frequency,
+                    scale.frequency(),
                     salt,
                     exclusionZone,
-                    randomSpread.spacing(),
+                    scale.spacing(),
                     randomSpread.separation(),
                     randomSpread.spreadType());
         }
-        if (placement instanceof ConcentricRingsStructurePlacement rings) {
+        if (placement.getClass() == ConcentricRingsStructurePlacement.class) {
+            ConcentricRingsStructurePlacement rings =
+                    (ConcentricRingsStructurePlacement) placement;
+            float scaledFrequency = NativeStructureFrequencyScale.probability(
+                    frequency, frequencyMultiplier);
             return new ConcentricRingsStructurePlacement(
                     locateOffset,
                     frequencyReductionMethod,
-                    frequency,
+                    scaledFrequency,
                     salt,
                     exclusionZone,
                     rings.distance(),
@@ -247,7 +405,8 @@ final class DatapackStructureStateFilter {
                     rings.count(),
                     rings.preferredBiomes());
         }
-        throw new IllegalStateException("Unsupported structure placement with an exclusion zone: "
+        throw new IllegalStateException("Unsupported native structure placement in an affected "
+                + "frequency-override or datapack-scope graph: "
                 + placement.getClass().getName());
     }
 
@@ -286,4 +445,15 @@ final class DatapackStructureStateFilter {
             int excludedManagedSets
     ) {
     }
+
+    private static final class ReboundStructureSetHolder extends Holder.Reference<StructureSet> {
+        private ReboundStructureSetHolder(ResourceKey<StructureSet> key) {
+            super(Type.STAND_ALONE, new HolderOwner<>() {
+            }, key, null);
+        }
+
+        private void bind(StructureSet structureSet) {
+            bindValue(structureSet);
+        }
+    }
 }

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/IrisChunkGenerator.java

@@ -788,7 +788,7 @@ public class IrisChunkGenerator extends CustomChunkGenerator {
             throw new IllegalStateException("Iris cannot generate native structures in chunk "
                     + disabledChunk.x() + "," + disabledChunk.z()
                     + " because structure generation is disabled outside the pack; enable native structure generation "
-                    + "and deny individual structures through importedStructures.disabled");
+                    + "and deny families through importedStructures.disabled or complete keys through importedStructures.disabledExact");
         }
         ChunkPos chunkPos = chunk.getPos();
         SectionPos sectionPos = SectionPos.of(chunkPos, world.getMinSectionY());

adapters/bukkit/nms/v26_2_R1/src/main/java/art/arcane/iris/core/nms/v26_2_R1/NMSBinding.java

@@ -6,6 +6,7 @@ import ca.spottedleaf.moonrise.patches.chunk_system.scheduling.NewChunkHolder;
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import art.arcane.iris.core.datapack.DatapackStructureScopeIndex;
 import art.arcane.iris.core.nms.DatapackStructureScopeResult;
+import art.arcane.iris.engine.object.IrisImportedStructureControl;
 import art.arcane.iris.spi.IrisLogging;
 import art.arcane.iris.core.nms.INMSBinding;
 import art.arcane.iris.core.nms.MinecraftVersion;
@@ -1221,7 +1222,8 @@ public class NMSBinding implements INMSBinding {
     public DatapackStructureScopeResult scopeDatapackStructures(
             World world,
             DatapackStructureScopeIndex scopeIndex,
-            Set<String> declaredSources
+            Set<String> declaredSources,
+            IrisImportedStructureControl importedStructures
     ) throws NoSuchFieldException, IllegalAccessException {
         ServerLevel level = ((CraftWorld) world).getHandle();
         ChunkMap chunkMap = level.getChunkSource().chunkMap;
@@ -1229,7 +1231,7 @@ public class NMSBinding implements INMSBinding {
         net.minecraft.world.level.chunk.ChunkGenerator generator = level.getChunkSource().getGenerator();
         ChunkGeneratorStructureState scopedState = createStructureState(level, generator, currentState);
         DatapackStructureStateFilter.Selection selection = DatapackStructureStateFilter.filter(
-                scopedState.possibleStructureSets(), scopeIndex, declaredSources);
+                scopedState.possibleStructureSets(), scopeIndex, declaredSources, importedStructures);
 
         Field possibleSetsField = getField(scopedState.getClass(), List.class);
         possibleSetsField.setAccessible(true);

adapters/bukkit/nms/v26_2_R1/src/test/java/art/arcane/iris/core/nms/v26_2_R1/NMSBindingDatapackStructureScopeTest.java

@@ -2,6 +2,9 @@ package art.arcane.iris.core.nms.v26_2_R1;
 
 import art.arcane.iris.core.datapack.DatapackIngestService;
 import art.arcane.iris.core.datapack.DatapackStructureScopeIndex;
+import art.arcane.iris.engine.object.IrisImportedStructureControl;
+import art.arcane.iris.engine.object.IrisStructureSetFrequencyOverride;
+import art.arcane.volmlib.util.collection.KList;
 import com.mojang.datafixers.util.Either;
 import net.minecraft.SharedConstants;
 import net.minecraft.core.Holder;
@@ -18,6 +21,7 @@ import net.minecraft.world.level.levelgen.structure.StructureSet;
 import net.minecraft.world.level.levelgen.structure.placement.RandomSpreadStructurePlacement;
 import net.minecraft.world.level.levelgen.structure.placement.RandomSpreadType;
 import net.minecraft.world.level.levelgen.structure.placement.StructurePlacement;
+import net.minecraft.world.level.levelgen.structure.placement.StructurePlacementType;
 import net.minecraft.world.level.chunk.ChunkGeneratorStructureState;
 import org.junit.Test;
 import org.junit.BeforeClass;
@@ -33,7 +37,9 @@ import java.util.stream.Stream;
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotSame;
 import static org.junit.Assert.assertSame;
+import static org.junit.Assert.assertThrows;
 import static org.junit.Assert.assertTrue;
 
 public class NMSBindingDatapackStructureScopeTest {
@@ -126,6 +132,161 @@ public class NMSBindingDatapackStructureScopeTest {
                 DatapackStructureStateFilter.structureSetKey(Holder.direct(structureSet)));
     }
 
+    @Test
+    public void exactFrequencyOverridesScaleOnlyTheNamedNativeStructureSet() {
+        Holder<StructureSet> complexes = structureSetHolder(
+                "minecraft:nether_complexes",
+                new RandomSpreadStructurePlacement(27, 4, RandomSpreadType.LINEAR, 30084232),
+                structureHolder("minecraft:fortress"));
+        Holder<StructureSet> fossils = structureSetHolder(
+                "minecraft:nether_fossils",
+                new RandomSpreadStructurePlacement(2, 1, RandomSpreadType.LINEAR, 14357921),
+                structureHolder("minecraft:nether_fossil"));
+        KList<IrisStructureSetFrequencyOverride> overrides = new KList<>();
+        overrides.add(new IrisStructureSetFrequencyOverride()
+                .setStructureSet("minecraft:nether_complexes")
+                .setMultiplier(1.1D));
+        IrisImportedStructureControl control = new IrisImportedStructureControl()
+                .setFrequencyOverrides(overrides);
+
+        DatapackStructureStateFilter.Selection selection = DatapackStructureStateFilter.filter(
+                List.of(complexes, fossils), index(List.of(), List.of()), Set.of(), control);
+
+        RandomSpreadStructurePlacement scaledComplexes =
+                (RandomSpreadStructurePlacement) selection.structureSets().get(0).value().placement();
+        RandomSpreadStructurePlacement unchangedFossils =
+                (RandomSpreadStructurePlacement) selection.structureSets().get(1).value().placement();
+        assertEquals(26, scaledComplexes.spacing());
+        assertEquals(4, scaledComplexes.separation());
+        assertEquals(2, unchangedFossils.spacing());
+        assertSame(fossils, selection.structureSets().get(1));
+        assertEquals(27, ((RandomSpreadStructurePlacement) complexes.value().placement()).spacing());
+    }
+
+    @Test
+    public void frequencyOnlyPassLeavesUnrelatedCustomPlacementUntouched() {
+        Holder<StructureSet> exclusionTarget = structureSetHolder(
+                "example:target", structureHolder("example:target"));
+        Holder<StructureSet> custom = structureSetHolder(
+                "example:custom",
+                new UnsupportedPlacement(Optional.of(
+                        new StructurePlacement.ExclusionZone(exclusionTarget, 1))),
+                structureHolder("example:custom"));
+        KList<IrisStructureSetFrequencyOverride> overrides = new KList<>();
+        overrides.add(new IrisStructureSetFrequencyOverride()
+                .setStructureSet("minecraft:nether_complexes")
+                .setMultiplier(1.1D));
+        IrisImportedStructureControl control = new IrisImportedStructureControl()
+                .setFrequencyOverrides(overrides);
+
+        DatapackStructureStateFilter.Selection selection = DatapackStructureStateFilter.filter(
+                List.of(custom), index(List.of(), List.of()), Set.of(), control);
+
+        assertSame(custom, selection.structureSets().getFirst());
+    }
+
+    @Test
+    public void frequencyOnlyPassRebindsDependentExclusionTarget() {
+        Holder<StructureSet> target = structureSetHolder(
+                "example:target",
+                new RandomSpreadStructurePlacement(27, 4, RandomSpreadType.LINEAR, 30084232),
+                structureHolder("example:target"));
+        RandomSpreadStructurePlacement dependentPlacement = new RandomSpreadStructurePlacement(
+                Vec3i.ZERO,
+                StructurePlacement.FrequencyReductionMethod.DEFAULT,
+                1.0F,
+                4567,
+                Optional.of(new StructurePlacement.ExclusionZone(target, 1)),
+                32,
+                8,
+                RandomSpreadType.LINEAR);
+        Holder<StructureSet> dependent = structureSetHolder(
+                "example:dependent",
+                dependentPlacement,
+                structureHolder("example:dependent"));
+        KList<IrisStructureSetFrequencyOverride> overrides = new KList<>();
+        overrides.add(new IrisStructureSetFrequencyOverride()
+                .setStructureSet("example:target")
+                .setMultiplier(1.1D));
+        IrisImportedStructureControl control = new IrisImportedStructureControl()
+                .setFrequencyOverrides(overrides);
+
+        DatapackStructureStateFilter.Selection selection = DatapackStructureStateFilter.filter(
+                List.of(dependent, target), index(List.of(), List.of()), Set.of(), control);
+
+        Holder<StructureSet> scaledDependent = selection.structureSets().get(0);
+        Holder<StructureSet> scaledTarget = selection.structureSets().get(1);
+        assertNotSame(dependent, scaledDependent);
+        assertNotSame(target, scaledTarget);
+        assertSame(scaledTarget, DatapackStructureStateFilter.exclusionZone(
+                scaledDependent.value().placement()).orElseThrow().otherSet());
+        assertEquals(26, ((RandomSpreadStructurePlacement)
+                scaledTarget.value().placement()).spacing());
+    }
+
+    @Test
+    public void frequencyOnlyPassRebindsAffectedExclusionCycle() {
+        MutableStructureSetHolder first = new MutableStructureSetHolder("example:first");
+        MutableStructureSetHolder second = new MutableStructureSetHolder("example:second");
+        first.bind(structureSet(
+                new RandomSpreadStructurePlacement(
+                        Vec3i.ZERO,
+                        StructurePlacement.FrequencyReductionMethod.DEFAULT,
+                        1.0F,
+                        101,
+                        Optional.of(new StructurePlacement.ExclusionZone(second, 1)),
+                        32,
+                        8,
+                        RandomSpreadType.LINEAR),
+                "example:first"));
+        second.bind(structureSet(
+                new RandomSpreadStructurePlacement(
+                        Vec3i.ZERO,
+                        StructurePlacement.FrequencyReductionMethod.DEFAULT,
+                        1.0F,
+                        102,
+                        Optional.of(new StructurePlacement.ExclusionZone(first, 1)),
+                        27,
+                        4,
+                        RandomSpreadType.LINEAR),
+                "example:second"));
+        KList<IrisStructureSetFrequencyOverride> overrides = new KList<>();
+        overrides.add(new IrisStructureSetFrequencyOverride()
+                .setStructureSet("example:second")
+                .setMultiplier(1.1D));
+        IrisImportedStructureControl control = new IrisImportedStructureControl()
+                .setFrequencyOverrides(overrides);
+
+        DatapackStructureStateFilter.Selection selection = DatapackStructureStateFilter.filter(
+                List.of(first, second), index(List.of(), List.of()), Set.of(), control);
+
+        Holder<StructureSet> scaledFirst = selection.structureSets().get(0);
+        Holder<StructureSet> scaledSecond = selection.structureSets().get(1);
+        assertSame(scaledSecond, DatapackStructureStateFilter.exclusionZone(
+                scaledFirst.value().placement()).orElseThrow().otherSet());
+        assertSame(scaledFirst, DatapackStructureStateFilter.exclusionZone(
+                scaledSecond.value().placement()).orElseThrow().otherSet());
+        assertEquals(26, ((RandomSpreadStructurePlacement)
+                scaledSecond.value().placement()).spacing());
+    }
+
+    @Test
+    public void affectedRandomSpreadSubclassFailsInsteadOfLosingSubtypeBehavior() {
+        Holder<StructureSet> custom = structureSetHolder(
+                "example:custom",
+                new CustomRandomSpreadPlacement(),
+                structureHolder("example:custom"));
+        KList<IrisStructureSetFrequencyOverride> overrides = new KList<>();
+        overrides.add(new IrisStructureSetFrequencyOverride()
+                .setStructureSet("example:custom")
+                .setMultiplier(1.1D));
+        IrisImportedStructureControl control = new IrisImportedStructureControl()
+                .setFrequencyOverrides(overrides);
+
+        assertThrows(IllegalStateException.class, () -> DatapackStructureStateFilter.filter(
+                List.of(custom), index(List.of(), List.of()), Set.of(), control));
+    }
+
     @Test
     public void excludedManagedSetCannotSuppressAnAllowedSetThroughExclusionZone() {
         Holder<StructureSet> managedSet = structureSetHolder(
@@ -273,6 +434,13 @@ public class NMSBindingDatapackStructureScopeTest {
                 value);
     }
 
+    private static StructureSet structureSet(StructurePlacement placement, String structureKey) {
+        return new StructureSet(
+                List.of(new StructureSet.StructureSelectionEntry(
+                        structureHolder(structureKey), 1)),
+                placement);
+    }
+
     private static final class KeyedHolder<T> implements Holder<T> {
         private final ResourceKey<T> key;
         private final T value;
@@ -352,4 +520,37 @@ public class NMSBindingDatapackStructureScopeTest {
             return true;
         }
     }
+
+    private static final class UnsupportedPlacement extends StructurePlacement {
+        private UnsupportedPlacement(Optional<ExclusionZone> exclusionZone) {
+            super(Vec3i.ZERO, FrequencyReductionMethod.DEFAULT, 1F, 1, exclusionZone);
+        }
+
+        @Override
+        protected boolean isPlacementChunk(ChunkGeneratorStructureState state, int x, int z) {
+            return false;
+        }
+
+        @Override
+        public StructurePlacementType<?> type() {
+            return null;
+        }
+    }
+
+    private static final class MutableStructureSetHolder extends Holder.Reference<StructureSet> {
+        private MutableStructureSetHolder(String key) {
+            super(Type.STAND_ALONE, new HolderOwner<>() {
+            }, ResourceKey.create(Registries.STRUCTURE_SET, Identifier.parse(key)), null);
+        }
+
+        private void bind(StructureSet structureSet) {
+            bindValue(structureSet);
+        }
+    }
+
+    private static final class CustomRandomSpreadPlacement extends RandomSpreadStructurePlacement {
+        private CustomRandomSpreadPlacement() {
+            super(27, 4, RandomSpreadType.LINEAR, 30084232);
+        }
+    }
 }