Initial Bukkit Biome Config

.github/CODEOWNERS

@@ -1,13 +1,19 @@
 # Global owners, automatically request review when pull request is submitted
-*                   @dfsek @solonovamax @duplexsystem @Astrashh @justaureus
+*                   @dfsek @solonovamax
 
 # Platforms
-/platforms/         @dfsek @solonovamax @duplexsystem @justaureus
+## dfsek wrote the majority of the platform impls
+/platforms/bukkit/  @dfsek
+/platforms/fabric/  @dfsek
+/platforms/forge/   @dfsek
+/platforms/sponge/  @dfsek
+## solonovamax is working on the region generator (unless duplexsystem takes it over)
+/platforms/region/  @solonovamax
 
 # Common
-/common/            @dfsek @solonovamax @duplexsystem @Astrashh
+/common/            @dfsek @solonovamax
 
 # Gradle Stuff
-/buildSrc/          @dfsek @solonovamax @duplexsystem
-*.gradle.kts        @dfsek @solonovamax @duplexsystem
-/gradle/            @dfsek @solonovamax @duplexsystem
+## Most gradle stuff was written by solonovamax
+/buildSrc/           @solonovamax
+*.gradle.kts        @solonovamax

buildSrc/src/main/kotlin/AddonConfig.kt

@@ -18,7 +18,7 @@ fun Project.addonDir(dir: File, task: Task) {
             matchingAddons(dir) {
                 it.name.startsWith("Terra-") // Assume everything that starts with Terra- is a core addon.
             }.forEach {
-                logger.info("Deleting old addon: " + it.absolutePath)
+                println("Deleting old addon: " + it.absolutePath)
                 it.delete()
             }
             forSubProjects(":common:addons") {
@@ -29,7 +29,7 @@ fun Project.addonDir(dir: File, task: Task) {
                 
                 val base = "${jar.archiveBaseName.get()}-${version}"
                 
-                logger.info("Copying addon ${jar.archiveFileName.get()} to ${target.absolutePath}. Base name: $base")
+                println("Copying addon ${jar.archiveFileName.get()} to ${target.absolutePath}. Base name: $base")
                 
                 jar.archiveFile.orNull?.asFile?.copyTo(target)
             }

buildSrc/src/main/kotlin/DistributionConfig.kt

@@ -53,7 +53,7 @@ fun Project.configureDistribution() {
                 forSubProjects(":common:addons") {
                     val jar = getJarTask()
                     
-                    logger.info("Packaging addon ${jar.archiveFileName.get()} to $dest. size: ${jar.archiveFile.get().asFile.length() / 1024}KB")
+                    println("Packaging addon ${jar.archiveFileName.get()} to $dest. size: ${jar.archiveFile.get().asFile.length() / 1024}KB")
                     
                     val boot = if (extra.has("bootstrap") && extra.get("bootstrap") as Boolean) "bootstrap/" else ""
                     val addonPath = fs.getPath("/addons/$boot${jar.archiveFileName.get()}")

buildSrc/src/main/kotlin/Utils.kt

@@ -42,10 +42,10 @@ fun preRelease(preRelease: Boolean) {
 fun Project.versionProjects(project: String, version: String) {
     forSubProjects(project) {
         this.version = version
-        logger.info("Setting version of $path to $version")
+        println("Setting version of $path to $version")
     }
     project(project).version = version
-    logger.info("Setting version of $project to $version")
+    println("Setting version of $project to $version")
 }
 
 fun Project.version(version: String): String {

buildSrc/src/main/kotlin/com/dfsek/terra/tectonicdoc/GenerateDocsTask.kt

@@ -82,7 +82,7 @@ abstract class GenerateDocsTask : DefaultTask() {
                         }
                         
                         template.add(keyName.toString(), description.toString().ifBlank {
-                            logger.info("No description provided for field " + field.name + " in class " + name)
+                            println("No description provided for field " + field.name + " in class " + name)
                             "*No description provided.*"
                         })
                     }

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java

@@ -7,13 +7,13 @@
 
 package com.dfsek.terra.addons.biome.image.v2;
 
-import java.util.Optional;
-
 import com.dfsek.terra.addons.image.colorsampler.ColorSampler;
 import com.dfsek.terra.addons.image.converter.ColorConverter;
 import com.dfsek.terra.api.world.biome.Biome;
 import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 
+import java.util.Optional;
+
 
 public class ImageBiomeProvider implements BiomeProvider {
     private final int resolution;

common/addons/config-ore/build.gradle.kts

@@ -1,4 +1,4 @@
-version = version("1.1.1")
+version = version("1.1.0")
 
 dependencies {
     compileOnlyApi(project(":common:addons:manifest-addon-loader"))

common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/utils/VanillaOreUtils.java

@@ -8,24 +8,31 @@ import com.dfsek.terra.api.world.WritableWorld;
 
 
 public class VanillaOreUtils {
-    private static boolean shouldExpose(Random random, double exposedChance) {
-        if(exposedChance >= 1.0F) return true;
-        if(exposedChance <= 0.0F) return false;
-        return random.nextFloat() < exposedChance;
+    protected static boolean shouldNotDiscard(Random random, double chance) {
+        if(chance <= 0.0F) {
+            return true;
+        } else if(chance >= 1.0F) {
+            return false;
+        } else {
+            return random.nextFloat() >= chance;
+        }
     }
 
-    public static boolean shouldPlace(MaterialSet replaceable, BlockType type, Double exposedChance, Random random, WritableWorld world,
-                                      int x,
+    public static boolean shouldPlace(MaterialSet replaceable, BlockType type, Double exposed, Random random, WritableWorld world, int x,
                                       int y, int z) {
-        if(!replaceable.contains(type)) return false;
-        if(shouldExpose(random, exposedChance)) return true; // Exposed blocks can be placed regardless of adjacency to air
-        // Adjacency is checked after determining not exposed rather than vice-versa, assuming block checks are more expensive
-        boolean adjacentAir = world.getBlockState(x, y, z - 1).isAir() ||
-                              world.getBlockState(x, y, z + 1).isAir() ||
-                              world.getBlockState(x, y - 1, z).isAir() ||
-                              world.getBlockState(x, y + 1, z).isAir() ||
-                              world.getBlockState(x - 1, y, z).isAir() ||
-                              world.getBlockState(x + 1, y, z).isAir();
-        return !adjacentAir; // Exposed check did not pass earlier so only blocks not adjacent air should place
+        if(!replaceable.contains(type)) {
+            return false;
+        } else if(shouldNotDiscard(random, exposed)) {
+            return true;
+        } else {
+            return !(world.getBlockState(x, y, z - 1).isAir() ||
+                     world.getBlockState(x, y, z + 1).isAir() ||
+                     world.getBlockState(x, y - 1, z).isAir() ||
+                     world.getBlockState(x, y + 1, z).isAir() ||
+                     world.getBlockState(x - 1, y, z).isAir() ||
+                     world.getBlockState(x + 1, y, z).isAir());
+        }
     }
+
 }
+

common/addons/language-yaml/src/main/java/com/dfsek/terra/addons/yaml/YamlAddon.java

@@ -11,16 +11,12 @@ import com.dfsek.tectonic.yaml.YamlConfiguration;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
-import java.io.IOException;
-import java.nio.file.Files;
-
 import com.dfsek.terra.addons.manifest.api.AddonInitializer;
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.addon.BaseAddon;
 import com.dfsek.terra.api.event.events.config.ConfigurationDiscoveryEvent;
 import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
 import com.dfsek.terra.api.inject.annotations.Inject;
-import com.dfsek.terra.api.util.FileUtil;
 
 
 public class YamlAddon implements AddonInitializer {
@@ -37,21 +33,10 @@ public class YamlAddon implements AddonInitializer {
         platform.getEventManager()
             .getHandler(FunctionalEventHandler.class)
             .register(addon, ConfigurationDiscoveryEvent.class)
-            .then(event -> {
-                try {
-                    FileUtil.filesWithExtension(event.getPack().getRootPath(), ".yml")
-                        .forEach((key, value) -> {
-                            LOGGER.debug("Discovered config {}", key);
-                            try {
-                                event.register(key, new YamlConfiguration(Files.newInputStream(value), key));
-                            } catch(IOException e) {
-                                throw new RuntimeException("Failed to load config " + key, e);
-                            }
-                        });
-                } catch(IOException e) {
-                    throw new RuntimeException("Error occurred while reading config pack files", e);
-                }
-            })
+            .then(event -> event.getLoader().open("", ".yml").thenEntries(entries -> entries.forEach(entry -> {
+                LOGGER.debug("Discovered config {}", entry.getKey());
+                event.register(entry.getKey(), new YamlConfiguration(entry.getValue(), entry.getKey()));
+            })).close())
             .failThrough();
     }
 }

common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/ImageLibraryAddon.java

@@ -60,8 +60,8 @@ public class ImageLibraryAddon implements AddonInitializer {
             .then(event -> {
                 ConfigPack pack = event.getPack();
                 CheckedRegistry<Supplier<ObjectTemplate<Image>>> imageRegistry = pack.getOrCreateRegistry(IMAGE_REGISTRY_KEY);
-                imageRegistry.register(addon.key("BITMAP"), () -> new ImageTemplate(pack));
-                imageRegistry.register(addon.key("STITCHED_BITMAP"), () -> new StitchedImageTemplate(pack));
+                imageRegistry.register(addon.key("BITMAP"), () -> new ImageTemplate(pack.getLoader(), pack));
+                imageRegistry.register(addon.key("STITCHED_BITMAP"), () -> new StitchedImageTemplate(pack.getLoader(), pack));
             })
             .then(event -> {
                 event.getPack()

common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageCache.java

@@ -4,10 +4,8 @@ import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.LoadingCache;
 
 import javax.imageio.ImageIO;
+import java.io.FileNotFoundException;
 import java.io.IOException;
-import java.io.InputStream;
-import java.nio.file.Files;
-import java.nio.file.Path;
 import java.util.concurrent.TimeUnit;
 
 import com.dfsek.terra.addons.image.config.ImageLibraryPackConfigTemplate;
@@ -15,6 +13,7 @@ import com.dfsek.terra.addons.image.image.BufferedImageWrapper;
 import com.dfsek.terra.addons.image.image.Image;
 import com.dfsek.terra.addons.image.image.SuppliedImage;
 import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.Loader;
 import com.dfsek.terra.api.properties.Properties;
 import com.dfsek.terra.api.util.generic.Lazy;
 
@@ -23,13 +22,13 @@ import com.dfsek.terra.api.util.generic.Lazy;
  * Cache prevents configs from loading the same image multiple times into memory
  */
 record ImageCache(LoadingCache<String, Image> cache) implements Properties {
-    public static Image load(String path, ConfigPack pack) throws IOException {
+    public static Image load(String path, ConfigPack pack, Loader files) throws IOException {
         ImageLibraryPackConfigTemplate config = pack.getContext().get(ImageLibraryPackConfigTemplate.class);
         ImageCache images;
         if(!pack.getContext().has(ImageCache.class)) {
             var cacheBuilder = Caffeine.newBuilder();
             if(config.unloadOnTimeout()) cacheBuilder.expireAfterAccess(config.getCacheTimeout(), TimeUnit.SECONDS);
-            images = new ImageCache(cacheBuilder.build(s -> loadImage(s, pack.getRootPath())));
+            images = new ImageCache(cacheBuilder.build(s -> loadImage(s, files)));
             pack.getContext().put(images);
         } else images = pack.getContext().get(ImageCache.class);
 
@@ -46,8 +45,17 @@ record ImageCache(LoadingCache<String, Image> cache) implements Properties {
         return images.cache.get(path);
     }
 
-    private static Image loadImage(String path, Path directory) throws IOException {
-        InputStream is = Files.newInputStream(directory.resolve(path));
-        return new BufferedImageWrapper(ImageIO.read(is));
+    private static Image loadImage(String path, Loader files) throws IOException {
+        try {
+            return new BufferedImageWrapper(ImageIO.read(files.get(path)));
+        } catch(IllegalArgumentException e) {
+            throw new IllegalArgumentException("Unable to load image (image might be too large?)", e);
+        } catch(IOException e) {
+            if(e instanceof FileNotFoundException) {
+                // Rethrow using nicer message
+                throw new IOException("Unable to load image: No such file or directory: " + path, e);
+            }
+            throw new IOException("Unable to load image", e);
+        }
     }
 }

common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/ImageTemplate.java

@@ -7,22 +7,25 @@ import java.io.IOException;
 
 import com.dfsek.terra.addons.image.image.Image;
 import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.Loader;
 
 
 public class ImageTemplate implements ObjectTemplate<Image> {
 
+    private final Loader files;
     private final ConfigPack pack;
     @Value("path")
     private String path;
 
-    public ImageTemplate(ConfigPack pack) {
+    public ImageTemplate(Loader files, ConfigPack pack) {
+        this.files = files;
         this.pack = pack;
     }
 
     @Override
     public Image get() {
         try {
-            return ImageCache.load(path, pack);
+            return ImageCache.load(path, pack, files);
         } catch(IOException e) {
             throw new RuntimeException(e);
         }

common/addons/library-image/src/main/java/com/dfsek/terra/addons/image/config/image/StitchedImageTemplate.java

@@ -11,10 +11,12 @@ import java.io.IOException;
 import com.dfsek.terra.addons.image.image.Image;
 import com.dfsek.terra.addons.image.image.StitchedImage;
 import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.Loader;
 
 
 public class StitchedImageTemplate implements ObjectTemplate<Image>, ValidatedConfigTemplate {
 
+    private final Loader files;
     private final ConfigPack pack;
     @Value("path-format")
     private String path;
@@ -26,7 +28,8 @@ public class StitchedImageTemplate implements ObjectTemplate<Image>, ValidatedCo
     @Default
     private boolean zeroIndexed = false;
 
-    public StitchedImageTemplate(ConfigPack pack) {
+    public StitchedImageTemplate(Loader files, ConfigPack pack) {
+        this.files = files;
         this.pack = pack;
     }
 
@@ -36,7 +39,7 @@ public class StitchedImageTemplate implements ObjectTemplate<Image>, ValidatedCo
         for(int i = 0; i < rows; i++) {
             for(int j = 0; j < cols; j++) {
                 try {
-                    grid[i][j] = ImageCache.load(getFormattedPath(i, j), pack);
+                    grid[i][j] = ImageCache.load(getFormattedPath(i, j), pack, files);
                 } catch(IOException e) {
                     throw new RuntimeException(e);
                 }

common/addons/structure-sponge-loader/src/main/java/com/dfsek/terra/addons/sponge/SpongeSchematicAddon.java

@@ -16,7 +16,6 @@ import net.querz.nbt.tag.Tag;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.PushbackInputStream;
-import java.nio.file.Files;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.zip.GZIPInputStream;
@@ -30,7 +29,7 @@ import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
 import com.dfsek.terra.api.inject.annotations.Inject;
 import com.dfsek.terra.api.registry.CheckedRegistry;
 import com.dfsek.terra.api.structure.Structure;
-import com.dfsek.terra.api.util.FileUtil;
+import com.dfsek.terra.api.util.StringUtil;
 import com.dfsek.terra.api.util.vector.Vector3Int;
 
 
@@ -59,21 +58,13 @@ public class SpongeSchematicAddon implements AddonInitializer {
             .register(addon, ConfigPackPreLoadEvent.class)
             .then(event -> {
                 CheckedRegistry<Structure> structureRegistry = event.getPack().getOrCreateRegistry(Structure.class);
-                try {
-                    FileUtil.filesWithExtension(event.getPack().getRootPath(), ".schem")
-                        .entrySet()
+                event.getPack()
+                    .getLoader()
+                    .open("", ".schem")
+                    .thenEntries(entries -> entries
                         .stream()
-                        .map(entry -> {
-                            try {
-                                return convert(Files.newInputStream(entry.getValue()), FileUtil.fileName(entry.getKey()));
-                            } catch(IOException e) {
-                                throw new RuntimeException("Failed to load config " + entry.getKey(), e);
-                            }
-                        })
-                        .forEach(structureRegistry::register);
-                } catch(IOException e) {
-                    throw new RuntimeException("Error occurred while reading config pack files", e);
-                }
+                        .map(entry -> convert(entry.getValue(), StringUtil.fileName(entry.getKey())))
+                        .forEach(structureRegistry::register)).close();
             })
             .failThrough();
     }

common/addons/structure-terrascript-loader/src/main/java/com/dfsek/terra/addons/terrascript/TerraScriptAddon.java

@@ -7,9 +7,6 @@
 
 package com.dfsek.terra.addons.terrascript;
 
-import java.io.IOException;
-import java.nio.file.Files;
-
 import com.dfsek.terra.addons.manifest.api.AddonInitializer;
 import com.dfsek.terra.addons.terrascript.parser.exceptions.ParseException;
 import com.dfsek.terra.addons.terrascript.parser.lang.functions.FunctionBuilder;
@@ -22,7 +19,7 @@ import com.dfsek.terra.api.inject.annotations.Inject;
 import com.dfsek.terra.api.registry.CheckedRegistry;
 import com.dfsek.terra.api.structure.LootTable;
 import com.dfsek.terra.api.structure.Structure;
-import com.dfsek.terra.api.util.FileUtil;
+import com.dfsek.terra.api.util.StringUtil;
 
 
 public class TerraScriptAddon implements AddonInitializer {
@@ -40,28 +37,26 @@ public class TerraScriptAddon implements AddonInitializer {
             .then(event -> {
                 CheckedRegistry<Structure> structureRegistry = event.getPack().getOrCreateRegistry(Structure.class);
                 CheckedRegistry<LootTable> lootRegistry = event.getPack().getOrCreateRegistry(LootTable.class);
-                try {
-                    FileUtil.filesWithExtension(event.getPack().getRootPath(), ".tesf")
-                        .entrySet()
-                        .stream()
-                        .parallel()
-                        .map(entry -> {
-                            try {
-                                String id = FileUtil.fileName(entry.getKey());
-                                return new StructureScript(Files.newInputStream(entry.getValue()),
-                                    addon.key(id),
-                                    platform,
-                                    structureRegistry,
-                                    lootRegistry,
-                                    event.getPack().getOrCreateRegistry(FunctionBuilder.class));
-                            } catch(ParseException | IOException e) {
-                                throw new RuntimeException("Failed to load script \"" + entry.getKey() + "\"", e);
-                            }
-                        })
-                        .forEach(structureRegistry::register);
-                } catch(IOException e) {
-                    throw new RuntimeException("Error occurred while reading config pack files", e);
-                }
+                event.getPack().getLoader().open("", ".tesf").thenEntries(
+                        entries ->
+                            entries.stream()
+                                .parallel()
+                                .map(entry -> {
+                                    try {
+                                        String id = StringUtil.fileName(entry.getKey());
+                                        return new StructureScript(entry.getValue(),
+                                            addon.key(id),
+                                            platform,
+                                            structureRegistry,
+                                            lootRegistry,
+                                            event.getPack().getOrCreateRegistry(FunctionBuilder.class));
+                                    } catch(ParseException e) {
+                                        throw new RuntimeException("Failed to load script \"" + entry.getKey() + "\"", e);
+                                    }
+                                })
+                                .toList()
+                                .forEach(structureRegistry::register))
+                    .close();
             })
             .priority(100)
             .failThrough();

common/api/src/main/java/com/dfsek/terra/api/config/ConfigPack.java

@@ -10,7 +10,6 @@ package com.dfsek.terra.api.config;
 import ca.solostudios.strata.version.Version;
 import ca.solostudios.strata.version.VersionRange;
 
-import java.nio.file.Path;
 import java.util.List;
 import java.util.Map;
 
@@ -44,7 +43,7 @@ public interface ConfigPack extends LoaderRegistrar,
 
     List<GenerationStage> getStages();
 
-    Path getRootPath();
+    Loader getLoader();
 
     String getAuthor();
 

common/api/src/main/java/com/dfsek/terra/api/config/Loader.java

@@ -0,0 +1,47 @@
+/*
+ * Copyright (c) 2020-2023 Polyhedral Development
+ *
+ * The Terra API is licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in the common/api directory.
+ */
+
+package com.dfsek.terra.api.config;
+
+import com.dfsek.tectonic.api.exception.ConfigException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+
+
+public interface Loader {
+
+    Loader thenNames(Consumer<List<String>> consumer) throws ConfigException;
+
+    Loader thenEntries(Consumer<Set<Map.Entry<String, InputStream>>> consumer) throws ConfigException;
+
+    /**
+     * Get a single file from this Loader.
+     *
+     * @param singleFile File to get
+     *
+     * @return InputStream from file.
+     */
+    InputStream get(String singleFile) throws IOException;
+
+    /**
+     * Open a subdirectory.
+     *
+     * @param directory Directory to open
+     * @param extension File extension
+     */
+    Loader open(String directory, String extension);
+
+    /**
+     * Close all InputStreams opened.
+     */
+    Loader close();
+}

common/api/src/main/java/com/dfsek/terra/api/event/events/config/ConfigurationDiscoveryEvent.java

@@ -12,6 +12,7 @@ import com.dfsek.tectonic.api.config.Configuration;
 import java.util.function.BiConsumer;
 
 import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.Loader;
 import com.dfsek.terra.api.event.events.FailThroughEvent;
 import com.dfsek.terra.api.event.events.PackEvent;
 
@@ -24,11 +25,13 @@ import com.dfsek.terra.api.event.events.PackEvent;
  */
 public class ConfigurationDiscoveryEvent implements PackEvent, FailThroughEvent {
     private final ConfigPack pack;
+    private final Loader loader;
 
     private final BiConsumer<String, Configuration> consumer;
 
-    public ConfigurationDiscoveryEvent(ConfigPack pack, BiConsumer<String, Configuration> consumer) {
+    public ConfigurationDiscoveryEvent(ConfigPack pack, Loader loader, BiConsumer<String, Configuration> consumer) {
         this.pack = pack;
+        this.loader = loader;
         this.consumer = consumer;
     }
 
@@ -40,4 +43,8 @@ public class ConfigurationDiscoveryEvent implements PackEvent, FailThroughEvent
     public ConfigPack getPack() {
         return pack;
     }
+
+    public Loader getLoader() {
+        return loader;
+    }
 }

common/api/src/main/java/com/dfsek/terra/api/structure/Structure.java

@@ -7,12 +7,12 @@
 
 package com.dfsek.terra.api.structure;
 
+import java.util.Random;
+
 import com.dfsek.terra.api.util.Rotation;
 import com.dfsek.terra.api.util.vector.Vector3Int;
 import com.dfsek.terra.api.world.WritableWorld;
 
-import java.util.Random;
-
 
 public interface Structure {
     boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation);

common/api/src/main/java/com/dfsek/terra/api/util/FileUtil.java

@@ -1,38 +0,0 @@
-package com.dfsek.terra.api.util;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Arrays;
-import java.util.Collections;
-import java.util.Map;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-import static java.util.function.Function.identity;
-
-
-public class FileUtil {
-    public static Map<String, Path> filesWithExtension(Path start, String... extensions) throws IOException {
-        if(Files.notExists(start) || !Files.isDirectory(start)) return Collections.emptyMap();
-        try(Stream<Path> paths = Files.walk(start)) {
-            return paths
-                .filter(Files::isRegularFile)
-                .filter(p -> Arrays.stream(extensions).anyMatch(e -> p.getFileName().toString().endsWith(e)))
-                .collect(Collectors.toMap(p -> start.relativize(p).toString(), identity()));
-        }
-    }
-
-    public static String fileName(String path) {
-        if(path.contains(File.separator)) {
-            return path.substring(path.lastIndexOf(File.separatorChar) + 1, path.lastIndexOf('.'));
-        } else if(path.contains("/")) {
-            return path.substring(path.lastIndexOf("/") + 1, path.lastIndexOf('.'));
-        } else if(path.contains(".")) {
-            return path.substring(0, path.lastIndexOf('.'));
-        } else {
-            return path;
-        }
-    }
-}

common/api/src/main/java/com/dfsek/terra/api/util/StringUtil.java

@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2020-2023 Polyhedral Development
+ *
+ * The Terra API is licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in the common/api directory.
+ */
+
+package com.dfsek.terra.api.util;
+
+import java.io.File;
+
+
+public class StringUtil {
+    public static String fileName(String path) {
+        if(path.contains(File.separator)) {
+            return path.substring(path.lastIndexOf(File.separatorChar) + 1, path.lastIndexOf('.'));
+        } else if(path.contains("/")) {
+            return path.substring(path.lastIndexOf("/") + 1, path.lastIndexOf('.'));
+        } else if(path.contains(".")) {
+            return path.substring(0, path.lastIndexOf('.'));
+        } else {
+            return path;
+        }
+    }
+}

common/implementation/base/src/main/java/com/dfsek/terra/AbstractPlatform.java

@@ -18,9 +18,6 @@
 package com.dfsek.terra;
 
 import com.dfsek.tectonic.api.TypeRegistry;
-
-import com.dfsek.terra.registry.master.ConfigRegistry.PackLoadFailuresException;
-
 import org.apache.commons.io.FileUtils;
 import org.apache.commons.io.IOUtils;
 import org.jetbrains.annotations.NotNull;
@@ -150,29 +147,18 @@ public abstract class AbstractPlatform implements Platform {
 
         eventManager.getHandler(FunctionalEventHandler.class)
             .register(internalAddon, PlatformInitializationEvent.class)
-            .then(event -> loadConfigPacks())
+            .then(event -> {
+                logger.info("Loading config packs...");
+                configRegistry.loadAll(this);
+                logger.info("Loaded packs.");
+            })
             .global();
 
+
         logger.info("Terra addons successfully loaded.");
         logger.info("Finished initialization.");
     }
 
-    protected boolean loadConfigPacks() {
-        logger.info("Loading config packs...");
-        ConfigRegistry configRegistry = getRawConfigRegistry();
-        configRegistry.clear();
-        try {
-            configRegistry.loadAll(this);
-        } catch(IOException e) {
-            logger.error("Failed to load config packs", e);
-            return false;
-        } catch(PackLoadFailuresException e) {
-            e.getExceptions().forEach(ex -> logger.error("Failed to load config pack", ex));
-            return false;
-        }
-        return true;
-    }
-
     protected InternalAddon loadAddons() {
         List<BaseAddon> addonList = new ArrayList<>();
 

common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/FolderLoader.java

@@ -0,0 +1,66 @@
+/*
+ * This file is part of Terra.
+ *
+ * Terra is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Terra is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Terra.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.dfsek.terra.config.fileloaders;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.stream.Stream;
+
+
+/**
+ * Load all {@code *.yml} files from a {@link java.nio.file.Path}.
+ */
+public class FolderLoader extends LoaderImpl {
+    private static final Logger logger = LoggerFactory.getLogger(FolderLoader.class);
+
+    private final Path path;
+
+    public FolderLoader(Path path) {
+        this.path = path;
+    }
+
+    @Override
+    public InputStream get(String singleFile) throws IOException {
+        return new FileInputStream(new File(path.toFile(), singleFile));
+    }
+
+    protected void load(String directory, String extension) {
+        File newPath = new File(path.toFile(), directory);
+        newPath.mkdirs();
+        try(Stream<Path> paths = Files.walk(newPath.toPath())) {
+            paths.filter(Files::isRegularFile).filter(file -> file.toString().toLowerCase().endsWith(extension)).forEach(file -> {
+                try {
+                    String rel = newPath.toPath().relativize(file).toString();
+                    streams.put(rel, new FileInputStream(file.toFile()));
+                } catch(FileNotFoundException e) {
+                    logger.error("Could not find file to load", e);
+                }
+            });
+        } catch(IOException e) {
+            logger.error("Error while loading files", e);
+        }
+    }
+}

common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/LoaderImpl.java

@@ -0,0 +1,83 @@
+/*
+ * This file is part of Terra.
+ *
+ * Terra is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Terra is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Terra.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.dfsek.terra.config.fileloaders;
+
+import com.dfsek.tectonic.api.exception.ConfigException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Consumer;
+
+import com.dfsek.terra.api.config.Loader;
+
+
+public abstract class LoaderImpl implements Loader {
+    private static final Logger logger = LoggerFactory.getLogger(LoaderImpl.class);
+
+    protected final Map<String, InputStream> streams = new HashMap<>();
+
+    @Override
+    public Loader thenNames(Consumer<List<String>> consumer) throws ConfigException {
+        consumer.accept(new ArrayList<>(streams.keySet()));
+        return this;
+    }
+
+    @Override
+    public Loader thenEntries(Consumer<Set<Map.Entry<String, InputStream>>> consumer) throws ConfigException {
+        consumer.accept(streams.entrySet());
+        return this;
+    }
+
+    /**
+     * Open a subdirectory.
+     *
+     * @param directory Directory to open
+     * @param extension File extension
+     */
+    @Override
+    public LoaderImpl open(String directory, String extension) {
+        if(!streams.isEmpty()) throw new IllegalStateException("Attempted to load new directory before closing existing InputStreams");
+        load(directory, extension);
+        return this;
+    }
+
+    /**
+     * Close all InputStreams opened.
+     */
+    @Override
+    public Loader close() {
+        streams.forEach((name, input) -> {
+            try {
+                input.close();
+            } catch(IOException e) {
+                logger.error("Error occurred while loading", e);
+            }
+        });
+        streams.clear();
+        return this;
+    }
+
+    protected abstract void load(String directory, String extension);
+}

common/implementation/base/src/main/java/com/dfsek/terra/config/fileloaders/ZIPLoader.java

@@ -0,0 +1,63 @@
+/*
+ * This file is part of Terra.
+ *
+ * Terra is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * Terra is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with Terra.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.dfsek.terra.config.fileloaders;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Enumeration;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+
+public class ZIPLoader extends LoaderImpl {
+    private static final Logger logger = LoggerFactory.getLogger(ZIPLoader.class);
+
+    private final ZipFile file;
+
+    public ZIPLoader(ZipFile file) {
+        this.file = file;
+    }
+
+    @Override
+    public InputStream get(String singleFile) throws IOException {
+        Enumeration<? extends ZipEntry> entries = file.entries();
+        while(entries.hasMoreElements()) {
+            ZipEntry entry = entries.nextElement();
+            if(!entry.isDirectory() && entry.getName().equals(singleFile)) return file.getInputStream(entry);
+        }
+        throw new IllegalArgumentException("No such file: " + singleFile);
+    }
+
+    protected void load(String directory, String extension) {
+        Enumeration<? extends ZipEntry> entries = file.entries();
+        while(entries.hasMoreElements()) {
+            ZipEntry entry = entries.nextElement();
+            if(!entry.isDirectory() && entry.getName().startsWith(directory) && entry.getName().endsWith(extension)) {
+                try {
+                    String rel = entry.getName().substring(directory.length());
+                    streams.put(rel, file.getInputStream(entry));
+                } catch(IOException e) {
+                    logger.error("Error while loading file from zip", e);
+                }
+            }
+        }
+    }
+}

common/implementation/base/src/main/java/com/dfsek/terra/config/loaders/config/BufferedImageLoader.java

@@ -27,10 +27,10 @@ import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.IOException;
 import java.lang.reflect.AnnotatedType;
-import java.nio.file.Files;
 import java.util.concurrent.ConcurrentHashMap;
 
 import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.Loader;
 import com.dfsek.terra.api.properties.Properties;
 
 
@@ -39,10 +39,12 @@ import com.dfsek.terra.api.properties.Properties;
  */
 @Deprecated
 public class BufferedImageLoader implements TypeLoader<BufferedImage> {
+    private final Loader files;
 
     private final ConfigPack pack;
 
-    public BufferedImageLoader(ConfigPack pack) {
+    public BufferedImageLoader(Loader files, ConfigPack pack) {
+        this.files = files;
         this.pack = pack;
         if(!pack.getContext().has(ImageCache.class))
             pack.getContext().put(new ImageCache(new ConcurrentHashMap<>()));
@@ -53,7 +55,7 @@ public class BufferedImageLoader implements TypeLoader<BufferedImage> {
     throws LoadException {
         return pack.getContext().get(ImageCache.class).map.computeIfAbsent((String) c, s -> {
             try {
-                return ImageIO.read(Files.newInputStream(pack.getRootPath().resolve(s)));
+                return ImageIO.read(files.get(s));
             } catch(IOException e) {
                 throw new LoadException("Unable to load image", e, depthTracker);
             }

common/implementation/base/src/main/java/com/dfsek/terra/config/pack/ConfigPackImpl.java

@@ -26,37 +26,13 @@ import com.dfsek.tectonic.api.loader.AbstractConfigLoader;
 import com.dfsek.tectonic.api.loader.ConfigLoader;
 import com.dfsek.tectonic.api.loader.type.TypeLoader;
 import com.dfsek.tectonic.yaml.YamlConfiguration;
-import com.google.common.collect.ListMultimap;
-import com.google.common.collect.Multimaps;
-import org.jetbrains.annotations.NotNull;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.awt.image.BufferedImage;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.nio.file.FileSystem;
-import java.nio.file.FileSystems;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeMap;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.function.Supplier;
 
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.addon.BaseAddon;
 import com.dfsek.terra.api.config.ConfigFactory;
 import com.dfsek.terra.api.config.ConfigPack;
 import com.dfsek.terra.api.config.ConfigType;
+import com.dfsek.terra.api.config.Loader;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.event.events.config.ConfigurationDiscoveryEvent;
 import com.dfsek.terra.api.event.events.config.ConfigurationLoadEvent;
@@ -69,24 +45,39 @@ import com.dfsek.terra.api.registry.OpenRegistry;
 import com.dfsek.terra.api.registry.Registry;
 import com.dfsek.terra.api.registry.key.RegistryKey;
 import com.dfsek.terra.api.tectonic.ShortcutLoader;
+import com.dfsek.terra.api.util.generic.Construct;
 import com.dfsek.terra.api.util.generic.pair.Pair;
 import com.dfsek.terra.api.util.reflection.ReflectionUtil;
 import com.dfsek.terra.api.util.reflection.TypeKey;
 import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 import com.dfsek.terra.api.world.chunk.generation.stage.GenerationStage;
 import com.dfsek.terra.api.world.chunk.generation.util.provider.ChunkGeneratorProvider;
+import com.dfsek.terra.config.fileloaders.FolderLoader;
+import com.dfsek.terra.config.fileloaders.ZIPLoader;
 import com.dfsek.terra.config.loaders.GenericTemplateSupplierLoader;
 import com.dfsek.terra.config.loaders.config.BufferedImageLoader;
-import com.dfsek.terra.config.preprocessor.MetaListLikePreprocessor;
-import com.dfsek.terra.config.preprocessor.MetaMapPreprocessor;
-import com.dfsek.terra.config.preprocessor.MetaNumberPreprocessor;
-import com.dfsek.terra.config.preprocessor.MetaStringPreprocessor;
-import com.dfsek.terra.config.preprocessor.MetaValuePreprocessor;
+import com.dfsek.terra.config.preprocessor.*;
 import com.dfsek.terra.config.prototype.ProtoConfig;
 import com.dfsek.terra.registry.CheckedRegistryImpl;
 import com.dfsek.terra.registry.OpenRegistryImpl;
 import com.dfsek.terra.registry.ShortcutHolder;
 
+import com.google.common.collect.ListMultimap;
+import com.google.common.collect.Multimaps;
+import org.jetbrains.annotations.NotNull;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.awt.image.BufferedImage;
+import java.io.*;
+import java.lang.reflect.ParameterizedType;
+import java.lang.reflect.Type;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
 
 /**
  * Represents a Terra configuration pack.
@@ -101,7 +92,7 @@ public class ConfigPackImpl implements ConfigPack {
     private final AbstractConfigLoader abstractConfigLoader = new AbstractConfigLoader();
     private final ConfigLoader selfLoader = new ConfigLoader();
     private final Platform platform;
-    private final Path rootPath;
+    private final Loader loader;
 
     private final Map<BaseAddon, VersionRange> addons;
 
@@ -115,29 +106,40 @@ public class ConfigPackImpl implements ConfigPack {
 
     private final RegistryKey key;
 
-    @SuppressWarnings({ "rawtypes" })
-    public ConfigPackImpl(Path path, Platform platform) throws IOException {
+    public ConfigPackImpl(File folder, Platform platform) {
+        this(new FolderLoader(folder.toPath()), Construct.construct(() -> {
+            try {
+                return new YamlConfiguration(new FileInputStream(new File(folder, "pack.yml")), "pack.yml");
+            } catch(FileNotFoundException e) {
+                throw new UncheckedIOException("No pack.yml file found in " + folder.getAbsolutePath(), e);
+            }
+        }), platform);
+    }
+
+    public ConfigPackImpl(ZipFile file, Platform platform) {
+        this(new ZIPLoader(file), Construct.construct(() -> {
+            ZipEntry pack = null;
+            Enumeration<? extends ZipEntry> entries = file.entries();
+            while(entries.hasMoreElements()) {
+                ZipEntry entry = entries.nextElement();
+                if(entry.getName().equals("pack.yml")) pack = entry;
+            }
+
+            if(pack == null) throw new IllegalArgumentException("No pack.yml file found in " + file.getName());
+
+            try {
+                return new YamlConfiguration(file.getInputStream(pack), "pack.yml");
+            } catch(IOException e) {
+                throw new UncheckedIOException("Unable to load pack.yml from ZIP file", e);
+            }
+        }), platform);
+    }
+
+    @SuppressWarnings({ "rawtypes", "unchecked" })
+    private ConfigPackImpl(Loader loader, Configuration packManifest, Platform platform) {
         long start = System.nanoTime();
 
-        if(Files.notExists(path)) throw new FileNotFoundException("Could not load config pack, " + path + " does not exist");
-
-        if(Files.isDirectory(path)) {
-            this.rootPath = path;
-        } else if(Files.isRegularFile(path)) {
-            if(!path.getFileName().toString().endsWith(".zip")) {
-                throw new IOException("Could not load config pack, file " + path + " is not a zip");
-            }
-            FileSystem zipfs = FileSystems.newFileSystem(path);
-            this.rootPath = zipfs.getPath("/");
-        } else {
-            throw new IOException("Could not load config pack from " + path);
-        }
-
-        Path packManifestPath = rootPath.resolve("pack.yml");
-        if(Files.notExists(packManifestPath)) throw new IOException("No pack.yml found in " + path);
-        Configuration packManifest = new YamlConfiguration(Files.newInputStream(packManifestPath),
-            packManifestPath.getFileName().toString());
-
+        this.loader = loader;
         this.platform = platform;
         this.configTypeRegistry = createConfigRegistry();
 
@@ -221,7 +223,7 @@ public class ConfigPackImpl implements ConfigPack {
 
     private Map<String, Configuration> discoverConfigurations() {
         Map<String, Configuration> configurations = new HashMap<>();
-        platform.getEventManager().callEvent(new ConfigurationDiscoveryEvent(this,
+        platform.getEventManager().callEvent(new ConfigurationDiscoveryEvent(this, loader,
             (s, c) -> configurations.put(s.replace("\\", "/"),
                 c))); // Create all the configs.
         return configurations;
@@ -266,7 +268,7 @@ public class ConfigPackImpl implements ConfigPack {
     @Override
     public void register(TypeRegistry registry) {
         registry.registerLoader(ConfigType.class, configTypeRegistry)
-            .registerLoader(BufferedImage.class, new BufferedImageLoader(this));
+            .registerLoader(BufferedImage.class, new BufferedImageLoader(loader, this));
         registryMap.forEach(registry::registerLoader);
         shortcuts.forEach(registry::registerLoader); // overwrite with delegated shortcuts if present
     }
@@ -292,6 +294,7 @@ public class ConfigPackImpl implements ConfigPack {
         return seededBiomeProvider;
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public <T> CheckedRegistry<T> getOrCreateRegistry(TypeKey<T> typeKey) {
         return (CheckedRegistry<T>) registryMap.computeIfAbsent(typeKey.getType(), c -> {
@@ -330,8 +333,8 @@ public class ConfigPackImpl implements ConfigPack {
     }
 
     @Override
-    public Path getRootPath() {
-        return rootPath;
+    public Loader getLoader() {
+        return loader;
     }
 
     @Override
@@ -344,7 +347,7 @@ public class ConfigPackImpl implements ConfigPack {
         return template.getVersion();
     }
 
-    @SuppressWarnings("rawtypes")
+    @SuppressWarnings("unchecked,rawtypes")
     @Override
     public <T> ConfigPack registerShortcut(TypeKey<T> clazz, String shortcut, ShortcutLoader<T> loader) {
         ShortcutHolder<?> holder = shortcuts
@@ -388,10 +391,12 @@ public class ConfigPackImpl implements ConfigPack {
     }
 
     @Override
+    @SuppressWarnings("unchecked")
     public <T> CheckedRegistry<T> getRegistry(Type type) {
         return (CheckedRegistry<T>) registryMap.get(type);
     }
 
+    @SuppressWarnings("unchecked")
     @Override
     public <T> CheckedRegistry<T> getCheckedRegistry(Type type) throws IllegalStateException {
         return (CheckedRegistry<T>) registryMap.get(type);

common/implementation/base/src/main/java/com/dfsek/terra/registry/master/ConfigRegistry.java

@@ -17,13 +17,14 @@
 
 package com.dfsek.terra.registry.master;
 
+import com.dfsek.tectonic.api.exception.ConfigException;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.File;
 import java.io.IOException;
-import java.io.Serial;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Stream;
+import java.util.Objects;
+import java.util.zip.ZipFile;
 
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.config.ConfigPack;
@@ -36,42 +37,44 @@ import com.dfsek.terra.registry.OpenRegistryImpl;
  * Class to hold config packs
  */
 public class ConfigRegistry extends OpenRegistryImpl<ConfigPack> {
+    private static final Logger logger = LoggerFactory.getLogger(ConfigRegistry.class);
 
     public ConfigRegistry() {
         super(TypeKey.of(ConfigPack.class));
     }
 
-    public void loadAll(Platform platform) throws IOException, PackLoadFailuresException {
-        Path packsDirectory = platform.getDataFolder().toPath().resolve("packs");
-        Files.createDirectories(packsDirectory);
-        List<IOException> failedLoads = new ArrayList<>();
-        try(Stream<Path> packs = Files.list(packsDirectory)) {
-            packs.forEach(path -> {
-                try {
-                    ConfigPack pack = new ConfigPackImpl(path, platform);
-                    registerChecked(pack.getRegistryKey(), pack);
-                } catch(IOException e) {
-                    failedLoads.add(e);
-                }
-            });
-        }
-        if(!failedLoads.isEmpty()) {
-            throw new PackLoadFailuresException(failedLoads);
-        }
+    public void load(File folder, Platform platform) throws ConfigException {
+        ConfigPack pack = new ConfigPackImpl(folder, platform);
+        registerChecked(pack.getRegistryKey(), pack);
     }
 
-    public static class PackLoadFailuresException extends Exception {
-        @Serial
-        private static final long serialVersionUID = 538998844645186306L;
-
-        private final List<Throwable> exceptions;
-
-        public PackLoadFailuresException(List<? extends Throwable> exceptions) {
-            this.exceptions = (List<Throwable>) exceptions;
+    public boolean loadAll(Platform platform) {
+        boolean valid = true;
+        File packsFolder = new File(platform.getDataFolder(), "packs");
+        packsFolder.mkdirs();
+        for(File dir : Objects.requireNonNull(packsFolder.listFiles(File::isDirectory))) {
+            try {
+                load(dir, platform);
+            } catch(ConfigException e) {
+                logger.error("Error loading config pack {}", dir.getName(), e);
+                valid = false;
+            }
         }
-
-        public List<Throwable> getExceptions() {
-            return exceptions;
+        for(File zip : Objects.requireNonNull(
+            packsFolder.listFiles(file -> file.getName().endsWith(".zip") || file.getName().endsWith(".terra")))) {
+            try {
+                logger.info("Loading ZIP archive: {}", zip.getName());
+                load(new ZipFile(zip), platform);
+            } catch(IOException | ConfigException e) {
+                logger.error("Error loading config pack {}", zip.getName(), e);
+                valid = false;
+            }
         }
+        return valid;
+    }
+
+    public void load(ZipFile file, Platform platform) throws ConfigException {
+        ConfigPackImpl pack = new ConfigPackImpl(file, platform);
+        registerChecked(pack.getRegistryKey(), pack);
     }
 }

platforms/bukkit/build.gradle.kts

@@ -10,11 +10,6 @@ repositories {
 
 dependencies {
     shaded(project(":platforms:bukkit:common"))
-    shaded(project(":platforms:bukkit:nms:v1_18_R2", configuration = "reobf"))
-    shaded(project(":platforms:bukkit:nms:v1_19_R1", configuration = "reobf"))
-    shaded(project(":platforms:bukkit:nms:v1_19_R2", configuration = "reobf"))
-    shaded(project(":platforms:bukkit:nms:v1_19_R3", configuration = "reobf"))
-    shaded(project(":platforms:bukkit:nms:v1_20_R1", configuration = "reobf"))
     shaded(project(":platforms:bukkit:nms:v1_20_R2", configuration = "reobf"))
     shaded("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
 }

platforms/bukkit/common/src/main/java/com/dfsek/terra/bukkit/PlatformImpl.java

@@ -20,9 +20,6 @@ package com.dfsek.terra.bukkit;
 import com.dfsek.tectonic.api.TypeRegistry;
 import com.dfsek.tectonic.api.depth.DepthTracker;
 import com.dfsek.tectonic.api.exception.LoadException;
-
-import com.dfsek.terra.registry.master.ConfigRegistry.PackLoadFailuresException;
-
 import org.bukkit.Bukkit;
 import org.bukkit.entity.EntityType;
 import org.jetbrains.annotations.NotNull;
@@ -30,7 +27,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
-import java.io.IOException;
 import java.util.List;
 import java.util.Locale;
 
@@ -67,7 +63,8 @@ public class PlatformImpl extends AbstractPlatform {
     @Override
     public boolean reload() {
         getTerraConfig().load(this);
-        boolean succeed = loadConfigPacks();
+        getRawConfigRegistry().clear();
+        boolean succeed = getRawConfigRegistry().loadAll(this);
 
         Bukkit.getWorlds().forEach(world -> {
             if(world.getGenerator() instanceof BukkitChunkGeneratorWrapper wrapper) {

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

@@ -1,17 +0,0 @@
-apply(plugin = "io.papermc.paperweight.userdev")
-
-repositories {
-    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
-}
-
-dependencies {
-    api(project(":platforms:bukkit:common"))
-    paperDevBundle("1.18.2-R0.1-SNAPSHOT")
-    implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
-}
-
-tasks {
-    assemble {
-        dependsOn("reobfJar")
-    }
-}

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

@@ -1,115 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-import com.google.common.collect.ImmutableMap;
-import com.mojang.serialization.Lifecycle;
-import net.minecraft.core.Holder;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.core.Registry;
-import net.minecraft.core.WritableRegistry;
-import net.minecraft.data.BuiltinRegistries;
-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.List;
-import java.util.Map;
-
-import com.dfsek.terra.bukkit.world.BukkitPlatformBiome;
-import com.dfsek.terra.registry.master.ConfigRegistry;
-
-
-public class AwfulBukkitHacks {
-    private static final Logger LOGGER = LoggerFactory.getLogger(NMSBiomeInjector.class);
-    private static final Map<ResourceLocation, List<ResourceLocation>> terraBiomeMap = new HashMap<>();
-
-
-    public static void registerBiomes(ConfigRegistry configRegistry) {
-        try {
-            LOGGER.info("Hacking biome registry...");
-            WritableRegistry<Biome> biomeRegistry = (WritableRegistry<Biome>) Registries.biomeRegistry();
-
-            Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry<?>) biomeRegistry, false);
-
-            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 = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey());
-                    Biome platform = NMSBiomeInjector.createBiome(
-                        biome,
-                        biomeRegistry.get(vanillaMinecraftKey) // get
-                    );
-
-                    ResourceKey<Biome> delegateKey = ResourceKey.create(Registry.BIOME_REGISTRY, new ResourceLocation("terra",
-                        NMSBiomeInjector.createBiomeID(
-                            pack, key)));
-
-                    BuiltinRegistries.register(BuiltinRegistries.BIOME, delegateKey, platform);
-                    biomeRegistry.register(delegateKey, platform, Lifecycle.stable());
-                    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((MappedRegistry<?>) 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.getFirst(), new ArrayList<>(pair.getSecond().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.unwrapKey()
-                                                    .orElseThrow()
-                                                    .location() +
-                                                " (vanilla for " +
-                                                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)));
-
-            biomeRegistry.resetTags(); // clearTags
-            biomeRegistry.bindTags(ImmutableMap.copyOf(collect)); // populateTags
-
-        } catch(SecurityException | IllegalArgumentException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-}

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

@@ -1,10 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-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_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeInjector.java

@@ -1,79 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-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.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.config.VanillaBiomeProperties;
-
-
-public class NMSBiomeInjector {
-
-    public static <T> Optional<Holder<T>> getEntry(Registry<T> registry, ResourceLocation identifier) {
-        return registry.getOptional(identifier)
-            .flatMap(registry::getResourceKey)
-            .map(registry::getOrCreateHolder);
-    }
-
-    public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla)
-    throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-        Biome.BiomeBuilder builder = new Biome.BiomeBuilder(); // Builder
-
-
-        builder.biomeCategory(Reflection.BIOME.getBiomeCategory(vanilla))
-            .precipitation(vanilla.getPrecipitation()) // getPrecipitation
-            .mobSpawnSettings(vanilla.getMobSettings())
-            .generationSettings(vanilla.getGenerationSettings())
-            .temperature(vanilla.getBaseTemperature())
-            .downfall(vanilla.getDownfall());
-
-
-        BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder();
-
-        effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier());
-
-        VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
-
-        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()));
-
-        if(vanillaBiomeProperties.getFoliageColor() == null) {
-            vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride);
-        } else {
-            effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor());
-        }
-
-        if(vanillaBiomeProperties.getGrassColor() == null) {
-            vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride);
-        } else {
-            effects.grassColorOverride(vanillaBiomeProperties.getGrassColor());
-        }
-
-        vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound);
-        vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound);
-        vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound);
-        vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic);
-        vanilla.getAmbientParticle().ifPresent(effects::ambientParticle);
-
-        builder.specialEffects(effects.build());
-
-        return builder.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_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/NMSBiomeProvider.java

@@ -1,49 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-import com.mojang.serialization.Codec;
-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 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 BiomeSource vanilla;
-    private final long seed;
-    private final Registry<Biome> biomeRegistry = Registries.biomeRegistry();
-
-    public NMSBiomeProvider(BiomeProvider delegate, BiomeSource vanilla, long seed) {
-        super(delegate.stream()
-            .map(biome -> Registries.biomeRegistry()
-                .getOrCreateHolder(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext()
-                    .get(NMSBiomeInfo.class)
-                    .biomeKey())));
-        this.delegate = delegate;
-        this.vanilla = vanilla;
-        this.seed = seed;
-    }
-
-    @Override
-    protected Codec<? extends BiomeSource> codec() {
-        return BiomeSource.CODEC;
-    }
-
-    @Override
-    public @NotNull BiomeSource withSeed(long seed) {
-        return new NMSBiomeProvider(delegate, vanilla, seed);
-    }
-
-    @Override
-    public @NotNull Holder<Biome> getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) {
-        return biomeRegistry.getOrCreateHolder(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed).getPlatformBiome())
-            .getContext()
-            .get(NMSBiomeInfo.class)
-            .biomeKey());
-    }
-}

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

@@ -1,254 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-import com.mojang.datafixers.util.Pair;
-import com.mojang.serialization.Codec;
-import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Holder;
-import net.minecraft.core.SectionPos;
-import net.minecraft.server.level.WorldGenRegion;
-import net.minecraft.world.level.ChunkPos;
-import net.minecraft.world.level.LevelHeightAccessor;
-import net.minecraft.world.level.NoiseColumn;
-import net.minecraft.world.level.StructureFeatureManager;
-import net.minecraft.world.level.WorldGenLevel;
-import net.minecraft.world.level.biome.Biome;
-import net.minecraft.world.level.biome.BiomeManager;
-import net.minecraft.world.level.biome.Climate;
-import net.minecraft.world.level.biome.Climate.Sampler;
-import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import net.minecraft.world.level.levelgen.GenerationStep;
-import net.minecraft.world.level.levelgen.Heightmap;
-import net.minecraft.world.level.levelgen.blending.Blender;
-import net.minecraft.world.level.levelgen.structure.StructureSet;
-import net.minecraft.world.level.levelgen.structure.placement.ConcentricRingsStructurePlacement;
-import net.minecraft.world.level.levelgen.structure.placement.StructurePlacement;
-import org.bukkit.craftbukkit.v1_18_R2.block.data.CraftBlockData;
-import org.jetbrains.annotations.NotNull;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Random;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.stream.Collectors;
-
-import com.dfsek.terra.api.config.ConfigPack;
-import com.dfsek.terra.api.util.MathUtil;
-import com.dfsek.terra.api.util.generic.Lazy;
-import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
-import com.dfsek.terra.api.world.info.WorldProperties;
-
-
-public class NMSChunkGeneratorDelegate extends ChunkGenerator {
-    private static final Logger LOGGER = LoggerFactory.getLogger(NMSChunkGeneratorDelegate.class);
-    private static final Lazy<List<ChunkPos>> EMPTY = Lazy.lazy(List::of);
-    private final NMSBiomeProvider biomeSource;
-    private final com.dfsek.terra.api.world.chunk.generation.ChunkGenerator delegate;
-    private final ChunkGenerator vanilla;
-    private final ConfigPack pack;
-    private final long seed;
-    private final Map<ConcentricRingsStructurePlacement, Lazy<List<ChunkPos>>> ringPositions = new Object2ObjectArrayMap<>();
-    private volatile boolean rings = false;
-
-    public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) {
-        super(Registries.structureSet(), Optional.empty(), biomeProvider, biomeProvider, seed);
-        this.delegate = pack.getGeneratorProvider().newInstance(pack);
-        this.vanilla = vanilla;
-        this.biomeSource = biomeProvider;
-        this.pack = pack;
-        this.seed = seed;
-    }
-
-    @Override
-    public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull BiomeManager biomeAccess,
-                             @NotNull StructureFeatureManager structureAccessor,
-                             @NotNull ChunkAccess chunk, GenerationStep.@NotNull Carving generationStep) {
-        // no-op
-    }
-
-    @Override
-    public void applyBiomeDecoration(@NotNull WorldGenLevel world, @NotNull ChunkAccess chunk,
-                                     @NotNull StructureFeatureManager structureAccessor) {
-        vanilla.applyBiomeDecoration(world, chunk, structureAccessor);
-    }
-
-    @Override
-    public int getSeaLevel() {
-        return vanilla.getSeaLevel();
-    }
-
-    @Override
-    public @NotNull CompletableFuture<ChunkAccess> fillFromNoise(@NotNull Executor executor, @NotNull Blender blender,
-                                                                 @NotNull StructureFeatureManager structureAccessor,
-                                                                 @NotNull ChunkAccess chunk) {
-        return vanilla.fillFromNoise(executor, blender, structureAccessor, chunk);
-    }
-
-    @Override
-    public void buildSurface(@NotNull WorldGenRegion region, @NotNull StructureFeatureManager structures, @NotNull ChunkAccess chunk) {
-        // no-op
-    }
-
-    @Override
-    protected @NotNull Codec<? extends ChunkGenerator> codec() {
-        return ChunkGenerator.CODEC;
-    }
-
-    @Override
-    public @NotNull NoiseColumn getBaseColumn(int x, int z, LevelHeightAccessor height) {
-        /*
-        BlockState[] array = new BlockState[height.getHeight()];
-        WorldProperties properties = new NMSWorldProperties(seed, height);
-        BiomeProvider biomeProvider = pack.getBiomeProvider().caching(properties);
-        for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) {
-            array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider)
-                                                                             .getHandle()).getState();
-        }
-        return new NoiseColumn(getMinY(), array);
-         */
-        return vanilla.getBaseColumn(x, z, height);
-    }
-
-    @Override // withSeed
-    public @NotNull ChunkGenerator withSeed(long seed) {
-        return new NMSChunkGeneratorDelegate(vanilla, pack, biomeSource, seed);
-    }
-
-    @Override
-    public void spawnOriginalMobs(@NotNull WorldGenRegion regionlimitedworldaccess) {
-        vanilla.spawnOriginalMobs(regionlimitedworldaccess);
-    }
-
-    @Override
-    public int getGenDepth() {
-        return vanilla.getGenDepth();
-    }
-
-    @Override
-    public @NotNull Sampler climateSampler() {
-        return Climate.empty();
-    }
-
-    @Override
-    public int getMinY() {
-        return vanilla.getMinY();
-    }
-
-    @Override
-    public int getBaseHeight(int x, int z, Heightmap.@NotNull Types heightmap, @NotNull LevelHeightAccessor world) {
-        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;
-    }
-
-    @Nullable
-    @Override
-    public List<ChunkPos> getRingPositionsFor(@NotNull ConcentricRingsStructurePlacement concentricringsstructureplacement) {
-        ensureStructuresGenerated();
-        return ringPositions.getOrDefault(concentricringsstructureplacement, EMPTY).value();
-    }
-
-    @Override
-    public synchronized void ensureStructuresGenerated() {
-        if(!this.rings) {
-            super.ensureStructuresGenerated();
-            this.populateStrongholdData();
-            this.rings = true;
-        }
-    }
-
-    private void populateStrongholdData() {
-        LOGGER.info("Generating safe stronghold data. This may take up to a minute.");
-        Set<Holder<Biome>> set = this.runtimeBiomeSource.possibleBiomes();
-        possibleStructureSets().map(Holder::value).forEach((holder) -> { // we dont need the spigot crap because it doesnt touch concentric.
-            StructurePlacement structureplacement = holder.placement();
-            if(structureplacement instanceof ConcentricRingsStructurePlacement concentricringsstructureplacement) {
-                if(holder.structures().stream().anyMatch((structureset_a1) -> structureset_a1.generatesInMatchingBiome(set::contains))) {
-                    this.ringPositions.put(concentricringsstructureplacement,
-                        Lazy.lazy(() -> this.generateRingPositions(holder, concentricringsstructureplacement)));
-                }
-            }
-        });
-    }
-
-    private List<ChunkPos> generateRingPositions(StructureSet holder,
-                                                 ConcentricRingsStructurePlacement concentricringsstructureplacement) { // Spigot
-        if(concentricringsstructureplacement.count() == 0) {
-            return List.of();
-        }
-
-        List<ChunkPos> list = new ArrayList<>();
-        Set<Holder<Biome>> set = holder
-            .structures()
-            .stream()
-            .flatMap((structureset_a) -> structureset_a.structure().value().biomes().stream())
-            .collect(Collectors.toSet());
-        int i = concentricringsstructureplacement.distance();
-        int j = concentricringsstructureplacement.count();
-        int k = concentricringsstructureplacement.spread();
-        Random random = new Random();
-
-        // Paper start
-        if(this.conf.strongholdSeed != null && this.structureSets.getResourceKey(holder).orElse(null) ==
-                                               net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.STRONGHOLDS) {
-            random.setSeed(this.conf.strongholdSeed);
-        } else {
-            // Paper end
-            random.setSeed(this.ringPlacementSeed);
-        } // Paper
-        double d0 = random.nextDouble() * 3.141592653589793D * 2.0D;
-        int l = 0;
-        int i1 = 0;
-
-        for(int j1 = 0; j1 < j; ++j1) {
-            double d1 = (double) (4 * i + i * i1 * 6) + (random.nextDouble() - 0.5D) * (double) i * 2.5D;
-            int k1 = (int) Math.round(MathUtil.cos(d0) * d1);
-            int l1 = (int) Math.round(MathUtil.sin(d0) * d1);
-            int i2 = SectionPos.sectionToBlockCoord(k1, 8);
-            int j2 = SectionPos.sectionToBlockCoord(l1, 8);
-
-            Objects.requireNonNull(set);
-            Pair<BlockPos, Holder<Biome>> pair = this.biomeSource.findBiomeHorizontal(i2, 0, j2, 112, set::contains, random,
-                this.climateSampler());
-
-            if(pair != null) {
-                BlockPos blockposition = pair.getFirst();
-
-                k1 = SectionPos.blockToSectionCoord(blockposition.getX());
-                l1 = SectionPos.blockToSectionCoord(blockposition.getZ());
-            }
-
-            list.add(new ChunkPos(k1, l1));
-            d0 += 6.283185307179586D / (double) k;
-            ++l;
-            if(l == k) {
-                ++i1;
-                l = 0;
-                k += 2 * k / (i1 + 1);
-                k = Math.min(k, j - j1);
-                d0 += random.nextDouble() * 3.141592653589793D * 2.0D;
-            }
-        }
-
-        return list;
-    }
-
-    @Override
-    public void addDebugScreenInfo(@NotNull List<String> arg0, @NotNull BlockPos arg1) {
-
-    }
-}

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

@@ -1,15 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-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());
-    }
-}

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

@@ -1,53 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_18_R2.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(), vanilla.getBiomeSource(), craftWorld.getSeed());
-            NMSChunkGeneratorDelegate custom = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed());
-
-            custom.conf = vanilla.conf; // world config from Spigot
-
-            serverWorld.getChunkSource().chunkMap.generator = custom;
-
-            LOGGER.info("Successfully injected into world.");
-
-            serverWorld.getChunkSource().chunkMap.generator.ensureStructuresGenerated(); // generate stronghold data now
-
-            INJECT_LOCK.unlock();
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-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.getMaxBuildHeight();
-    }
-
-    @Override
-    public int getMinHeight() {
-        return height.getMinBuildHeight();
-    }
-}

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

@@ -1,38 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.world.level.biome.Biome;
-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.Proxies;
-
-
-public class Reflection {
-    public static final MappedRegistryProxy MAPPED_REGISTRY;
-    public static final BiomeProxy BIOME;
-
-    static {
-        ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar();
-        ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper,
-            Reflection.class.getClassLoader());
-
-        MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class);
-        BIOME = reflectionProxyFactory.reflectionProxy(BiomeProxy.class);
-    }
-
-
-    @Proxies(MappedRegistry.class)
-    public interface MappedRegistryProxy {
-        @FieldSetter("frozen")
-        void setFrozen(MappedRegistry<?> instance, boolean frozen);
-    }
-
-
-    @Proxies(Biome.class)
-    public interface BiomeProxy {
-        @FieldGetter("biomeCategory")
-        Biome.BiomeCategory getBiomeCategory(Biome instance);
-    }
-}

platforms/bukkit/nms/v1_18_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_18_R2/Registries.java

@@ -1,30 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_18_R2;
-
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.server.dedicated.DedicatedServer;
-import net.minecraft.world.level.biome.Biome;
-import net.minecraft.world.level.levelgen.structure.StructureSet;
-import org.bukkit.Bukkit;
-import org.bukkit.craftbukkit.v1_18_R2.CraftServer;
-
-
-public class Registries {
-    private static <T> Registry<T> getRegistry(ResourceKey<Registry<T>> key) {
-        CraftServer craftserver = (CraftServer) Bukkit.getServer();
-        DedicatedServer dedicatedserver = craftserver.getServer();
-        return dedicatedserver
-            .registryAccess()
-            .registryOrThrow( // getRegistry
-                key
-            );
-    }
-
-    public static Registry<Biome> biomeRegistry() {
-        return getRegistry(Registry.BIOME_REGISTRY);
-    }
-
-    public static Registry<StructureSet> structureSet() {
-        return getRegistry(Registry.STRUCTURE_SET_REGISTRY);
-    }
-}

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

@@ -1,17 +0,0 @@
-apply(plugin = "io.papermc.paperweight.userdev")
-
-repositories {
-    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
-}
-
-dependencies {
-    api(project(":platforms:bukkit:common"))
-    paperDevBundle("1.19-R0.1-SNAPSHOT")
-    implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
-}
-
-tasks {
-    assemble {
-        dependsOn("reobfJar")
-    }
-}

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

@@ -1,116 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-import com.google.common.collect.ImmutableMap;
-import com.mojang.serialization.Lifecycle;
-import net.minecraft.core.Holder;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.core.Registry;
-import net.minecraft.core.WritableRegistry;
-import net.minecraft.data.BuiltinRegistries;
-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.List;
-import java.util.Map;
-import java.util.Objects;
-
-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...");
-            WritableRegistry<Biome> biomeRegistry = (WritableRegistry<Biome>) Registries.biomeRegistry();
-
-            Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry<?>) biomeRegistry, false);
-
-            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 = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey());
-                    Biome platform = NMSBiomeInjector.createBiome(
-                        biome,
-                        Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey)) // get
-                    );
-
-                    ResourceKey<Biome> delegateKey = ResourceKey.create(Registry.BIOME_REGISTRY,
-                        new ResourceLocation("terra",
-                            NMSBiomeInjector.createBiomeID(pack, key)));
-
-                    BuiltinRegistries.register(BuiltinRegistries.BIOME, delegateKey, platform);
-                    biomeRegistry.register(delegateKey, platform, Lifecycle.stable());
-                    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((MappedRegistry<?>) 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.getFirst(), new ArrayList<>(pair.getSecond().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.unwrapKey()
-                                                    .orElseThrow()
-                                                    .location() +
-                                                " (vanilla for " +
-                                                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)));
-
-            biomeRegistry.resetTags();
-            biomeRegistry.bindTags(ImmutableMap.copyOf(collect));
-
-        } catch(SecurityException | IllegalArgumentException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-}

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

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

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

@@ -1,79 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-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.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.config.VanillaBiomeProperties;
-
-
-public class NMSBiomeInjector {
-
-    public static <T> Optional<Holder<T>> getEntry(Registry<T> registry, ResourceLocation identifier) {
-        return registry.getOptional(identifier)
-            .flatMap(registry::getResourceKey)
-            .map(registry::getOrCreateHolderOrThrow);
-    }
-
-    public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla)
-    throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-        Biome.BiomeBuilder builder = new Biome.BiomeBuilder();
-
-        builder
-            .precipitation(vanilla.getPrecipitation())
-            .downfall(vanilla.getDownfall())
-            .temperature(vanilla.getBaseTemperature())
-            .mobSpawnSettings(vanilla.getMobSettings())
-            .generationSettings(vanilla.getGenerationSettings());
-
-
-        BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder();
-
-        effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier());
-
-        VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
-
-        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()));
-
-        if(vanillaBiomeProperties.getFoliageColor() == null) {
-            vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride);
-        } else {
-            effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor());
-        }
-
-        if(vanillaBiomeProperties.getGrassColor() == null) {
-            vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride);
-        } else {
-            // grass
-            effects.grassColorOverride(vanillaBiomeProperties.getGrassColor());
-        }
-
-        vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound);
-        vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound);
-        vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound);
-        vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic);
-        vanilla.getAmbientParticle().ifPresent(effects::ambientParticle);
-
-        builder.specialEffects(effects.build());
-
-        return builder.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_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/NMSBiomeProvider.java

@@ -1,42 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-import com.mojang.serialization.Codec;
-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 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 = Registries.biomeRegistry();
-
-    public NMSBiomeProvider(BiomeProvider delegate, long seed) {
-        super(delegate.stream()
-            .map(biome -> Registries.biomeRegistry()
-                .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext()
-                    .get(NMSBiomeInfo.class)
-                    .biomeKey())));
-        this.delegate = delegate;
-        this.seed = seed;
-    }
-
-    @Override
-    protected @NotNull Codec<? extends BiomeSource> codec() {
-        return BiomeSource.CODEC;
-    }
-
-    @Override
-    public @NotNull Holder<Biome> getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) {
-        return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed)
-            .getPlatformBiome()).getContext()
-            .get(NMSBiomeInfo.class)
-            .biomeKey());
-    }
-}

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

@@ -1,291 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-import com.mojang.datafixers.util.Pair;
-import com.mojang.serialization.Codec;
-import it.unimi.dsi.fastutil.objects.Object2ObjectArrayMap;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Holder;
-import net.minecraft.core.HolderSet;
-import net.minecraft.core.SectionPos;
-import net.minecraft.server.level.WorldGenRegion;
-import net.minecraft.util.RandomSource;
-import net.minecraft.world.level.ChunkPos;
-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.Biome;
-import net.minecraft.world.level.biome.BiomeManager;
-import net.minecraft.world.level.block.Blocks;
-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.GenerationStep.Carving;
-import net.minecraft.world.level.levelgen.Heightmap.Types;
-import net.minecraft.world.level.levelgen.RandomState;
-import net.minecraft.world.level.levelgen.blending.Blender;
-import net.minecraft.world.level.levelgen.structure.Structure;
-import net.minecraft.world.level.levelgen.structure.StructureSet;
-import net.minecraft.world.level.levelgen.structure.StructureSet.StructureSelectionEntry;
-import net.minecraft.world.level.levelgen.structure.placement.ConcentricRingsStructurePlacement;
-import org.bukkit.craftbukkit.v1_19_R1.block.data.CraftBlockData;
-import org.jetbrains.annotations.NotNull;
-import org.slf4j.Logger;
-import org.slf4j.LoggerFactory;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Executor;
-import java.util.stream.Stream;
-
-import com.dfsek.terra.api.config.ConfigPack;
-import com.dfsek.terra.api.util.MathUtil;
-import com.dfsek.terra.api.util.generic.Lazy;
-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;
-    private final Map<ConcentricRingsStructurePlacement, Lazy<List<ChunkPos>>> ringPositions = new Object2ObjectArrayMap<>();
-    private volatile boolean rings = false;
-
-    public NMSChunkGeneratorDelegate(ChunkGenerator vanilla, ConfigPack pack, NMSBiomeProvider biomeProvider, long seed) {
-        super(Registries.structureSet(), Optional.empty(), biomeProvider);
-        this.delegate = pack.getGeneratorProvider().newInstance(pack);
-        this.vanilla = vanilla;
-        this.pack = pack;
-        this.seed = seed;
-    }
-
-    @Override
-    protected @NotNull Codec<? extends ChunkGenerator> codec() {
-        return ChunkGenerator.CODEC;
-    }
-
-    @Override
-    public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world,
-                             @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) {
-        // 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 @NotNull CompletableFuture<ChunkAccess> fillFromNoise(@NotNull Executor executor, @NotNull Blender blender,
-                                                                 @NotNull RandomState noiseConfig,
-                                                                 @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) {
-        return vanilla.fillFromNoise(executor, 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(), false);
-                        depth++;
-                    } else if(noise < airThreshold) {
-                        chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false);
-                    } 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().caching(properties);
-        for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) {
-            array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider)
-                                                                             .getHandle()).getState();
-        }
-        return new NoiseColumn(getMinY(), array);
-
-         */
-        return vanilla.getBaseColumn(x, z, world, noiseConfig);
-    }
-
-    @Override
-    public void addDebugScreenInfo(@NotNull List<String> text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) {
-
-    }
-
-    @Override
-    public void ensureStructuresGenerated(@NotNull RandomState noiseConfig) {
-        if(!this.rings) {
-            super.ensureStructuresGenerated(noiseConfig);
-            this.populateStrongholdData(noiseConfig);
-            this.rings = true;
-        }
-
-    }
-
-    @Override
-    public List<ChunkPos> getRingPositionsFor(@NotNull ConcentricRingsStructurePlacement structurePlacement,
-                                              @NotNull RandomState noiseConfig) {
-        ensureStructuresGenerated(noiseConfig);
-        return ringPositions.get(structurePlacement).value();
-    }
-
-    private void populateStrongholdData(RandomState noiseConfig) {
-        LOGGER.info("Generating safe stronghold data. This may take up to a minute.");
-        Set<Holder<Biome>> set = this.biomeSource.possibleBiomes();
-        possibleStructureSets().map(Holder::value).forEach((holder) -> {
-            boolean match = false;
-            for(StructureSelectionEntry structureset_a : holder.structures()) {
-                Structure structure = structureset_a.structure().value();
-                Stream<Holder<Biome>> stream = structure.biomes().stream();
-                if(stream.anyMatch(set::contains)) {
-                    match = true;
-                }
-            }
-
-            if(match) {
-                if(holder.placement() instanceof ConcentricRingsStructurePlacement concentricringsstructureplacement) {
-                    this.ringPositions.put(concentricringsstructureplacement, Lazy.lazy(
-                        () -> this.generateRingPositions(holder, noiseConfig, concentricringsstructureplacement)));
-                }
-            }
-        });
-    }
-
-    private List<ChunkPos> generateRingPositions(StructureSet holder, RandomState randomstate,
-                                                 ConcentricRingsStructurePlacement concentricringsstructureplacement) { // Spigot
-        if(concentricringsstructureplacement.count() == 0) {
-            return List.of();
-        }
-
-        List<ChunkPos> list = new ArrayList<>();
-        int i = concentricringsstructureplacement.distance();
-        int j = concentricringsstructureplacement.count();
-        int k = concentricringsstructureplacement.spread();
-        HolderSet<Biome> holderset = concentricringsstructureplacement.preferredBiomes();
-        RandomSource randomsource = RandomSource.create();
-
-        if(this.conf.strongholdSeed != null && this.structureSets.getResourceKey(holder).orElse(null) ==
-                                               net.minecraft.world.level.levelgen.structure.BuiltinStructureSets.STRONGHOLDS) {
-            randomsource.setSeed(this.conf.strongholdSeed);
-        } else {
-            randomsource.setSeed(randomstate.legacyLevelSeed());
-        }
-        double d0 = randomsource.nextDouble() * 3.141592653589793D * 2.0D;
-        int l = 0;
-        int i1 = 0;
-
-        for(int j1 = 0; j1 < j; ++j1) {
-            double d1 = (double) (4 * i + i * i1 * 6) + (randomsource.nextDouble() - 0.5D) * (double) i * 2.5D;
-            int k1 = (int) Math.round(MathUtil.cos(d0) * d1);
-            int l1 = (int) Math.round(MathUtil.sin(d0) * d1);
-            int i2 = SectionPos.sectionToBlockCoord(k1, 8);
-            int j2 = SectionPos.sectionToBlockCoord(l1, 8);
-
-            Objects.requireNonNull(holderset);
-            Pair<BlockPos, Holder<Biome>> pair = this.biomeSource.findBiomeHorizontal(i2, 0, j2, 112, holderset::contains, randomsource,
-                randomstate.sampler());
-
-            if(pair != null) {
-                BlockPos blockposition = pair.getFirst();
-
-                k1 = SectionPos.blockToSectionCoord(blockposition.getX());
-                l1 = SectionPos.blockToSectionCoord(blockposition.getZ());
-            }
-
-            list.add(new ChunkPos(k1, l1));
-            d0 += 6.283185307179586D / (double) k;
-            ++l;
-            if(l == k) {
-                ++i1;
-                l = 0;
-                k += 2 * k / (i1 + 1);
-                k = Math.min(k, j - j1);
-                d0 += randomsource.nextDouble() * 3.141592653589793D * 2.0D;
-            }
-        }
-
-        return list;
-    }
-}

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

@@ -1,15 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-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());
-    }
-}

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

@@ -1,51 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_19_R1.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());
-            NMSChunkGeneratorDelegate custom = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed());
-
-            custom.conf = vanilla.conf; // world config from Spigot
-
-            serverWorld.getChunkSource().chunkMap.generator = custom;
-
-            LOGGER.info("Successfully injected into world.");
-
-            INJECT_LOCK.unlock();
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-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.getMaxBuildHeight();
-    }
-
-    @Override
-    public int getMinHeight() {
-        return height.getMinBuildHeight();
-    }
-}

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

@@ -1,39 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.world.level.LevelAccessor;
-import net.minecraft.world.level.StructureManager;
-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.Proxies;
-
-
-public class Reflection {
-    public static final MappedRegistryProxy MAPPED_REGISTRY;
-    public static final StructureManagerProxy STRUCTURE_MANAGER;
-
-    static {
-        ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar();
-        ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper,
-            Reflection.class.getClassLoader());
-
-        MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class);
-        STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class);
-    }
-
-
-    @Proxies(MappedRegistry.class)
-    public interface MappedRegistryProxy {
-        @FieldSetter("frozen")
-        void setFrozen(MappedRegistry<?> instance, boolean frozen);
-    }
-
-
-    @Proxies(StructureManager.class)
-    public interface StructureManagerProxy {
-        @FieldGetter("level")
-        LevelAccessor getLevel(StructureManager instance);
-    }
-}

platforms/bukkit/nms/v1_19_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R1/Registries.java

@@ -1,30 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R1;
-
-import net.minecraft.core.Registry;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.server.dedicated.DedicatedServer;
-import net.minecraft.world.level.biome.Biome;
-import net.minecraft.world.level.levelgen.structure.StructureSet;
-import org.bukkit.Bukkit;
-import org.bukkit.craftbukkit.v1_19_R1.CraftServer;
-
-
-public class Registries {
-    private static <T> Registry<T> getRegistry(ResourceKey<Registry<T>> key) {
-        CraftServer craftserver = (CraftServer) Bukkit.getServer();
-        DedicatedServer dedicatedserver = craftserver.getServer();
-        return dedicatedserver
-            .registryAccess()
-            .registryOrThrow( // getRegistry
-                key
-            );
-    }
-
-    public static Registry<Biome> biomeRegistry() {
-        return getRegistry(Registry.BIOME_REGISTRY);
-    }
-
-    public static Registry<StructureSet> structureSet() {
-        return getRegistry(Registry.STRUCTURE_SET_REGISTRY);
-    }
-}

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

@@ -1,17 +0,0 @@
-apply(plugin = "io.papermc.paperweight.userdev")
-
-repositories {
-    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
-}
-
-dependencies {
-    api(project(":platforms:bukkit:common"))
-    paperDevBundle("1.19.3-R0.1-SNAPSHOT")
-    implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
-}
-
-tasks {
-    assemble {
-        dependsOn("reobfJar")
-    }
-}

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

@@ -1,100 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-import com.google.common.collect.ImmutableMap;
-import com.mojang.serialization.Lifecycle;
-import net.minecraft.core.Holder;
-import net.minecraft.core.Holder.Reference;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.core.WritableRegistry;
-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.List;
-import java.util.Map;
-import java.util.Objects;
-
-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...");
-            WritableRegistry<Biome> biomeRegistry = (WritableRegistry<Biome>) RegistryFetcher.biomeRegistry();
-
-            Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry<?>) biomeRegistry, false);
-
-            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 = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey());
-                    Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey)));
-
-                    ResourceKey<Biome> delegateKey = ResourceKey.create(
-                        Registries.BIOME,
-                        new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key))
-                    );
-
-                    Reference<Biome> holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable());
-                    Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder.
-
-                    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((MappedRegistry<?>) 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.getFirst(), new ArrayList<>(pair.getSecond().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)));
-
-            biomeRegistry.resetTags();
-            biomeRegistry.bindTags(ImmutableMap.copyOf(collect));
-
-        } catch(SecurityException | IllegalArgumentException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-}

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

@@ -1,10 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-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_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeInjector.java

@@ -1,79 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-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.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.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::getHolder);
-    }
-
-    public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla)
-    throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-        Biome.BiomeBuilder builder = new Biome.BiomeBuilder();
-
-        builder
-            .precipitation(vanilla.getPrecipitation())
-            .downfall(vanilla.getDownfall())
-            .temperature(vanilla.getBaseTemperature())
-            .mobSpawnSettings(vanilla.getMobSettings())
-            .generationSettings(vanilla.getGenerationSettings());
-
-
-        BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder();
-
-        effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier());
-
-        VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
-
-        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()));
-
-        if(vanillaBiomeProperties.getFoliageColor() == null) {
-            vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride);
-        } else {
-            effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor());
-        }
-
-        if(vanillaBiomeProperties.getGrassColor() == null) {
-            vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride);
-        } else {
-            // grass
-            effects.grassColorOverride(vanillaBiomeProperties.getGrassColor());
-        }
-
-        vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound);
-        vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound);
-        vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound);
-        vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic);
-        vanilla.getAmbientParticle().ifPresent(effects::ambientParticle);
-
-        builder.specialEffects(effects.build());
-
-        return builder.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_19_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R2/NMSBiomeProvider.java

@@ -1,42 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-import com.mojang.serialization.Codec;
-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 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(delegate.stream()
-            .map(biome -> RegistryFetcher.biomeRegistry()
-                .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext()
-                    .get(NMSBiomeInfo.class)
-                    .biomeKey())));
-        this.delegate = delegate;
-        this.seed = seed;
-    }
-
-    @Override
-    protected @NotNull Codec<? extends BiomeSource> codec() {
-        return BiomeSource.CODEC;
-    }
-
-    @Override
-    public @NotNull Holder<Biome> getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) {
-        return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed)
-            .getPlatformBiome()).getContext()
-            .get(NMSBiomeInfo.class)
-            .biomeKey());
-    }
-}

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

@@ -1,174 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-import com.mojang.serialization.Codec;
-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.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.GenerationStep.Carving;
-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.v1_19_R2.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 java.util.concurrent.Executor;
-
-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 Codec<? extends ChunkGenerator> codec() {
-        return ChunkGenerator.CODEC;
-    }
-
-    @Override
-    public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world,
-                             @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) {
-        // 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 @NotNull CompletableFuture<ChunkAccess> fillFromNoise(@NotNull Executor executor, @NotNull Blender blender,
-                                                                 @NotNull RandomState noiseConfig,
-                                                                 @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) {
-        return vanilla.fillFromNoise(executor, 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(), false);
-                        depth++;
-                    } else if(noise < airThreshold) {
-                        chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false);
-                    } 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().caching(properties);
-        for(int y = properties.getMaxHeight() - 1; y >= properties.getMinHeight(); y--) {
-            array[y - properties.getMinHeight()] = ((CraftBlockData) delegate.getBlock(properties, x, y, z, biomeProvider)
-                                                                             .getHandle()).getState();
-        }
-        return new NoiseColumn(getMinY(), array);
-
-         */
-        return vanilla.getBaseColumn(x, z, world, noiseConfig);
-    }
-
-    @Override
-    public void addDebugScreenInfo(@NotNull List<String> text, @NotNull RandomState noiseConfig, @NotNull BlockPos pos) {
-
-    }
-}

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

@@ -1,15 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-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());
-    }
-}

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

@@ -1,48 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_19_R2.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());
-
-            serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed());
-
-            LOGGER.info("Successfully injected into world.");
-
-            INJECT_LOCK.unlock();
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-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.getMaxBuildHeight();
-    }
-
-    @Override
-    public int getMinHeight() {
-        return height.getMinBuildHeight();
-    }
-}

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

@@ -1,52 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-import net.minecraft.core.Holder;
-import net.minecraft.core.Holder.Reference;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.world.level.LevelAccessor;
-import net.minecraft.world.level.StructureManager;
-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;
-
-
-public class Reflection {
-    public static final MappedRegistryProxy MAPPED_REGISTRY;
-    public static final StructureManagerProxy STRUCTURE_MANAGER;
-
-    public static final ReferenceProxy REFERENCE;
-
-    static {
-        ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar();
-        ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper,
-            Reflection.class.getClassLoader());
-
-        MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class);
-        STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class);
-        REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class);
-    }
-
-
-    @Proxies(MappedRegistry.class)
-    public interface MappedRegistryProxy {
-        @FieldSetter("frozen")
-        void setFrozen(MappedRegistry<?> instance, boolean frozen);
-    }
-
-
-    @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);
-    }
-}

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

@@ -1,24 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R2;
-
-import net.minecraft.core.Registry;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.server.dedicated.DedicatedServer;
-import net.minecraft.world.level.biome.Biome;
-import org.bukkit.Bukkit;
-import org.bukkit.craftbukkit.v1_19_R2.CraftServer;
-
-
-public class RegistryFetcher {
-    private static <T> Registry<T> getRegistry(ResourceKey<Registry<T>> key) {
-        CraftServer craftserver = (CraftServer) Bukkit.getServer();
-        DedicatedServer dedicatedserver = craftserver.getServer();
-        return dedicatedserver
-            .registryAccess()
-            .registryOrThrow(key);
-    }
-
-    public static Registry<Biome> biomeRegistry() {
-        return getRegistry(Registries.BIOME);
-    }
-}

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

@@ -1,17 +0,0 @@
-apply(plugin = "io.papermc.paperweight.userdev")
-
-repositories {
-    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
-}
-
-dependencies {
-    api(project(":platforms:bukkit:common"))
-    paperDevBundle("1.19.4-R0.1-SNAPSHOT")
-    implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
-}
-
-tasks {
-    assemble {
-        dependsOn("reobfJar")
-    }
-}

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

@@ -1,101 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-import com.google.common.collect.ImmutableMap;
-import com.mojang.serialization.Lifecycle;
-import net.minecraft.core.Holder;
-import net.minecraft.core.Holder.Reference;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.core.WritableRegistry;
-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.List;
-import java.util.Map;
-import java.util.Objects;
-
-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...");
-            WritableRegistry<Biome> biomeRegistry = (WritableRegistry<Biome>) RegistryFetcher.biomeRegistry();
-
-            Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry<?>) biomeRegistry, false);
-
-            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 = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey());
-                    Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey)));
-
-                    ResourceKey<Biome> delegateKey = ResourceKey.create(
-                        Registries.BIOME,
-                        new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key))
-                    );
-
-                    Reference<Biome> holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable());
-                    Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder.
-
-                    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((MappedRegistry<?>) 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.getFirst(), new ArrayList<>(pair.getSecond().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)));
-
-            biomeRegistry.resetTags();
-            biomeRegistry.bindTags(ImmutableMap.copyOf(collect));
-
-        } catch(SecurityException | IllegalArgumentException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-}
-

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

@@ -1,10 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-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_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeInjector.java

@@ -1,78 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-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.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.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::getHolder);
-    }
-
-    public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla)
-    throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-        Biome.BiomeBuilder builder = new Biome.BiomeBuilder();
-
-        builder
-            .downfall(vanilla.climateSettings.downfall())
-            .temperature(vanilla.getBaseTemperature())
-            .mobSpawnSettings(vanilla.getMobSettings())
-            .generationSettings(vanilla.getGenerationSettings());
-
-
-        BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder();
-
-        effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier());
-
-        VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
-
-        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()));
-
-        if(vanillaBiomeProperties.getFoliageColor() == null) {
-            vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride);
-        } else {
-            effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor());
-        }
-
-        if(vanillaBiomeProperties.getGrassColor() == null) {
-            vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride);
-        } else {
-            // grass
-            effects.grassColorOverride(vanillaBiomeProperties.getGrassColor());
-        }
-
-        vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound);
-        vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound);
-        vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound);
-        vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic);
-        vanilla.getAmbientParticle().ifPresent(effects::ambientParticle);
-
-        builder.specialEffects(effects.build());
-
-        return builder.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_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSBiomeProvider.java

@@ -1,49 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-import com.mojang.serialization.Codec;
-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()
-                .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext()
-                    .get(NMSBiomeInfo.class)
-                    .biomeKey()));
-    }
-
-    @Override
-    protected @NotNull Codec<? extends BiomeSource> codec() {
-        return BiomeSource.CODEC;
-    }
-
-    @Override
-    public @NotNull Holder<Biome> getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) {
-        return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed)
-            .getPlatformBiome()).getContext()
-            .get(NMSBiomeInfo.class)
-            .biomeKey());
-    }
-}

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

@@ -1,171 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-import com.mojang.serialization.Codec;
-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.GenerationStep.Carving;
-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.v1_19_R3.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 java.util.concurrent.Executor;
-
-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 Codec<? extends ChunkGenerator> codec() {
-        return ChunkGenerator.CODEC;
-    }
-
-    @Override
-    public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world,
-                             @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) {
-        // 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 @NotNull CompletableFuture<ChunkAccess> fillFromNoise(@NotNull Executor executor, @NotNull Blender blender,
-                                                                 @NotNull RandomState noiseConfig,
-                                                                 @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) {
-        return vanilla.fillFromNoise(executor, 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(), false);
-                        depth++;
-                    } else if(noise < airThreshold) {
-                        chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false);
-                    } 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() - 1; 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_19_R3/src/main/java/com/dfsek/terra/bukkit/nms/v1_19_R3/NMSInitializer.java

@@ -1,15 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-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());
-    }
-}

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

@@ -1,48 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_19_R3.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());
-
-            serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed());
-
-            LOGGER.info("Successfully injected into world.");
-
-            INJECT_LOCK.unlock();
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-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.getMaxBuildHeight();
-    }
-
-    @Override
-    public int getMinHeight() {
-        return height.getMinBuildHeight();
-    }
-}

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

@@ -1,52 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-import net.minecraft.core.Holder;
-import net.minecraft.core.Holder.Reference;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.world.level.LevelAccessor;
-import net.minecraft.world.level.StructureManager;
-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;
-
-
-public class Reflection {
-    public static final MappedRegistryProxy MAPPED_REGISTRY;
-    public static final StructureManagerProxy STRUCTURE_MANAGER;
-
-    public static final ReferenceProxy REFERENCE;
-
-    static {
-        ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar();
-        ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper,
-            Reflection.class.getClassLoader());
-
-        MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class);
-        STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class);
-        REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class);
-    }
-
-
-    @Proxies(MappedRegistry.class)
-    public interface MappedRegistryProxy {
-        @FieldSetter("frozen")
-        void setFrozen(MappedRegistry<?> instance, boolean frozen);
-    }
-
-
-    @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);
-    }
-}

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

@@ -1,24 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_19_R3;
-
-import net.minecraft.core.Registry;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.server.dedicated.DedicatedServer;
-import net.minecraft.world.level.biome.Biome;
-import org.bukkit.Bukkit;
-import org.bukkit.craftbukkit.v1_19_R3.CraftServer;
-
-
-public class RegistryFetcher {
-    private static <T> Registry<T> getRegistry(ResourceKey<Registry<T>> key) {
-        CraftServer craftserver = (CraftServer) Bukkit.getServer();
-        DedicatedServer dedicatedserver = craftserver.getServer();
-        return dedicatedserver
-            .registryAccess()
-            .registryOrThrow(key);
-    }
-
-    public static Registry<Biome> biomeRegistry() {
-        return getRegistry(Registries.BIOME);
-    }
-}

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

@@ -1,17 +0,0 @@
-apply(plugin = "io.papermc.paperweight.userdev")
-
-repositories {
-    maven("https://s01.oss.sonatype.org/content/repositories/snapshots/")
-}
-
-dependencies {
-    api(project(":platforms:bukkit:common"))
-    paperDevBundle("1.20.1-R0.1-SNAPSHOT")
-    implementation("xyz.jpenilla", "reflection-remapper", Versions.Bukkit.reflectionRemapper)
-}
-
-tasks {
-    assemble {
-        dependsOn("reobfJar")
-    }
-}

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

@@ -1,101 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-import com.google.common.collect.ImmutableMap;
-import com.mojang.serialization.Lifecycle;
-import net.minecraft.core.Holder;
-import net.minecraft.core.Holder.Reference;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.core.WritableRegistry;
-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.List;
-import java.util.Map;
-import java.util.Objects;
-
-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...");
-            WritableRegistry<Biome> biomeRegistry = (WritableRegistry<Biome>) RegistryFetcher.biomeRegistry();
-
-            Reflection.MAPPED_REGISTRY.setFrozen((MappedRegistry<?>) biomeRegistry, false);
-
-            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 = new ResourceLocation(vanillaBukkitKey.getNamespace(), vanillaBukkitKey.getKey());
-                    Biome platform = NMSBiomeInjector.createBiome(biome, Objects.requireNonNull(biomeRegistry.get(vanillaMinecraftKey)));
-
-                    ResourceKey<Biome> delegateKey = ResourceKey.create(
-                        Registries.BIOME,
-                        new ResourceLocation("terra", NMSBiomeInjector.createBiomeID(pack, key))
-                    );
-
-                    Reference<Biome> holder = biomeRegistry.register(delegateKey, platform, Lifecycle.stable());
-                    Reflection.REFERENCE.invokeBindValue(holder, platform); // IMPORTANT: bind holder.
-
-                    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((MappedRegistry<?>) 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.getFirst(), new ArrayList<>(pair.getSecond().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)));
-
-            biomeRegistry.resetTags();
-            biomeRegistry.bindTags(ImmutableMap.copyOf(collect));
-
-        } catch(SecurityException | IllegalArgumentException exception) {
-            throw new RuntimeException(exception);
-        }
-    }
-}
-

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

@@ -1,10 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-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_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeInjector.java

@@ -1,78 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-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.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.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::getHolder);
-    }
-
-    public static Biome createBiome(com.dfsek.terra.api.world.biome.Biome biome, Biome vanilla)
-    throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {
-        Biome.BiomeBuilder builder = new Biome.BiomeBuilder();
-
-        builder
-            .downfall(vanilla.climateSettings.downfall())
-            .temperature(vanilla.getBaseTemperature())
-            .mobSpawnSettings(vanilla.getMobSettings())
-            .generationSettings(vanilla.getGenerationSettings());
-
-
-        BiomeSpecialEffects.Builder effects = new BiomeSpecialEffects.Builder();
-
-        effects.grassColorModifier(vanilla.getSpecialEffects().getGrassColorModifier());
-
-        VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
-
-        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()));
-
-        if(vanillaBiomeProperties.getFoliageColor() == null) {
-            vanilla.getSpecialEffects().getFoliageColorOverride().ifPresent(effects::foliageColorOverride);
-        } else {
-            effects.foliageColorOverride(vanillaBiomeProperties.getFoliageColor());
-        }
-
-        if(vanillaBiomeProperties.getGrassColor() == null) {
-            vanilla.getSpecialEffects().getGrassColorOverride().ifPresent(effects::grassColorOverride);
-        } else {
-            // grass
-            effects.grassColorOverride(vanillaBiomeProperties.getGrassColor());
-        }
-
-        vanilla.getAmbientLoop().ifPresent(effects::ambientLoopSound);
-        vanilla.getAmbientAdditions().ifPresent(effects::ambientAdditionsSound);
-        vanilla.getAmbientMood().ifPresent(effects::ambientMoodSound);
-        vanilla.getBackgroundMusic().ifPresent(effects::backgroundMusic);
-        vanilla.getAmbientParticle().ifPresent(effects::ambientParticle);
-
-        builder.specialEffects(effects.build());
-
-        return builder.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_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSBiomeProvider.java

@@ -1,49 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-import com.mojang.serialization.Codec;
-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()
-                .getHolderOrThrow(((BukkitPlatformBiome) biome.getPlatformBiome()).getContext()
-                    .get(NMSBiomeInfo.class)
-                    .biomeKey()));
-    }
-
-    @Override
-    protected @NotNull Codec<? extends BiomeSource> codec() {
-        return BiomeSource.CODEC;
-    }
-
-    @Override
-    public @NotNull Holder<Biome> getNoiseBiome(int x, int y, int z, @NotNull Sampler sampler) {
-        return biomeRegistry.getHolderOrThrow(((BukkitPlatformBiome) delegate.getBiome(x << 2, y << 2, z << 2, seed)
-            .getPlatformBiome()).getContext()
-            .get(NMSBiomeInfo.class)
-            .biomeKey());
-    }
-}

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

@@ -1,171 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-import com.mojang.serialization.Codec;
-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.GenerationStep.Carving;
-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.v1_20_R1.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 java.util.concurrent.Executor;
-
-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 Codec<? extends ChunkGenerator> codec() {
-        return ChunkGenerator.CODEC;
-    }
-
-    @Override
-    public void applyCarvers(@NotNull WorldGenRegion chunkRegion, long seed, @NotNull RandomState noiseConfig, @NotNull BiomeManager world,
-                             @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk, @NotNull Carving carverStep) {
-        // 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 @NotNull CompletableFuture<ChunkAccess> fillFromNoise(@NotNull Executor executor, @NotNull Blender blender,
-                                                                 @NotNull RandomState noiseConfig,
-                                                                 @NotNull StructureManager structureAccessor, @NotNull ChunkAccess chunk) {
-        return vanilla.fillFromNoise(executor, 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(), false);
-                        depth++;
-                    } else if(noise < airThreshold) {
-                        chunk.setBlockState(new BlockPos(x, y, z), Blocks.AIR.defaultBlockState(), false);
-                    } 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() - 1; 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_20_R1/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R1/NMSInitializer.java

@@ -1,15 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-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());
-    }
-}

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

@@ -1,48 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.chunk.ChunkGenerator;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_20_R1.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());
-
-            serverWorld.getChunkSource().chunkMap.generator = new NMSChunkGeneratorDelegate(vanilla, pack, provider, craftWorld.getSeed());
-
-            LOGGER.info("Successfully injected into world.");
-
-            INJECT_LOCK.unlock();
-        }
-    }
-}

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

@@ -1,36 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-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.getMaxBuildHeight();
-    }
-
-    @Override
-    public int getMinHeight() {
-        return height.getMinBuildHeight();
-    }
-}

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

@@ -1,52 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-import net.minecraft.core.Holder;
-import net.minecraft.core.Holder.Reference;
-import net.minecraft.core.MappedRegistry;
-import net.minecraft.world.level.LevelAccessor;
-import net.minecraft.world.level.StructureManager;
-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;
-
-
-public class Reflection {
-    public static final MappedRegistryProxy MAPPED_REGISTRY;
-    public static final StructureManagerProxy STRUCTURE_MANAGER;
-
-    public static final ReferenceProxy REFERENCE;
-
-    static {
-        ReflectionRemapper reflectionRemapper = ReflectionRemapper.forReobfMappingsInPaperJar();
-        ReflectionProxyFactory reflectionProxyFactory = ReflectionProxyFactory.create(reflectionRemapper,
-            Reflection.class.getClassLoader());
-
-        MAPPED_REGISTRY = reflectionProxyFactory.reflectionProxy(MappedRegistryProxy.class);
-        STRUCTURE_MANAGER = reflectionProxyFactory.reflectionProxy(StructureManagerProxy.class);
-        REFERENCE = reflectionProxyFactory.reflectionProxy(ReferenceProxy.class);
-    }
-
-
-    @Proxies(MappedRegistry.class)
-    public interface MappedRegistryProxy {
-        @FieldSetter("frozen")
-        void setFrozen(MappedRegistry<?> instance, boolean frozen);
-    }
-
-
-    @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);
-    }
-}

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

@@ -1,24 +0,0 @@
-package com.dfsek.terra.bukkit.nms.v1_20_R1;
-
-import net.minecraft.core.Registry;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.server.dedicated.DedicatedServer;
-import net.minecraft.world.level.biome.Biome;
-import org.bukkit.Bukkit;
-import org.bukkit.craftbukkit.v1_20_R1.CraftServer;
-
-
-public class RegistryFetcher {
-    private static <T> Registry<T> getRegistry(ResourceKey<Registry<T>> key) {
-        CraftServer craftserver = (CraftServer) Bukkit.getServer();
-        DedicatedServer dedicatedserver = craftserver.getServer();
-        return dedicatedserver
-            .registryAccess()
-            .registryOrThrow(key);
-    }
-
-    public static Registry<Biome> biomeRegistry() {
-        return getRegistry(Registries.BIOME);
-    }
-}

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

@@ -0,0 +1,28 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/config/BiomeMoodSoundTemplate.java

@@ -0,0 +1,36 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/config/BiomeParticleConfigTemplate.java

@@ -0,0 +1,34 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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.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), BuiltInRegistries.PARTICLE_TYPE.asLookup()), probability);
+        } catch(CommandSyntaxException e) {
+            throw new RuntimeException(e);
+        }
+    }
+}

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

@@ -0,0 +1,21 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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.Registry;
+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);
+    }
+}

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

@@ -0,0 +1,36 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/config/SoundEventTemplate.java

@@ -0,0 +1,29 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/config/SpawnCostConfig.java

@@ -0,0 +1,38 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/config/SpawnEntryTemplate.java

@@ -0,0 +1,31 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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 SpawnEntryTemplate implements ObjectTemplate<SpawnerData> {
+    @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;
+    
+    @Override
+    public SpawnerData get() {
+        return new SpawnerData(type, weight, minGroupSize, maxGroupSize);
+    }
+}

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

@@ -0,0 +1,57 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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 net.minecraft.world.level.biome.MobSpawnSettings.SpawnerData;
+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();
+            if (spawn.getEntries() != null) {
+                for(SpawnerData entry : spawn.getEntries()) {
+                    builder.addSpawn(group, entry);
+                }
+            } else if (spawn.getEntry() != null) {
+                if(!used) {
+                    logger.warn("The entry sub-field of spawns is deprecated. " +
+                                "It is recommended to use the entries sub-field instead.");
+                    used = true;
+                }
+            }
+        }
+        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_20_R2/src/main/java/com/dfsek/terra/bukkit/nms/v1_20_R2/config/SpawnTypeConfig.java

@@ -0,0 +1,42 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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.SpawnerData;
+
+
+public class SpawnTypeConfig implements ObjectTemplate<SpawnTypeConfig> {
+    @Value("group")
+    @Default
+    private MobCategory group = null;
+
+    @Value("entries")
+    @Default
+    private List<SpawnerData> entries = null;
+
+    @Value("entry")
+    @Default
+    @Deprecated
+    private SpawnerData entry = null;
+
+    public MobCategory getGroup() {
+        return group;
+    }
+
+    public List<SpawnerData> getEntries() {
+        return entries;
+    }
+
+    @Deprecated
+    public SpawnerData getEntry() {
+        return entry;
+    }
+
+    @Override
+    public SpawnTypeConfig get() {
+        return this;
+    }
+}

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

@@ -0,0 +1,174 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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 java.util.List;
+import net.minecraft.resources.ResourceLocation;
+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.Precipitation;
+import net.minecraft.world.level.biome.Biome.TemperatureModifier;
+import net.minecraft.world.level.biome.BiomeSpecialEffects.GrassColorModifier;
+import net.minecraft.world.level.biome.MobSpawnSettings;
+import com.dfsek.terra.api.properties.Properties;
+
+
+public class VanillaBiomeProperties implements ConfigTemplate, Properties {
+
+    @Value("tags")
+    @Default
+    private List<ResourceLocation> tags = null;
+
+    @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.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 = null;
+
+    @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("spawning")
+    @Default
+    private MobSpawnSettings spawnSettings = null;
+
+    @Value("villager-type")
+    @Default
+    private VillagerType villagerType = null;
+    
+    public List<ResourceLocation> getTags() {
+        return tags;
+    }
+    
+    public Integer getGrassColor() {
+        return grassColor;
+    }
+    
+    public Integer getFogColor() {
+        return fogColor;
+    }
+    
+    public Integer getWaterColor() {
+        return waterColor;
+    }
+    
+    public Integer getWaterFogColor() {
+        return waterFogColor;
+    }
+    
+    public Integer getFoliageColor() {
+        return foliageColor;
+    }
+    
+    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 MobSpawnSettings getSpawnSettings() {
+        return spawnSettings;
+    }
+    
+    public VillagerType getVillagerType() {
+        return villagerType;
+    }
+}

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

@@ -0,0 +1,23 @@
+package com.dfsek.terra.bukkit.nms.v1_20_R2.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.Registry;
+import net.minecraft.core.RegistryCodecs;
+import net.minecraft.core.registries.BuiltInRegistries;
+import net.minecraft.core.registries.Registries;
+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);
+    }
+}

platforms/forge/src/main/java/com/dfsek/terra/forge/ForgePlatform.java

@@ -20,9 +20,6 @@ package com.dfsek.terra.forge;
 import ca.solostudios.strata.Versions;
 import ca.solostudios.strata.parser.tokenizer.ParseException;
 import ca.solostudios.strata.version.Version;
-
-import com.dfsek.terra.registry.master.ConfigRegistry.PackLoadFailuresException;
-
 import net.minecraft.MinecraftVersion;
 import net.minecraft.registry.Registry;
 import net.minecraft.server.MinecraftServer;
@@ -37,7 +34,6 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
 import java.io.File;
-import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
@@ -66,7 +62,8 @@ public class ForgePlatform extends ModPlatform {
     @Override
     public boolean reload() {
         getTerraConfig().load(this);
-        boolean succeed = loadConfigPacks();
+        getRawConfigRegistry().clear();
+        boolean succeed = getRawConfigRegistry().loadAll(this);
 
         MinecraftServer server = getServer();
 

platforms/forge/src/main/java/com/dfsek/terra/forge/util/BiomeUtil.java

@@ -60,13 +60,13 @@ public final class BiomeUtil {
         } else {
             VanillaBiomeProperties vanillaBiomeProperties = biome.getContext().get(VanillaBiomeProperties.class);
 
-            net.minecraft.world.biome.Biome minecraftBiome = MinecraftUtil.createBiome(biome,
+            net.minecraft.world.biome.Biome minecraftBiome = com.dfsek.terra.mod.util.BiomeUtil.createBiome(biome,
                 ForgeRegistries.BIOMES.getDelegateOrThrow(
                         vanilla.getKey().orElseThrow())
                     .value(),
                 vanillaBiomeProperties);
 
-            Identifier identifier = new Identifier("terra", MinecraftUtil.createBiomeID(pack, id));
+            Identifier identifier = new Identifier("terra", com.dfsek.terra.mod.util.BiomeUtil.createBiomeID(pack, id));
 
             if(ForgeRegistries.BIOMES.containsKey(identifier)) {
                 ((ProtoPlatformBiome) biome.getPlatformBiome()).setDelegate(ForgeRegistries.BIOMES.getHolder(identifier)
@@ -83,7 +83,7 @@ public final class BiomeUtil {
                 Objects.requireNonNullElse(vanillaBiomeProperties.getVillagerType(),
                     villagerMap.getOrDefault(vanilla.getKey().orElseThrow(), VillagerType.PLAINS)));
 
-            MinecraftUtil.TERRA_BIOME_MAP.computeIfAbsent(vanilla.getKey().orElseThrow().getValue(), i -> new ArrayList<>()).add(
+            com.dfsek.terra.mod.util.BiomeUtil.TERRA_BIOME_MAP.computeIfAbsent(vanilla.getKey().orElseThrow().getValue(), i -> new ArrayList<>()).add(
                 identifier);
         }
     }

platforms/merged/build.gradle.kts

@@ -13,7 +13,7 @@ val dump = tasks.create("dumpDependents") {
     doFirst {
         taskSet.forEach {
             val resource = File(resourcesDir, it.archiveFileName.get())
-            logger.info("Including archive " + it.archiveFileName.orNull + " in directory " + resource.absolutePath)
+            println("Including archive " + it.archiveFileName.orNull + " in directory " + resource.absolutePath)
             it.archiveFile.get().asFile.copyTo(resource, true)
         }
     }
@@ -32,6 +32,6 @@ afterEvaluate {
         }
         tasks["dumpDependents"].dependsOn(task)
         taskSet.add(task)
-        logger.info("Merged JAR will incorporate task ${task.name} from platform ${it.name}.")
+        println("Merged JAR will incorporate task ${task.name} from platform ${it.name}.")
     }
 }