Updated Bukkit to 1.21.7

platforms/bukkit/nms/v1_21_7/build.gradle.kts

@@ -0,0 +1,9 @@
+plugins {
+    id("io.papermc.paperweight.userdev")
+}
+
+dependencies {
+    api(project(":platforms:bukkit:common"))
+    paperweight.paperDevBundle(Versions.Bukkit.paperDevBundle)
+    implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/AwfulBukkitHacks.java

@@ -0,0 +1,152 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import com.dfsek.terra.bukkit.nms.v1_21_7.config.VanillaBiomeProperties;
+
+import com.dfsek.terra.bukkit.world.BukkitBiomeInfo;
+
+import net.minecraft.core.Holder;
+import net.minecraft.core.Holder.Reference;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.HolderSet.Named;
+import net.minecraft.core.MappedRegistry;
+import net.minecraft.core.RegistrationInfo;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.biome.Biome;
+import org.bukkit.NamespacedKey;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.IdentityHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+import com.dfsek.terra.bukkit.world.BukkitPlatformBiome;
+import com.dfsek.terra.registry.master.ConfigRegistry;
+
+
+public class AwfulBukkitHacks {
+    private static final Logger LOGGER = LoggerFactory.getLogger(AwfulBukkitHacks.class);
+
+    private static final Map<ResourceLocation, List<ResourceLocation>> terraBiomeMap = new HashMap<>();
+
+    public static void registerBiomes(ConfigRegistry configRegistry) {
+        try {
+            LOGGER.info("Hacking biome registry...");
+            MappedRegistry<Biome> biomeRegistry = (MappedRegistry<Biome>) RegistryFetcher.biomeRegistry();
+
+            // Unfreeze the biome registry to allow modification
+            Reflection.MAPPED_REGISTRY.setFrozen(biomeRegistry, false);
+
+            // Register the terra biomes to the registry
+            configRegistry.forEach(pack -> pack.getRegistry(com.dfsek.terra.api.world.biome.Biome.class).forEach((key, biome) -> {
+                try {
+                    BukkitPlatformBiome platformBiome = (BukkitPlatformBiome) biome.getPlatformBiome();
+                    NamespacedKey vanillaBukkitKey = platformBiome.getHandle().getKey();
+                    ResourceLocation vanillaMinecraftKey = ResourceLocation.fromNamespaceAndPath(vanillaBukkitKey.getNamespace(),
+                        vanillaBukkitKey.getKey());
+
+                    VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
+
+                    Biome platform = NMSBiomeInjector.createBiome(biomeRegistry.get(vanillaMinecraftKey).orElseThrow().value(), vanillaBiomeProperties);
+
+                    ResourceLocation delegateMinecraftKey = ResourceLocation.fromNamespaceAndPath("terra", NMSBiomeInjector.createBiomeID(pack, key));
+                    NamespacedKey delegateBukkitKey = NamespacedKey.fromString(delegateMinecraftKey.toString());
+                    ResourceKey<Biome> delegateKey = ResourceKey.create(Registries.BIOME, delegateMinecraftKey);
+
+                    Reference<Biome> holder = biomeRegistry.register(delegateKey, platform, RegistrationInfo.BUILT_IN);
+                    Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder.
+
+                    platformBiome.getContext().put(new BukkitBiomeInfo(delegateBukkitKey));
+                    platformBiome.getContext().put(new NMSBiomeInfo(delegateKey));
+
+                    terraBiomeMap.computeIfAbsent(vanillaMinecraftKey, i -> new ArrayList<>()).add(delegateKey.location());
+
+                    LOGGER.debug("Registered biome: " + delegateKey);
+                } catch(NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException e) {
+                    throw new RuntimeException(e);
+                }
+            }));
+
+            Reflection.MAPPED_REGISTRY.setFrozen(biomeRegistry, true); // freeze registry again :)
+
+            LOGGER.info("Doing tag garbage....");
+            Map<TagKey<Biome>, List<Holder<Biome>>> collect = biomeRegistry
+                .getTags() // streamKeysAndEntries
+                .collect(HashMap::new,
+                    (map, pair) ->
+                        map.put(pair.key(), new ArrayList<>(Reflection.HOLDER_SET.invokeContents(pair).stream().toList())),
+                    HashMap::putAll);
+
+            terraBiomeMap
+                .forEach((vb, terraBiomes) ->
+                    NMSBiomeInjector.getEntry(biomeRegistry, vb).ifPresentOrElse(
+                        vanilla -> terraBiomes.forEach(
+                            tb -> NMSBiomeInjector.getEntry(biomeRegistry, tb).ifPresentOrElse(
+                                terra -> {
+                                    LOGGER.debug("{} (vanilla for {}): {}",
+                                        vanilla.unwrapKey().orElseThrow().location(),
+                                        terra.unwrapKey().orElseThrow().location(),
+                                        vanilla.tags().toList());
+                                    vanilla.tags()
+                                        .forEach(tag -> collect
+                                            .computeIfAbsent(tag, t -> new ArrayList<>())
+                                            .add(terra));
+                                },
+                                () -> LOGGER.error("No such biome: {}", tb))),
+                        () -> LOGGER.error("No vanilla biome: {}", vb)));
+
+            resetTags(biomeRegistry);
+            bindTags(biomeRegistry, collect);
+
+        } catch(SecurityException | IllegalArgumentException exception) {
+            throw new RuntimeException(exception);
+        }
+    }
+
+    private static <T> void bindTags(MappedRegistry<T> registry, Map<TagKey<T>, List<Holder<T>>> tagEntries) {
+        Map<Holder.Reference<T>, List<TagKey<T>>> map = new IdentityHashMap<>();
+        Reflection.MAPPED_REGISTRY.getByKey(registry).values().forEach(entry -> map.put(entry, new ArrayList<>()));
+        tagEntries.forEach((tag, entries) -> {
+            for (Holder<T> holder : entries) {
+//                if (!holder.canSerializeIn(registry.asLookup())) {
+//                    throw new IllegalStateException("Can't create named set " + tag + " containing value " + holder + " from outside registry " + this);
+//                }
+
+                if (!(holder instanceof Holder.Reference<T> reference)) {
+                    throw new IllegalStateException("Found direct holder " + holder + " value in tag " + tag);
+                }
+
+                map.get(reference).add(tag);
+            }
+        });
+//        Set<TagKey<T>> set = Sets.difference(registry.tags.keySet(), tagEntries.keySet());
+//        if (!set.isEmpty()) {
+//            LOGGER.warn(
+//                "Not all defined tags for registry {} are present in data pack: {}",
+//                registry.key(),
+//                set.stream().map(tag -> tag.location().toString()).sorted().collect(Collectors.joining(", "))
+//            );
+//        }
+
+        Map<TagKey<T>, HolderSet.Named<T>> map2 = new IdentityHashMap<>(registry.getTags().collect(Collectors.toMap(
+            Named::key,
+            (named) -> named
+        )));
+        tagEntries.forEach((tag, entries) -> Reflection.HOLDER_SET.invokeBind(map2.computeIfAbsent(tag, key -> Reflection.MAPPED_REGISTRY.invokeCreateTag(registry, key)), entries));
+        map.forEach(Reflection.HOLDER_REFERENCE::invokeBindTags);
+        Reflection.MAPPED_REGISTRY.setAllTags(registry, Reflection.MAPPED_REGISTRY_TAG_SET.invokeFromMap(map2));
+    }
+
+    private static void resetTags(MappedRegistry<?> registry) {
+        registry.getTags().forEach(entryList -> Reflection.HOLDER_SET.invokeBind(entryList, List.of()));
+        Reflection.MAPPED_REGISTRY.getByKey(registry).values().forEach(entry -> Reflection.HOLDER_REFERENCE.invokeBindTags(entry, Set.of()));
+    }
+}
+

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSAddon.java

@@ -0,0 +1,31 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import com.dfsek.terra.api.event.events.config.ConfigurationLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.bukkit.BukkitAddon;
+import com.dfsek.terra.bukkit.PlatformImpl;
+import com.dfsek.terra.bukkit.nms.v1_21_7.config.VanillaBiomeProperties;
+
+
+public class NMSAddon extends BukkitAddon {
+
+    public NMSAddon(PlatformImpl platform) {
+        super(platform);
+    }
+
+    @Override
+    public void initialize() {
+        super.initialize();
+
+        terraBukkitPlugin.getEventManager()
+            .getHandler(FunctionalEventHandler.class)
+            .register(this, ConfigurationLoadEvent.class)
+            .then(event -> {
+                if(event.is(Biome.class)) {
+                    event.getLoadedObject(Biome.class).getContext().put(event.load(new VanillaBiomeProperties()));
+                }
+            })
+            .global();
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSBiomeInfo.java

@@ -0,0 +1,10 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.world.level.biome.Biome;
+
+import com.dfsek.terra.api.properties.Properties;
+
+
+public record NMSBiomeInfo(ResourceKey<Biome> biomeKey) implements Properties {
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSBiomeInjector.java

@@ -0,0 +1,101 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import net.minecraft.core.Holder;
+import net.minecraft.core.Registry;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeGenerationSettings;
+import net.minecraft.world.level.biome.BiomeSpecialEffects;
+
+import java.util.Locale;
+import java.util.Objects;
+import java.util.Optional;
+
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.bukkit.nms.v1_21_7.config.VanillaBiomeProperties;
+
+
+public class NMSBiomeInjector {
+
+    public static <T> Optional<Holder<T>> getEntry(Registry<T> registry, ResourceLocation identifier) {
+        return registry.getOptional(identifier)
+            .flatMap(registry::getResourceKey)
+            .flatMap(registry::get);
+    }
+
+    public static Biome createBiome(Biome vanilla, VanillaBiomeProperties vanillaBiomeProperties)
+    throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
+        Biome.BiomeBuilder builder = new Biome.BiomeBuilder();
+
+        BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder();
+
+        effects.fogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getFogColor(), vanilla.getFogColor()))
+            .waterColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterColor(), vanilla.getWaterColor()))
+            .waterFogColor(Objects.requireNonNullElse(vanillaBiomeProperties.getWaterFogColor(), vanilla.getWaterFogColor()))
+            .skyColor(Objects.requireNonNullElse(vanillaBiomeProperties.getSkyColor(), vanilla.getSkyColor()))
+            .grassColorModifier(Objects.requireNonNullElse(vanillaBiomeProperties.getGrassColorModifier(), vanilla.getSpecialEffects().getGrassColorModifier()))
+            .backgroundMusicVolume(Objects.requireNonNullElse(vanillaBiomeProperties.getMusicVolume(), vanilla.getBackgroundMusicVolume()));
+
+        if(vanillaBiomeProperties.getGrassColor() == null) {
+            vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride);
+        } else {
+            effects.grassColorOverride(vanillaBiomeProperties.getGrassColor());
+        }
+
+        if(vanillaBiomeProperties.getFoliageColor() == null) {
+            vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride);
+        } else {
+            effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor());
+        }
+
+        if(vanillaBiomeProperties.getParticleConfig() == null) {
+            vanilla.getSpecialEffects().getAmbientParticleSettings().ifPresent(effects::ambientParticle);
+        } else {
+            effects.ambientParticle(vanillaBiomeProperties.getParticleConfig());
+        }
+
+        if(vanillaBiomeProperties.getLoopSound() == null) {
+            vanilla.getSpecialEffects().getAmbientLoopSoundEvent().ifPresent(effects::ambientLoopSound);
+        } else {
+            RegistryFetcher.soundEventRegistry().get(vanillaBiomeProperties.getLoopSound().location()).ifPresent(effects::ambientLoopSound);
+        }
+
+        if(vanillaBiomeProperties.getMoodSound() == null) {
+            vanilla.getSpecialEffects().getAmbientMoodSettings().ifPresent(effects::ambientMoodSound);
+        } else {
+            effects.ambientMoodSound(vanillaBiomeProperties.getMoodSound());
+        }
+
+        if(vanillaBiomeProperties.getAdditionsSound() == null) {
+            vanilla.getSpecialEffects().getAmbientAdditionsSettings().ifPresent(effects::ambientAdditionsSound);
+        } else {
+            effects.ambientAdditionsSound(vanillaBiomeProperties.getAdditionsSound());
+        }
+
+        if(vanillaBiomeProperties.getMusic() == null) {
+            vanilla.getSpecialEffects().getBackgroundMusic().ifPresent(effects::backgroundMusic);
+        } else {
+            effects.backgroundMusic(vanillaBiomeProperties.getMusic());
+        }
+
+        builder.hasPrecipitation(Objects.requireNonNullElse(vanillaBiomeProperties.getPrecipitation(), vanilla.hasPrecipitation()));
+
+        builder.temperature(Objects.requireNonNullElse(vanillaBiomeProperties.getTemperature(), vanilla.getBaseTemperature()));
+
+        builder.downfall(Objects.requireNonNullElse(vanillaBiomeProperties.getDownfall(), vanilla.climateSettings.downfall()));
+
+        builder.temperatureAdjustment(Objects.requireNonNullElse(vanillaBiomeProperties.getTemperatureModifier(), vanilla.climateSettings.temperatureModifier()));
+
+        builder.mobSpawnSettings(Objects.requireNonNullElse(vanillaBiomeProperties.getSpawnSettings(), vanilla.getMobSettings()));
+
+        return builder
+            .specialEffects(effects.build())
+            .generationSettings(new BiomeGenerationSettings.PlainBuilder().build())
+            .build();
+    }
+
+    public static String createBiomeID(ConfigPack pack, com.dfsek.terra.api.registry.key.RegistryKey biomeID) {
+        return pack.getID()
+                   .toLowerCase() + "/" + biomeID.getNamespace().toLowerCase(Locale.ROOT) + "/" + biomeID.getID().toLowerCase(Locale.ROOT);
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSBiomeProvider.java

@@ -0,0 +1,53 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.Holder;
+import net.minecraft.core.Registry;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.biome.Climate.Sampler;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.stream.Stream;
+
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.bukkit.world.BukkitPlatformBiome;
+
+
+public class NMSBiomeProvider extends BiomeSource {
+    private final BiomeProvider delegate;
+    private final long seed;
+    private final Registry<Biome> biomeRegistry = RegistryFetcher.biomeRegistry();
+
+    public NMSBiomeProvider(BiomeProvider delegate, long seed) {
+        super();
+        this.delegate = delegate;
+        this.seed = seed;
+    }
+
+    @Override
+    protected Stream<Holder<Biome>> collectPossibleBiomes() {
+        return delegate.stream()
+            .map(biome -> RegistryFetcher.biomeRegistry()
+                .getOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext()
+                    .get(NMSBiomeInfo.class)
+                    .biomeKey()));
+    }
+
+    @Override
+    protected @NotNull MapCodec<? extends BiomeSource> codec() {
+        return MapCodec.assumeMapUnsafe(BiomeSource.CODEC);
+        //        return MapCodec.unit(null);
+        //        BuiltInRegistries.BIOME_SOURCE.byNameCodec().dispatchMap(this::codec, Function.identity());
+        //        BuiltInRegistries.BIOME_SOURCE.byNameCodec().dispatchStable(BiomeSource::codec, Function.identity());
+        //        return BiomeSource.CODEC;
+    }
+
+    @Override
+    public @NotNull Holder<Biome> getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) {
+        return biomeRegistry.getOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed)
+            .getPlatformBiome()).getContext()
+            .get(NMSBiomeInfo.class)
+            .biomeKey());
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSChunkGeneratorDelegate.java

@@ -0,0 +1,169 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import com.mojang.serialization.MapCodec;
+import net.minecraft.core.BlockPos;
+import net.minecraft.server.level.WorldGenRegion;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.LevelHeightAccessor;
+import net.minecraft.world.level.NoiseColumn;
+import net.minecraft.world.level.StructureManager;
+import net.minecraft.world.level.WorldGenLevel;
+import net.minecraft.world.level.biome.BiomeManager;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.levelgen.Beardifier;
+import net.minecraft.world.level.levelgen.DensityFunction.SinglePointContext;
+import net.minecraft.world.level.levelgen.Heightmap.Types;
+import net.minecraft.world.level.levelgen.RandomState;
+import net.minecraft.world.level.levelgen.blending.Blender;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+import com.dfsek.terra.api.world.info.WorldProperties;
+import com.dfsek.terra.bukkit.config.PreLoadCompatibilityOptions;
+import com.dfsek.terra.bukkit.world.BukkitWorldProperties;
+import com.dfsek.terra.bukkit.world.block.data.BukkitBlockState;
+
+
+public class NMSChunkGeneratorDelegate extends ChunkGenerator {
+    private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class);
+    private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate;
+
+    private final ChunkGenerator vanilla;
+    private final ConfigPack pack;
+
+    private final long seed;
+
+    public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) {
+        super(biomeProvider);
+        this.delegate = pack.getGeneratorProvider().newInstance(pack);
+        this.vanilla = vanilla;
+        this.pack = pack;
+        this.seed = seed;
+    }
+
+    @Override
+    protected @NotNull MapCodec<? extends ChunkGenerator> codec() {
+        return MapCodec.assumeMapUnsafe(ChunkGenerator.CODEC);
+    }
+
+    @Override
+    public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world,
+                             @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) {
+        // no-op
+    }
+
+    @Override
+    public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureManager structures, @NotNull RandomState noiseConfig,
+                             @NotNull ChunkAccess chunk) {
+        // no-op
+    }
+
+    @Override
+    public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk,
+                                     @NotNull StructureManager structureAccessor) {
+        vanilla.applyBiomeDecoration(world, chunk, structureAccessor);
+    }
+
+    @Override
+    public void spawnOriginalMobs(@NotNull WorldGenRegion region) {
+        vanilla.spawnOriginalMobs(region);
+    }
+
+    @Override
+    public int getGenDepth() {
+        return vanilla.getGenDepth();
+    }
+
+    @Override
+    public CompletableFuture<ChunkAccess> fillFromNoise(@NotNull Blender blender,
+                                                        @NotNull RandomState noiseConfig,
+                                                        @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) {
+        return vanilla.fillFromNoise(blender, noiseConfig, structureAccessor, chunk)
+            .thenApply(c -> {
+                LevelAccessor level = Reflection.STRUCTURE_MANAGER.getLevel(structureAccessor);
+                BiomeProvider biomeProvider = pack.getBiomeProvider();
+                PreLoadCompatibilityOptions compatibilityOptions = pack.getContext().get(PreLoadCompatibilityOptions.class);
+                if(compatibilityOptions.isBeard()) {
+                    beard(structureAccessor, chunk, new BukkitWorldProperties(level.getMinecraftWorld().getWorld()),
+                        biomeProvider, compatibilityOptions);
+                }
+                return c;
+            });
+    }
+
+    private void beard(StructureManager structureAccessor, ChunkAccess chunk, WorldProperties world, BiomeProvider biomeProvider,
+                       PreLoadCompatibilityOptions compatibilityOptions) {
+        Beardifier structureWeightSampler = Beardifier.forStructuresInChunk(structureAccessor, chunk.getPos());
+        double threshold = compatibilityOptions.getBeardThreshold();
+        double airThreshold = compatibilityOptions.getAirThreshold();
+        int xi = chunk.getPos().x << 4;
+        int zi = chunk.getPos().z << 4;
+        for(int x = 0; x < 16; x++) {
+            for(int z = 0; z < 16; z++) {
+                int depth = 0;
+                for(int y = world.getMaxHeight(); y >= world.getMinHeight(); y--) {
+                    double noise = structureWeightSampler.compute(new SinglePointContext(x + xi, y, z + zi));
+                    if(noise > threshold) {
+                        chunk.setBlockState(new BlockPos(x, y, z), ((CraftBlockData) ((BukkitBlockState) delegate
+                            .getPalette(x + xi, y, z + zi, world, biomeProvider)
+                            .get(depth, x + xi, y, z + zi, world.getSeed())).getHandle()).getState(), 0);
+                        depth++;
+                    } else if(noise < airThreshold) {
+                        chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), 0);
+                    } else {
+                        depth = 0;
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    public int getSeaLevel() {
+        return vanilla.getSeaLevel();
+    }
+
+    @Override
+    public int getMinY() {
+        return vanilla.getMinY();
+    }
+
+    @Override
+    public int getBaseHeight(int x, int z, @NotNull Types heightmap, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) {
+        WorldProperties properties = new NMSWorldProperties(seed, world);
+        int y = properties.getMaxHeight();
+        BiomeProvider biomeProvider = pack.getBiomeProvider();
+        while(y >= getMinY() && !heightmap.isOpaque().test(
+            ((CraftBlockData) delegate.getBlock(properties, x, y - 1, z, biomeProvider).getHandle()).getState())) {
+            y--;
+        }
+        return y;
+    }
+
+    @Override
+    public @NotNull NoiseColumn getBaseColumn(int x, int z, @NotNull LevelHeightAccessor world, @NotNull RandomState noiseConfig) {
+        BlockState[] array = new BlockState[world.getHeight()];
+        WorldProperties properties = new NMSWorldProperties(seed, world);
+        BiomeProvider biomeProvider = pack.getBiomeProvider();
+        for(int y = properties.getMaxHeight(); y >= properties.getMinHeight(); y--) {
+            array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider)
+                .getHandle()).getState();
+        }
+        return new NoiseColumn(getMinY(), array);
+    }
+
+    @Override
+    public void addDebugScreenInfo(@NotNull List<String> text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) {
+
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSInitializer.java

@@ -0,0 +1,22 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import com.dfsek.terra.bukkit.BukkitAddon;
+
+import org.bukkit.Bukkit;
+
+import com.dfsek.terra.bukkit.PlatformImpl;
+import com.dfsek.terra.bukkit.nms.Initializer;
+
+
+public class NMSInitializer implements Initializer {
+    @Override
+    public void initialize(PlatformImpl platform) {
+        AwfulBukkitHacks.registerBiomes(platform.getRawConfigRegistry());
+        Bukkit.getPluginManager().registerEvents(new NMSInjectListener(), platform.getPlugin());
+    }
+
+    @Override
+    public BukkitAddon getNMSAddon(PlatformImpl plugin) {
+        return new NMSAddon(plugin);
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSInjectListener.java

@@ -0,0 +1,58 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import net.minecraft.server.level.ChunkMap;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.level.chunk.ChunkGenerator;
+import net.minecraft.world.level.chunk.status.WorldGenContext;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldInitEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.locks.ReentrantLock;
+
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.bukkit.generator.BukkitChunkGeneratorWrapper;
+
+
+public class NMSInjectListener implements Listener {
+    private static final Logger LOGGER = LoggerFactory.getLogger(NMSInjectListener.class);
+    private static final Set<World> INJECTED = new HashSet<>();
+    private static final ReentrantLock INJECT_LOCK = new ReentrantLock();
+
+    @EventHandler
+    public void onWorldInit(WorldInitEvent event) {
+        if(!INJECTED.contains(event.getWorld()) &&
+           event.getWorld().getGenerator() instanceof BukkitChunkGeneratorWrapper bukkitChunkGeneratorWrapper) {
+            INJECT_LOCK.lock();
+            INJECTED.add(event.getWorld());
+            LOGGER.info("Preparing to take over the world: {}", event.getWorld().getName());
+            CraftWorld craftWorld = (CraftWorld) event.getWorld();
+            ServerLevel serverWorld = craftWorld.getHandle();
+
+            ConfigPack pack = bukkitChunkGeneratorWrapper.getPack();
+
+            ChunkGenerator vanilla = serverWorld.getChunkSource().getGenerator();
+            NMSBiomeProvider provider = new NMSBiomeProvider(pack.getBiomeProvider(), craftWorld.getSeed());
+            ChunkMap chunkMap = serverWorld.getChunkSource().chunkMap;
+            WorldGenContext worldGenContext = Reflection.CHUNKMAP.getWorldGenContext(chunkMap);
+            Reflection.CHUNKMAP.setWorldGenContext(chunkMap, new WorldGenContext(
+                worldGenContext.level(),
+                new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed()),
+                worldGenContext.structureManager(),
+                worldGenContext.lightEngine(),
+                worldGenContext.mainThreadExecutor(),
+                worldGenContext.unsavedListener()
+            ));
+
+            LOGGER.info("Successfully injected into world.");
+
+            INJECT_LOCK.unlock();
+        }
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/NMSWorldProperties.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import net.minecraft.world.level.LevelHeightAccessor;
+
+import com.dfsek.terra.api.world.info.WorldProperties;
+
+
+public class NMSWorldProperties implements WorldProperties {
+    private final long seed;
+    private final LevelHeightAccessor height;
+
+    public NMSWorldProperties(long seed, LevelHeightAccessor height) {
+        this.seed = seed;
+        this.height = height;
+    }
+
+    @Override
+    public Object getHandle() {
+        return height;
+    }
+
+    @Override
+    public long getSeed() {
+        return seed;
+    }
+
+    @Override
+    public int getMaxHeight() {
+        return height.getMaxY();
+    }
+
+    @Override
+    public int getMinHeight() {
+        return height.getMinY();
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/Reflection.java

@@ -0,0 +1,124 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import net.minecraft.core.Holder;
+import net.minecraft.core.Holder.Reference;
+import net.minecraft.core.HolderSet;
+import net.minecraft.core.MappedRegistry;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.level.ChunkMap;
+import net.minecraft.tags.TagKey;
+import net.minecraft.world.level.LevelAccessor;
+import net.minecraft.world.level.StructureManager;
+import net.minecraft.world.level.biome.Biome;
+import net.minecraft.world.level.chunk.status.WorldGenContext;
+import xyz.jpenilla.reflectionremapper.ReflectionRemapper;
+import xyz.jpenilla.reflectionremapper.proxy.ReflectionProxyFactory;
+import xyz.jpenilla.reflectionremapper.proxy.annotation.FieldGetter;
+import xyz.jpenilla.reflectionremapper.proxy.annotation.FieldSetter;
+import xyz.jpenilla.reflectionremapper.proxy.annotation.MethodName;
+import xyz.jpenilla.reflectionremapper.proxy.annotation.Proxies;
+import xyz.jpenilla.reflectionremapper.proxy.annotation.Static;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+
+
+public class Reflection {
+    public static final MappedRegistryProxy MAPPED_REGISTRY;
+    public static final MappedRegistryTagSetProxy MAPPED_REGISTRY_TAG_SET;
+    public static final StructureManagerProxy STRUCTURE_MANAGER;
+
+    public static final ReferenceProxy REFERENCE;
+
+
+    public static final ChunkMapProxy CHUNKMAP;
+    public static final HolderReferenceProxy HOLDER_REFERENCE;
+    public static final HolderSetNamedProxy HOLDER_SET;
+    public static final BiomeProxy BIOME;
+
+    static {
+        ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar();
+        ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper,
+            Reflection.class.getClassLoader());
+
+        MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class);
+        MAPPED_REGISTRY_TAG_SET = reflectionProxyFactory.reflectionProxy(MappedRegistryTagSetProxy.class);
+        STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class);
+        REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class);
+        CHUNKMAP = reflectionProxyFactory.reflectionProxy(ChunkMapProxy.class);
+        HOLDER_REFERENCE = reflectionProxyFactory.reflectionProxy(HolderReferenceProxy.class);
+        HOLDER_SET = reflectionProxyFactory.reflectionProxy(HolderSetNamedProxy.class);
+        BIOME = reflectionProxyFactory.reflectionProxy(BiomeProxy.class);
+    }
+
+
+    @Proxies(MappedRegistry.class)
+    public interface MappedRegistryProxy {
+        @FieldGetter("byKey")
+        <T> Map<ResourceKey<T>, Reference<T>> getByKey(MappedRegistry<T> instance);
+
+        @FieldSetter("allTags")
+        <T> void setAllTags(MappedRegistry<T> instance, Object obj);
+
+        @FieldSetter("frozen")
+        void setFrozen(MappedRegistry<?> instance, boolean frozen);
+
+        @MethodName("createTag")
+        <T> HolderSet.Named<T> invokeCreateTag(MappedRegistry<T> instance, TagKey<T> tag);
+    }
+
+    @Proxies(className = "net.minecraft.core.MappedRegistry$TagSet")
+    public interface MappedRegistryTagSetProxy {
+        @MethodName("fromMap")
+        @Static
+        <T> Object invokeFromMap(Map<TagKey<T>, HolderSet.Named<T>> map);
+    }
+
+
+    @Proxies(StructureManager.class)
+    public interface StructureManagerProxy {
+        @FieldGetter("level")
+        LevelAccessor getLevel(StructureManager instance);
+    }
+
+
+    @Proxies(Holder.Reference.class)
+    public interface ReferenceProxy {
+        @MethodName("bindValue")
+        <T> void invokeBindValue(Reference<T> instance, T value);
+
+        @MethodName("bindTags")
+        <T> void invokeBindTags(Reference<T> instance, Collection<TagKey<T>> tags);
+    }
+
+    @Proxies(ChunkMap.class)
+    public interface ChunkMapProxy {
+        @FieldGetter("worldGenContext")
+        WorldGenContext getWorldGenContext(ChunkMap instance);
+
+        @FieldSetter("worldGenContext")
+        void setWorldGenContext(ChunkMap instance, WorldGenContext worldGenContext);
+    }
+
+    @Proxies(Holder.Reference.class)
+    public interface HolderReferenceProxy {
+        @MethodName("bindTags")
+        <T> void invokeBindTags(Holder.Reference<T> instance, Collection<TagKey<T>> tags);
+    }
+
+    @Proxies(HolderSet.Named.class)
+    public interface HolderSetNamedProxy {
+        @MethodName("bind")
+        <T> void invokeBind(HolderSet.Named<T> instance, List<Holder<T>> entries);
+
+        @MethodName("contents")
+        <T> List<Holder<T>> invokeContents(HolderSet.Named<T> instance);
+    }
+
+    @Proxies(Biome.class)
+    public interface BiomeProxy {
+        @MethodName("getGrassColorFromTexture")
+        int invokeGrassColorFromTexture(Biome instance);
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/RegistryFetcher.java

@@ -0,0 +1,25 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7;
+
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.resources.ResourceKey;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.world.level.biome.Biome;
+
+
+public class RegistryFetcher {
+    private static <T> Registry<T> getRegistry(ResourceKey<Registry<T>> key) {
+        return MinecraftServer.getServer()
+            .registryAccess()
+            .lookupOrThrow(key);
+    }
+
+    public static Registry<Biome> biomeRegistry() {
+        return getRegistry(Registries.BIOME);
+    }
+
+    public static Registry<SoundEvent> soundEventRegistry() {
+        return getRegistry(Registries.SOUND_EVENT);
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/BiomeAdditionsSoundTemplate.java

@@ -0,0 +1,28 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.world.level.biome.AmbientAdditionsSettings;
+
+
+public class BiomeAdditionsSoundTemplate implements ObjectTemplate<AmbientAdditionsSettings> {
+    @Value("sound")
+    @Default
+    private SoundEvent sound = null;
+    
+    @Value("sound-chance")
+    @Default
+    private Double soundChance = null;
+    
+    @Override
+    public AmbientAdditionsSettings get() {
+        if(sound == null || soundChance == null) {
+            return null;
+        } else {
+            return new AmbientAdditionsSettings(BuiltInRegistries.SOUND_EVENT.wrapAsHolder(sound), soundChance);
+        }
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/BiomeMoodSoundTemplate.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.world.level.biome.AmbientMoodSettings;
+
+
+public class BiomeMoodSoundTemplate implements ObjectTemplate<AmbientMoodSettings> {
+    @Value("sound")
+    @Default
+    private SoundEvent sound = null;
+    
+    @Value("cultivation-ticks")
+    @Default
+    private Integer soundCultivationTicks = null;
+    
+    @Value("spawn-range")
+    @Default
+    private Integer soundSpawnRange = null;
+    
+    @Value("extra-distance")
+    @Default
+    private Double soundExtraDistance = null;
+    
+    @Override
+    public AmbientMoodSettings get() {
+        if(sound == null || soundCultivationTicks == null || soundSpawnRange == null || soundExtraDistance == null) {
+            return null;
+        } else {
+            return new AmbientMoodSettings(BuiltInRegistries.SOUND_EVENT.wrapAsHolder(sound), soundCultivationTicks, soundSpawnRange, soundExtraDistance);
+        }
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/BiomeParticleConfigTemplate.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.minecraft.commands.arguments.ParticleArgument;
+import net.minecraft.core.HolderLookup.Provider;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.world.level.biome.AmbientParticleSettings;
+
+
+public class BiomeParticleConfigTemplate implements ObjectTemplate<AmbientParticleSettings> {
+    @Value("particle")
+    @Default
+    private String particle = null;
+    
+    @Value("probability")
+    @Default
+    private Integer probability = null;
+    
+    @Override
+    public AmbientParticleSettings get() {
+        if(particle == null || probability == null) {
+            return null;
+        }
+        
+        try {
+            return new AmbientParticleSettings(ParticleArgument.readParticle(new StringReader(particle),
+                (Provider) BuiltInRegistries.PARTICLE_TYPE.asHolderIdMap()), probability);
+        } catch(CommandSyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/EntityTypeTemplate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.EntityType;
+
+
+public class EntityTypeTemplate implements ObjectTemplate<EntityType<?>> {
+    @Value("id")
+    @Default
+    private ResourceLocation id = null;
+    
+    @Override
+    public EntityType<?> get() {
+        return BuiltInRegistries.ENTITY_TYPE.get(id).orElseThrow().value();
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/MusicSoundTemplate.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.sounds.Music;
+import net.minecraft.sounds.SoundEvent;
+
+
+public class MusicSoundTemplate implements ObjectTemplate<Music> {
+    @Value("sound")
+    @Default
+    private SoundEvent sound = null;
+    
+    @Value("min-delay")
+    @Default
+    private Integer minDelay = null;
+    
+    @Value("max-delay")
+    @Default
+    private Integer maxDelay = null;
+    
+    @Value("replace-current-music")
+    @Default
+    private Boolean replaceCurrentMusic = null;
+    
+    @Override
+    public Music get() {
+        if(sound == null || minDelay == null || maxDelay == null || replaceCurrentMusic == null) {
+            return null;
+        } else {
+            return new Music(BuiltInRegistries.SOUND_EVENT.wrapAsHolder(sound), minDelay, maxDelay, replaceCurrentMusic);
+        }
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/SoundEventTemplate.java

@@ -0,0 +1,29 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.sounds.SoundEvent;
+
+
+public class SoundEventTemplate implements ObjectTemplate<SoundEvent> {
+    @Value("id")
+    @Default
+    private ResourceLocation id = null;
+    
+    @Value("distance-to-travel")
+    @Default
+    private Float distanceToTravel = null;
+    
+    @Override
+    public SoundEvent get() {
+        if(id == null) {
+            return null;
+        } else if(distanceToTravel == null) {
+            return SoundEvent.createVariableRangeEvent(id);
+        } else {
+            return SoundEvent.createFixedRangeEvent(id, distanceToTravel);
+        }
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/SpawnCostConfig.java

@@ -0,0 +1,38 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.world.entity.EntityType;
+
+
+public class SpawnCostConfig implements ObjectTemplate<SpawnCostConfig> {
+    @Value("type")
+    @Default
+    private EntityType<?> type = null;
+    
+    @Value("mass")
+    @Default
+    private Double mass = null;
+    
+    @Value("gravity")
+    @Default
+    private Double gravity = null;
+    
+    public EntityType<?> getType() {
+        return type;
+    }
+    
+    public Double getMass() {
+        return mass;
+    }
+    
+    public Double getGravity() {
+        return gravity;
+    }
+    
+    @Override
+    public SpawnCostConfig get() {
+        return this;
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/SpawnEntryConfig.java

@@ -0,0 +1,39 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.level.biome.MobSpawnSettings.SpawnerData;
+
+
+public class SpawnEntryConfig implements ObjectTemplate<SpawnEntryConfig> {
+    @Value("type")
+    @Default
+    private EntityType<?> type = null;
+    
+    @Value("weight")
+    @Default
+    private Integer weight = null;
+    
+    @Value("min-group-size")
+    @Default
+    private Integer minGroupSize = null;
+    
+    @Value("max-group-size")
+    @Default
+    private Integer maxGroupSize = null;
+
+    public Integer getWeight() {
+        return weight;
+    }
+
+    public SpawnerData getSpawnerData() {
+        return new SpawnerData(type, minGroupSize, maxGroupSize);
+    }
+    
+    @Override
+    public SpawnEntryConfig get() {
+        return this;
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/SpawnSettingsTemplate.java

@@ -0,0 +1,48 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import java.util.List;
+import net.minecraft.world.entity.MobCategory;
+import net.minecraft.world.level.biome.MobSpawnSettings;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+
+public class SpawnSettingsTemplate implements ObjectTemplate<MobSpawnSettings> {
+
+    private static final Logger logger = LoggerFactory.getLogger(SpawnTypeConfig.class);
+    private static boolean used = false;
+
+    @Value("spawns")
+    @Default
+    private List<SpawnTypeConfig> spawns = null;
+    
+    @Value("costs")
+    @Default
+    private List<SpawnCostConfig> costs = null;
+    
+    @Value("probability")
+    @Default
+    private Float probability = null;
+    
+    @Override
+    public MobSpawnSettings get() {
+        MobSpawnSettings.Builder builder = new MobSpawnSettings.Builder();
+        for(SpawnTypeConfig spawn : spawns) {
+            MobCategory group = spawn.getGroup();
+            for(SpawnEntryConfig entry : spawn.getEntries()) {
+                builder.addSpawn(group, entry.getWeight(), entry.getSpawnerData());
+            }
+        }
+        for(SpawnCostConfig cost : costs) {
+            builder.addMobCharge(cost.getType(), cost.getMass(), cost.getGravity());
+        }
+        if(probability != null) {
+            builder.creatureGenerationProbability(probability);
+        }
+        
+        return builder.build();
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/SpawnTypeConfig.java

@@ -0,0 +1,31 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import java.util.List;
+import net.minecraft.world.entity.MobCategory;
+
+
+public class SpawnTypeConfig implements ObjectTemplate<SpawnTypeConfig> {
+    @Value("group")
+    @Default
+    private MobCategory group = null;
+
+    @Value("entries")
+    @Default
+    private List<SpawnEntryConfig> entries = null;
+
+    public MobCategory getGroup() {
+        return group;
+    }
+
+    public List<SpawnEntryConfig> getEntries() {
+        return entries;
+    }
+
+    @Override
+    public SpawnTypeConfig get() {
+        return this;
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/VanillaBiomeProperties.java

@@ -0,0 +1,180 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.ConfigTemplate;
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.api.properties.Properties;
+
+import net.minecraft.sounds.Music;
+import net.minecraft.sounds.SoundEvent;
+import net.minecraft.world.entity.npc.VillagerType;
+import net.minecraft.world.level.biome.AmbientAdditionsSettings;
+import net.minecraft.world.level.biome.AmbientMoodSettings;
+import net.minecraft.world.level.biome.AmbientParticleSettings;
+import net.minecraft.world.level.biome.Biome.TemperatureModifier;
+import net.minecraft.world.level.biome.BiomeSpecialEffects.GrassColorModifier;
+import net.minecraft.world.level.biome.MobSpawnSettings;
+
+
+public class VanillaBiomeProperties implements ConfigTemplate, Properties {
+    @Value("colors.grass")
+    @Default
+    private Integer grassColor = null;
+
+    @Value("colors.fog")
+    @Default
+    private Integer fogColor = null;
+
+    @Value("colors.water")
+    @Default
+    private Integer waterColor = null;
+
+    @Value("colors.water-fog")
+    @Default
+    private Integer waterFogColor = null;
+
+    @Value("colors.foliage")
+    @Default
+    private Integer foliageColor = null;
+
+    @Value("colors.dry-foliage")
+    @Default
+    private Integer dryFoliageColor = null;
+
+    @Value("colors.sky")
+    @Default
+    private Integer skyColor = null;
+
+    @Value("colors.modifier")
+    @Default
+    private GrassColorModifier grassColorModifier = null;
+
+    @Value("particles")
+    @Default
+    private AmbientParticleSettings particleConfig = null;
+
+    @Value("climate.precipitation")
+    @Default
+    private Boolean precipitation = true;
+
+    @Value("climate.temperature")
+    @Default
+    private Float temperature = null;
+
+    @Value("climate.temperature-modifier")
+    @Default
+    private TemperatureModifier temperatureModifier = null;
+
+    @Value("climate.downfall")
+    @Default
+    private Float downfall = null;
+
+    @Value("sound.loop-sound.sound")
+    @Default
+    private SoundEvent loopSound = null;
+
+    @Value("sound.mood-sound")
+    @Default
+    private AmbientMoodSettings moodSound = null;
+
+    @Value("sound.additions-sound")
+    @Default
+    private AmbientAdditionsSettings additionsSound = null;
+
+    @Value("sound.music")
+    @Default
+    private Music music = null;
+
+    @Value("sound.music-volume")
+    @Default
+    private Float musicVolume = null;
+
+    @Value("spawning")
+    @Default
+    private MobSpawnSettings spawnSettings = null;
+
+    @Value("villager-type")
+    @Default
+    private VillagerType villagerType = null;
+
+    public Integer getFogColor() {
+        return fogColor;
+    }
+
+    public Integer getFoliageColor() {
+        return foliageColor;
+    }
+
+    public Integer getDryFoliageColor() {
+        return dryFoliageColor;
+    }
+
+    public Integer getGrassColor() {
+        return grassColor;
+    }
+
+    public Integer getWaterColor() {
+        return waterColor;
+    }
+
+    public Integer getWaterFogColor() {
+        return waterFogColor;
+    }
+
+    public Integer getSkyColor() {
+        return skyColor;
+    }
+
+    public GrassColorModifier getGrassColorModifier() {
+        return grassColorModifier;
+    }
+
+    public AmbientParticleSettings getParticleConfig() {
+        return particleConfig;
+    }
+
+    public Boolean getPrecipitation() {
+        return precipitation;
+    }
+
+    public Float getTemperature() {
+        return temperature;
+    }
+
+    public TemperatureModifier getTemperatureModifier() {
+        return temperatureModifier;
+    }
+
+    public Float getDownfall() {
+        return downfall;
+    }
+
+    public SoundEvent getLoopSound() {
+        return loopSound;
+    }
+
+    public AmbientMoodSettings getMoodSound() {
+        return moodSound;
+    }
+
+    public AmbientAdditionsSettings getAdditionsSound() {
+        return additionsSound;
+    }
+
+    public Music getMusic() {
+        return music;
+    }
+
+    public Float getMusicVolume() {
+        return musicVolume;
+    }
+
+    public MobSpawnSettings getSpawnSettings() {
+        return spawnSettings;
+    }
+
+    public VillagerType getVillagerType() {
+        return villagerType;
+    }
+}

platforms/bukkit/nms/v1_21_7/src/main/java/com/dfsek/terra/bukkit/nms/v1_21_7/config/VillagerTypeTemplate.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.bukkit.nms.v1_21_7.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.world.entity.npc.VillagerType;
+
+
+public class VillagerTypeTemplate implements ObjectTemplate<VillagerType> {
+    @Value("id")
+    @Default
+    private ResourceLocation id = null;
+    
+    @Override
+    public VillagerType get() {
+        return BuiltInRegistries.VILLAGER_TYPE.get(id).orElseThrow().value();
+    }
+}