implement priority to static placement component

# Conflicts:
#	core/src/main/java/com/volmit/iris/engine/IrisEngineMantle.java

README.md

@@ -15,17 +15,17 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma
 
 ### Command Line Builds
 
-1. Install [Java JDK 21](https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html)
+1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
 2. Set the JDK installation path to `JAVA_HOME` as an environment variable.
     * Windows
         1. Start > Type `env` and press Enter
         2. Advanced > Environment Variables
         3. Under System Variables, click `New...`
         4. Variable Name: `JAVA_HOME`
-        5. Variable Value: `C:\Program Files\Java\jdk-21.0.1` (verify this exists after installing java don't just copy
+        5. Variable Value: `C:\Program Files\Java\jdk-17.0.1` (verify this exists after installing java don't just copy
            the example text)
     * MacOS
-        1. Run `/usr/libexec/java_home -V` and look for Java 21
+        1. Run `/usr/libexec/java_home -V` and look for Java 17
         2. Run `sudo nano ~/.zshenv`
         3. Add `export JAVA_HOME=$(/usr/libexec/java_home)` as a new line
         4. Use `CTRL + X`, then Press `Y`, Then `ENTER`
@@ -35,7 +35,7 @@ Consider supporting our development by buying Iris on spigot! We work hard to ma
 
 ### IDE Builds (for development)
 
-* Configure ITJ Gradle to use JDK 21 (in settings, search for gradle)
+* Configure ITJ Gradle to use JDK 17 (in settings, search for gradle)
 * Add a build line in the build.gradle for your own build task to directly compile Iris into your plugins folder if you
   prefer.
 * Resync the project & run your newly created task (under the development folder in gradle tasks!)

build.gradle

@@ -1,5 +1,3 @@
-import xyz.jpenilla.runpaper.task.RunServer
-
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
  * Copyright (c) 2021 Arcane Arts (Volmit Software)
@@ -32,11 +30,9 @@ plugins {
     id 'java-library'
     id "io.github.goooler.shadow" version "8.1.7"
     id "de.undercouch.download" version "5.0.1"
-    id "xyz.jpenilla.run-paper" version "2.3.1"
 }
 
-
-version '3.6.6-1.20.1-1.21.4'
+version '3.5.2-1.19.2-1.21.3'
 
 // ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
 // ======================== WINDOWS =============================
@@ -56,48 +52,32 @@ registerCustomOutputTaskUnix('PixelMac', '/Users/test/Desktop/mcserver/plugins')
 registerCustomOutputTaskUnix('CrazyDev22LT', '/home/julian/Desktop/server/plugins')
 // ==============================================================
 
-def MIN_HEAP_SIZE = "2G"
-def MAX_HEAP_SIZE = "8G"
-//Valid values are: none, truecolor, indexed256, indexed16, indexed8
-def COLOR = "truecolor"
-
 def NMS_BINDINGS = Map.of(
-        "v1_21_R3", "1.21.4-R0.1-SNAPSHOT",
         "v1_21_R2", "1.21.3-R0.1-SNAPSHOT",
         "v1_21_R1", "1.21.1-R0.1-SNAPSHOT",
         "v1_20_R4", "1.20.6-R0.1-SNAPSHOT",
         "v1_20_R3", "1.20.4-R0.1-SNAPSHOT",
         "v1_20_R2", "1.20.2-R0.1-SNAPSHOT",
         "v1_20_R1", "1.20.1-R0.1-SNAPSHOT",
+        "v1_19_R3", "1.19.4-R0.1-SNAPSHOT",
+        "v1_19_R2", "1.19.3-R0.1-SNAPSHOT",
+        "v1_19_R1", "1.19.2-R0.1-SNAPSHOT"
 )
-def JVM_VERSION = Map.<String, Integer>of()
-NMS_BINDINGS.forEach { key, value ->
-    project(":nms:$key") {
+def JVM_VERSION = Map.of()
+NMS_BINDINGS.each { nms ->
+    project(":nms:${nms.key}") {
         apply plugin: 'java'
         apply plugin: 'com.volmit.nmstools'
 
         nmsTools {
-            it.jvm = JVM_VERSION.getOrDefault(key, 21)
-            it.version = value
+            it.jvm = JVM_VERSION.getOrDefault(nms.key, 21)
+            it.version = nms.value
         }
 
         dependencies {
             implementation project(":core")
         }
     }
-
-    tasks.register("runServer-$key", RunServer) {
-        group("servers")
-        minecraftVersion(value.split("-")[0])
-        minHeapSize(MIN_HEAP_SIZE)
-        maxHeapSize(MAX_HEAP_SIZE)
-        pluginJars(tasks.shadowJar.archiveFile)
-        javaLauncher = javaToolchains.launcherFor { it.languageVersion = JavaLanguageVersion.of(JVM_VERSION.getOrDefault(key, 21))}
-        runDirectory.convention(layout.buildDirectory.dir("run/$key"))
-        systemProperty("disable.watchdog", "")
-        systemProperty("net.kyori.ansi.colorLevel", COLOR)
-        systemProperty("com.mojang.eula.agree", true)
-    }
 }
 
 shadowJar {
@@ -149,7 +129,7 @@ allprojects {
         annotationProcessor 'org.projectlombok:lombok:1.18.36'
 
         // Shaded
-        implementation 'com.dfsek:paralithic:0.8.1'
+        implementation 'com.dfsek:Paralithic:0.4.0'
         implementation 'io.papermc:paperlib:1.0.5'
         implementation "net.kyori:adventure-text-minimessage:4.17.0"
         implementation 'net.kyori:adventure-platform-bukkit:4.3.4'

core/build.gradle

@@ -62,7 +62,7 @@ dependencies {
 
     // Third Party Integrations
     compileOnly 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
-    compileOnly 'com.nexomc:nexo:1.0.0-dev.38'
+    compileOnly 'com.nexomc:nexo:0.6.0-dev.0'
     compileOnly 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
     compileOnly 'com.github.PlaceholderAPI:placeholderapi:2.11.3'
     compileOnly 'com.github.Ssomar-Developement:SCore:4.23.10.8'

core/src/main/java/com/volmit/iris/Iris.java

@@ -32,10 +32,8 @@ import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import com.volmit.iris.core.pregenerator.LazyPregenerator;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.core.tools.IrisWorldCreator;
 import com.volmit.iris.engine.EnginePanic;
 import com.volmit.iris.engine.object.IrisCompat;
-import com.volmit.iris.engine.object.IrisContextInjector;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
@@ -103,6 +101,8 @@ import static com.volmit.iris.core.safeguard.ServerBootSFG.passedserversoftware;
 
 @SuppressWarnings("CanBeFinal")
 public class Iris extends VolmitPlugin implements Listener {
+    public static final String OVERWORLD_TAG = "31000";
+
     private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
 
     public static Iris instance;
@@ -459,12 +459,9 @@ public class Iris extends VolmitPlugin implements Listener {
         initialize("com.volmit.iris.core.service").forEach((i) -> services.put((Class<? extends IrisService>) i.getClass(), (IrisService) i));
         INMS.get();
         IO.delete(new File("iris"));
-        compat = IrisCompat.configured(getDataFile("compat.json"));
-        ServerConfigurator.configure();
-        new IrisContextInjector();
         IrisSafeguard.IrisSafeguardSystem();
         getSender().setTag(getTag());
-        IrisSafeguard.earlySplash();
+        compat = IrisCompat.configured(getDataFile("compat.json"));
         linkMultiverseCore = new MultiverseCoreLink();
         linkMythicMobs = new MythicMobsLink();
         configWatcher = new FileWatcher(getDataFile("settings.json"));
@@ -519,10 +516,10 @@ public class Iris extends VolmitPlugin implements Listener {
                 Iris.info("Loading World: %s | Generator: %s", s, generator);
 
                 Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
-                WorldCreator c = new WorldCreator(s)
+                new WorldCreator(s)
                         .generator(getDefaultWorldGenerator(s, generator))
-                        .environment(IrisData.loadAnyDimension(generator).getEnvironment());
-                INMS.get().createWorld(c);
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
                 Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
             }
         } catch (Throwable e) {
@@ -675,12 +672,10 @@ public class Iris extends VolmitPlugin implements Listener {
                 metrics.addCustomChart(new DrilldownPie("used_packs", () -> Bukkit.getWorlds().stream()
                         .map(IrisToolbelt::access)
                         .filter(Objects::nonNull)
-                        .map(PlatformChunkGenerator::getEngine)
-                        .collect(Collectors.toMap(engine -> engine.getDimension().getLoadKey(), engine -> {
-                            var hash32 = engine.getHash32().getNow(null);
-                            if (hash32 == null) return Map.of();
-                            int version = engine.getDimension().getVersion();
-                            String checksum = Long.toHexString(hash32);
+                        .map(PlatformChunkGenerator::getTarget)
+                        .collect(Collectors.toMap(target -> target.getDimension().getLoadKey(), target -> {
+                            int version = target.getDimension().getVersion();
+                            String checksum = IO.hashRecursive(target.getData().getDataFolder());
 
                             return Map.of("v" + version + " (" + checksum + ")", 1);
                         }, (a, b) -> {
@@ -782,7 +777,7 @@ public class Iris extends VolmitPlugin implements Listener {
             service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
         }
 
-        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey(), false);
     }
 
     public void splash() {

core/src/main/java/com/volmit/iris/core/IrisSettings.java

@@ -181,7 +181,6 @@ public class IrisSettings {
         public boolean splashLogoStartup = true;
         public boolean useConsoleCustomColors = true;
         public boolean useCustomColorsIngame = true;
-        public boolean adjustVanillaHeight = false;
         public String forceMainWorld = "";
         public int spinh = -20;
         public int spins = 7;

core/src/main/java/com/volmit/iris/core/ServerConfigurator.java

@@ -28,28 +28,20 @@ import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.object.IrisRange;
 import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.misc.ServerProperties;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
-import lombok.Data;
-import lombok.NonNull;
 import org.bukkit.Bukkit;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
-import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Arrays;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
-import java.util.stream.Stream;
-
-import static com.volmit.iris.core.nms.datapack.IDataFixer.Dimension.*;
 
 public class ServerConfigurator {
     public static void configure() {
@@ -92,13 +84,12 @@ public class ServerConfigurator {
         }
     }
 
-    private static KList<File> getDatapacksFolder() {
+    private static List<File> getDatapacksFolder() {
         if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
             return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
         }
         KList<File> worlds = new KList<>();
         Bukkit.getServer().getWorlds().forEach(w -> worlds.add(new File(w.getWorldFolder(), "datapacks")));
-        if (worlds.isEmpty()) worlds.add(new File(Bukkit.getWorldContainer(), ServerProperties.LEVEL_NAME + "/datapacks"));
         return worlds;
     }
 
@@ -108,17 +99,57 @@ public class ServerConfigurator {
 
     public static void installDataPacks(IDataFixer fixer, boolean fullInstall) {
         Iris.info("Checking Data Packs...");
-        DimensionHeight height = new DimensionHeight(fixer);
-        KList<File> folders = getDatapacksFolder();
-        KMap<String, KSet<String>> biomes = new KMap<>();
+        File packs = new File("plugins/Iris/packs");
+        double ultimateMaxHeight = 0;
+        double ultimateMinHeight = 0;
+        if (packs.exists() && packs.isDirectory()) {
+            for (File pack : packs.listFiles()) {
+                IrisData data = IrisData.get(pack);
+                if (pack.isDirectory()) {
+                    File dimensionsFolder = new File(pack, "dimensions");
+                    if (dimensionsFolder.exists() && dimensionsFolder.isDirectory()) {
+                        for (File file : dimensionsFolder.listFiles()) {
+                            if (file.isFile() && file.getName().endsWith(".json")) {
+                                IrisDimension dim = data.getDimensionLoader().load(file.getName().split("\\Q.\\E")[0]);
+                                if (ultimateMaxHeight < dim.getDimensionHeight().getMax()) {
+                                    ultimateMaxHeight = dim.getDimensionHeight().getMax();
+                                }
+                                if (ultimateMinHeight > dim.getDimensionHeight().getMin()) {
+                                    ultimateMinHeight = dim.getDimensionHeight().getMin();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
 
-        allPacks().flatMap(height::merge)
-                .parallel()
-                .forEach(dim -> {
-                    Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
-                    dim.installBiomes(fixer, dim::getLoader, folders, biomes.computeIfAbsent(dim.getLoadKey(), k -> new KSet<>()));
-                });
-        IrisDimension.writeShared(folders, height);
+        if (packs.exists()) {
+            for (File i : packs.listFiles()) {
+                if (i.isDirectory()) {
+                    Iris.verbose("Checking Pack: " + i.getPath());
+                    IrisData data = IrisData.get(i);
+                    File dims = new File(i, "dimensions");
+
+                    if (dims.exists()) {
+                        for (File j : dims.listFiles()) {
+                            if (j.getName().endsWith(".json")) {
+                                IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
+
+                                if (dim == null) {
+                                    continue;
+                                }
+
+                                Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
+                                for (File dpack : getDatapacksFolder()) {
+                                    dim.installDataPack(fixer, () -> data, dpack, ultimateMaxHeight, ultimateMinHeight);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
 
         Iris.info("Data Packs Setup!");
 
@@ -127,40 +158,57 @@ public class ServerConfigurator {
     }
 
     private static void verifyDataPacksPost(boolean allowRestarting) {
-        boolean bad = allPacks()
-                .map(data -> {
-                    Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
-                    var loader = data.getDimensionLoader();
-                    return loader.loadAll(loader.getPossibleKeys())
-                            .stream()
-                            .map(ServerConfigurator::verifyDataPackInstalled)
-                            .toList()
-                            .contains(false);
-                })
-                .toList()
-                .contains(true);
-        if (!bad) return;
+        File packs = new File("plugins/Iris/packs");
 
+        boolean bad = false;
+        if (packs.exists()) {
+            for (File i : packs.listFiles()) {
+                if (i.isDirectory()) {
+                    Iris.verbose("Checking Pack: " + i.getPath());
+                    IrisData data = IrisData.get(i);
+                    File dims = new File(i, "dimensions");
 
-        if (allowRestarting) {
-            restart();
-        } else if (INMS.get().supportsDataPacks()) {
-            Iris.error("============================================================================");
-            Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
-            Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
-            Iris.error("----------------------------------------------------------------------------");
-            Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
-            Iris.error("============================================================================");
+                    if (dims.exists()) {
+                        for (File j : dims.listFiles()) {
+                            if (j.getName().endsWith(".json")) {
+                                IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
 
-            for (Player i : Bukkit.getOnlinePlayers()) {
-                if (i.isOp() || i.hasPermission("iris.all")) {
-                    VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
-                    sender.sendMessage("There are some Iris Packs that have custom biomes in them");
-                    sender.sendMessage("You need to restart your server to use these packs.");
+                                if (dim == null) {
+                                    Iris.error("Failed to load " + j.getPath() + " ");
+                                    continue;
+                                }
+
+                                if (!verifyDataPackInstalled(dim)) {
+                                    bad = true;
+                                }
+                            }
+                        }
+                    }
                 }
             }
+        }
 
-            J.sleep(3000);
+        if (bad) {
+            if (allowRestarting) {
+                restart();
+            } else if (INMS.get().supportsDataPacks()) {
+                Iris.error("============================================================================");
+                Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
+                Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
+                Iris.error("----------------------------------------------------------------------------");
+                Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
+                Iris.error("============================================================================");
+
+                for (Player i : Bukkit.getOnlinePlayers()) {
+                    if (i.isOp() || i.hasPermission("iris.all")) {
+                        VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
+                        sender.sendMessage("There are some Iris Packs that have custom biomes in them");
+                        sender.sendMessage("You need to restart your server to use these packs.");
+                    }
+                }
+
+                J.sleep(3000);
+            }
         }
     }
 
@@ -170,7 +218,7 @@ public class ServerConfigurator {
             Iris.warn("This will only happen when your pack changes (updates/first time setup)");
             Iris.warn("(You can disable this auto restart in iris settings)");
             J.s(() -> {
-                Iris.warn("Looks like the restart command didn't work. Stopping the server instead!");
+                Iris.warn("Looks like the restart command diddn't work. Stopping the server instead!");
                 Bukkit.shutdown();
             }, 100);
             Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "restart");
@@ -178,24 +226,22 @@ public class ServerConfigurator {
     }
 
     public static boolean verifyDataPackInstalled(IrisDimension dimension) {
+        IrisData idm = IrisData.get(Iris.instance.getDataFolder("packs", dimension.getLoadKey()));
         KSet<String> keys = new KSet<>();
         boolean warn = false;
 
-        for (IrisBiome i : dimension.getAllBiomes(dimension::getLoader)) {
+        for (IrisBiome i : dimension.getAllBiomes(() -> idm)) {
             if (i.isCustom()) {
                 for (IrisBiomeCustom j : i.getCustomDerivitives()) {
                     keys.add(dimension.getLoadKey() + ":" + j.getId());
                 }
             }
         }
-        String key = getWorld(dimension.getLoader());
-        if (key == null) key = dimension.getLoadKey();
-        else key += "/" + dimension.getLoadKey();
 
         if (!INMS.get().supportsDataPacks()) {
             if (!keys.isEmpty()) {
                 Iris.warn("===================================================================================");
-                Iris.warn("Pack " + key + " has " + keys.size() + " custom biome(s). ");
+                Iris.warn("Pack " + dimension.getLoadKey() + " has " + keys.size() + " custom biome(s). ");
                 Iris.warn("Your server version does not yet support datapacks for iris.");
                 Iris.warn("The world will generate these biomes as backup biomes.");
                 Iris.warn("====================================================================================");
@@ -214,74 +260,10 @@ public class ServerConfigurator {
         }
 
         if (warn) {
-            Iris.error("The Pack " + key + " is INCAPABLE of generating custom biomes");
+            Iris.error("The Pack " + dimension.getLoadKey() + " is INCAPABLE of generating custom biomes");
             Iris.error("If not done automatically, restart your server before generating with this pack!");
         }
 
         return !warn;
     }
-
-    public static Stream<IrisData> allPacks() {
-        return Stream.concat(listFiles(new File("plugins/Iris/packs")),
-                        listFiles(Bukkit.getWorldContainer()).map(w -> new File(w, "iris/pack")))
-                .filter(File::isDirectory)
-                .map(IrisData::get);
-    }
-
-    @Nullable
-    public static String getWorld(@NonNull IrisData data) {
-        String worldContainer = Bukkit.getWorldContainer().getAbsolutePath();
-        if (!worldContainer.endsWith(File.separator)) worldContainer += File.separator;
-        
-        String path = data.getDataFolder().getAbsolutePath();
-        if (!path.startsWith(worldContainer)) return null;
-        int l = path.endsWith(File.separator) ? 11 : 10;
-        return path.substring(worldContainer.length(), path.length() - l);
-    }
-
-    private static Stream<File> listFiles(File parent) {
-        var files = parent.listFiles();
-        return files == null ? Stream.empty() : Arrays.stream(files);
-    }
-
-    @Data
-    public static class DimensionHeight {
-        private final IDataFixer fixer;
-        private IrisRange overworld = new IrisRange();
-        private IrisRange nether = new IrisRange();
-        private IrisRange end = new IrisRange();
-        private int logicalOverworld = 0;
-        private int logicalNether = 0;
-        private int logicalEnd = 0;
-
-        public Stream<IrisDimension> merge(IrisData data) {
-            Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
-            var loader = data.getDimensionLoader();
-            return loader.loadAll(loader.getPossibleKeys())
-                    .stream()
-                    .peek(this::merge);
-        }
-
-        public void merge(IrisDimension dimension) {
-            overworld.merge(dimension.getDimensionHeight());
-            nether.merge(dimension.getDimensionHeight());
-            end.merge(dimension.getDimensionHeight());
-
-            logicalOverworld = Math.max(logicalOverworld, dimension.getLogicalHeight());
-            logicalNether = Math.max(logicalNether, dimension.getLogicalHeightNether());
-            logicalEnd = Math.max(logicalEnd, dimension.getLogicalHeightEnd());
-        }
-
-        public String overworldType() {
-            return fixer.createDimension(OVERRWORLD, overworld, logicalOverworld).toString(4);
-        }
-
-        public String netherType() {
-            return fixer.createDimension(NETHER, nether, logicalNether).toString(4);
-        }
-
-        public String endType() {
-            return fixer.createDimension(THE_END, end, logicalEnd).toString(4);
-        }
-    }
 }

core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java

@@ -22,11 +22,11 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.nms.datapack.DataVersion;
+import com.volmit.iris.core.service.IrisEngineSVC;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.service.EngineStatusSVC;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -66,20 +66,53 @@ public class CommandDeveloper implements DecreeExecutor {
 
     @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
     public void EngineStatus() {
-        var status = EngineStatusSVC.getStatus();
+        List<World> IrisWorlds = new ArrayList<>();
+        int TotalLoadedChunks = 0;
+        int TotalQueuedTectonicPlates = 0;
+        int TotalNotQueuedTectonicPlates = 0;
+        int TotalTectonicPlates = 0;
 
-        sender().sendMessage("-------------------------");
-        sender().sendMessage(C.DARK_PURPLE + "Engine Status");
-        sender().sendMessage(C.DARK_PURPLE + "Total Engines: " + C.LIGHT_PURPLE + status.engineCount());
-        sender().sendMessage(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + status.loadedChunks());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + status.tectonicLimit());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + status.tectonicPlates());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + status.activeTectonicPlates());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + status.queuedTectonicPlates());
-        sender().sendMessage(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.minTectonicUnloadDuration()));
-        sender().sendMessage(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.maxTectonicUnloadDuration()));
-        sender().sendMessage(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
-        sender().sendMessage("-------------------------");
+        long lowestUnloadDuration = 0;
+        long highestUnloadDuration = 0;
+
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+
+        for (World world : IrisWorlds) {
+            Engine engine = IrisToolbelt.access(world).getEngine();
+            TotalQueuedTectonicPlates += (int) engine.getMantle().getToUnload();
+            TotalNotQueuedTectonicPlates += (int) engine.getMantle().getNotQueuedLoadedRegions();
+            TotalTectonicPlates += engine.getMantle().getLoadedRegionCount();
+            if (highestUnloadDuration <= (long) engine.getMantle().getTectonicDuration()) {
+                highestUnloadDuration = (long) engine.getMantle().getTectonicDuration();
+            }
+            if (lowestUnloadDuration >= (long) engine.getMantle().getTectonicDuration()) {
+                lowestUnloadDuration = (long) engine.getMantle().getTectonicDuration();
+            }
+            for (Chunk chunk : world.getLoadedChunks()) {
+                if (chunk.isLoaded()) {
+                    TotalLoadedChunks++;
+                }
+            }
+        }
+        Iris.info("-------------------------");
+        Iris.info(C.DARK_PURPLE + "Engine Status");
+        Iris.info(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + TotalLoadedChunks);
+        Iris.info(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + IrisEngineSVC.getTectonicLimit());
+        Iris.info(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + TotalTectonicPlates);
+        Iris.info(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + TotalNotQueuedTectonicPlates);
+        Iris.info(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + TotalQueuedTectonicPlates);
+        Iris.info(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(lowestUnloadDuration));
+        Iris.info(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(highestUnloadDuration));
+        Iris.info(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
+        Iris.info("-------------------------");
     }
 
     @Decree(description = "Test")
@@ -107,7 +140,7 @@ public class CommandDeveloper implements DecreeExecutor {
     public void packBenchmark(
             @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
             IrisDimension dimension,
-            @Param(description = "Radius in regions", defaultValue = "2048")
+            @Param(description = "Radius in regions", defaultValue = "5")
             int radius,
             @Param(description = "Open GUI while benchmarking", defaultValue = "false")
             boolean gui

core/src/main/java/com/volmit/iris/core/commands/CommandIris.java

@@ -20,8 +20,9 @@ package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.datapack.DataVersion;
 import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisBenchmarking;
@@ -42,7 +43,9 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
+import lombok.Getter;
 import org.bukkit.Bukkit;
+import org.bukkit.Difficulty;
 import org.bukkit.World;
 import org.bukkit.WorldCreator;
 import org.bukkit.configuration.ConfigurationSection;
@@ -52,8 +55,10 @@ import org.bukkit.entity.Player;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.scheduler.BukkitRunnable;
 
+import java.io.Console;
 import java.io.File;
 import java.io.IOException;
+import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
@@ -89,7 +94,9 @@ public class CommandIris implements DecreeExecutor {
             @Param(aliases = "dimension", description = "The dimension type to create the world with", defaultValue = "default")
             IrisDimension type,
             @Param(description = "The seed to generate the world with", defaultValue = "1337")
-            long seed
+            long seed,
+            @Param(description = "If it should convert the dimension to match the vanilla height system.", defaultValue = "false")
+            boolean vanillaheight
     ) {
         if(sender() instanceof Player) {
             if (incompatibilities.get("Multiverse-Core")) {
@@ -133,6 +140,7 @@ public class CommandIris implements DecreeExecutor {
                     .seed(seed)
                     .sender(sender())
                     .studio(false)
+                    .smartVanillaHeight(vanillaheight)
                     .create();
         } catch (Throwable e) {
             sender().sendMessage(C.RED + "Exception raised during creation. See the console for more details.");
@@ -266,17 +274,6 @@ public class CommandIris implements DecreeExecutor {
             return;
         }
         sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
-
-        if (!IrisToolbelt.evacuate(world)) {
-            sender().sendMessage(C.RED + "Failed to evacuate world: " + world.getName());
-            return;
-        }
-
-        if (!Bukkit.unloadWorld(world, false)) {
-            sender().sendMessage(C.RED + "Failed to unload world: " + world.getName());
-            return;
-        }
-
         try {
             if (IrisToolbelt.removeWorld(world)) {
                 sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
@@ -289,32 +286,27 @@ public class CommandIris implements DecreeExecutor {
         }
         IrisToolbelt.evacuate(world, "Deleting world");
         deletingWorld = true;
-        if (!delete) {
-            deletingWorld = false;
-            return;
-        }
-        VolmitSender sender = sender();
-        J.a(() -> {
-            int retries = 12;
-
+        Bukkit.unloadWorld(world, false);
+        int retries = 12;
+        if (delete) {
             if (deleteDirectory(world.getWorldFolder())) {
-                sender.sendMessage(C.GREEN + "Successfully removed world folder");
+                sender().sendMessage(C.GREEN + "Successfully removed world folder");
             } else {
                 while(true){
                     if (deleteDirectory(world.getWorldFolder())){
-                        sender.sendMessage(C.GREEN + "Successfully removed world folder");
+                        sender().sendMessage(C.GREEN + "Successfully removed world folder");
                         break;
                     }
                     retries--;
                     if (retries == 0){
-                        sender.sendMessage(C.RED + "Failed to remove world folder");
+                        sender().sendMessage(C.RED + "Failed to remove world folder");
                         break;
                     }
                     J.sleep(3000);
                 }
             }
-            deletingWorld = false;
-        });
+        }
+        deletingWorld = false;
     }
 
     public static boolean deleteDirectory(File dir) {
@@ -413,7 +405,7 @@ public class CommandIris implements DecreeExecutor {
     ) {
         sender().sendMessage(C.GREEN + "Downloading pack: " + pack + "/" + branch + (trim ? " trimmed" : "") + (overwrite ? " overwriting" : ""));
         if (pack.equals("overworld")) {
-            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + INMS.OVERWORLD_TAG + "/overworld.zip";
+            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + Iris.OVERWORLD_TAG + "/overworld.zip";
             Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
         } else {
             Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
@@ -599,10 +591,10 @@ public class CommandIris implements DecreeExecutor {
                     continue;
                 }
                 Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
-                WorldCreator c = new WorldCreator(s)
+                new WorldCreator(s)
                         .generator(getDefaultWorldGenerator(s, generator))
-                        .environment(IrisData.loadAnyDimension(generator).getEnvironment());
-                INMS.get().createWorld(c);
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
                 Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
             }
         } catch (Throwable e) {
@@ -657,6 +649,6 @@ public class CommandIris implements DecreeExecutor {
             ff.mkdirs();
             service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
         }
-        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey(), false);
     }
 }

core/src/main/java/com/volmit/iris/core/commands/CommandObject.java

@@ -28,8 +28,6 @@ import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.data.Cuboid;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.data.registry.Materials;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -38,9 +36,12 @@ import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Direction;
 import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.scheduling.Queue;
 import org.bukkit.*;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
@@ -53,7 +54,7 @@ import java.util.*;
 @Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
 public class CommandObject implements DecreeExecutor {
 
-    private static final Set<Material> skipBlocks = Set.of(Materials.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
+    private static final Set<Material> skipBlocks = Set.of(E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS"), Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
             Material.POPPY, Material.DANDELION);
 
     public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
@@ -78,10 +79,7 @@ public class CommandObject implements DecreeExecutor {
 
                 futureBlockChanges.put(block, block.getBlockData());
 
-                if (d instanceof IrisCustomData data) {
-                    block.setBlockData(data.getBase());
-                    Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
-                } else block.setBlockData(d);
+                block.setBlockData(d);
             }
 
             @Override

core/src/main/java/com/volmit/iris/core/commands/CommandPregen.java

@@ -19,7 +19,9 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.PregeneratorJob;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.decree.DecreeExecutor;
@@ -27,9 +29,12 @@ import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Position2;
+import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.util.Vector;
 
+import java.io.File;
+
 @Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
 public class CommandPregen implements DecreeExecutor {
     @Decree(description = "Pregenerate a world")
@@ -47,12 +52,13 @@ public class CommandPregen implements DecreeExecutor {
                 sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
             }
             radius = Math.max(radius, 1024);
+            int w = (radius >> 9 + 1) * 2;
             IrisToolbelt.pregenerate(PregenTask
                     .builder()
-                    .center(new Position2(center.getBlockX(), center.getBlockZ()))
+                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
                     .gui(true)
-                    .radiusX(radius)
-                    .radiusZ(radius)
+                    .width(w)
+                    .height(w)
                     .build(), world);
             String msg = C.GREEN + "Pregen started in " + C.GOLD + world.getName() + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
             sender().sendMessage(msg);

core/src/main/java/com/volmit/iris/core/commands/CommandSupport.java

@@ -21,6 +21,7 @@ package com.volmit.iris.core.commands;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.pregenerator.ChunkUpdater;
+import com.volmit.iris.core.service.IrisEngineSVC;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;

core/src/main/java/com/volmit/iris/core/gui/PregeneratorJob.java

@@ -24,6 +24,7 @@ import com.volmit.iris.core.pregenerator.IrisPregenerator;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
+import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.format.Form;
@@ -44,6 +45,8 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 
+import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmarkInProgress;
+
 public class PregeneratorJob implements PregenListener {
     private static final Color COLOR_EXISTS = parseColor("#4d7d5b");
     private static final Color COLOR_BLACK = parseColor("#4d7d5b");
@@ -78,12 +81,12 @@ public class PregeneratorJob implements PregenListener {
         this.task = task;
         this.pregenerator = new IrisPregenerator(task, method, this);
         max = new Position2(0, 0);
-        min = new Position2(Integer.MAX_VALUE, Integer.MAX_VALUE);
-        task.iterateAllChunks((xx, zz) -> {
-            min.setX(Math.min(xx, min.getX()));
-            min.setZ(Math.min(zz, min.getZ()));
-            max.setX(Math.max(xx, max.getX()));
-            max.setZ(Math.max(zz, max.getZ()));
+        min = new Position2(0, 0);
+        task.iterateRegions((xx, zz) -> {
+            min.setX(Math.min(xx << 5, min.getX()));
+            min.setZ(Math.min(zz << 5, min.getZ()));
+            max.setX(Math.max((xx << 5) + 31, max.getX()));
+            max.setZ(Math.max((zz << 5) + 31, max.getZ()));
         });
 
         if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
@@ -159,7 +162,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public void drawRegion(int x, int z, Color color) {
-        J.a(() -> task.iterateChunks(x, z, (xx, zz) -> {
+        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
             draw(xx, zz, color);
             J.sleep(3);
         }));

core/src/main/java/com/volmit/iris/core/gui/VisionGUI.java

@@ -30,7 +30,6 @@ import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.registry.Attributes;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.math.BlockPosition;
 import com.volmit.iris.util.math.M;
@@ -57,8 +56,6 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.BiFunction;
 
-import static com.volmit.iris.util.data.registry.Attributes.MAX_HEALTH;
-
 public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener, MouseMotionListener, MouseInputListener {
     private static final long serialVersionUID = 2094606939770332040L;
     private final KList<LivingEntity> lastEntities = new KList<>();
@@ -639,7 +636,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
                 k.add("Pos: " + h.getLocation().getBlockX() + ", " + h.getLocation().getBlockY() + ", " + h.getLocation().getBlockZ());
                 k.add("UUID: " + h.getUniqueId());
-                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(MAX_HEALTH).getValue());
+                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue());
 
                 drawCardTR(g, k);
             }

core/src/main/java/com/volmit/iris/core/gui/components/IrisRenderer.java

@@ -55,10 +55,10 @@ public class IrisRenderer {
                 IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
                 IrisBiomeGeneratorLink g = b.getGenerators().get(0);
                 Color c;
-                if (g.getMax() <= 0) {
+                if (g.getMax(renderer) <= 0) {
                     // Max is below water level, so it is most likely an ocean biome
                     c = Color.BLUE;
-                } else if (g.getMin() < 0) {
+                } else if (g.getMin(renderer) < 0) {
                     // Min is below water level, but max is not, so it is most likely a shore biome
                     c = Color.YELLOW;
                 } else {

core/src/main/java/com/volmit/iris/core/link/ExternalDataProvider.java

@@ -2,7 +2,7 @@ package com.volmit.iris.core.link;
 
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import lombok.Getter;
 import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
@@ -49,7 +49,7 @@ public abstract class ExternalDataProvider {
      * @param blockId The id of the block to get
      * @param state The state of the block to get
      * @return Corresponding {@link BlockData} to the blockId
-     *         may return {@link IrisCustomData} for blocks that need a world for placement
+     *         may return {@link IrisBlockData} for blocks that need a world for placement
      * @throws MissingResourceException when the blockId is invalid
      */
     @NotNull
@@ -77,7 +77,7 @@ public abstract class ExternalDataProvider {
 
     /**
      * This method is used for placing blocks that need to use the plugins api
-     * it will only be called when the {@link ExternalDataProvider#getBlockData(Identifier, KMap)} returned a {@link IrisCustomData}
+     * it will only be called when the {@link ExternalDataProvider#getBlockData(Identifier, KMap)} returned a {@link IrisBlockData}
      *
      * @param engine The engine of the world the block is being placed in
      * @param block The block where the block should be placed

core/src/main/java/com/volmit/iris/core/link/HMCLeavesDataProvider.java

@@ -6,7 +6,7 @@ import com.volmit.iris.core.service.ExternalDataSVC;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.reflect.WrappedField;
 import com.volmit.iris.util.reflect.WrappedReturningMethod;
 import org.bukkit.Bukkit;
@@ -64,7 +64,7 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		BlockData blockData = Bukkit.createBlockData(material);
 		if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
 			leaves.setPersistent(true);
-		return new IrisCustomData(blockData, ExternalDataSVC.buildState(blockId, state));
+		return new IrisBlockData(blockData, ExternalDataSVC.buildState(blockId, state));
 	}
 
 	@NotNull

core/src/main/java/com/volmit/iris/core/link/MythicCrucibleDataProvider.java

@@ -27,7 +27,7 @@ import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.math.RNG;
 import io.lumine.mythic.bukkit.BukkitAdapter;
 import io.lumine.mythic.bukkit.utils.serialize.Chroma;
@@ -71,7 +71,7 @@ public class MythicCrucibleDataProvider extends ExternalDataProvider {
         CustomBlockItemContext blockItemContext = crucibleItem.getBlockData();
         FurnitureItemContext furnitureItemContext = crucibleItem.getFurnitureData();
         if (furnitureItemContext != null) {
-            return new IrisCustomData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
+            return new IrisBlockData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
         } else if (blockItemContext != null) {
             return blockItemContext.getBlockData();
         }

core/src/main/java/com/volmit/iris/core/link/MythicMobsLink.java

@@ -26,7 +26,6 @@ import org.bukkit.plugin.Plugin;
 
 import javax.annotation.Nullable;
 import java.util.Collection;
-import java.util.List;
 
 public class MythicMobsLink {
 
@@ -55,6 +54,6 @@ public class MythicMobsLink {
     }
 
     public Collection<String> getMythicMobTypes() {
-        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : List.of();
+        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : null;
     }
 }

core/src/main/java/com/volmit/iris/core/link/NexoDataProvider.java

@@ -11,7 +11,7 @@ import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.math.RNG;
 import org.bukkit.Color;
 import org.bukkit.block.Block;
@@ -49,9 +49,9 @@ public class NexoDataProvider extends ExternalDataProvider {
             BlockData data = NexoBlocks.blockData(blockId.key());
             if (data == null)
                 throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-            return new IrisCustomData(data, blockState);
+            return new IrisBlockData(data, blockState);
         } else if (NexoFurniture.isFurniture(blockId.key())) {
-            return new IrisCustomData(B.getAir(), blockState);
+            return new IrisBlockData(B.getAir(), blockState);
         }
 
         throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
@@ -125,7 +125,7 @@ public class NexoDataProvider extends ExternalDataProvider {
     @NotNull
     @Override
     public Identifier[] getBlockTypes() {
-        return NexoItems.itemNames().stream()
+        return Arrays.stream(NexoItems.itemNames())
                 .map(i -> new Identifier("nexo", i))
                 .filter(i -> {
                     try {
@@ -140,7 +140,7 @@ public class NexoDataProvider extends ExternalDataProvider {
     @NotNull
     @Override
     public Identifier[] getItemTypes() {
-        return NexoItems.itemNames().stream()
+        return Arrays.stream(NexoItems.itemNames())
                 .map(i -> new Identifier("nexo", i))
                 .filter(i -> {
                     try {

core/src/main/java/com/volmit/iris/core/loader/ResourceLoader.java

@@ -44,7 +44,6 @@ import lombok.EqualsAndHashCode;
 import lombok.ToString;
 
 import java.io.*;
-import java.util.Arrays;
 import java.util.Locale;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
@@ -220,10 +219,6 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         return s.map(this::load);
     }
 
-    public Stream<T> streamAllPossible() {
-        return streamAll(Arrays.stream(getPossibleKeys()));
-    }
-
     public KList<T> loadAll(KList<String> s) {
         KList<T> m = new KList<>();
 

core/src/main/java/com/volmit/iris/core/nms/INMS.java

@@ -23,28 +23,19 @@ import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import org.bukkit.Bukkit;
 
-import java.util.List;
 import java.util.Map;
 
 public class INMS {
     private static final Map<String, String> REVISION = Map.of(
-            "1.20.5", "v1_20_R4",
-            "1.20.6", "v1_20_R4",
-            "1.21", "v1_21_R1",
-            "1.21.1", "v1_21_R1",
-            "1.21.2", "v1_21_R2",
-            "1.21.3", "v1_21_R2",
-            "1.21.4", "v1_21_R3"
+        "1.20.5", "v1_20_R4",
+        "1.20.6", "v1_20_R4",
+        "1.21", "v1_21_R1",
+        "1.21.1", "v1_21_R1",
+        "1.21.2", "v1_21_R2",
+        "1.21.3", "v1_21_R2"
     );
-    private static final List<Version> PACKS = List.of(
-            new Version(21, 4, "31020"),
-            new Version(21, 2, "31000"),
-            new Version(20, 1, "3910")
-    );
-
     //@done
     private static final INMSBinding binding = bind();
-    public static final String OVERWORLD_TAG = getOverworldTag();
 
     public static INMSBinding get() {
         return binding;
@@ -95,26 +86,4 @@ public class INMS {
 
         return new NMSBinding1X();
     }
-
-    private static String getOverworldTag() {
-        var version = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.", 3);
-        int major = 0;
-        int minor = 0;
-
-        if (version.length > 2) {
-            major = Integer.parseInt(version[1]);
-            minor = Integer.parseInt(version[2]);
-        } else if (version.length == 2) {
-            major = Integer.parseInt(version[1]);
-        }
-
-        for (var p : PACKS) {
-            if (p.major > major || p.minor > minor)
-                continue;
-            return p.tag;
-        }
-        return "3910";
-    }
-
-    private record Version(int major, int minor, String tag) {}
 }

core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java

@@ -18,7 +18,6 @@
 
 package com.volmit.iris.core.nms;
 
-import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.nms.container.BiomeColor;
 import com.volmit.iris.core.nms.datapack.DataVersion;
 import com.volmit.iris.engine.framework.Engine;
@@ -31,12 +30,15 @@ import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
+import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
+import java.awt.*;
 import java.awt.Color;
 
 public interface INMSBinding {
@@ -89,13 +91,7 @@ public interface INMSBinding {
     MCABiomeContainer newBiomeContainer(int min, int max);
 
     default World createWorld(WorldCreator c) {
-        if (missingDimensionTypes(true, true, true))
-            throw new IllegalStateException("Missing dimenstion types to create world");
-
-        try (var ignored = injectLevelStems()) {
-            ignored.storeContext();
-            return c.createWorld();
-        }
+        return c.createWorld();
     }
 
     int countCustomBiomes();
@@ -129,14 +125,4 @@ public interface INMSBinding {
     }
 
     KList<String> getStructureKeys();
-
-    AutoClosing injectLevelStems();
-
-    default AutoClosing injectUncached(boolean overworld, boolean nether, boolean end) {
-        return null;
-    }
-
-    boolean missingDimensionTypes(boolean overworld, boolean nether, boolean end);
-
-    void removeCustomDimensions(World world);
 }

core/src/main/java/com/volmit/iris/core/nms/container/AutoClosing.java

@@ -1,39 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.function.NastyRunnable;
-import lombok.AllArgsConstructor;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-
-@AllArgsConstructor
-public class AutoClosing implements AutoCloseable {
-    private static final KMap<Thread, AutoClosing> CONTEXTS = new KMap<>();
-    private final AtomicBoolean closed = new AtomicBoolean();
-    private final NastyRunnable action;
-
-    @Override
-    public void close() {
-        if (closed.getAndSet(true)) return;
-        try {
-            removeContext();
-            action.run();
-        } catch (Throwable e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public void storeContext() {
-        CONTEXTS.put(Thread.currentThread(), this);
-    }
-
-    public void removeContext() {
-        CONTEXTS.values().removeIf(c -> c == this);
-    }
-
-    public static void closeContext() {
-        AutoClosing closing = CONTEXTS.remove(Thread.currentThread());
-        if (closing == null) return;
-        closing.close();
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/datapack/IDataFixer.java

@@ -1,28 +1,11 @@
 package com.volmit.iris.core.nms.datapack;
 
 import com.volmit.iris.engine.object.IrisBiomeCustom;
-import com.volmit.iris.engine.object.IrisRange;
 import com.volmit.iris.util.json.JSONObject;
 
 public interface IDataFixer {
 
-    default JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
-        return json;
-    }
+    JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json);
 
-    JSONObject rawDimension(Dimension dimension);
-
-    default JSONObject createDimension(Dimension dimension, IrisRange height, int logicalHeight) {
-        JSONObject obj = rawDimension(dimension);
-        obj.put("min_y", height.getMin());
-        obj.put("height", height.getMax() - height.getMin());
-        obj.put("logical_height", logicalHeight);
-        return obj;
-    }
-
-    enum Dimension {
-        OVERRWORLD,
-        NETHER,
-        THE_END
-    }
+    JSONObject fixDimension(JSONObject json);
 }

core/src/main/java/com/volmit/iris/core/nms/datapack/v1192/DataFixerV1192.java

@@ -1,81 +1,18 @@
 package com.volmit.iris.core.nms.datapack.v1192;
 
 import com.volmit.iris.core.nms.datapack.IDataFixer;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.util.json.JSONObject;
-import java.util.Map;
 
 public class DataFixerV1192 implements IDataFixer {
 
-    private static final Map<Dimension, String> DIMENSIONS = Map.of(
-            Dimension.OVERRWORLD, """
-            {
-              "ambient_light": 0.0,
-              "bed_works": true,
-              "coordinate_scale": 1.0,
-              "effects": "minecraft:overworld",
-              "has_ceiling": false,
-              "has_raids": true,
-              "has_skylight": true,
-              "infiniburn": "#minecraft:infiniburn_overworld",
-              "monster_spawn_block_light_limit": 0,
-              "monster_spawn_light_level": {
-                "type": "minecraft:uniform",
-                "value": {
-                  "max_inclusive": 7,
-                  "min_inclusive": 0
-                }
-              },
-              "natural": true,
-              "piglin_safe": false,
-              "respawn_anchor_works": false,
-              "ultrawarm": false
-            }""",
-            Dimension.NETHER, """
-            {
-              "ambient_light": 0.1,
-              "bed_works": false,
-              "coordinate_scale": 8.0,
-              "effects": "minecraft:the_nether",
-              "fixed_time": 18000,
-              "has_ceiling": true,
-              "has_raids": false,
-              "has_skylight": false,
-              "infiniburn": "#minecraft:infiniburn_nether",
-              "monster_spawn_block_light_limit": 15,
-              "monster_spawn_light_level": 7,
-              "natural": false,
-              "piglin_safe": true,
-              "respawn_anchor_works": true,
-              "ultrawarm": true
-            }""",
-            Dimension.THE_END, """
-            {
-              "ambient_light": 0.0,
-              "bed_works": false,
-              "coordinate_scale": 1.0,
-              "effects": "minecraft:the_end",
-              "fixed_time": 6000,
-              "has_ceiling": false,
-              "has_raids": true,
-              "has_skylight": false,
-              "infiniburn": "#minecraft:infiniburn_end",
-              "monster_spawn_block_light_limit": 0,
-              "monster_spawn_light_level": {
-                "type": "minecraft:uniform",
-                "value": {
-                  "max_inclusive": 7,
-                  "min_inclusive": 0
-                }
-              },
-              "natural": false,
-              "piglin_safe": false,
-              "respawn_anchor_works": false,
-              "ultrawarm": false
-            }"""
-    );
+    @Override
+    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        return json;
+    }
 
     @Override
-    public JSONObject rawDimension(Dimension dimension) {
-        return new JSONObject(DIMENSIONS.get(dimension));
+    public JSONObject fixDimension(JSONObject json) {
+        return json;
     }
 }

core/src/main/java/com/volmit/iris/core/nms/datapack/v1206/DataFixerV1206.java

@@ -1,6 +1,6 @@
 package com.volmit.iris.core.nms.datapack.v1206;
 
-import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
+import com.volmit.iris.core.nms.datapack.IDataFixer;
 import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
@@ -10,7 +10,7 @@ import com.volmit.iris.util.json.JSONObject;
 
 import java.util.Locale;
 
-public class DataFixerV1206 extends DataFixerV1192 {
+public class DataFixerV1206 implements IDataFixer {
     @Override
     public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
         int spawnRarity = biome.getSpawnRarity();
@@ -45,8 +45,7 @@ public class DataFixerV1206 extends DataFixerV1192 {
     }
 
     @Override
-    public JSONObject rawDimension(Dimension dimension) {
-        JSONObject json = super.rawDimension(dimension);
+    public JSONObject fixDimension(JSONObject json) {
         if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
             return json;
         var value = (JSONObject) lightLevel.remove("value");

core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java

@@ -20,9 +20,7 @@ package com.volmit.iris.core.nms.v1X;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
-import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
@@ -120,26 +118,6 @@ public class NMSBinding1X implements INMSBinding {
         return new KList<>(list);
     }
 
-    @Override
-    public AutoClosing injectLevelStems() {
-        return new AutoClosing(() -> {});
-    }
-
-    @Override
-    public AutoClosing injectUncached(boolean overworld, boolean nether, boolean end) {
-        return injectLevelStems();
-    }
-
-    @Override
-    public boolean missingDimensionTypes(boolean overworld, boolean nether, boolean end) {
-        return false;
-    }
-
-    @Override
-    public void removeCustomDimensions(World world) {
-
-    }
-
     @Override
     public CompoundTag serializeEntity(Entity location) {
         return null;

core/src/main/java/com/volmit/iris/core/pregenerator/ChunkUpdater.java

@@ -165,11 +165,8 @@ public class ChunkUpdater {
             if (rX < dimensions.min.getX() || rX > dimensions.max.getX() || rZ < dimensions.min.getZ() || rZ > dimensions.max.getZ()) {
                 return;
             }
-            if (!new File(world.getWorldFolder(), "region" + File.separator + rX + "." + rZ + ".mca").exists()) {
-                return;
-            }
 
-            task.iterateChunks(rX, rZ, (x, z) -> {
+            PregenTask.iterateRegion(rX, rZ, (x, z) -> {
                 while (paused.get() && !cancelled.get()) {
                     J.sleep(50);
                 }
@@ -351,8 +348,8 @@ public class ChunkUpdater {
         int width = maxZ - minZ + 1;
 
         return new Dimensions(new Position2(minX, minZ), new Position2(maxX, maxZ), height * width, PregenTask.builder()
-                .radiusZ((int) Math.ceil(width / 2d * 512))
-                .radiusX((int) Math.ceil(height / 2d * 512))
+                .width((int) Math.ceil(width / 2d))
+                .height((int) Math.ceil(height / 2d))
                 .center(new Position2(oX, oZ))
                 .build());
     }

core/src/main/java/com/volmit/iris/core/pregenerator/IrisPregenerator.java

@@ -19,6 +19,7 @@
 package com.volmit.iris.core.pregenerator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.pack.IrisPack;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KSet;
@@ -82,7 +83,7 @@ public class IrisPregenerator {
         generatedLast = new AtomicInteger(0);
         generatedLastMinute = new AtomicInteger(0);
         totalChunks = new AtomicInteger(0);
-        task.iterateAllChunks((_a, _b) -> totalChunks.incrementAndGet());
+        task.iterateRegions((_a, _b) -> totalChunks.addAndGet(1024));
         startTime = new AtomicLong(M.ms());
         ticker = new Looper() {
             @Override
@@ -193,7 +194,7 @@ public class IrisPregenerator {
         } else if (!regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
-            task.iterateChunks(x, z, (xx, zz) -> {
+            PregenTask.iterateRegion(x, z, (xx, zz) -> {
                 while (paused.get() && !shutdown.get()) {
                     J.sleep(50);
                 }

core/src/main/java/com/volmit/iris/core/pregenerator/PregenTask.java

@@ -32,26 +32,17 @@ import java.util.Comparator;
 @Data
 public class PregenTask {
     private static final Position2 ZERO = new Position2(0, 0);
+    private static final KList<Position2> ORDER_CENTER = computeChunkOrder();
     private static final KMap<Position2, KList<Position2>> ORDERS = new KMap<>();
 
     @Builder.Default
-    private final boolean gui = false;
+    private boolean gui = false;
     @Builder.Default
-    private final Position2 center = new Position2(0, 0);
+    private Position2 center = new Position2(0, 0);
     @Builder.Default
-    private final int radiusX = 1;
+    private int width = 1;
     @Builder.Default
-    private final int radiusZ = 1;
-
-    private final Bounds bounds = new Bounds();
-
-    protected PregenTask(boolean gui, Position2 center, int radiusX, int radiusZ) {
-        this.gui = gui;
-        this.center = new ProxiedPos(center);
-        this.radiusX = radiusX;
-        this.radiusZ = radiusZ;
-        bounds.update();
-    }
+    private int height = 1;
 
     public static void iterateRegion(int xr, int zr, Spiraled s, Position2 pull) {
         for (Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
@@ -79,72 +70,29 @@ public class PregenTask {
         return p;
     }
 
-    public void iterateRegions(Spiraled s) {
-        var bound = bounds.region();
-        new Spiraler(bound.sizeX, bound.sizeZ, ((x, z) -> {
-            if (bound.check(x, z)) s.on(x, z);
-        })).setOffset(center.getX() >> 9, center.getZ() >> 9).drain();
+    private static KList<Position2> computeChunkOrder() {
+        Position2 center = new Position2(15, 15);
+        KList<Position2> p = new KList<>();
+        new Spiraler(33, 33, (x, z) -> {
+            int xx = x + 15;
+            int zz = z + 15;
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+                return;
+            }
+
+            p.add(new Position2(xx, zz));
+        }).drain();
+        p.sort(Comparator.comparing((i) -> i.distance(center)));
+        return p;
     }
 
-    public void iterateChunks(int rX, int rZ, Spiraled s) {
-        var bound = bounds.chunk();
-        iterateRegion(rX, rZ, ((x, z) -> {
-            if (bound.check(x, z)) s.on(x, z);
-        }));
+    public void iterateRegions(Spiraled s) {
+        new Spiraler(getWidth() * 2, getHeight() * 2, s)
+                .setOffset(center.getX(), center.getZ()).drain();
     }
 
     public void iterateAllChunks(Spiraled s) {
-        iterateRegions(((rX, rZ) -> iterateChunks(rX, rZ, s)));
-    }
-
-    private class Bounds {
-        private Bound chunk = null;
-        private Bound region = null;
-
-        public void update() {
-            int maxX = center.getX() + radiusX;
-            int maxZ = center.getZ() + radiusZ;
-            int minX = center.getX() - radiusX;
-            int minZ = center.getZ() - radiusZ;
-
-            chunk = new Bound(minX >> 4, minZ >> 4, Math.ceilDiv(maxX, 16), Math.ceilDiv(maxZ, 16));
-            region = new Bound(minX >> 9, minZ >> 9, Math.ceilDiv(maxX, 512), Math.ceilDiv(maxZ, 512));
-        }
-
-        public Bound chunk() {
-            if (chunk == null) update();
-            return chunk;
-        }
-
-        public Bound region() {
-            if (region == null) update();
-            return region;
-        }
-    }
-
-    private record Bound(int minX, int maxX, int minZ, int maxZ, int sizeX, int sizeZ) {
-        private Bound(int minX, int minZ, int maxX, int maxZ) {
-            this(minX, maxX, minZ, maxZ, maxZ - minZ + 1, maxZ - minZ + 1);
-        }
-
-        boolean check(int x, int z) {
-            return x >= minX && x <= maxX && z >= minZ && z <= maxZ;
-        }
-    }
-
-    private static class ProxiedPos extends Position2 {
-        public ProxiedPos(Position2 p) {
-            super(p.getX(), p.getZ());
-        }
-
-        @Override
-        public void setX(int x) {
-            throw new IllegalStateException("This Position2 may not be modified");
-        }
-
-        @Override
-        public void setZ(int z) {
-            throw new IllegalStateException("This Position2 may not be modified");
-        }
+        new Spiraler(getWidth() * 2, getHeight() * 2, (x, z) -> iterateRegion(x, z, s))
+                .setOffset(center.getX(), center.getZ()).drain();
     }
 }

core/src/main/java/com/volmit/iris/core/safeguard/IrisSafeguard.java

@@ -1,7 +1,6 @@
 package com.volmit.iris.core.safeguard;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
 
 public class IrisSafeguard {
     public static boolean unstablemode = false;
@@ -12,13 +11,5 @@ public class IrisSafeguard {
         Iris.info("Enabled Iris SafeGuard");
         ServerBootSFG.BootCheck();
     }
-
-    public static void earlySplash() {
-        if (ServerBootSFG.safeguardPassed || IrisSettings.get().getGeneral().DoomsdayAnnihilationSelfDestructMode)
-            return;
-
-        Iris.instance.splash();
-        UtilsSFG.splash();
-    }
 }
 

core/src/main/java/com/volmit/iris/core/safeguard/ServerBootSFG.java

@@ -3,7 +3,6 @@ package com.volmit.iris.core.safeguard;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import com.volmit.iris.engine.object.IrisContextInjector;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
@@ -30,7 +29,6 @@ public class ServerBootSFG {
     public static boolean isJRE = false;
     public static boolean hasPrivileges = true;
     public static boolean unsuportedversion = false;
-    public static boolean missingDimensionTypes = false;
     protected static boolean safeguardPassed;
     public static boolean passedserversoftware = true;
     protected static int count;
@@ -112,12 +110,6 @@ public class ServerBootSFG {
             severityMedium++;
         }
 
-        if (IrisContextInjector.isMissingDimensionTypes()) {
-            missingDimensionTypes = true;
-            joiner.add("Missing Dimension Types");
-            severityHigh++;
-        }
-
         allIncompatibilities = joiner.toString();
 
         safeguardPassed = (severityHigh == 0 && severityMedium == 0 && severityLow == 0);

core/src/main/java/com/volmit/iris/core/safeguard/UtilsSFG.java

@@ -37,12 +37,7 @@ public class UtilsSFG {
             }
             if (ServerBootSFG.unsuportedversion) {
                 Iris.safeguard(C.RED + "Server Version");
-                Iris.safeguard(C.RED + "- Iris only supports 1.20.1 > 1.21.4");
-            }
-            if (ServerBootSFG.missingDimensionTypes) {
-                Iris.safeguard(C.RED + "Dimension Types");
-                Iris.safeguard(C.RED + "- Required Iris dimension types were not loaded.");
-                Iris.safeguard(C.RED + "- If this still happens after a restart please contact support.");
+                Iris.safeguard(C.RED + "- Iris only supports 1.19.2 > 1.21.3");
             }
             if (!ServerBootSFG.passedserversoftware) {
                 Iris.safeguard(C.YELLOW + "Unsupported Server Software");

core/src/main/java/com/volmit/iris/core/service/IrisEngineSVC.java

@@ -0,0 +1,317 @@
+package com.volmit.iris.core.service;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.mantle.TectonicPlate;
+import com.volmit.iris.util.misc.getHardware;
+import com.volmit.iris.util.plugin.IrisService;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.Looper;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.event.server.ServerLoadEvent;
+import org.bukkit.event.world.WorldLoadEvent;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.checkerframework.checker.units.qual.A;
+
+import java.util.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Supplier;
+
+public class IrisEngineSVC implements IrisService {
+    public static IrisEngineSVC instance;
+    public boolean isServerShuttingDown = false;
+    public boolean isServerLoaded = false;
+    private static final AtomicInteger tectonicLimit = new AtomicInteger(30);
+    private ReentrantLock lastUseLock;
+    private KMap<World, Long> lastUse;
+    private List<World> IrisWorlds;
+    private Looper cacheTicker;
+    private Looper trimTicker;
+    private Looper unloadTicker;
+    private Looper updateTicker;
+    private PrecisionStopwatch trimAlive;
+    private PrecisionStopwatch unloadAlive;
+    public PrecisionStopwatch trimActiveAlive;
+    public PrecisionStopwatch unloadActiveAlive;
+    private AtomicInteger TotalTectonicPlates;
+    private AtomicInteger TotalQueuedTectonicPlates;
+    private AtomicInteger TotalNotQueuedTectonicPlates;
+    private AtomicBoolean IsUnloadAlive;
+    private AtomicBoolean IsTrimAlive;
+    ChronoLatch cl;
+
+    public List<World> corruptedIrisWorlds = new ArrayList<>();
+
+    @Override
+    public void onEnable() {
+        this.cl = new ChronoLatch(5000);
+        lastUse = new KMap<>();
+        lastUseLock = new ReentrantLock();
+        IrisWorlds = new ArrayList<>();
+        IsUnloadAlive = new AtomicBoolean(true);
+        IsTrimAlive = new AtomicBoolean(true);
+        trimActiveAlive = new PrecisionStopwatch();
+        unloadActiveAlive = new PrecisionStopwatch();
+        trimAlive = new PrecisionStopwatch();
+        unloadAlive = new PrecisionStopwatch();
+        TotalTectonicPlates = new AtomicInteger();
+        TotalQueuedTectonicPlates = new AtomicInteger();
+        TotalNotQueuedTectonicPlates = new AtomicInteger();
+        tectonicLimit.set(2);
+        long t = getHardware.getProcessMemory();
+        while (t > 200) {
+            tectonicLimit.getAndAdd(1);
+            t = t - 200;
+        }
+        this.setup();
+        this.TrimLogic();
+        this.UnloadLogic();
+
+        trimAlive.begin();
+        unloadAlive.begin();
+        trimActiveAlive.begin();
+        unloadActiveAlive.begin();
+
+        updateTicker.start();
+        cacheTicker.start();
+        //trimTicker.start();
+        //unloadTicker.start();
+        instance = this;
+
+    }
+
+    public void engineStatus() {
+        boolean trimAlive = trimTicker.isAlive();
+        boolean unloadAlive = unloadTicker.isAlive();
+        Iris.info("Status:");
+        Iris.info("- Trim: " + trimAlive);
+        Iris.info("- Unload: " + unloadAlive);
+
+    }
+
+    public static int getTectonicLimit() {
+        return tectonicLimit.get();
+    }
+
+    @EventHandler
+    public void onWorldUnload(WorldUnloadEvent event) {
+        updateWorlds();
+    }
+
+    @EventHandler
+    public void onWorldLoad(WorldLoadEvent event) {
+        updateWorlds();
+    }
+
+    @EventHandler
+    public void onServerBoot(ServerLoadEvent event) {
+        isServerLoaded = true;
+    }
+
+    @EventHandler
+    public void onPluginDisable(PluginDisableEvent event) {
+        if (event.getPlugin().equals(Iris.instance)) {
+            isServerShuttingDown = true;
+        }
+    }
+
+    public void updateWorlds() {
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+    }
+
+    private void setup() {
+        cacheTicker = new Looper() {
+            @Override
+            protected long loop() {
+                long now = System.currentTimeMillis();
+                lastUseLock.lock();
+                try {
+                    for (World key : new ArrayList<>(lastUse.keySet())) {
+                        Long last = lastUse.get(key);
+                        if (last == null)
+                            continue;
+                        if (now - last > 60000) {
+                            lastUse.remove(key);
+                        }
+                    }
+                } finally {
+                    lastUseLock.unlock();
+                }
+                return 1000;
+            }
+        };
+
+        updateTicker = new Looper() {
+            @Override
+            protected long loop() {
+                try {
+                    TotalQueuedTectonicPlates.set(0);
+                    TotalNotQueuedTectonicPlates.set(0);
+                    TotalTectonicPlates.set(0);
+                    for (World world : IrisWorlds) {
+                        Engine engine = Objects.requireNonNull(IrisToolbelt.access(world)).getEngine();
+                        TotalQueuedTectonicPlates.addAndGet((int) engine.getMantle().getToUnload());
+                        TotalNotQueuedTectonicPlates.addAndGet((int) engine.getMantle().getNotQueuedLoadedRegions());
+                        TotalTectonicPlates.addAndGet(engine.getMantle().getLoadedRegionCount());
+                    }
+                    if (!isServerShuttingDown && isServerLoaded) {
+                        if (!trimTicker.isAlive()) {
+                            Iris.info(C.RED + "TrimTicker found dead! Booting it up!");
+                            try {
+                                TrimLogic();
+                            } catch (Exception e) {
+                                Iris.error("What happened?");
+                                e.printStackTrace();
+                            }
+                        }
+
+                        if (!unloadTicker.isAlive()) {
+                            Iris.info(C.RED + "UnloadTicker found dead! Booting it up!");
+                            try {
+                               UnloadLogic();
+                            } catch (Exception e) {
+                                Iris.error("What happened?");
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+
+                } catch (Exception e) {
+                    return -1;
+                }
+                return 1000;
+            }
+        };
+    }
+    public void TrimLogic() {
+        if (trimTicker == null || !trimTicker.isAlive()) {
+            trimTicker = new Looper() {
+                private final Supplier<Engine> supplier = createSupplier();
+
+                @Override
+                protected long loop() {
+                    long start = System.currentTimeMillis();
+                    trimAlive.reset();
+                    try {
+                        Engine engine = supplier.get();
+                        if (engine != null) {
+                            engine.getMantle().trim(tectonicLimit.get() / lastUse.size());
+                        }
+                    } catch (Throwable e) {
+                        Iris.reportError(e);
+                        Iris.info(C.RED + "EngineSVC: Failed to trim.");
+                        e.printStackTrace();
+                        return -1;
+                    }
+
+                    int size = lastUse.size();
+                    long time = (size > 0 ? 1000 / size : 1000) - (System.currentTimeMillis() - start);
+                    if (time <= 0)
+                        return 0;
+                    return time;
+                }
+            };
+            trimTicker.start();
+        }
+    }
+    public void UnloadLogic() {
+        if (unloadTicker == null || !unloadTicker.isAlive()) {
+            unloadTicker = new Looper() {
+                private final Supplier<Engine> supplier = createSupplier();
+
+                @Override
+                protected long loop() {
+                    long start = System.currentTimeMillis();
+                    unloadAlive.reset();
+                    try {
+                        Engine engine = supplier.get();
+                        if (engine != null) {
+                            long unloadStart = System.currentTimeMillis();
+                            int count = engine.getMantle().unloadTectonicPlate(tectonicLimit.get() / lastUse.size());
+                            if (count > 0) {
+                                Iris.debug(C.GOLD + "Unloaded " + C.YELLOW + count + " TectonicPlates in " + C.RED + Form.duration(System.currentTimeMillis() - unloadStart, 2));
+                            }
+                        }
+                    } catch (Throwable e) {
+                        Iris.reportError(e);
+                        Iris.info(C.RED + "EngineSVC: Failed to unload.");
+                        e.printStackTrace();
+                        return -1;
+                    }
+
+                    int size = lastUse.size();
+                    long time = (size > 0 ? 1000 / size : 1000) - (System.currentTimeMillis() - start);
+                    if (time <= 0)
+                        return 0;
+                    return time;
+                }
+            };
+            unloadTicker.start();
+        }
+    }
+
+    private Supplier<Engine> createSupplier() {
+        AtomicInteger i = new AtomicInteger();
+        return () -> {
+            List<World> worlds = Bukkit.getWorlds();
+            if (i.get() >= worlds.size()) {
+                i.set(0);
+            }
+            try {
+                for (int j = 0; j < worlds.size(); j++) {
+                    World world = worlds.get(i.getAndIncrement());
+                    PlatformChunkGenerator generator = IrisToolbelt.access(world);
+                    if (i.get() >= worlds.size()) {
+                        i.set(0);
+                    }
+
+                    if (generator != null) {
+                        Engine engine = generator.getEngine();
+                        boolean closed = engine.getMantle().getData().isClosed();
+                        if (engine != null && !engine.isStudio() && !closed) {
+                            lastUseLock.lock();
+                            lastUse.put(world, System.currentTimeMillis());
+                            lastUseLock.unlock();
+                            return engine;
+                        }
+                    }
+                }
+            } catch (Throwable e) {
+                Iris.info(C.RED + "EngineSVC: Failed to create supplier.");
+                e.printStackTrace();
+                Iris.reportError(e);
+            }
+            return null;
+        };
+    }
+
+    @Override
+    public void onDisable() {
+        cacheTicker.interrupt();
+        trimTicker.interrupt();
+        unloadTicker.interrupt();
+        lastUse.clear();
+    }
+}

core/src/main/java/com/volmit/iris/core/service/StudioSVC.java

@@ -24,7 +24,6 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.pack.IrisPack;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.tools.IrisToolbelt;
@@ -65,7 +64,7 @@ public class StudioSVC implements IrisService {
             if (!f.exists()) {
                 Iris.info("Downloading Default Pack " + pack);
                 if (pack.equals("overworld")) {
-                    String url = "https://github.com/IrisDimensions/overworld/releases/download/" + INMS.OVERWORLD_TAG + "/overworld.zip";
+                    String url = "https://github.com/IrisDimensions/overworld/releases/download/" + Iris.OVERWORLD_TAG + "/overworld.zip";
                     Iris.service(StudioSVC.class).downloadRelease(Iris.getSender(), url, false, false);
                 } else {
                     downloadSearch(Iris.getSender(), pack, false);

core/src/main/java/com/volmit/iris/core/service/TreeSVC.java

@@ -27,7 +27,6 @@ import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.Cuboid;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.math.BlockPosition;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.plugin.IrisService;
@@ -35,6 +34,7 @@ import com.volmit.iris.util.scheduling.J;
 import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
+import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.type.Sapling;
 import org.bukkit.event.EventHandler;
@@ -142,9 +142,7 @@ public class TreeSVC implements IrisService {
             public void set(int x, int y, int z, BlockData d) {
                 Block b = event.getWorld().getBlockAt(x, y, z);
                 BlockState state = b.getState();
-                if (d instanceof IrisCustomData data)
-                    state.setBlockData(data.getBase());
-                else state.setBlockData(d);
+                state.setBlockData(d);
                 blockStateList.add(b.getState());
                 dataCache.put(new Location(event.getWorld(), x, y, z), d);
             }
@@ -215,17 +213,12 @@ public class TreeSVC implements IrisService {
             block = false;
 
             if (!iGrow.isCancelled()) {
-                for (BlockState state : iGrow.getBlocks()) {
-                    Location l = state.getLocation();
+                for (BlockState block : iGrow.getBlocks()) {
+                    Location l = block.getLocation();
 
-                    BlockData d = dataCache.get(l);
-                    if (d == null) continue;
-                    Block block = l.getBlock();
-
-                    if (d instanceof IrisCustomData data) {
-                        block.setBlockData(data.getBase(), false);
-                        Iris.service(ExternalDataSVC.class).processUpdate(engine, block, data.getCustom());
-                    } else block.setBlockData(d);
+                    if (dataCache.containsKey(l)) {
+                        l.getBlock().setBlockData(dataCache.get(l), false);
+                    }
                 }
             }
         });

core/src/main/java/com/volmit/iris/core/service/WandSVC.java

@@ -30,12 +30,15 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.matter.Matter;
 import com.volmit.iris.util.matter.WorldMatter;
+import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.S;
 import com.volmit.iris.util.scheduling.SR;
 import com.volmit.iris.util.scheduling.jobs.Job;
 import org.bukkit.*;
+import org.bukkit.block.Block;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -53,11 +56,11 @@ import java.awt.Color;
 import java.util.ArrayList;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
-
-import static com.volmit.iris.util.data.registry.Particles.CRIT_MAGIC;
-import static com.volmit.iris.util.data.registry.Particles.REDSTONE;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class WandSVC implements IrisService {
+    private static final Particle CRIT_MAGIC = E.getOrDefault(Particle.class, "CRIT_MAGIC", "CRIT");
+    private static final Particle REDSTONE = E.getOrDefault(Particle.class,  "REDSTONE", "DUST");
     private static final int MS_PER_TICK = Integer.parseInt(System.getProperty("iris.ms_per_tick", "30"));
 
     private static ItemStack dust;

core/src/main/java/com/volmit/iris/core/tools/IrisCreator.java

@@ -22,7 +22,6 @@ import com.google.common.util.concurrent.AtomicDouble;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
-import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.engine.object.IrisDimension;
@@ -84,6 +83,7 @@ public class IrisCreator {
      * Benchmark mode
      */
     private boolean benchmark = false;
+    private boolean smartVanillaHeight = false;
 
     public static boolean removeFromBukkitYml(String name) throws IOException {
         YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
@@ -137,6 +137,7 @@ public class IrisCreator {
                 .name(name)
                 .seed(seed)
                 .studio(studio)
+                .smartVanillaHeight(smartVanillaHeight)
                 .create();
         ServerConfigurator.installDataPacks(false);
 
@@ -171,7 +172,7 @@ public class IrisCreator {
 
         try {
             J.sfut(() -> {
-                world.set(INMS.get().createWorld(wc));
+                world.set(wc.createWorld());
             }).get();
         } catch (Throwable e) {
             e.printStackTrace();

core/src/main/java/com/volmit/iris/core/tools/IrisPackBenchmarking.java

@@ -146,8 +146,8 @@ public class IrisPackBenchmarking {
         IrisToolbelt.pregenerate(PregenTask
                 .builder()
                 .gui(gui)
-                .radiusX(radius)
-                .radiusZ(radius)
+                .width(radius)
+                .height(radius)
                 .build(), Bukkit.getWorld("benchmark")
         );
     }

core/src/main/java/com/volmit/iris/core/tools/IrisWorldCreator.java

@@ -21,13 +21,10 @@ package com.volmit.iris.core.tools;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
-import com.volmit.iris.util.reflect.WrappedField;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.WorldCreator;
-import org.bukkit.WorldType;
 import org.bukkit.generator.ChunkGenerator;
-import sun.misc.Unsafe;
 
 import java.io.File;
 
@@ -35,6 +32,7 @@ public class IrisWorldCreator {
     private String name;
     private boolean studio = false;
     private String dimensionName = null;
+    private boolean smartVanillaHeight = false;
     private long seed = 1337;
 
     public IrisWorldCreator() {
@@ -66,6 +64,11 @@ public class IrisWorldCreator {
         return this;
     }
 
+    public IrisWorldCreator smartVanillaHeight(boolean smartVanillaHeight) {
+        this.smartVanillaHeight = smartVanillaHeight;
+        return this;
+    }
+
     public WorldCreator create() {
         IrisDimension dim = IrisData.loadAnyDimension(dimensionName);
 
@@ -79,7 +82,7 @@ public class IrisWorldCreator {
                 .build();
         ChunkGenerator g = new BukkitChunkGenerator(w, studio, studio
                 ? dim.getLoader().getDataFolder() :
-                new File(w.worldFolder(), "iris/pack"), dimensionName);
+                new File(w.worldFolder(), "iris/pack"), dimensionName, smartVanillaHeight);
 
 
         return new WorldCreator(name)

core/src/main/java/com/volmit/iris/core/wand/WandSelection.java

@@ -20,6 +20,8 @@ package com.volmit.iris.core.wand;
 
 import com.volmit.iris.util.data.Cuboid;
 import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.E;
 import org.bukkit.Location;
 import org.bukkit.Particle;
 import org.bukkit.entity.Player;
@@ -27,9 +29,8 @@ import org.bukkit.util.Vector;
 
 import java.awt.*;
 
-import static com.volmit.iris.util.data.registry.Particles.REDSTONE;
-
 public class WandSelection {
+    private static final Particle REDSTONE = E.getOrDefault(Particle.class, "REDSTONE", "DUST");
     private final Cuboid c;
     private final Player p;
     private static final double STEP = 0.10;

core/src/main/java/com/volmit/iris/engine/IrisEngine.java

@@ -21,10 +21,10 @@ package com.volmit.iris.engine;
 import com.google.common.util.concurrent.AtomicDouble;
 import com.google.gson.Gson;
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.events.IrisEngineHotloadEvent;
 import com.volmit.iris.core.gui.PregeneratorJob;
-import com.volmit.iris.core.loader.ResourceLoader;
 import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.core.project.IrisProject;
@@ -43,7 +43,6 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.io.JarScanner;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.RNG;
@@ -54,6 +53,7 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
+import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -61,23 +61,18 @@ import org.bukkit.command.CommandSender;
 
 import java.io.File;
 import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Collections;
 import java.util.HashSet;
-import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 @Data
 @EqualsAndHashCode(exclude = "context")
 @ToString(exclude = "context")
 public class IrisEngine implements Engine {
-    private static final Map<Class<? extends IrisEngineService>, Constructor<? extends IrisEngineService>> SERVICES = scanServices();
-    private final KMap<Class<? extends IrisEngineService>, IrisEngineService> services;
     private final AtomicInteger bud;
     private final AtomicInteger buds;
     private final AtomicInteger generated;
@@ -97,7 +92,6 @@ public class IrisEngine implements Engine {
     private final AtomicBoolean cleaning;
     private final ChronoLatch cleanLatch;
     private final SeedManager seedManager;
-    private CompletableFuture<Long> hash32;
     private EngineMode mode;
     private EngineEffects effects;
     private EngineExecutionEnvironment execution;
@@ -118,7 +112,6 @@ public class IrisEngine implements Engine {
         getEngineData();
         verifySeed();
         this.seedManager = new SeedManager(target.getWorld().getRawWorldSeed());
-        services = new KMap<>();
         bud = new AtomicInteger(0);
         buds = new AtomicInteger(0);
         metrics = new EngineMetrics(32);
@@ -145,26 +138,6 @@ public class IrisEngine implements Engine {
         Iris.debug("Engine Initialized " + getCacheID());
     }
 
-    @SuppressWarnings("unchecked")
-    private static Map<Class<? extends IrisEngineService>, Constructor<? extends IrisEngineService>> scanServices() {
-        JarScanner js = new JarScanner(Iris.instance.getJarFile(), "com.volmit.iris.engine.service");
-        J.attempt(js::scan);
-        KMap<Class<? extends IrisEngineService>, Constructor<? extends IrisEngineService>> map = new KMap<>();
-        js.getClasses()
-                .stream()
-                .filter(IrisEngineService.class::isAssignableFrom)
-                .map(c -> (Class<? extends IrisEngineService>) c)
-                .forEach(c -> {
-                    try {
-                        map.put(c, c.getConstructor(Engine.class));
-                    } catch (NoSuchMethodException e) {
-                        Iris.warn("Failed to load service " + c.getName() + " due to missing constructor");
-                    }
-                });
-
-        return Collections.unmodifiableMap(map);
-    }
-
     private void verifySeed() {
         if (getEngineData().getSeed() != null && getEngineData().getSeed() != target.getWorld().getRawWorldSeed()) {
             target.getWorld().setRawWorldSeed(getEngineData().getSeed());
@@ -189,8 +162,6 @@ public class IrisEngine implements Engine {
         execution.close();
         effects.close();
         mode.close();
-        services.values().forEach(s -> s.onDisable(true));
-        services.values().forEach(Iris.instance::unregisterListener);
 
         J.a(() -> new IrisProject(getData().getDataFolder()).updateWorkspace());
     }
@@ -199,39 +170,12 @@ public class IrisEngine implements Engine {
         try {
             Iris.debug("Setup Engine " + getCacheID());
             cacheId = RNG.r.nextInt();
-            boolean hotload = true;
-            if (services.isEmpty()) {
-                SERVICES.forEach((s, c) -> {
-                    try {
-                        services.put(s, c.newInstance(this));
-                    } catch (InstantiationException | IllegalAccessException |
-                             InvocationTargetException e) {
-                        Iris.error("Failed to create service " + s.getName());
-                        e.printStackTrace();
-                    }
-                });
-                hotload = false;
-            }
-            for (var service : services.values()) {
-                service.onEnable(hotload);
-                Iris.instance.registerListener(service);
-            }
-
             worldManager = new IrisWorldManager(this);
             complex = new IrisComplex(this);
             execution = new IrisExecutionEnvironment(this);
             effects = new IrisEngineEffects(this);
-            hash32 = new CompletableFuture<>();
             setupMode();
             J.a(this::computeBiomeMaxes);
-            J.a(() -> {
-                File[] roots = getData().getLoaders()
-                        .values()
-                        .stream()
-                        .map(ResourceLoader::getRoot)
-                        .toArray(File[]::new);
-                hash32.complete(IO.hashRecursive(roots));
-            });
         } catch (Throwable e) {
             Iris.error("FAILED TO SETUP ENGINE!");
             e.printStackTrace();
@@ -466,7 +410,6 @@ public class IrisEngine implements Engine {
         PregeneratorJob.shutdownInstance();
         closed = true;
         J.car(art);
-        services.values().forEach(s -> s.onDisable(false));
         getWorldManager().close();
         getTarget().close();
         saveEngineData();

core/src/main/java/com/volmit/iris/engine/IrisEngineMantle.java

@@ -23,12 +23,11 @@ import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.mantle.EngineMantle;
 import com.volmit.iris.engine.mantle.MantleComponent;
-import com.volmit.iris.engine.mantle.components.MantleCarvingComponent;
-import com.volmit.iris.engine.mantle.components.MantleFluidBodyComponent;
-import com.volmit.iris.engine.mantle.components.MantleJigsawComponent;
-import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
+import com.volmit.iris.engine.mantle.components.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.mantle.Mantle;
 import lombok.*;
 
@@ -58,6 +57,7 @@ public class IrisEngineMantle implements EngineMantle {
         registerComponent(jigsaw);
         object = new MantleObjectComponent(this);
         registerComponent(object);
+        registerComponent(new MantleStaticComponent(this));
     }
 
     @Override

core/src/main/java/com/volmit/iris/engine/IrisWorldManager.java

@@ -27,6 +27,7 @@ import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.M;
@@ -61,7 +62,6 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Predicate;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
@@ -71,6 +71,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
     private final Looper looper;
     private final int id;
     private final KList<Runnable> updateQueue = new KList<>();
+    private final ChronoLatch cl;
     private final ChronoLatch clw;
     private final ChronoLatch ecl;
     private final ChronoLatch cln;
@@ -81,10 +82,12 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
     private long charge = 0;
     private int actuallySpawned = 0;
     private int cooldown = 0;
+    private List<Entity> precount = new KList<>();
     private KSet<Position2> injectBiomes = new KSet<>();
 
     public IrisWorldManager() {
         super(null);
+        cl = null;
         ecl = null;
         cln = null;
         clw = null;
@@ -99,6 +102,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
         chunkUpdater = new ChronoLatch(3000);
         chunkDiscovery = new ChronoLatch(5000);
         cln = new ChronoLatch(60000);
+        cl = new ChronoLatch(3000);
         ecl = new ChronoLatch(250);
         clw = new ChronoLatch(1000, true);
         id = engine.getCacheID();
@@ -146,12 +150,27 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
                         engine.getEngineData().cleanup(getEngine());
                     }
 
+                    if (precount != null) {
+                        entityCount = 0;
+                        for (Entity i : precount) {
+                            if (i instanceof LivingEntity) {
+                                if (!i.isDead()) {
+                                    entityCount++;
+                                }
+                            }
+                        }
+
+                        precount = null;
+                    }
+
                     if (energy < 650) {
                         if (ecl.flip()) {
                             energy *= 1 + (0.02 * M.clip((1D - getEntitySaturation()), 0D, 1D));
                             fixEnergy();
                         }
                     }
+
+                    onAsyncTick();
                 }
 
                 return IrisSettings.get().getWorld().getAsyncTickIntervalMS();
@@ -194,7 +213,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
                             int finalZ = c.getZ() + z;
                             J.a(() -> getMantle().raiseFlag(finalX, finalZ, MantleFlag.INITIAL_SPAWNED_MARKER,
                                     () -> {
-                                        J.a(() -> spawnIn(cx), RNG.r.i(5, 200));
+                                        J.a(() -> spawnIn(cx, true), RNG.r.i(5, 200));
                                         getSpawnersFromMarkers(cx).forEach((blockf, spawners) -> {
                                             if (spawners.isEmpty()) {
                                                 return;
@@ -202,7 +221,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
 
                                             IrisPosition block = new IrisPosition(blockf.getX(), blockf.getY() + getEngine().getWorld().minHeight(), blockf.getZ());
                                             IrisSpawner s = new KList<>(spawners).getRandom();
-                                            spawn(block, s);
+                                            spawn(block, s, true);
                                         });
                                     }));
                         }
@@ -212,16 +231,95 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
         }
     }
 
+    private boolean onAsyncTick() {
+        if (getEngine().isClosed()) {
+            return false;
+        }
+
+        actuallySpawned = 0;
+
+        if (energy < 100) {
+            J.sleep(200);
+            return false;
+        }
+
+        if (!getEngine().getWorld().hasRealWorld()) {
+            Iris.debug("Can't spawn. No real world");
+            J.sleep(5000);
+            return false;
+        }
+
+        double epx = getEntitySaturation();
+        if (epx > IrisSettings.get().getWorld().getTargetSpawnEntitiesPerChunk()) {
+            Iris.debug("Can't spawn. The entity per chunk ratio is at " + Form.pc(epx, 2) + " > 100% (total entities " + entityCount + ")");
+            J.sleep(5000);
+            return false;
+        }
+
+        if (cl.flip()) {
+            try {
+                J.s(() -> precount = getEngine().getWorld().realWorld().getEntities());
+            } catch (Throwable e) {
+                close();
+            }
+        }
+
+        int spawnBuffer = RNG.r.i(2, 12);
+
+        Chunk[] cc = getEngine().getWorld().realWorld().getLoadedChunks();
+        while (spawnBuffer-- > 0) {
+            if (cc.length == 0) {
+                Iris.debug("Can't spawn. No chunks!");
+                return false;
+            }
+
+            Chunk c = cc[RNG.r.nextInt(cc.length)];
+
+            if (!c.isLoaded() || !Chunks.isSafe(c.getWorld(), c.getX(), c.getZ())) {
+                continue;
+            }
+
+            spawnIn(c, false);
+        }
+
+        energy -= (actuallySpawned / 2D);
+        return actuallySpawned > 0;
+    }
+
     private void fixEnergy() {
         energy = M.clip(energy, 1D, getDimension().getMaximumEnergy());
     }
 
-    private void spawnIn(Chunk c) {
+    private void spawnIn(Chunk c, boolean initial) {
         if (getEngine().isClosed()) {
             return;
         }
 
-        energy += 1.2;
+        if (initial) {
+            energy += 1.2;
+        }
+
+        //@builder
+        IrisBiome biome = IrisSettings.get().getWorld().isAnbientEntitySpawningSystem()
+                ? getEngine().getSurfaceBiome(c) : null;
+        IrisEntitySpawn v = IrisSettings.get().getWorld().isAnbientEntitySpawningSystem()
+                ? spawnRandomly(Stream.concat(getData().getSpawnerLoader()
+                                .loadAll(getDimension().getEntitySpawners())
+                                .shuffleCopy(RNG.r).stream()
+                                .filter(this::canSpawn)
+                                .filter((i) -> i.isValid(biome))
+                                .flatMap((i) -> stream(i, initial)),
+                        Stream.concat(getData().getSpawnerLoader()
+                                        .loadAll(getEngine().getRegion(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
+                                        .shuffleCopy(RNG.r).stream().filter(this::canSpawn)
+                                        .flatMap((i) -> stream(i, initial)),
+                                getData().getSpawnerLoader()
+                                        .loadAll(getEngine().getSurfaceBiome(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
+                                        .shuffleCopy(RNG.r).stream().filter(this::canSpawn)
+                                        .flatMap((i) -> stream(i, initial))))
+                .collect(Collectors.toList()))
+                .popRandom(RNG.r) : null;
+        //@done
 
         if (IrisSettings.get().getWorld().isMarkerEntitySpawningSystem()) {
             getSpawnersFromMarkers(c).forEach((blockf, spawners) -> {
@@ -231,82 +329,110 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
 
                 IrisPosition block = new IrisPosition(blockf.getX(), blockf.getY() + getEngine().getWorld().minHeight(), blockf.getZ());
                 IrisSpawner s = new KList<>(spawners).getRandom();
+                spawn(block, s, false);
                 J.a(() -> getMantle().raiseFlag(c.getX(), c.getZ(), MantleFlag.INITIAL_SPAWNED_MARKER,
-                        () -> spawn(block, s)));
+                        () -> spawn(block, s, true)));
             });
         }
 
-        if (!IrisSettings.get().getWorld().isAnbientEntitySpawningSystem()) {
-            return;
-        }
+        if (v != null && v.getReferenceSpawner() != null) {
+            int maxEntCount = v.getReferenceSpawner().getMaxEntitiesPerChunk();
 
-        //@builder
-        Predicate<IrisSpawner> filter = i -> i.canSpawn(getEngine(), c.getX(), c.getZ());
-        ChunkCounter counter = new ChunkCounter(c.getEntities());
+            for (Entity i : c.getEntities()) {
+                if (i instanceof LivingEntity) {
+                    if (-maxEntCount <= 0) {
+                        return;
+                    }
+                }
+            }
 
-        IrisBiome biome = getEngine().getSurfaceBiome(c);
-        IrisEntitySpawn v = spawnRandomly(Stream.concat(getData().getSpawnerLoader()
-                                .loadAll(getDimension().getEntitySpawners())
-                                .shuffleCopy(RNG.r)
-                                .stream()
-                                .filter(filter)
-                                .filter((i) -> i.isValid(biome)),
-                        Stream.concat(getData()
-                                        .getSpawnerLoader()
-                                        .loadAll(getEngine().getRegion(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
-                                        .shuffleCopy(RNG.r)
-                                        .stream()
-                                        .filter(filter),
-                                getData().getSpawnerLoader()
-                                        .loadAll(getEngine().getSurfaceBiome(c.getX() << 4, c.getZ() << 4).getEntitySpawners())
-                                        .shuffleCopy(RNG.r)
-                                        .stream()
-                                        .filter(filter)))
-                .filter(counter)
-                .flatMap(this::stream)
-                .collect(Collectors.toList()))
-                .getRandom();
-        //@done
-        if (v == null || v.getReferenceSpawner() == null)
-            return;
-
-        try {
-            spawn(c, v);
-        } catch (Throwable e) {
-            J.s(() -> spawn(c, v));
+            try {
+                spawn(c, v);
+            } catch (Throwable e) {
+                J.s(() -> spawn(c, v));
+            }
         }
     }
 
     private void spawn(Chunk c, IrisEntitySpawn i) {
-        IrisSpawner ref = i.getReferenceSpawner();
-        int s = i.spawn(getEngine(), c, RNG.r);
-        actuallySpawned += s;
-        if (s > 0) {
-            ref.spawn(getEngine(), c.getX(), c.getZ());
-            energy -= s * ((i.getEnergyMultiplier() * ref.getEnergyMultiplier() * 1));
+        boolean allow = true;
+
+        if (!i.getReferenceSpawner().getMaximumRatePerChunk().isInfinite()) {
+            allow = false;
+            IrisEngineChunkData cd = getEngine().getEngineData().getChunk(c.getX(), c.getZ());
+            IrisEngineSpawnerCooldown sc = null;
+            for (IrisEngineSpawnerCooldown j : cd.getCooldowns()) {
+                if (j.getSpawner().equals(i.getReferenceSpawner().getLoadKey())) {
+                    sc = j;
+                    break;
+                }
+            }
+
+            if (sc == null) {
+                sc = new IrisEngineSpawnerCooldown();
+                sc.setSpawner(i.getReferenceSpawner().getLoadKey());
+                cd.getCooldowns().add(sc);
+            }
+
+            if (sc.canSpawn(i.getReferenceSpawner().getMaximumRatePerChunk())) {
+                sc.spawn(getEngine());
+                allow = true;
+            }
+        }
+
+        if (allow) {
+            int s = i.spawn(getEngine(), c, RNG.r);
+            actuallySpawned += s;
+            if (s > 0) {
+                getCooldown(i.getReferenceSpawner()).spawn(getEngine());
+                energy -= s * ((i.getEnergyMultiplier() * i.getReferenceSpawner().getEnergyMultiplier() * 1));
+            }
         }
     }
 
-    private void spawn(IrisPosition pos, IrisEntitySpawn i) {
-        IrisSpawner ref = i.getReferenceSpawner();
-        if (!ref.canSpawn(getEngine(), pos.getX() >> 4, pos.getZ()))
-            return;
+    private void spawn(IrisPosition c, IrisEntitySpawn i) {
+        boolean allow = true;
 
-        int s = i.spawn(getEngine(), pos, RNG.r);
-        actuallySpawned += s;
-        if (s > 0) {
-            ref.spawn(getEngine(), pos.getX() >> 4, pos.getZ() >> 4);
-            energy -= s * ((i.getEnergyMultiplier() * ref.getEnergyMultiplier() * 1));
+        if (!i.getReferenceSpawner().getMaximumRatePerChunk().isInfinite()) {
+            allow = false;
+            IrisEngineChunkData cd = getEngine().getEngineData().getChunk(c.getX() >> 4, c.getZ() >> 4);
+            IrisEngineSpawnerCooldown sc = null;
+            for (IrisEngineSpawnerCooldown j : cd.getCooldowns()) {
+                if (j.getSpawner().equals(i.getReferenceSpawner().getLoadKey())) {
+                    sc = j;
+                    break;
+                }
+            }
+
+            if (sc == null) {
+                sc = new IrisEngineSpawnerCooldown();
+                sc.setSpawner(i.getReferenceSpawner().getLoadKey());
+                cd.getCooldowns().add(sc);
+            }
+
+            if (sc.canSpawn(i.getReferenceSpawner().getMaximumRatePerChunk())) {
+                sc.spawn(getEngine());
+                allow = true;
+            }
+        }
+
+        if (allow) {
+            int s = i.spawn(getEngine(), c, RNG.r);
+            actuallySpawned += s;
+            if (s > 0) {
+                getCooldown(i.getReferenceSpawner()).spawn(getEngine());
+                energy -= s * ((i.getEnergyMultiplier() * i.getReferenceSpawner().getEnergyMultiplier() * 1));
+            }
         }
     }
 
-    private Stream<IrisEntitySpawn> stream(IrisSpawner s) {
-        for (IrisEntitySpawn i : s.getInitialSpawns()) {
+    private Stream<IrisEntitySpawn> stream(IrisSpawner s, boolean initial) {
+        for (IrisEntitySpawn i : initial ? s.getInitialSpawns() : s.getSpawns()) {
             i.setReferenceSpawner(s);
             i.setReferenceMarker(s.getReferenceMarker());
         }
 
-        return (s.getInitialSpawns()).stream();
+        return (initial ? s.getInitialSpawns() : s.getSpawns()).stream();
     }
 
     private KList<IrisEntitySpawn> spawnRandomly(List<IrisEntitySpawn> types) {
@@ -324,6 +450,31 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
         return rarityTypes;
     }
 
+    public boolean canSpawn(IrisSpawner i) {
+        return i.isValid(getEngine().getWorld().realWorld())
+                && getCooldown(i).canSpawn(i.getMaximumRate());
+    }
+
+    private IrisEngineSpawnerCooldown getCooldown(IrisSpawner i) {
+        IrisEngineData ed = getEngine().getEngineData();
+        IrisEngineSpawnerCooldown cd = null;
+
+        for (IrisEngineSpawnerCooldown j : ed.getSpawnerCooldowns().copy()) {
+            if (j.getSpawner().equals(i.getLoadKey())) {
+                cd = j;
+            }
+        }
+
+        if (cd == null) {
+            cd = new IrisEngineSpawnerCooldown();
+            cd.setSpawner(i.getLoadKey());
+            cd.setLastSpawn(M.ms() - i.getMaximumRate().getInterval());
+            ed.getSpawnerCooldowns().add(cd);
+        }
+
+        return cd;
+    }
+
     @Override
     public void onTick() {
 
@@ -353,7 +504,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
         }
     }
 
-    private void spawn(IrisPosition block, IrisSpawner spawner) {
+    private void spawn(IrisPosition block, IrisSpawner spawner, boolean initial) {
         if (getEngine().isClosed()) {
             return;
         }
@@ -362,7 +513,7 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
             return;
         }
 
-        KList<IrisEntitySpawn> s = spawner.getInitialSpawns();
+        KList<IrisEntitySpawn> s = initial ? spawner.getInitialSpawns() : spawner.getSpawns();
         if (s.isEmpty()) {
             return;
         }
@@ -557,27 +708,4 @@ public class IrisWorldManager extends EngineAssignedWorldManager {
 
         return (double) entityCount / (getEngine().getWorld().realWorld().getLoadedChunks().length + 1) * 1.28;
     }
-
-    @Data
-    private static class ChunkCounter implements Predicate<IrisSpawner> {
-        private final Entity[] entities;
-        private transient int index = 0;
-        private transient int count = 0;
-
-        @Override
-        public boolean test(IrisSpawner spawner) {
-            int max = spawner.getMaxEntitiesPerChunk();
-            if (max <= count)
-                return false;
-
-            while (index < entities.length) {
-                if (entities[index++] instanceof LivingEntity) {
-                    if (++count >= max)
-                        return false;
-                }
-            }
-
-            return true;
-        }
-    }
 }

core/src/main/java/com/volmit/iris/engine/data/chunk/LinkedTerrainChunk.java

@@ -21,7 +21,7 @@ package com.volmit.iris.engine.data.chunk;
 import com.volmit.iris.core.nms.BiomeBaseInjector;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.util.data.IrisBiomeStorage;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import lombok.Setter;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -121,7 +121,7 @@ public class LinkedTerrainChunk implements TerrainChunk {
 
     @Override
     public synchronized void setBlock(int x, int y, int z, BlockData blockData) {
-        if (blockData instanceof IrisCustomData d)
+        if (blockData instanceof IrisBlockData d)
             blockData = d.getBase();
         rawChunkData.setBlock(x, y, z, blockData);
     }

core/src/main/java/com/volmit/iris/engine/data/chunk/MCATerrainChunk.java

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.data.chunk;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.BiomeBaseInjector;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.nbt.mca.Chunk;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import lombok.AllArgsConstructor;
@@ -89,7 +89,7 @@ public class MCATerrainChunk implements TerrainChunk {
         if (blockData == null) {
             Iris.error("NULL BD");
         }
-        if (blockData instanceof IrisCustomData data)
+        if (blockData instanceof IrisBlockData data)
             blockData = data.getBase();
 
         mcaChunk.setBlockStateAt(xx, y, zz, NBTWorld.getCompound(blockData), false);

core/src/main/java/com/volmit/iris/engine/decorator/IrisCeilingDecorator.java

@@ -18,16 +18,18 @@
 
 package com.volmit.iris.engine.decorator;
 
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
+import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.math.RNG;
 import org.bukkit.Material;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.MultipleFacing;
 import org.bukkit.block.data.type.PointedDripstone;
 
 public class IrisCeilingDecorator extends IrisEngineDecorator {
@@ -38,14 +40,12 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
     @BlockCoordinates
     @Override
     public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
-        RNG rng = getRNG(realX, realZ);
-        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
-
+        IrisDecorator decorator = getDecorator(biome, realX, realZ);
         if (decorator != null) {
             if (!decorator.isStacking()) {
-                data.set(x, height, z, fixFaces(decorator.getBlockData100(biome, rng, realX, height, realZ, getData()), data, x, z, realX, height, realZ));
+                data.set(x, height, z, fixFaces(decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()), realX, height, realZ));
             } else {
-                int stack = decorator.getHeight(rng, realX, realZ, getData());
+                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
                 if (decorator.isScaleStack()) {
                     stack = Math.min((int) Math.ceil((double) max * ((double) stack / 100)), decorator.getAbsoluteMaxStack());
                 } else {
@@ -53,7 +53,7 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
                 }
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
                     return;
                 }
 
@@ -66,8 +66,8 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
                     double threshold = (((double) i) / (double) (stack - 1));
 
                     BlockData bd = threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData());
+                            decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData());
 
                     if (bd instanceof PointedDripstone) {
                         PointedDripstone.Thickness th = PointedDripstone.Thickness.BASE;
@@ -97,4 +97,24 @@ public class IrisCeilingDecorator extends IrisEngineDecorator {
             }
         }
     }
+
+    private BlockData fixFaces(BlockData b, int x, int y, int z) {
+        if (B.isVineBlock(b)) {
+            MultipleFacing data = (MultipleFacing) b.clone();
+            boolean found = false;
+            for (BlockFace f : BlockFace.values()) {
+                if (!f.isCartesian())
+                    continue;
+                Material m = getEngine().getMantle().get(x + f.getModX(), y + f.getModY(), z + f.getModZ()).getMaterial();
+                if (m.isSolid()) {
+                    found = true;
+                    data.setFace(f, m.isSolid());
+                }
+            }
+            if (!found)
+                data.setFace(BlockFace.UP, true);
+            return data;
+        }
+        return b;
+    }
 }

core/src/main/java/com/volmit/iris/engine/decorator/IrisEngineDecorator.java

@@ -19,6 +19,7 @@
 package com.volmit.iris.engine.decorator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineAssignedComponent;
 import com.volmit.iris.engine.framework.EngineDecorator;
@@ -26,42 +27,30 @@ import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.math.RNG;
 import lombok.Getter;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.BlockSupport;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.MultipleFacing;
 
 public abstract class IrisEngineDecorator extends EngineAssignedComponent implements EngineDecorator {
+
+    @Getter
+    private final RNG rng;
+
     @Getter
     private final IrisDecorationPart part;
-    private final long seed;
-    private final long modX, modZ;
 
     public IrisEngineDecorator(Engine engine, String name, IrisDecorationPart part) {
         super(engine, name + " Decorator");
         this.part = part;
-        this.seed = getSeed() + 29356788 - (part.ordinal() * 10439677L);
-        this.modX = 29356788 ^ (part.ordinal() + 6);
-        this.modZ = 10439677 ^ (part.ordinal() + 1);
+        this.rng = new RNG(getSeed() + 29356788 - (part.ordinal() * 10439677L));
     }
 
-    @BlockCoordinates
-    protected RNG getRNG(int x, int z) {
-        return new RNG(x * modX + z * modZ + seed);
-    }
-
-    protected IrisDecorator getDecorator(RNG rng, IrisBiome biome, double realX, double realZ) {
+    protected IrisDecorator getDecorator(IrisBiome biome, double realX, double realZ) {
         KList<IrisDecorator> v = new KList<>();
+        RNG rng = new RNG(Cache.key((int) realX, (int) realZ));
 
-        RNG gRNG = new RNG(seed);
         for (IrisDecorator i : biome.getDecorators()) {
             try {
-                if (i.getPartOf().equals(part) && i.getBlockData(biome, gRNG, realX, realZ, getData()) != null) {
+                if (i.getPartOf().equals(part) && i.getBlockData(biome, this.rng, realX, realZ, getData()) != null) {
                     v.add(i);
                 }
             } catch (Throwable e) {
@@ -76,40 +65,4 @@ public abstract class IrisEngineDecorator extends EngineAssignedComponent implem
 
         return null;
     }
-
-    protected BlockData fixFaces(BlockData b, Hunk<BlockData> hunk, int rX, int rZ, int x, int y, int z) {
-        if (B.isVineBlock(b)) {
-            MultipleFacing data = (MultipleFacing) b.clone();
-            data.getFaces().forEach(f -> data.setFace(f, false));
-
-            boolean found = false;
-            for (BlockFace f : BlockFace.values()) {
-                if (!f.isCartesian())
-                    continue;
-                int yy = y + f.getModY();
-
-                BlockData r = getEngine().getMantle().get(x + f.getModX(), yy, z + f.getModZ());
-                if (r.isFaceSturdy(f.getOppositeFace(), BlockSupport.FULL)) {
-                    found = true;
-                    data.setFace(f, true);
-                    continue;
-                }
-
-                int xx = rX + f.getModX();
-                int zz = rZ + f.getModZ();
-                if (xx < 0 || xx > 15 || zz < 0 || zz > 15 || yy < 0 || yy > hunk.getHeight())
-                    continue;
-
-                r = hunk.get(xx, yy, zz);
-                if (r.isFaceSturdy(f.getOppositeFace(), BlockSupport.FULL)) {
-                    found = true;
-                    data.setFace(f, true);
-                }
-            }
-            if (!found)
-                data.setFace(BlockFace.DOWN, true);
-            return data;
-        }
-        return b;
-    }
 }

core/src/main/java/com/volmit/iris/engine/decorator/IrisSeaFloorDecorator.java

@@ -18,13 +18,13 @@
 
 package com.volmit.iris.engine.decorator;
 
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.math.RNG;
 import org.bukkit.block.data.BlockData;
 
 public class IrisSeaFloorDecorator extends IrisEngineDecorator {
@@ -35,8 +35,7 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
     @BlockCoordinates
     @Override
     public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
-        RNG rng = getRNG(realX, realZ);
-        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
+        IrisDecorator decorator = getDecorator(biome, realX, realZ);
 
         if (decorator != null) {
             if (!decorator.isStacking()) {
@@ -45,17 +44,17 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
                     return;
                 }
                 if (height >= 0 || height < getEngine().getHeight()) {
-                    data.set(x, height, z, decorator.getBlockData100(biome, rng, realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
                 }
             } else {
-                int stack = decorator.getHeight(rng, realX, realZ, getData());
+                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
                 if (decorator.isScaleStack()) {
                     int maxStack = max - height;
                     stack = (int) Math.ceil((double) maxStack * ((double) stack / 100));
                 } else stack = Math.min(stack, max - height);
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
                     return;
                 }
 
@@ -67,8 +66,8 @@ public class IrisSeaFloorDecorator extends IrisEngineDecorator {
 
                     double threshold = ((double) i) / (stack - 1);
                     data.set(x, h, z, threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData()));
+                            decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData()));
                 }
             }
         }

core/src/main/java/com/volmit/iris/engine/decorator/IrisSeaSurfaceDecorator.java

@@ -18,13 +18,13 @@
 
 package com.volmit.iris.engine.decorator;
 
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.math.RNG;
 import org.bukkit.block.data.BlockData;
 
 public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
@@ -35,23 +35,22 @@ public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
     @BlockCoordinates
     @Override
     public void decorate(int x, int z, int realX, int realX1, int realX_1, int realZ, int realZ1, int realZ_1, Hunk<BlockData> data, IrisBiome biome, int height, int max) {
-        RNG rng = getRNG(realX, realZ);
-        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
+        IrisDecorator decorator = getDecorator(biome, realX, realZ);
 
         if (decorator != null) {
             if (!decorator.isStacking()) {
                 if (height >= 0 || height < getEngine().getHeight()) {
-                    data.set(x, height + 1, z, decorator.getBlockData100(biome, rng, realX, height, realZ, getData()));
+                    data.set(x, height + 1, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
                 }
             } else {
-                int stack = decorator.getHeight(rng, realX, realZ, getData());
+                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
                 if (decorator.isScaleStack()) {
                     int maxStack = max - height;
                     stack = (int) Math.ceil((double) maxStack * ((double) stack / 100));
                 }
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
                     return;
                 }
 
@@ -63,8 +62,8 @@ public class IrisSeaSurfaceDecorator extends IrisEngineDecorator {
 
                     double threshold = ((double) i) / (stack - 1);
                     data.set(x, h + 1, z, threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData()));
+                            decorator.getBlockDataForTop(biome, getRng().nextParallelRNG(i), realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, getRng().nextParallelRNG(i), realX, h, realZ, getData()));
                 }
             }
         }

core/src/main/java/com/volmit/iris/engine/decorator/IrisShoreLineDecorator.java

@@ -18,13 +18,13 @@
 
 package com.volmit.iris.engine.decorator;
 
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisDecorationPart;
 import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.math.RNG;
 import org.bukkit.block.data.BlockData;
 
 public class IrisShoreLineDecorator extends IrisEngineDecorator {
@@ -42,8 +42,7 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
                     Math.round(getComplex().getHeightStream().get(realX, realZ1)) < getComplex().getFluidHeight() ||
                     Math.round(getComplex().getHeightStream().get(realX, realZ_1)) < getComplex().getFluidHeight()
             ) {
-                RNG rng = getRNG(realX, realZ);
-                IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
+                IrisDecorator decorator = getDecorator(biome, realX, realZ);
 
                 if (decorator != null) {
                     if (!decorator.isForcePlace() && !decorator.getSlopeCondition().isDefault()
@@ -52,16 +51,16 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
                     }
 
                     if (!decorator.isStacking()) {
-                        data.set(x, height + 1, z, decorator.getBlockData100(biome, rng, realX, height, realZ, getData()));
+                        data.set(x, height + 1, z, decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData()));
                     } else {
-                        int stack = decorator.getHeight(rng, realX, realZ, getData());
+                        int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
                         if (decorator.isScaleStack()) {
                             int maxStack = max - height;
                             stack = (int) Math.ceil((double) maxStack * ((double) stack / 100));
                         } else stack = Math.min(max - height, stack);
 
                         if (stack == 1) {
-                            data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
+                            data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
                             return;
                         }
 
@@ -69,8 +68,8 @@ public class IrisShoreLineDecorator extends IrisEngineDecorator {
                             int h = height + i;
                             double threshold = ((double) i) / (stack - 1);
                             data.set(x, h + 1, z, threshold >= decorator.getTopThreshold() ?
-                                    decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
-                                    decorator.getBlockData100(biome, rng, realX, h, realZ, getData()));
+                                    decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
+                                    decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData()));
                         }
                     }
                 }

core/src/main/java/com/volmit/iris/engine/decorator/IrisSurfaceDecorator.java

@@ -19,6 +19,7 @@
 package com.volmit.iris.engine.decorator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.InferredType;
 import com.volmit.iris.engine.object.IrisBiome;
@@ -27,11 +28,11 @@ import com.volmit.iris.engine.object.IrisDecorator;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.math.RNG;
 import org.bukkit.Material;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.Bisected;
 import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.MultipleFacing;
 import org.bukkit.block.data.type.PointedDripstone;
 
 public class IrisSurfaceDecorator extends IrisEngineDecorator {
@@ -47,8 +48,7 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
         }
 
         BlockData bd, bdx;
-        RNG rng = getRNG(realX, realZ);
-        IrisDecorator decorator = getDecorator(rng, biome, realX, realZ);
+        IrisDecorator decorator = getDecorator(biome, realX, realZ);
         bdx = data.get(x, height, z);
         boolean underwater = height < getDimension().getFluidHeight();
 
@@ -59,7 +59,7 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
             }
 
             if (!decorator.isStacking()) {
-                bd = decorator.getBlockData100(biome, rng, realX, height, realZ, getData());
+                bd = decorator.getBlockData100(biome, getRng(), realX, height, realZ, getData());
 
                 if (!underwater) {
                     if (!canGoOn(bd, bdx) && (!decorator.isForcePlace() && decorator.getForceBlock() == null)) {
@@ -68,12 +68,12 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                 }
 
                 if (decorator.getForceBlock() != null) {
-                    data.set(x, height, z, fixFaces(decorator.getForceBlock().getBlockData(getData()), data, x, z, realX, height, realZ));
+                    data.set(x, height, z, fixFaces(decorator.getForceBlock().getBlockData(getData()), x, height, z));
                 } else if (!decorator.isForcePlace()) {
                     if (decorator.getWhitelist() != null && decorator.getWhitelist().stream().noneMatch(d -> d.getBlockData(getData()).equals(bdx))) {
                         return;
                     }
-                    if (decorator.getBlacklist() != null && decorator.getBlacklist().stream().anyMatch(d -> d.getBlockData(getData()).equals(bdx))) {
+                    if (decorator.getBlacklist() != null && decorator.getWhitelist().stream().anyMatch(d -> d.getBlockData(getData()).equals(bdx))) {
                         return;
                     }
                 }
@@ -91,14 +91,14 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                 }
 
                 if (B.isAir(data.get(x, height + 1, z))) {
-                    data.set(x, height + 1, z, fixFaces(bd, data, x, z, realX, height + 1, realZ));
+                    data.set(x, height + 1, z, fixFaces(bd, x, height + 1, z));
                 }
             } else {
                 if (height < getDimension().getFluidHeight()) {
                     max = getDimension().getFluidHeight();
                 }
 
-                int stack = decorator.getHeight(rng, realX, realZ, getData());
+                int stack = decorator.getHeight(getRng().nextParallelRNG(Cache.key(realX, realZ)), realX, realZ, getData());
 
                 if (decorator.isScaleStack()) {
                     stack = Math.min((int) Math.ceil((double) max * ((double) stack / 100)), decorator.getAbsoluteMaxStack());
@@ -107,7 +107,7 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                 }
 
                 if (stack == 1) {
-                    data.set(x, height, z, decorator.getBlockDataForTop(biome, rng, realX, height, realZ, getData()));
+                    data.set(x, height, z, decorator.getBlockDataForTop(biome, getRng(), realX, height, realZ, getData()));
                     return;
                 }
 
@@ -115,8 +115,8 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
                     int h = height + i;
                     double threshold = ((double) i) / (stack - 1);
                     bd = threshold >= decorator.getTopThreshold() ?
-                            decorator.getBlockDataForTop(biome, rng, realX, h, realZ, getData()) :
-                            decorator.getBlockData100(biome, rng, realX, h, realZ, getData());
+                            decorator.getBlockDataForTop(biome, getRng(), realX, h, realZ, getData()) :
+                            decorator.getBlockData100(biome, getRng(), realX, h, realZ, getData());
 
                     if (bd == null) {
                         break;
@@ -158,4 +158,24 @@ public class IrisSurfaceDecorator extends IrisEngineDecorator {
             }
         }
     }
+
+    private BlockData fixFaces(BlockData b, int x, int y, int z) {
+        if (B.isVineBlock(b)) {
+            MultipleFacing data = (MultipleFacing) b.clone();
+            boolean found = false;
+            for (BlockFace f : BlockFace.values()) {
+                if (!f.isCartesian())
+                    continue;
+                Material m = getEngine().getMantle().get(x + f.getModX(), y + f.getModY(), z + f.getModZ()).getMaterial();
+                if (m.isSolid()) {
+                    found = true;
+                    data.setFace(f, m.isSolid());
+                }
+            }
+            if (!found)
+                data.setFace(BlockFace.UP, true);
+            return data;
+        }
+        return b;
+    }
 }

core/src/main/java/com/volmit/iris/engine/framework/Engine.java

@@ -42,7 +42,7 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.data.DataProvider;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.format.C;
@@ -80,7 +80,6 @@ import java.awt.Color;
 import java.util.Arrays;
 import java.util.Set;
 import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -259,8 +258,10 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         if (B.isUpdatable(data)) {
             getMantle().updateBlock(x, y, z);
         }
-        if (data instanceof IrisCustomData) {
-            getMantle().getMantle().flag(x >> 4, z >> 4, MantleFlag.CUSTOM, true);
+        if (data instanceof IrisBlockData d) {
+            getMantle().getMantle().set(x, y, z, d.getCustom());
+        } else {
+            getMantle().getMantle().remove(x, y, z, Identifier.class);
         }
     }
 
@@ -610,8 +611,6 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
 
     int getGenerated();
 
-    CompletableFuture<Long> getHash32();
-
     default <T> IrisPosition lookForStreamResult(T find, ProceduralStream<T> stream, Function2<T, T, Boolean> matcher, long timeout) {
         AtomicInteger checked = new AtomicInteger();
         AtomicLong time = new AtomicLong(M.ms());
@@ -827,6 +826,13 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
                 return new PlacedObject(piece.getPlacementOptions(), getData().getObjectLoader().load(object), id, x, z);
         }
 
+        for (var staticPlacement : getDimension().getStaticPlacements().getObjects()) {
+            IrisObjectPlacement i = staticPlacement.placement();
+            if (i.getPlace().contains(object)) {
+                return new PlacedObject(i, getData().getObjectLoader().load(object), id, x, z);
+            }
+        }
+
         IrisRegion region = getRegion(x, z);
 
         for (IrisObjectPlacement i : region.getObjects()) {

core/src/main/java/com/volmit/iris/engine/framework/placer/WorldObjectPlacer.java

@@ -13,7 +13,6 @@ import com.volmit.iris.engine.object.IrisLootTable;
 import com.volmit.iris.engine.object.TileData;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.math.RNG;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
@@ -79,11 +78,7 @@ public class WorldObjectPlacer implements IObjectPlacer {
             }
         }
 
-
-        if (d instanceof IrisCustomData data) {
-            block.setBlockData(data.getBase());
-            Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
-        } else block.setBlockData(d);
+        block.setBlockData(d);
     }
 
     @Override

core/src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java

@@ -25,6 +25,7 @@ import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.placer.WorldObjectPlacer;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
@@ -154,6 +155,9 @@ public class PlannedStructure {
         return v.place(xx, height, zz, placer, options, rng, (b, data) -> {
             e.set(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id);
             e.set(b.getX(), b.getY(), b.getZ(), container);
+            if (data instanceof IrisBlockData d) {
+                e.set(b.getX(), b.getY(), b.getZ(), d.getCustom());
+            }
         }, null, getData().getEngine() != null ? getData() : eng.getData()) != -1;
     }
 

core/src/main/java/com/volmit/iris/engine/mantle/EngineMantle.java

@@ -34,7 +34,6 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
@@ -105,10 +104,7 @@ public interface EngineMantle extends IObjectPlacer {
 
     @Override
     default void set(int x, int y, int z, BlockData d) {
-        if (d instanceof IrisCustomData data) {
-            getMantle().set(x, y, z, data.getBase());
-            getMantle().set(x, y, z, data.getCustom());
-        } else getMantle().set(x, y, z, d == null ? AIR : d);
+        getMantle().set(x, y, z, d == null ? AIR : d);
     }
 
     @Override

core/src/main/java/com/volmit/iris/engine/mantle/MantleWriter.java

@@ -29,7 +29,6 @@ import com.volmit.iris.engine.object.IrisPosition;
 import com.volmit.iris.engine.object.TileData;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.function.Function3;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.mantle.MantleChunk;
@@ -167,10 +166,7 @@ public class MantleWriter implements IObjectPlacer, AutoCloseable {
 
     @Override
     public void set(int x, int y, int z, BlockData d) {
-        if (d instanceof IrisCustomData data) {
-            setData(x, y, z, data.getBase());
-            setData(x, y, z, data.getCustom());
-        } else setData(x, y, z, d);
+        setData(x, y, z, d);
     }
 
     @Override

core/src/main/java/com/volmit/iris/engine/mantle/components/MantleJigsawComponent.java

@@ -90,10 +90,8 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     private boolean placeStructures(MantleWriter writer, long seed, int x, int z, KList<IrisJigsawStructurePlacement> structures,
             KSet<Position2> cachedRegions, KMap<String, KSet<Position2>> cache, KMap<Position2, Double> distanceCache) {
         IrisJigsawStructurePlacement i = pick(structures, seed, x, z);
-        try {
-            if (i == null || checkMinDistances(i.collectMinDistances(), x, z, cachedRegions, cache, distanceCache))
-                return false;
-        } catch (Throwable ignored) {}
+        if (i == null || checkMinDistances(i.collectMinDistances(), x, z, cachedRegions, cache, distanceCache))
+            return false;
         RNG rng = new RNG(seed);
         IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
         IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
@@ -161,7 +159,7 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     @ChunkCoordinates
     private IrisJigsawStructurePlacement pick(List<IrisJigsawStructurePlacement> structures, long seed, int x, int z) {
         return IRare.pick(structures.stream()
-                .filter(p -> p.shouldPlace(getData(), getDimension().getJigsawStructureDivisor(), jigsaw(), x, z))
+                .filter(p -> p.shouldPlace(getDimension().getJigsawStructureDivisor(), jigsaw(), x, z))
                 .toList(), new RNG(seed).nextDouble());
     }
 

core/src/main/java/com/volmit/iris/engine/mantle/components/MantleObjectComponent.java

@@ -19,6 +19,7 @@
 package com.volmit.iris.engine.mantle.components;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.mantle.EngineMantle;
 import com.volmit.iris.engine.mantle.IrisMantleComponent;
@@ -29,6 +30,7 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.format.Form;
@@ -38,11 +40,13 @@ import com.volmit.iris.util.matter.MatterStructurePOI;
 import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.noise.NoiseType;
 import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
 import lombok.Getter;
 import org.bukkit.util.BlockVector;
 
 import java.io.IOException;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.concurrent.atomic.AtomicInteger;
 
@@ -115,6 +119,9 @@ public class MantleObjectComponent extends IrisMantleComponent {
                 if (objectPlacement.isDolphinTarget() && objectPlacement.isUnderwater() && B.isStorageChest(data)) {
                     writer.setData(b.getX(), b.getY(), b.getZ(), MatterStructurePOI.BURIED_TREASURE);
                 }
+                if (data instanceof IrisBlockData d) {
+                    writer.setData(b.getX(), b.getY(), b.getZ(), d.getCustom());
+                }
             }, null, getData());
         }
     }
@@ -158,99 +165,67 @@ public class MantleObjectComponent extends IrisMantleComponent {
     private int computeRadius() {
         var dimension = getDimension();
 
-        AtomicInteger xg = new AtomicInteger();
-        AtomicInteger zg = new AtomicInteger();
-
         KSet<String> objects = new KSet<>();
         KMap<IrisObjectScale, KList<String>> scalars = new KMap<>();
         for (var region : dimension.getAllRegions(this::getData)) {
-            for (var j : region.getObjects()) {
-                if (j.getScale().canScaleBeyond()) {
-                    scalars.put(j.getScale(), j.getPlace());
+            for (var placement : region.getObjects()) {
+                if (placement.getScale().canScaleBeyond()) {
+                    scalars.put(placement.getScale(), placement.getPlace());
                 } else {
-                    objects.addAll(j.getPlace());
+                    objects.addAll(placement.getPlace());
                 }
             }
-        }
-        for (var biome : dimension.getAllBiomes(this::getData)) {
-            for (var j : biome.getObjects()) {
-                if (j.getScale().canScaleBeyond()) {
-                    scalars.put(j.getScale(), j.getPlace());
-                } else {
-                    objects.addAll(j.getPlace());
+
+            for (var biome : region.getAllBiomes(this::getData)) {
+                for (var placement : biome.getObjects()) {
+                    if (placement.getScale().canScaleBeyond()) {
+                        scalars.put(placement.getScale(), placement.getPlace());
+                    } else {
+                        objects.addAll(placement.getPlace());
+                    }
                 }
             }
         }
 
-        BurstExecutor e = getEngineMantle().getTarget().getBurster().burst(objects.size());
+        return computeObjectRadius(objects, scalars, getEngineMantle().getTarget().getBurster(), getData());
+    }
+
+    static int computeObjectRadius(KSet<String> objects, KMap<IrisObjectScale, KList<String>> scalars, MultiBurst burst, IrisData data) {
+        AtomicInteger x = new AtomicInteger();
+        AtomicInteger z = new AtomicInteger();
+
+        BurstExecutor e = burst.burst(objects.size());
         KMap<String, BlockVector> sizeCache = new KMap<>();
-        for (String i : objects) {
+        for (String loadKey : objects) {
             e.queue(() -> {
                 try {
-                    BlockVector bv = sizeCache.computeIfAbsent(i, (k) -> {
-                        try {
-                            return IrisObject.sampleSize(getData().getObjectLoader().findFile(i));
-                        } catch (IOException ex) {
-                            Iris.reportError(ex);
-                            ex.printStackTrace();
-                        }
-
-                        return null;
-                    });
-
-                    if (bv == null) {
-                        throw new RuntimeException();
-                    }
+                    BlockVector bv = sampleSize(sizeCache, data, loadKey);
 
                     if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
-                        Iris.warn("Object " + i + " has a large size (" + bv + ") and may increase memory usage!");
+                        Iris.warn("Object " + loadKey + " has a large size (" + bv + ") and may increase memory usage!");
                     }
 
-                    synchronized (xg) {
-                        xg.getAndSet(Math.max(bv.getBlockX(), xg.get()));
-                    }
-
-                    synchronized (zg) {
-                        zg.getAndSet(Math.max(bv.getBlockZ(), zg.get()));
-                    }
+                    x.getAndUpdate(i -> Math.max(bv.getBlockX(), i));
+                    z.getAndUpdate(i -> Math.max(bv.getBlockZ(), i));
                 } catch (Throwable ed) {
                     Iris.reportError(ed);
-
                 }
             });
         }
 
         for (Map.Entry<IrisObjectScale, KList<String>> entry : scalars.entrySet()) {
             double ms = entry.getKey().getMaximumScale();
-            for (String j : entry.getValue()) {
+            for (String loadKey : entry.getValue()) {
                 e.queue(() -> {
                     try {
-                        BlockVector bv = sizeCache.computeIfAbsent(j, (k) -> {
-                            try {
-                                return IrisObject.sampleSize(getData().getObjectLoader().findFile(j));
-                            } catch (IOException ioException) {
-                                Iris.reportError(ioException);
-                                ioException.printStackTrace();
-                            }
-
-                            return null;
-                        });
-
-                        if (bv == null) {
-                            throw new RuntimeException();
-                        }
+                        BlockVector bv = sampleSize(sizeCache, data, loadKey);
 
                         if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
-                            Iris.warn("Object " + j + " has a large size (" + bv + ") and may increase memory usage! (Object scaled up to " + Form.pc(ms, 2) + ")");
+                            Iris.warn("Object " + loadKey + " has a large size (" + bv + ") and may increase memory usage! (Object scaled up to " + Form.pc(ms, 2) + ")");
                         }
 
-                        synchronized (xg) {
-                            xg.getAndSet((int) Math.max(Math.ceil(bv.getBlockX() * ms), xg.get()));
-                        }
-
-                        synchronized (zg) {
-                            zg.getAndSet((int) Math.max(Math.ceil(bv.getBlockZ() * ms), zg.get()));
-                        }
+                        x.getAndUpdate(i -> (int) Math.max(Math.ceil(bv.getBlockX() * ms), i));
+                        x.getAndUpdate(i -> (int) Math.max(Math.ceil(bv.getBlockZ() * ms), i));
                     } catch (Throwable ee) {
                         Iris.reportError(ee);
 
@@ -260,6 +235,20 @@ public class MantleObjectComponent extends IrisMantleComponent {
         }
 
         e.complete();
-        return Math.max(xg.get(), zg.get());
+        return Math.max(x.get(), z.get());
+    }
+
+    private static BlockVector sampleSize(KMap<String, BlockVector> sizeCache, IrisData data, String loadKey) {
+        BlockVector bv = sizeCache.computeIfAbsent(loadKey, (k) -> {
+            try {
+                return IrisObject.sampleSize(data.getObjectLoader().findFile(loadKey));
+            } catch (IOException ioException) {
+                Iris.reportError(ioException);
+                ioException.printStackTrace();
+            }
+
+            return null;
+        });
+        return Objects.requireNonNull(bv, "sampleSize returned a null block vector");
     }
 }

core/src/main/java/com/volmit/iris/engine/mantle/components/MantleStaticComponent.java

@@ -0,0 +1,59 @@
+package com.volmit.iris.engine.mantle.components;
+
+import com.volmit.iris.engine.mantle.EngineMantle;
+import com.volmit.iris.engine.mantle.IrisMantleComponent;
+import com.volmit.iris.engine.mantle.MantleWriter;
+import com.volmit.iris.engine.object.IrisObjectScale;
+import com.volmit.iris.engine.object.IrisStaticPlacement;
+import com.volmit.iris.engine.object.NoiseStyle;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.context.ChunkContext;
+import com.volmit.iris.util.mantle.MantleFlag;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.noise.CNG;
+import lombok.Getter;
+
+public class MantleStaticComponent extends IrisMantleComponent {
+    private final CNG cng;
+    @Getter
+    private final int radius = computeRadius();
+
+    public MantleStaticComponent(EngineMantle engineMantle) {
+        super(engineMantle, MantleFlag.STATIC, 1);
+        cng = NoiseStyle.STATIC.create(new RNG(seed()));
+    }
+
+    @Override
+    public void generateLayer(MantleWriter writer, int x, int z, ChunkContext context) {
+        RNG rng = new RNG(cng.fit(Integer.MIN_VALUE, Integer.MAX_VALUE, x, z));
+        for (IrisStaticPlacement placement : getDimension().getStaticPlacements().getAll(x, z)) {
+            placement.place(writer, rng, getData());
+        }
+    }
+
+    private int computeRadius() {
+        var placements = getDimension().getStaticPlacements();
+
+        KSet<String> objects = new KSet<>();
+        KMap<IrisObjectScale, KList<String>> scalars = new KMap<>();
+        for (var staticPlacement : placements.getObjects()) {
+            var placement = staticPlacement.placement();
+            if (placement.getScale().canScaleBeyond()) {
+                scalars.put(placement.getScale(), placement.getPlace());
+            } else {
+                objects.addAll(placement.getPlace());
+            }
+        }
+
+        int jigsaw = placements.getStructures()
+                .stream()
+                .mapToInt(staticPlacement -> staticPlacement.maxDimension(getData()))
+                .max()
+                .orElse(0);
+        int object = MantleObjectComponent.computeObjectRadius(objects, scalars, getEngineMantle().getTarget().getBurster(), getData());
+
+        return Math.max(jigsaw, object);
+    }
+}

core/src/main/java/com/volmit/iris/engine/mode/ModeOverworld.java

@@ -25,7 +25,10 @@ import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineMode;
 import com.volmit.iris.engine.framework.EngineStage;
 import com.volmit.iris.engine.framework.IrisEngineMode;
-import com.volmit.iris.engine.modifier.*;
+import com.volmit.iris.engine.modifier.IrisCarveModifier;
+import com.volmit.iris.engine.modifier.IrisDepositModifier;
+import com.volmit.iris.engine.modifier.IrisPerfectionModifier;
+import com.volmit.iris.engine.modifier.IrisPostModifier;
 import org.bukkit.block.data.BlockData;
 
 public class ModeOverworld extends IrisEngineMode implements EngineMode {
@@ -38,7 +41,6 @@ public class ModeOverworld extends IrisEngineMode implements EngineMode {
         var post = new IrisPostModifier(getEngine());
         var deposit = new IrisDepositModifier(getEngine());
         var perfection = new IrisPerfectionModifier(getEngine());
-        var custom = new IrisCustomModifier(getEngine());
         EngineStage sBiome = (x, z, k, p, m, c) -> biome.actuate(x, z, p, m, c);
         EngineStage sGenMatter = (x, z, k, p, m, c) -> generateMatter(x >> 4, z >> 4, m, c);
         EngineStage sTerrain = (x, z, k, p, m, c) -> terrain.actuate(x, z, k, m, c);
@@ -48,7 +50,6 @@ public class ModeOverworld extends IrisEngineMode implements EngineMode {
         EngineStage sPost = (x, z, k, p, m, c) -> post.modify(x, z, k, m, c);
         EngineStage sInsertMatter = (x, z, K, p, m, c) -> getMantle().insertMatter(x >> 4, z >> 4, BlockData.class, K, m);
         EngineStage sPerfection = (x, z, k, p, m, c) -> perfection.modify(x, z, k, m, c);
-        EngineStage sCustom = (x, z, k, p, m, c) -> custom.modify(x, z, k, m, c);
 
         registerStage(burst(
                 sGenMatter,
@@ -64,6 +65,6 @@ public class ModeOverworld extends IrisEngineMode implements EngineMode {
                 sDecorant
         ));
         registerStage(sPerfection);
-        registerStage(sCustom);
+
     }
 }

core/src/main/java/com/volmit/iris/engine/modifier/IrisCarveModifier.java

@@ -57,7 +57,7 @@ public class IrisCarveModifier extends EngineAssignedModifier<BlockData> {
     public void onModify(int x, int z, Hunk<BlockData> output, boolean multicore, ChunkContext context) {
         PrecisionStopwatch p = PrecisionStopwatch.start();
         Mantle mantle = getEngine().getMantle().getMantle();
-        MantleChunk mc = getEngine().getMantle().getMantle().getChunk(x, z).use();
+        MantleChunk mc = getEngine().getMantle().getMantle().getChunk(x, z);
         KMap<Long, KList<Integer>> positions = new KMap<>();
         KMap<IrisPosition, MatterCavern> walls = new KMap<>();
         Consumer4<Integer, Integer, Integer, MatterCavern> iterator = (xx, yy, zz, c) -> {
@@ -166,7 +166,6 @@ public class IrisCarveModifier extends EngineAssignedModifier<BlockData> {
         });
 
         getEngine().getMetrics().getDeposit().put(p.getMilliseconds());
-        mc.release();
     }
 
     private void processZone(Hunk<BlockData> output, MantleChunk mc, Mantle mantle, CaveZone zone, int rx, int rz, int xx, int zz) {
@@ -212,6 +211,14 @@ public class IrisCarveModifier extends EngineAssignedModifier<BlockData> {
 
         biome.setInferredType(InferredType.CAVE);
 
+        for (IrisDecorator i : biome.getDecorators()) {
+            if (i.getPartOf().equals(IrisDecorationPart.NONE) && B.isSolid(output.get(rx, zone.getFloor() - 1, rz))) {
+                decorant.getSurfaceDecorator().decorate(rx, rz, xx, xx, xx, zz, zz, zz, output, biome, zone.getFloor() - 1, zone.airThickness());
+            } else if (i.getPartOf().equals(IrisDecorationPart.CEILING) && B.isSolid(output.get(rx, zone.getCeiling() + 1, rz))) {
+                decorant.getCeilingDecorator().decorate(rx, rz, xx, xx, xx, zz, zz, zz, output, biome, zone.getCeiling(), zone.airThickness());
+            }
+        }
+
         KList<BlockData> blocks = biome.generateLayers(getDimension(), xx, zz, rng, 3, zone.floor, getData(), getComplex());
 
         for (int i = 0; i < zone.floor - 1; i++) {
@@ -253,14 +260,6 @@ public class IrisCarveModifier extends EngineAssignedModifier<BlockData> {
                 output.set(rx, zone.ceiling + i + 1, rz, b);
             }
         }
-
-        for (IrisDecorator i : biome.getDecorators()) {
-            if (i.getPartOf().equals(IrisDecorationPart.NONE) && B.isSolid(output.get(rx, zone.getFloor() - 1, rz))) {
-                decorant.getSurfaceDecorator().decorate(rx, rz, xx, xx, xx, zz, zz, zz, output, biome, zone.getFloor() - 1, zone.airThickness());
-            } else if (i.getPartOf().equals(IrisDecorationPart.CEILING) && B.isSolid(output.get(rx, zone.getCeiling() + 1, rz))) {
-                decorant.getCeilingDecorator().decorate(rx, rz, xx, xx, xx, zz, zz, zz, output, biome, zone.getCeiling(), zone.airThickness());
-            }
-        }
     }
 
     @Data

core/src/main/java/com/volmit/iris/engine/modifier/IrisCustomModifier.java

@@ -1,43 +0,0 @@
-package com.volmit.iris.engine.modifier;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.framework.EngineAssignedModifier;
-import com.volmit.iris.util.context.ChunkContext;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.mantle.MantleFlag;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import com.volmit.iris.util.parallel.MultiBurst;
-import org.bukkit.block.data.BlockData;
-public class IrisCustomModifier extends EngineAssignedModifier<BlockData> {
-    public IrisCustomModifier(Engine engine) {
-        super(engine, "Custom");
-    }
-    @Override
-    public void onModify(int x, int z, Hunk<BlockData> output, boolean multicore, ChunkContext context) {
-        var mc = getEngine().getMantle().getMantle().getChunk(x >> 4, z >> 4);
-        if (!mc.isFlagged(MantleFlag.CUSTOM_ACTIVE)) return;
-        mc.use();
-
-        BurstExecutor burst = MultiBurst.burst.burst(output.getHeight());
-        burst.setMulticore(multicore);
-        for (int y = 0; y < output.getHeight(); y++) {
-            int finalY = y;
-            burst.queue(() -> {
-                for (int rX = 0; rX < output.getWidth(); rX++) {
-                    for (int rZ = 0; rZ < output.getDepth(); rZ++) {
-                        BlockData b = output.get(rX, finalY, rZ);
-                        if (!(b instanceof IrisCustomData d)) continue;
-
-                        mc.getOrCreate(finalY >> 4)
-                                .slice(Identifier.class)
-                                .set(rX, finalY & 15, rZ, d.getCustom());
-                        output.set(rX, finalY, rZ, d.getBase());
-                    }
-                }
-            });
-        }
-        burst.complete();
-        mc.release();
-    }
-}

core/src/main/java/com/volmit/iris/engine/object/IrisBiome.java

@@ -200,7 +200,7 @@ public class IrisBiome extends IrisRegistrant implements IRare {
             KMap<String, Integer> l = new KMap<>();
 
             for (IrisBiomeGeneratorLink i : getGenerators()) {
-                l.put(i.getGenerator(), i.getMax());
+                l.put(i.getGenerator(), i.getMax(engine));
 
             }
 
@@ -216,7 +216,7 @@ public class IrisBiome extends IrisRegistrant implements IRare {
             KMap<String, Integer> l = new KMap<>();
 
             for (IrisBiomeGeneratorLink i : getGenerators()) {
-                l.put(i.getGenerator(), i.getMin());
+                l.put(i.getGenerator(), i.getMin(engine));
             }
 
             return l;
@@ -457,7 +457,7 @@ public class IrisBiome extends IrisRegistrant implements IRare {
             int maxHeight = 0;
 
             for (IrisBiomeGeneratorLink i : getGenerators()) {
-                maxHeight += i.getMax();
+                maxHeight += i.getMax(engine);
             }
 
             return maxHeight;
@@ -470,7 +470,7 @@ public class IrisBiome extends IrisRegistrant implements IRare {
             int maxHeight = 0;
 
             for (IrisBiomeGeneratorLink i : getGenerators()) {
-                maxHeight += i.getMax();
+                maxHeight += i.getMax(engine);
             }
 
             int gg = 0;

core/src/main/java/com/volmit/iris/engine/object/IrisBiomeGeneratorLink.java

@@ -18,7 +18,9 @@
 
 package com.volmit.iris.engine.object;
 
+import com.volmit.iris.Iris;
 import com.volmit.iris.engine.data.cache.AtomicCache;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.data.DataProvider;
 import com.volmit.iris.util.interpolation.IrisInterpolation;
@@ -37,16 +39,18 @@ public class IrisBiomeGeneratorLink {
     @RegistryListResource(IrisGenerator.class)
     @Desc("The generator id")
     private String generator = "default";
-    @DependsOn({"min", "max"})
+    @DependsOn({ "min", "max" })
     @Required
     @MinNumber(-2032) // TODO: WARNING HEIGHT
     @MaxNumber(2032) // TODO: WARNING HEIGHT
     @Desc("The min block value (value + fluidHeight)")
+    @Getter(AccessLevel.NONE)
     private int min = 0;
-    @DependsOn({"min", "max"})
+    @DependsOn({ "min", "max" })
     @Required
     @MinNumber(-2032) // TODO: WARNING HEIGHT
     @MaxNumber(2032) // TODO: WARNING HEIGHT
+    @Getter(AccessLevel.NONE)
     @Desc("The max block value (value + fluidHeight)")
     private int max = 0;
 
@@ -62,6 +66,70 @@ public class IrisBiomeGeneratorLink {
         });
     }
 
+    private int[] getBiomeGeneratorsRaw(Engine engine) {
+        int max = engine.getDimension().getMinHeight();
+        int min = engine.getDimension().getMaxHeight();
+        for (IrisBiome biome : engine.getAllBiomes()) {
+            for (IrisBiomeGeneratorLink i : biome.getGenerators()) {
+                int biomeRawMax = i.getMaxRaw();
+                int biomeRawMin = i.getMinRaw();
+                if (max < biomeRawMax)
+                    max = biomeRawMax;
+                if (min > biomeRawMin)
+                    min = biomeRawMin;
+            }
+        }
+
+        return new int[] { min, max };
+    }
+
+    private int calculateHeight(Engine engine, int option) {
+        int dmx = engine.getDimension().getMaxHeight();
+        int dmn = engine.getDimension().getMinHeight();
+        int[] heights = getBiomeGeneratorsRaw(engine);
+        int gmx = heights[1];
+        int gmn = heights[0];
+
+        int mx = getMaxRaw();
+        int mn = getMinRaw();
+        if (engine.getDimension().isSmartVanillaHeight()) {
+            if (mx > 0)
+                mx = Math.min((int) (((float) mx / (float) gmx) * 300.0f), 300);
+            if (mx < 0)
+                mx = Math.min((int) (((float) mx / (float) gmn) * 300.0f), 56);
+
+            if (mn > 0)
+                mn = Math.min((int) (((float) mn / (float) gmx) * 300.0f), 300);
+            if (mn < 0)
+                mn = Math.min((int) (((float) mn / (float) gmn) * 300.0f), 56);
+        }
+
+        if (option == 1) {
+            return mx;
+        }
+        if (option == 0) {
+            return mn;
+        }
+        Iris.error("Fatal Generator error!");
+        return 0;
+    }
+
+    public int getMax(Engine engine) {
+        return calculateHeight(engine, 1);
+    }
+
+    public int getMin(Engine engine) {
+        return calculateHeight(engine, 0);
+    }
+
+    private int getMaxRaw() {
+        return max;
+    }
+
+    private int getMinRaw() {
+        return min;
+    }
+
     public double getHeight(DataProvider xg, double x, double z, long seed) {
         double g = getCachedGenerator(xg).getHeight(x, z, seed);
         g = g < 0 ? 0 : g;

core/src/main/java/com/volmit/iris/engine/object/IrisContextInjector.java

@@ -1,66 +0,0 @@
-package com.volmit.iris.engine.object;
-
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.container.AutoClosing;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.misc.ServerProperties;
-import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.NamespacedKey;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.world.WorldInitEvent;
-
-import java.util.List;
-
-import static com.volmit.iris.Iris.instance;
-
-public class IrisContextInjector implements Listener {
-    @Getter
-    private static boolean missingDimensionTypes = false;
-    private AutoClosing autoClosing = null;
-
-    public IrisContextInjector() {
-        if (!Bukkit.getWorlds().isEmpty()) return;
-
-        String levelName = ServerProperties.LEVEL_NAME;
-        List<String> irisWorlds = irisWorlds();
-        boolean overworld = irisWorlds.contains(levelName);
-        boolean nether = irisWorlds.contains(levelName + "_nether");
-        boolean end = irisWorlds.contains(levelName + "_end");
-
-        if (INMS.get().missingDimensionTypes(overworld, nether, end)) {
-            missingDimensionTypes = true;
-            return;
-        }
-
-        if (overworld || nether || end) {
-            autoClosing = INMS.get().injectUncached(overworld, nether, end);
-        }
-
-        instance.registerListener(this);
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void on(WorldInitEvent event) {
-        if (autoClosing != null) {
-            autoClosing.close();
-            autoClosing = null;
-        }
-        instance.unregisterListener(this);
-    }
-
-    private List<String> irisWorlds() {
-        var config = YamlConfiguration.loadConfiguration(ServerProperties.BUKKIT_YML);
-        ConfigurationSection section = config.getConfigurationSection("worlds");
-        if (section == null) return List.of();
-
-        return section.getKeys(false)
-                .stream()
-                .filter(k -> section.getString(k + ".generator", "").startsWith("Iris"))
-                .toList();
-    }
-}

core/src/main/java/com/volmit/iris/engine/object/IrisDimension.java

@@ -19,8 +19,6 @@
 package com.volmit.iris.engine.object;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.ServerConfigurator.DimensionHeight;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.nms.INMS;
@@ -28,7 +26,6 @@ import com.volmit.iris.core.nms.datapack.IDataFixer;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.data.DataProvider;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONObject;
@@ -57,6 +54,73 @@ import java.io.IOException;
 public class IrisDimension extends IrisRegistrant {
     public static final BlockData STONE = Material.STONE.createBlockData();
     public static final BlockData WATER = Material.WATER.createBlockData();
+    private static final String DP_OVERWORLD_DEFAULT = """
+            {
+              "ambient_light": 0.0,
+              "bed_works": true,
+              "coordinate_scale": 1.0,
+              "effects": "minecraft:overworld",
+              "has_ceiling": false,
+              "has_raids": true,
+              "has_skylight": true,
+              "infiniburn": "#minecraft:infiniburn_overworld",
+              "monster_spawn_block_light_limit": 0,
+              "monster_spawn_light_level": {
+                "type": "minecraft:uniform",
+                "value": {
+                  "max_inclusive": 7,
+                  "min_inclusive": 0
+                }
+              },
+              "natural": true,
+              "piglin_safe": false,
+              "respawn_anchor_works": false,
+              "ultrawarm": false
+            }""";
+
+    private static final String DP_NETHER_DEFAULT = """
+            {
+              "ambient_light": 0.1,
+              "bed_works": false,
+              "coordinate_scale": 8.0,
+              "effects": "minecraft:the_nether",
+              "fixed_time": 18000,
+              "has_ceiling": true,
+              "has_raids": false,
+              "has_skylight": false,
+              "infiniburn": "#minecraft:infiniburn_nether",
+              "monster_spawn_block_light_limit": 15,
+              "monster_spawn_light_level": 7,
+              "natural": false,
+              "piglin_safe": true,
+              "respawn_anchor_works": true,
+              "ultrawarm": true
+            }""";
+
+    private static final String DP_END_DEFAULT = """
+            {
+              "ambient_light": 0.0,
+              "bed_works": false,
+              "coordinate_scale": 1.0,
+              "effects": "minecraft:the_end",
+              "fixed_time": 6000,
+              "has_ceiling": false,
+              "has_raids": true,
+              "has_skylight": false,
+              "infiniburn": "#minecraft:infiniburn_end",
+              "monster_spawn_block_light_limit": 0,
+              "monster_spawn_light_level": {
+                "type": "minecraft:uniform",
+                "value": {
+                  "max_inclusive": 7,
+                  "min_inclusive": 0
+                }
+              },
+              "natural": false,
+              "piglin_safe": false,
+              "respawn_anchor_works": false,
+              "ultrawarm": false
+            }""";
     private final transient AtomicCache<Position2> parallaxSize = new AtomicCache<>();
     private final transient AtomicCache<CNG> rockLayerGenerator = new AtomicCache<>();
     private final transient AtomicCache<CNG> fluidLayerGenerator = new AtomicCache<>();
@@ -170,6 +234,8 @@ public class IrisDimension extends IrisRegistrant {
     private IrisRange dimensionHeightEnd = new IrisRange(-64, 320);
     @Desc("Define the min and max Y bounds of this dimension. Please keep in mind that Iris internally generates from 0 to (max - min). \n\nFor example at -64 to 320, Iris is internally generating to 0 to 384, then on outputting chunks, it shifts it down by the min height (64 blocks). The default is -64 to 320. \n\nThe fluid height is placed at (fluid height + min height). So a fluid height of 63 would actually show up in the world at 1.")
     private IrisRange dimensionHeightNether = new IrisRange(-64, 320);
+    @Desc("Enable smart vanilla height")
+    private boolean smartVanillaHeight = false;
     @RegistryListResource(IrisBiome.class)
     @Desc("Keep this either undefined or empty. Setting any biome name into this will force iris to only generate the specified biome. Great for testing.")
     private String focus = "";
@@ -244,6 +310,8 @@ public class IrisDimension extends IrisRegistrant {
     @MaxNumber(318)
     @Desc("The Subterrain Fluid Layer Height")
     private int caveLavaHeight = 8;
+    @Desc("Static Placements for objects and structures")
+    private IrisStaticPlacements staticPlacements = new IrisStaticPlacements();
 
     public int getMaxHeight() {
         return (int) getDimensionHeight().getMax();
@@ -379,35 +447,61 @@ public class IrisDimension extends IrisRegistrant {
         return landBiomeStyle;
     }
 
-    public void installBiomes(IDataFixer fixer, DataProvider data, KList<File> folders, KSet<String> biomes) {
-        getAllBiomes(data)
-                .stream()
-                .filter(IrisBiome::isCustom)
-                .map(IrisBiome::getCustomDerivitives)
-                .flatMap(KList::stream)
-                .parallel()
-                .forEach(j -> {
-                    String json = j.generateJson(fixer);
-                    synchronized (biomes) {
-                        if (!biomes.add(j.getId())) {
-                            Iris.verbose("Duplicate Data Pack Biome: " + getLoadKey() + "/" + j.getId());
-                            return;
-                        }
+    public boolean installDataPack(IDataFixer fixer, DataProvider data, File datapacks, double ultimateMaxHeight, double ultimateMinHeight) {
+        boolean write = false;
+        boolean changed = false;
+
+        IO.delete(new File(datapacks, "iris/data/" + getLoadKey().toLowerCase()));
+
+        for (IrisBiome i : getAllBiomes(data)) {
+            if (i.isCustom()) {
+                write = true;
+
+                for (IrisBiomeCustom j : i.getCustomDerivitives()) {
+                    File output = new File(datapacks, "iris/data/" + getLoadKey().toLowerCase() + "/worldgen/biome/" + j.getId() + ".json");
+
+                    if (!output.exists()) {
+                        changed = true;
                     }
 
-                    for (File datapacks : folders) {
-                        File output = new File(datapacks, "iris/data/" + getLoadKey().toLowerCase() + "/worldgen/biome/" + j.getId() + ".json");
-
-                        Iris.verbose("    Installing Data Pack Biome: " + output.getPath());
-                        output.getParentFile().mkdirs();
-                        try {
-                            IO.writeAll(output, json);
-                        } catch (IOException e) {
-                            Iris.reportError(e);
-                            e.printStackTrace();
-                        }
+                    Iris.verbose("    Installing Data Pack Biome: " + output.getPath());
+                    output.getParentFile().mkdirs();
+                    try {
+                        IO.writeAll(output, j.generateJson(fixer));
+                    } catch (IOException e) {
+                        Iris.reportError(e);
+                        e.printStackTrace();
                     }
-                });
+                }
+            }
+        }
+
+        if (!dimensionHeight.equals(new IrisRange(-64, 320)) && this.name.equalsIgnoreCase("overworld")) {
+            Iris.verbose("    Installing Data Pack Dimension Types: \"minecraft:overworld\", \"minecraft:the_nether\", \"minecraft:the_end\"");
+            dimensionHeight.setMax(ultimateMaxHeight);
+            dimensionHeight.setMin(ultimateMinHeight);
+            changed = writeDimensionType(fixer, changed, datapacks);
+        }
+
+        if (write) {
+            File mcm = new File(datapacks, "iris/pack.mcmeta");
+            try {
+                IO.writeAll(mcm, """
+                        {
+                            "pack": {
+                                "description": "Iris Data Pack. This pack contains all installed Iris Packs' resources.",
+                                "pack_format": {}
+                            }
+                        }
+                        """.replace("{}", INMS.get().getDataVersion().getPackFormat() + ""));
+            } catch (IOException e) {
+                Iris.reportError(e);
+                e.printStackTrace();
+            }
+            Iris.verbose("    Installing Data Pack MCMeta: " + mcm.getPath());
+        }
+
+        return changed;
     }
 
     @Override
@@ -425,55 +519,66 @@ public class IrisDimension extends IrisRegistrant {
 
     }
 
-    public static void writeShared(KList<File> folders, DimensionHeight height) {
-        Iris.verbose("    Installing Data Pack Dimension Types: \"iris:overworld\", \"iris:the_nether\", \"iris:the_end\"");
-        for (File datapacks : folders) {
-            write(datapacks, "overworld", height.overworldType());
-            write(datapacks, "the_nether", height.netherType());
-            write(datapacks, "the_end", height.endType());
-        }
-
-        String raw = """
-                        {
-                            "pack": {
-                                "description": "Iris Data Pack. This pack contains all installed Iris Packs' resources.",
-                                "pack_format": {}
-                            }
-                        }
-                        """.replace("{}", INMS.get().getDataVersion().getPackFormat() + "");
-
-        for (File datapacks : folders) {
-            File mcm = new File(datapacks, "iris/pack.mcmeta");
-            try {
-                IO.writeAll(mcm, raw);
-            } catch (IOException e) {
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-            Iris.verbose("    Installing Data Pack MCMeta: " + mcm.getPath());
-        }
-    }
-
-    private static void write(File datapacks, String type, String json) {
-        File dimType = new File(datapacks, "iris/data/iris/dimension_type/" + type + ".json");
-        File dimTypeVanilla = new File(datapacks, "iris/data/minecraft/dimension_type/" + type + ".json");
-
-        dimType.getParentFile().mkdirs();
+    public boolean writeDimensionType(IDataFixer fixer, boolean changed, File datapacks) {
+        File dimTypeOverworld = new File(datapacks, "iris/data/minecraft/dimension_type/overworld.json");
+        if (!dimTypeOverworld.exists())
+            changed = true;
+        dimTypeOverworld.getParentFile().mkdirs();
         try {
-            IO.writeAll(dimType, json);
+            IO.writeAll(dimTypeOverworld, generateDatapackJsonOverworld(fixer));
         } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
 
-        if (IrisSettings.get().getGeneral().adjustVanillaHeight || dimTypeVanilla.exists()) {
-            dimTypeVanilla.getParentFile().mkdirs();
-            try {
-                IO.writeAll(dimTypeVanilla, json);
-            } catch (IOException e) {
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
+
+        File dimTypeNether = new File(datapacks, "iris/data/minecraft/dimension_type/the_nether.json");
+        if (!dimTypeNether.exists())
+            changed = true;
+        dimTypeNether.getParentFile().mkdirs();
+        try {
+            IO.writeAll(dimTypeNether, generateDatapackJsonNether(fixer));
+        } catch (IOException e) {
+            Iris.reportError(e);
+            e.printStackTrace();
         }
+
+
+        File dimTypeEnd = new File(datapacks, "iris/data/minecraft/dimension_type/the_end.json");
+        if (!dimTypeEnd.exists())
+            changed = true;
+        dimTypeEnd.getParentFile().mkdirs();
+        try {
+            IO.writeAll(dimTypeEnd, generateDatapackJsonEnd(fixer));
+        } catch (IOException e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+
+        return changed;
+    }
+
+    private String generateDatapackJsonOverworld(IDataFixer fixer) {
+        JSONObject obj = new JSONObject(DP_OVERWORLD_DEFAULT);
+        obj.put("min_y", dimensionHeight.getMin());
+        obj.put("height", dimensionHeight.getMax() - dimensionHeight.getMin());
+        obj.put("logical_height", logicalHeight);
+        return fixer.fixDimension(obj).toString(4);
+    }
+
+    private String generateDatapackJsonNether(IDataFixer fixer) {
+        JSONObject obj = new JSONObject(DP_NETHER_DEFAULT);
+        obj.put("min_y", dimensionHeightNether.getMin());
+        obj.put("height", dimensionHeightNether.getMax() - dimensionHeightNether.getMin());
+        obj.put("logical_height", logicalHeightNether);
+        return fixer.fixDimension(obj).toString(4);
+    }
+
+    private String generateDatapackJsonEnd(IDataFixer fixer) {
+        JSONObject obj = new JSONObject(DP_END_DEFAULT);
+        obj.put("min_y", dimensionHeightEnd.getMin());
+        obj.put("height", dimensionHeightEnd.getMax() - dimensionHeightEnd.getMin());
+        obj.put("logical_height", logicalHeightEnd);
+        return fixer.fixDimension(obj).toString(4);
     }
 }

core/src/main/java/com/volmit/iris/engine/object/IrisEngineChunkData.java

@@ -0,0 +1,43 @@
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *
+ * This program 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.
+ *
+ * This program 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 this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.engine.object;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import lombok.Data;
+
+@Data
+public class IrisEngineChunkData {
+    private long chunk;
+    private KList<IrisEngineSpawnerCooldown> cooldowns = new KList<>();
+
+    public void cleanup(Engine engine) {
+        for (IrisEngineSpawnerCooldown i : getCooldowns().copy()) {
+            IrisSpawner sp = engine.getData().getSpawnerLoader().load(i.getSpawner());
+
+            if (sp == null || i.canSpawn(sp.getMaximumRate())) {
+                getCooldowns().remove(i);
+            }
+        }
+    }
+
+    public boolean isEmpty() {
+        return cooldowns.isEmpty();
+    }
+}

core/src/main/java/com/volmit/iris/engine/object/IrisEngineData.java

@@ -20,31 +20,51 @@ package com.volmit.iris.engine.object;
 
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KList;
 import lombok.Data;
-import lombok.EqualsAndHashCode;
 
 @Data
-@EqualsAndHashCode(callSuper = true)
-public class IrisEngineData extends IrisSpawnerCooldowns {
+public class IrisEngineData {
     private IrisEngineStatistics statistics = new IrisEngineStatistics();
-    private KMap<Long, IrisSpawnerCooldowns> chunks = new KMap<>();
+    private KList<IrisEngineSpawnerCooldown> spawnerCooldowns = new KList<>();
+    private KList<IrisEngineChunkData> chunks = new KList<>();
     private Long seed = null;
 
     public void removeChunk(int x, int z) {
-        chunks.remove(Cache.key(x, z));
+        long k = Cache.key(x, z);
+        chunks.removeWhere((i) -> i.getChunk() == k);
     }
 
-    public IrisSpawnerCooldowns getChunk(int x, int z) {
-        return chunks.computeIfAbsent(Cache.key(x, z), k -> new IrisSpawnerCooldowns());
+    public IrisEngineChunkData getChunk(int x, int z) {
+        long k = Cache.key(x, z);
+
+        for (IrisEngineChunkData i : chunks) {
+            if (i.getChunk() == k) {
+                return i;
+            }
+        }
+
+        IrisEngineChunkData c = new IrisEngineChunkData();
+        c.setChunk(k);
+        chunks.add(c);
+        return c;
     }
 
     public void cleanup(Engine engine) {
-        super.cleanup(engine);
+        for (IrisEngineSpawnerCooldown i : getSpawnerCooldowns().copy()) {
+            IrisSpawner sp = engine.getData().getSpawnerLoader().load(i.getSpawner());
 
-        chunks.values().removeIf(chunk -> {
-            chunk.cleanup(engine);
-            return chunk.isEmpty();
-        });
+            if (sp == null || i.canSpawn(sp.getMaximumRate())) {
+                getSpawnerCooldowns().remove(i);
+            }
+        }
+
+        for (IrisEngineChunkData i : chunks.copy()) {
+            i.cleanup(engine);
+
+            if (i.isEmpty()) {
+                getChunks().remove(i);
+            }
+        }
     }
 }

core/src/main/java/com/volmit/iris/engine/object/IrisEngineService.java

@@ -1,19 +0,0 @@
-package com.volmit.iris.engine.object;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.engine.framework.Engine;
-import lombok.RequiredArgsConstructor;
-import org.bukkit.event.Listener;
-
-@RequiredArgsConstructor
-public abstract class IrisEngineService implements Listener {
-    protected final Engine engine;
-
-    public abstract void onEnable(boolean hotload);
-
-    public abstract void onDisable(boolean hotload);
-
-    public final void postShutdown(Runnable r) {
-        Iris.instance.postShutdown(r);
-    }
-}

core/src/main/java/com/volmit/iris/engine/object/IrisEntity.java

@@ -29,6 +29,7 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.plugin.Chunks;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
@@ -56,8 +57,6 @@ import java.util.concurrent.ExecutionException;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 
-import static com.volmit.iris.util.data.registry.Particles.ITEM;
-
 @SuppressWarnings("ALL")
 @Accessors(chain = true)
 @NoArgsConstructor
@@ -67,6 +66,7 @@ import static com.volmit.iris.util.data.registry.Particles.ITEM;
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class IrisEntity extends IrisRegistrant {
+    private static final Particle ITEM = E.getOrDefault(Particle.class, "ITEM_CRACK", "ITEM");
     @Required
     @Desc("The type of entity to spawn. To spawn a mythic mob, set this type to unknown and define mythic type.")
     private EntityType type = EntityType.UNKNOWN;
@@ -404,7 +404,7 @@ public class IrisEntity extends IrisRegistrant {
         });
 
 
-        return e.isValid() ? e : null;
+        return e;
     }
 
     private int surfaceY(Location l) {

core/src/main/java/com/volmit/iris/engine/object/IrisEntitySpawn.java

@@ -28,12 +28,19 @@ import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.matter.MatterMarker;
 import com.volmit.iris.util.matter.slices.MarkerMatter;
+import io.lumine.mythic.bukkit.adapters.BukkitEntity;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
-import org.bukkit.*;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.World;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.util.BoundingBox;
 
 @Snippet("entity-spawn")
 @Accessors(chain = true)
@@ -62,10 +69,6 @@ public class IrisEntitySpawn implements IRare {
     private transient IrisSpawner referenceSpawner;
     private transient IrisMarker referenceMarker;
 
-    public boolean check(Engine eng, IrisPosition c, ChunkSnapshot snapshot) {
-        return getRealEntity(eng).getSurface().matches(snapshot.getBlockData(c.getX() & 15, c.getY(), c.getZ() & 15));
-    }
-
     public int spawn(Engine gen, Chunk c, RNG rng) {
         int spawns = minSpawns == maxSpawns ? minSpawns : rng.i(Math.min(minSpawns, maxSpawns), Math.max(minSpawns, maxSpawns));
         int s = 0;
@@ -165,7 +168,7 @@ public class IrisEntitySpawn implements IRare {
                 return null;
             }
 
-            if (!ignoreSurfaces && !irisEntity.getSurface().matches(at.clone().subtract(0, 1, 0).getBlock().getBlockData())) {
+            if (!ignoreSurfaces && !irisEntity.getSurface().matches(at.clone().subtract(0, 1, 0).getBlock())) {
                 return null;
             }
 
@@ -180,10 +183,6 @@ public class IrisEntitySpawn implements IRare {
             Entity e = irisEntity.spawn(g, at.add(0.5, 0.5, 0.5), rng.aquire(() -> new RNG(g.getSeedManager().getEntity())));
             if (e != null) {
                 Iris.debug("Spawned " + C.DARK_AQUA + "Entity<" + getEntity() + "> " + C.GREEN + e.getType() + C.LIGHT_PURPLE + " @ " + C.GRAY + e.getLocation().getX() + ", " + e.getLocation().getY() + ", " + e.getLocation().getZ());
-
-                if (referenceSpawner != null) {
-                    referenceSpawner.getConditions().apply(e);
-                }
             }
 
             return e;

core/src/main/java/com/volmit/iris/engine/object/IrisExpression.java

@@ -24,7 +24,6 @@ import com.dfsek.paralithic.eval.parser.Scope;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.engine.object.IrisExpressionFunction.FunctionContext;
 import com.volmit.iris.engine.object.annotations.ArrayType;
 import com.volmit.iris.engine.object.annotations.Desc;
 import com.volmit.iris.engine.object.annotations.Required;
@@ -47,14 +46,12 @@ import lombok.experimental.Accessors;
 @Data
 @EqualsAndHashCode(callSuper = false)
 public class IrisExpression extends IrisRegistrant {
+    private static final Parser parser = new Parser();
+
     @ArrayType(type = IrisExpressionLoad.class, min = 1)
     @Desc("Variables to use in this expression")
     private KList<IrisExpressionLoad> variables = new KList<>();
 
-    @ArrayType(type = IrisExpressionFunction.class, min = 1)
-    @Desc("Functions to use in this expression")
-    private KList<IrisExpressionFunction> functions = new KList<>();
-
     @Required
     @Desc("The expression. Inherited variables are x, y and z. Avoid using those variable names.")
     private String expression;
@@ -65,7 +62,6 @@ public class IrisExpression extends IrisRegistrant {
     private Expression expression() {
         return expressionCache.aquire(() -> {
             Scope scope = new Scope(); // Create variable scope. This scope can hold both constants and invocation variables.
-            Parser parser = new Parser();
 
             try {
                 for (IrisExpressionLoad i : variables) {
@@ -80,12 +76,6 @@ public class IrisExpression extends IrisRegistrant {
                 Iris.error("Script Variable load error in " + getLoadFile().getPath());
             }
 
-            for (IrisExpressionFunction f : functions) {
-                if (!f.isValid()) continue;
-                f.setData(getLoader());
-                parser.registerFunction(f.getName(), f);
-            }
-
             try {
                 return parser.parse(getExpression(), scope);
             } catch (Throwable e) {
@@ -113,7 +103,7 @@ public class IrisExpression extends IrisRegistrant {
         g[m++] = z;
         g[m] = -1;
 
-        return expression().evaluate(new FunctionContext(rng), g);
+        return expression().evaluate(g);
     }
 
     public double evaluate(RNG rng, double x, double y, double z) {
@@ -127,7 +117,7 @@ public class IrisExpression extends IrisRegistrant {
         g[m++] = y;
         g[m] = z;
 
-        return expression().evaluate(new FunctionContext(rng), g);
+        return expression().evaluate(g);
     }
 
     @Override

core/src/main/java/com/volmit/iris/engine/object/IrisExpressionFunction.java

@@ -1,101 +0,0 @@
-package com.volmit.iris.engine.object;
-
-import com.dfsek.paralithic.functions.dynamic.Context;
-import com.dfsek.paralithic.functions.dynamic.DynamicFunction;
-import com.dfsek.paralithic.node.Statefulness;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.object.annotations.Desc;
-import com.volmit.iris.engine.object.annotations.MinNumber;
-import com.volmit.iris.engine.object.annotations.Required;
-import com.volmit.iris.engine.object.annotations.Snippet;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.math.RNG;
-import lombok.*;
-import lombok.experimental.Accessors;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-@Snippet("expression-function")
-@Accessors(chain = true)
-@NoArgsConstructor
-@AllArgsConstructor
-@Desc("Represents a function to use in your expression. Do not set the name to x, y, or z, also don't duplicate names.")
-@Data
-@EqualsAndHashCode(callSuper = false)
-public class IrisExpressionFunction implements DynamicFunction {
-    @Required
-    @Desc("The function to assign this value to. Do not set the name to x, y, or z")
-    private String name;
-
-    @Desc("If defined, this variable will use a generator style as it's value")
-    private IrisGeneratorStyle styleValue = null;
-
-    @Desc("If defined, iris will use an internal stream from the engine as it's value")
-    private IrisEngineStreamType engineStreamValue = null;
-
-    @MinNumber(2)
-    @Desc("Number of arguments for the function")
-    private int args = 2;
-
-    @Getter(AccessLevel.NONE)
-    @Setter(AccessLevel.NONE)
-    private transient final KMap<FunctionContext, Provider> cache = new KMap<>();
-    private transient IrisData data;
-
-    public boolean isValid() {
-        return styleValue != null || engineStreamValue != null;
-    }
-
-    @Override
-    public int getArgNumber() {
-        if (engineStreamValue != null) return 2;
-        return Math.max(args, 2);
-    }
-
-    @NotNull
-    @Override
-    public Statefulness statefulness() {
-        return Statefulness.STATEFUL;
-    }
-
-    @Override
-    public double eval(double... doubles) {
-        return 0;
-    }
-
-    @Override
-    public double eval(@Nullable Context raw, double... args) {
-        return cache.computeIfAbsent((FunctionContext) raw, context -> {
-            assert context != null;
-            if (engineStreamValue != null) {
-                var stream = engineStreamValue.get(data.getEngine());
-                return d -> stream.get(d[0], d[1]);
-            }
-
-            if (styleValue != null) {
-                return styleValue.createNoCache(context.rng, data)::noise;
-            }
-
-            return d -> Double.NaN;
-        }).eval(args);
-    }
-
-    public record FunctionContext(@NonNull RNG rng) implements Context {
-        @Override
-        public boolean equals(Object o) {
-            if (o == null || getClass() != o.getClass()) return false;
-            FunctionContext that = (FunctionContext) o;
-            return rng.getSeed() == that.rng.getSeed();
-        }
-
-        @Override
-        public int hashCode() {
-            return Long.hashCode(rng.getSeed());
-        }
-    }
-
-    @FunctionalInterface
-    private interface Provider {
-        double eval(double... args);
-    }
-}

core/src/main/java/com/volmit/iris/engine/object/IrisExpressionLoad.java

@@ -23,11 +23,12 @@ import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.object.annotations.Desc;
 import com.volmit.iris.engine.object.annotations.Required;
 import com.volmit.iris.engine.object.annotations.Snippet;
-import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.stream.ProceduralStream;
-import lombok.*;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
 
 @Snippet("expression-load")
@@ -56,9 +57,6 @@ public class IrisExpressionLoad {
 
     private transient AtomicCache<ProceduralStream<Double>> streamCache = new AtomicCache<>();
     private transient AtomicCache<Double> valueCache = new AtomicCache<>();
-    @Getter(AccessLevel.NONE)
-    @Setter(AccessLevel.NONE)
-    private transient final KMap<Long, CNG> styleCache = new KMap<>();
 
     public double getValue(RNG rng, IrisData data, double x, double z) {
         if (engineValue != null) {
@@ -70,8 +68,7 @@ public class IrisExpressionLoad {
         }
 
         if (styleValue != null) {
-            return styleCache.computeIfAbsent(rng.getSeed(), k -> styleValue.createNoCache(new RNG(k), data))
-                    .noise(x, z);
+            return styleValue.create(rng, data).noise(x, z);
         }
 
         return staticValue;
@@ -87,8 +84,7 @@ public class IrisExpressionLoad {
         }
 
         if (styleValue != null) {
-            return styleCache.computeIfAbsent(rng.getSeed(), k -> styleValue.createNoCache(new RNG(k), data))
-                    .noise(x, y, z);
+            return styleValue.create(rng, data).noise(x, y, z);
         }
 
         return staticValue;

core/src/main/java/com/volmit/iris/engine/object/IrisJigsawStructure.java

@@ -139,14 +139,6 @@ public class IrisJigsawStructure extends IrisRegistrant {
                     loadPiece(i, pools, pieces);
                 }
 
-                if (pieces.isEmpty()) {
-                    int max = 0;
-                    for (String i : getPieces()) {
-                        max = Math.max(max, getLoader().getJigsawPieceLoader().load(i).getMax2dDimension());
-                    }
-                    return max;
-                }
-
                 int avg = 0;
 
                 for (String i : pieces) {

core/src/main/java/com/volmit/iris/engine/object/IrisJigsawStructurePlacement.java

@@ -19,8 +19,13 @@
 package com.volmit.iris.engine.object;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.object.annotations.*;
+import com.volmit.iris.engine.object.annotations.ArrayType;
+import com.volmit.iris.engine.object.annotations.Desc;
+import com.volmit.iris.engine.object.annotations.MaxNumber;
+import com.volmit.iris.engine.object.annotations.MinNumber;
+import com.volmit.iris.engine.object.annotations.RegistryListResource;
+import com.volmit.iris.engine.object.annotations.Required;
+import com.volmit.iris.engine.object.annotations.Snippet;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
@@ -49,7 +54,6 @@ public class IrisJigsawStructurePlacement implements IRare {
     private int rarity = 100;
 
     @Required
-    @DependsOn({"spacing", "separation"})
     @Desc("The salt to use when generating the structure (to differentiate structures)")
     @MinNumber(Long.MIN_VALUE)
     @MaxNumber(Long.MAX_VALUE)
@@ -57,26 +61,16 @@ public class IrisJigsawStructurePlacement implements IRare {
 
     @Required
     @MinNumber(0)
-    @DependsOn({"salt", "separation"})
     @Desc("Average distance in chunks between two neighboring generation attempts")
     private int spacing = -1;
 
     @Required
     @MinNumber(0)
-    @DependsOn({"salt", "spacing"})
     @Desc("Minimum distance in chunks between two neighboring generation attempts\nThe maximum distance of two neighboring generation attempts is 2*spacing - separation")
     private int separation = -1;
 
     @Desc("The method used to spread the structure")
-    private SpreadType spreadType = SpreadType.LINEAR;
-
-    @DependsOn({"spreadType"})
-    @Desc("The noise style to use when spreadType is set to 'NOISE'\nThis ignores the spacing and separation parameters")
-    private IrisGeneratorStyle style = new IrisGeneratorStyle();
-
-    @DependsOn({"spreadType", "style"})
-    @Desc("Threshold for noise style")
-    private double threshold = 0.5;
+    private SpreadType spreadType = SpreadType.TRIANGULAR;
 
     @ArrayType(type = IrisJigsawMinDistance.class)
     @Desc("List of minimum distances to check for")
@@ -95,29 +89,20 @@ public class IrisJigsawStructurePlacement implements IRare {
     }
 
     private void calculateMissing(double divisor, long seed) {
-        if (salt != 0 && separation > 0 && spacing > 0)
-            return;
-        seed *= (long) structure.hashCode() * rarity;
+        seed = seed + hashCode();
         if (salt == 0) {
-            salt = new RNG(seed).l(Integer.MIN_VALUE, Integer.MAX_VALUE);
+            salt = new RNG(seed).nextLong(Integer.MIN_VALUE, Integer.MAX_VALUE);
         }
 
         if (separation == -1 || spacing == -1) {
             separation = (int) Math.round(rarity / divisor);
-            spacing = new RNG(seed).i(separation, separation * 2);
+            spacing = new RNG(seed).nextInt(separation, separation * 2);
         }
     }
 
     @ChunkCoordinates
-    public boolean shouldPlace(IrisData data, double divisor, long seed, int x, int z) {
+    public boolean shouldPlace(double divisor, long seed, int x, int z) {
         calculateMissing(divisor, seed);
-        if (spreadType != SpreadType.NOISE)
-            return shouldPlaceSpread(seed, x, z);
-
-        return style.create(new RNG(seed + salt), data).noise(x, z) > threshold;
-    }
-
-    private boolean shouldPlaceSpread(long seed, int x, int z) {
         if (separation > spacing) {
             separation = spacing;
             Iris.warn("JigsawStructurePlacement: separation must be less than or equal to spacing");
@@ -138,9 +123,7 @@ public class IrisJigsawStructurePlacement implements IRare {
         @Desc("Linear spread")
         LINEAR(RNG::i),
         @Desc("Triangular spread")
-        TRIANGULAR((rng, bound) -> (rng.i(bound) + rng.i(bound)) / 2),
-        @Desc("Noise based spread\nThis ignores the spacing and separation parameters")
-        NOISE((rng, bound) -> 0);
+        TRIANGULAR((rng, bound) -> (rng.i(bound) + rng.i(bound)) / 2);
         private final SpreadMethod method;
 
         SpreadType(SpreadMethod method) {

core/src/main/java/com/volmit/iris/engine/object/IrisObject.java

@@ -29,7 +29,7 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.interpolation.IrisInterpolation;
 import com.volmit.iris.util.json.JSONObject;
@@ -53,6 +53,8 @@ import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
+import org.bukkit.block.BlockState;
+import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.MultipleFacing;
 import org.bukkit.block.data.Waterlogged;
@@ -941,7 +943,7 @@ public class IrisObject extends IrisRegistrant {
                             if (j.isExact() ? k.matches(data) : k.getMaterial().equals(data.getMaterial())) {
                                 BlockData newData = j.getReplace(rng, i.getX() + x, i.getY() + y, i.getZ() + z, rdata).clone();
 
-                                if (newData.getMaterial() == data.getMaterial() && !(newData instanceof IrisCustomData || data instanceof IrisCustomData))
+                                if (newData.getMaterial() == data.getMaterial() && !(newData instanceof IrisBlockData || data instanceof IrisBlockData))
                                     data = data.merge(newData);
                                 else
                                     data = newData;
@@ -1010,9 +1012,8 @@ public class IrisObject extends IrisRegistrant {
                 }
 
                 boolean wouldReplace = B.isSolid(placer.get(xx, yy, zz)) && B.isVineBlock(data);
-                boolean place = !data.getMaterial().equals(Material.AIR) && !data.getMaterial().equals(Material.CAVE_AIR) && !wouldReplace;
 
-                if (data instanceof IrisCustomData || place) {
+                if (!data.getMaterial().equals(Material.AIR) && !data.getMaterial().equals(Material.CAVE_AIR) && !wouldReplace) {
                     placer.set(xx, yy, zz, data);
                     if (tile != null) {
                         placer.setTile(xx, yy, zz, tile);

core/src/main/java/com/volmit/iris/engine/object/IrisRange.java

@@ -50,10 +50,4 @@ public class IrisRange {
     public boolean contains(int v) {
         return v >= min && v <= max;
     }
-
-    public IrisRange merge(IrisRange other) {
-        min = Math.min(min, other.min);
-        max = Math.max(max, other.max);
-        return this;
-    }
 }

core/src/main/java/com/volmit/iris/engine/object/IrisRate.java

@@ -43,7 +43,7 @@ public class IrisRate {
     }
 
     public long getInterval() {
-        long t = per.toMilliseconds() / (amount == 0 ? 1 : amount);
+        long t = per.getMilliseconds() / (amount == 0 ? 1 : amount);
         return Math.abs(t <= 0 ? 1 : t);
     }
 

core/src/main/java/com/volmit/iris/engine/object/IrisSpawnCondition.java

@@ -1,58 +0,0 @@
-package com.volmit.iris.engine.object;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.engine.object.annotations.Desc;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-import lombok.experimental.Accessors;
-import org.bukkit.NamespacedKey;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.SpawnCategory;
-import org.bukkit.persistence.PersistentDataType;
-
-import java.util.UUID;
-import java.util.function.BooleanSupplier;
-
-@Accessors(chain = true)
-@NoArgsConstructor
-@AllArgsConstructor
-@Desc("Conditions for a spawner to be triggered")
-@Data
-public class IrisSpawnCondition {
-    private static final NamespacedKey CATEGORY_KEY = new NamespacedKey(Iris.instance, "spawn_category");
-
-    private SpawnCategory category = SpawnCategory.AMBIENT;
-    private int maxEntities = 60;
-
-    public boolean check(KMap<UUID, KMap<String, Boolean>> cache, KList<Entity> entities) {
-        int entityCount = 0;
-        for (Entity entity : entities) {
-            var map = cache.computeIfAbsent(entity.getUniqueId(), k -> new KMap<>());
-            if (check(map, "category_" + category.name(), () -> checkCategory(entity, category)) && ++entityCount >= maxEntities)
-                return false;
-        }
-        return true;
-    }
-
-    public void apply(Entity entity) {
-        var pdc = entity.getPersistentDataContainer();
-        pdc.set(CATEGORY_KEY, PersistentDataType.STRING, category.name());
-    }
-
-    private static boolean check(KMap<String, Boolean> cache, String key, BooleanSupplier predicate) {
-        return cache.computeIfAbsent(key, k -> predicate.getAsBoolean()) == Boolean.TRUE;
-    }
-
-    private static boolean checkCategory(Entity entity, SpawnCategory category) {
-        if (entity.getSpawnCategory() == category)
-            return true;
-
-        var pdc = entity.getPersistentDataContainer();
-        if (!pdc.has(CATEGORY_KEY, PersistentDataType.STRING))
-            return false;
-        return category.name().equals(pdc.get(CATEGORY_KEY, PersistentDataType.STRING));
-    }
-}

core/src/main/java/com/volmit/iris/engine/object/IrisSpawner.java

@@ -19,7 +19,6 @@
 package com.volmit.iris.engine.object;
 
 import com.volmit.iris.core.loader.IrisRegistrant;
-import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.annotations.ArrayType;
 import com.volmit.iris.engine.object.annotations.Desc;
 import com.volmit.iris.util.collection.KList;
@@ -74,9 +73,6 @@ public class IrisSpawner extends IrisRegistrant {
     @Desc("Where should these spawns be placed")
     private IrisSpawnGroup group = IrisSpawnGroup.NORMAL;
 
-    @Desc("Conditions for this spawner to be triggered")
-    private IrisSpawnCondition conditions = new IrisSpawnCondition();
-
     public boolean isValid(IrisBiome biome) {
         return switch (group) {
             case NORMAL -> switch (biome.getInferredType()) {
@@ -99,37 +95,6 @@ public class IrisSpawner extends IrisRegistrant {
         return timeBlock.isWithin(world) && weather.is(world);
     }
 
-    public boolean canSpawn(Engine engine) {
-        if (!isValid(engine.getWorld().realWorld()))
-            return false;
-
-        var rate = getMaximumRate();
-        return rate.isInfinite() || engine.getEngineData().getCooldown(this).canSpawn(rate);
-    }
-
-    public boolean canSpawn(Engine engine, int x, int z) {
-        if (!canSpawn(engine))
-            return false;
-
-        var rate = getMaximumRatePerChunk();
-        return rate.isInfinite() || engine.getEngineData().getChunk(x, z).getCooldown(this).canSpawn(rate);
-    }
-
-    public void spawn(Engine engine) {
-        if (getMaximumRate().isInfinite())
-            return;
-
-        engine.getEngineData().getCooldown(this).spawn(engine);
-    }
-
-    public void spawn(Engine engine, int x, int z) {
-        spawn(engine);
-        if (getMaximumRatePerChunk().isInfinite())
-            return;
-
-        engine.getEngineData().getChunk(x, z).getCooldown(this).spawn(engine);
-    }
-
     @Override
     public String getFolderName() {
         return "spawners";

core/src/main/java/com/volmit/iris/engine/object/IrisSpawnerCooldowns.java

@@ -1,34 +0,0 @@
-package com.volmit.iris.engine.object;
-
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import lombok.EqualsAndHashCode;
-import lombok.NonNull;
-
-@EqualsAndHashCode
-public class IrisSpawnerCooldowns {
-    private final KMap<String, IrisEngineSpawnerCooldown> cooldowns = new KMap<>();
-
-    public IrisEngineSpawnerCooldown getCooldown(@NonNull IrisSpawner spawner) {
-        return getCooldown(spawner.getLoadKey());
-    }
-
-    public IrisEngineSpawnerCooldown getCooldown(@NonNull String loadKey) {
-        return cooldowns.computeIfAbsent(loadKey, k -> {
-            IrisEngineSpawnerCooldown cd = new IrisEngineSpawnerCooldown();
-            cd.setSpawner(loadKey);
-            return cd;
-        });
-    }
-
-    public void cleanup(Engine engine) {
-        cooldowns.values().removeIf(cd -> {
-            IrisSpawner sp = engine.getData().getSpawnerLoader().load(cd.getSpawner());
-            return sp == null || cd.canSpawn(sp.getMaximumRate());
-        });
-    }
-
-    public boolean isEmpty() {
-        return cooldowns.isEmpty();
-    }
-}

core/src/main/java/com/volmit/iris/engine/object/IrisStaticObjectPlacement.java

@@ -0,0 +1,52 @@
+package com.volmit.iris.engine.object;
+
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.engine.mantle.MantleWriter;
+import com.volmit.iris.engine.object.annotations.Desc;
+import com.volmit.iris.engine.object.annotations.Required;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisBlockData;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.matter.MatterStructurePOI;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+@Data
+@Desc("Static Object Placement")
+@Accessors(chain = true, fluent = true)
+@NoArgsConstructor
+@AllArgsConstructor
+public class IrisStaticObjectPlacement implements IrisStaticPlacement {
+    @Required
+    @Desc("The X coordinate to spawn the object at")
+    private int x = 0;
+    @Required
+    @Desc("The Y coordinate to spawn the object at\nuse a value <0 to allow the placement modes to function")
+    private int y = 0;
+    @Required
+    @Desc("The Z coordinate to spawn the object at")
+    private int z = 0;
+    @Required
+    @Desc("The object placement to use")
+    private IrisObjectPlacement placement;
+
+    @Override
+    public void place(MantleWriter writer, RNG rng, IrisData irisData) {
+        IrisObject v = placement.getScale().get(rng, placement.getObject(() -> irisData, rng));
+        if (v == null) return;
+
+        v.place(x, y, z, writer, placement, rng, irisData);
+        int id = rng.i(0, Integer.MAX_VALUE);
+        v.place(x, y, z, writer, placement, rng, (b, data) -> {
+            writer.setData(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id);
+            if (placement.isDolphinTarget() && placement.isUnderwater() && B.isStorageChest(data)) {
+                writer.setData(b.getX(), b.getY(), b.getZ(), MatterStructurePOI.BURIED_TREASURE);
+            }
+            if (data instanceof IrisBlockData d) {
+                writer.setData(b.getX(), b.getY(), b.getZ(), d.getCustom());
+            }
+        }, null, irisData);
+    }
+}

core/src/main/java/com/volmit/iris/engine/object/IrisStaticPlacement.java

@@ -0,0 +1,19 @@
+package com.volmit.iris.engine.object;
+
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.engine.mantle.MantleWriter;
+import com.volmit.iris.util.documentation.ChunkCoordinates;
+import com.volmit.iris.util.math.RNG;
+
+public interface IrisStaticPlacement {
+    int x();
+    int y();
+    int z();
+
+    @ChunkCoordinates
+    default boolean shouldPlace(int chunkX, int chunkZ) {
+        return x() >> 4 == chunkX && z() >> 4 == chunkZ;
+    }
+
+    void place(MantleWriter writer, RNG rng, IrisData data);
+}

core/src/main/java/com/volmit/iris/engine/object/IrisStaticPlacements.java

@@ -0,0 +1,49 @@
+package com.volmit.iris.engine.object;
+
+
+import com.volmit.iris.engine.object.annotations.ArrayType;
+import com.volmit.iris.engine.object.annotations.Desc;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.documentation.ChunkCoordinates;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+@Accessors(chain = true)
+@NoArgsConstructor
+@AllArgsConstructor
+@Desc("Static Placements")
+@Data
+public class IrisStaticPlacements {
+    @Desc("List of static jigsaw structures")
+    @ArrayType(type = IrisStaticStructurePlacement.class)
+    private KList<IrisStaticStructurePlacement> structures = new KList<>();
+
+    @Desc("List of static objects")
+    @ArrayType(type = IrisStaticObjectPlacement.class)
+    private KList<IrisStaticObjectPlacement> objects = new KList<>();
+
+    @ChunkCoordinates
+    public KList<IrisStaticStructurePlacement> getStructures(int chunkX, int chunkZ) {
+        return filter(structures.stream(), chunkX, chunkZ);
+    }
+
+    @ChunkCoordinates
+    public KList<IrisStaticObjectPlacement> getObjects(int chunkX, int chunkZ) {
+        return filter(objects.stream(), chunkX, chunkZ);
+    }
+
+    @ChunkCoordinates
+    public KList<IrisStaticPlacement> getAll(int chunkX, int chunkZ) {
+        return filter(Stream.concat(structures.stream(), objects.stream()), chunkX, chunkZ);
+    }
+
+    private <T extends IrisStaticPlacement> KList<T> filter(Stream<T> stream, int chunkX, int chunkZ) {
+        return stream.filter(p -> p.shouldPlace(chunkX, chunkZ))
+                .collect(Collectors.toCollection(KList::new));
+    }
+}

core/src/main/java/com/volmit/iris/engine/object/IrisStaticStructurePlacement.java

@@ -0,0 +1,65 @@
+package com.volmit.iris.engine.object;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.engine.jigsaw.PlannedStructure;
+import com.volmit.iris.engine.mantle.MantleWriter;
+import com.volmit.iris.engine.object.annotations.ArrayType;
+import com.volmit.iris.engine.object.annotations.Desc;
+import com.volmit.iris.engine.object.annotations.RegistryListResource;
+import com.volmit.iris.engine.object.annotations.Required;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.math.RNG;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+import lombok.experimental.Accessors;
+
+@Data
+@Desc("Static Jigsaw Structure Placement")
+@Accessors(chain = true, fluent = true)
+@NoArgsConstructor
+@AllArgsConstructor
+public class IrisStaticStructurePlacement implements IrisStaticPlacement {
+    @Required
+    @Desc("The X coordinate to spawn the structure at")
+    private int x = 0;
+    @Required
+    @Desc("The Y coordinate to spawn the structure at")
+    private int y = 0;
+    @Required
+    @Desc("The Z coordinate to spawn the structure at")
+    private int z = 0;
+    @Required
+    @ArrayType(min = 1, type = String.class)
+    @RegistryListResource(IrisJigsawStructure.class)
+    @Desc("The structures to place")
+    private KList<String> structures;
+
+    public int maxDimension(IrisData data) {
+        return data.getJigsawStructureLoader().loadAll(structures)
+                .stream()
+                .mapToInt(IrisJigsawStructure::getMaxDimension)
+                .max()
+                .orElse(0);
+    }
+
+    @Override
+    public void place(MantleWriter writer, RNG rng, IrisData data) {
+        IrisJigsawStructure jigsaw = null;
+        while (jigsaw == null && !structures.isEmpty()) {
+            String loadKey = structures.popRandom(rng);
+            jigsaw = data.getJigsawStructureLoader().load(loadKey);
+
+            if (jigsaw == null)
+                Iris.error("Jigsaw structure not found " + loadKey);
+        }
+        if (jigsaw == null) {
+            Iris.error("No jigsaw structure found for " + structures);
+            return;
+        }
+
+        new PlannedStructure(jigsaw, new IrisPosition(x, y, z), rng, false)
+                .place(writer, writer.getMantle(), writer.getEngine());
+    }
+}

core/src/main/java/com/volmit/iris/engine/object/IrisSurface.java

@@ -20,7 +20,7 @@ package com.volmit.iris.engine.object;
 
 import com.volmit.iris.engine.object.annotations.Desc;
 import org.bukkit.Material;
-import org.bukkit.block.data.BlockData;
+import org.bukkit.block.Block;
 import org.bukkit.block.data.Waterlogged;
 
 @Desc("The type of surface entities should spawn on")
@@ -47,8 +47,8 @@ public enum IrisSurface {
      * @param state The blockstate
      * @return True if it matches
      */
-    public boolean matches(BlockData state) {
-        Material type = state.getMaterial();
+    public boolean matches(Block state) {
+        Material type = state.getType();
         if (type.isSolid()) {
             return this == LAND || this == OVERWORLD || (this == ANIMAL
                     && (type == Material.GRASS_BLOCK || type == Material.DIRT

core/src/main/java/com/volmit/iris/engine/object/TileData.java

@@ -35,6 +35,7 @@ import java.io.IOException;
 
 @SuppressWarnings("ALL")
 @Getter
+@ToString
 @EqualsAndHashCode
 @AllArgsConstructor
 @NoArgsConstructor(access = AccessLevel.PROTECTED)
@@ -136,9 +137,4 @@ public class TileData implements Cloneable {
         clone.properties = properties.copy(); //TODO make a deep copy
         return clone;
     }
-
-    @Override
-    public String toString() {
-        return material.getKey() + gson.toJson(properties);
-    }
 }

core/src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java

@@ -21,7 +21,6 @@ package com.volmit.iris.engine.platform;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.engine.IrisEngine;
 import com.volmit.iris.engine.data.chunk.TerrainChunk;
@@ -49,7 +48,6 @@ import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
 import org.bukkit.event.world.WorldInitEvent;
 import org.bukkit.generator.BiomeProvider;
@@ -60,6 +58,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
 import java.lang.reflect.Field;
 import java.util.List;
 import java.util.Random;
@@ -86,6 +86,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
     private final boolean studio;
     private final AtomicInteger a = new AtomicInteger(0);
     private final CompletableFuture<Integer> spawnChunks = new CompletableFuture<>();
+    private final boolean smartVanillaHeight;
     private Engine engine;
     private Looper hotloader;
     private StudioMode lastMode;
@@ -95,7 +96,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
 
     private boolean initialized = false;
 
-    public BukkitChunkGenerator(IrisWorld world, boolean studio, File dataLocation, String dimensionKey) {
+    public BukkitChunkGenerator(IrisWorld world, boolean studio, File dataLocation, String dimensionKey, boolean smartVanillaHeight) {
         setup = new AtomicBoolean(false);
         studioGenerator = null;
         dummyBiomeProvider = new DummyBiomeProvider();
@@ -107,6 +108,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
         this.dataLocation = dataLocation;
         this.dimensionKey = dimensionKey;
         this.folder = new ReactiveFolder(dataLocation, (_a, _b, _c) -> hotload());
+        this.smartVanillaHeight = smartVanillaHeight;
         Bukkit.getServer().getPluginManager().registerEvents(this, Iris.instance);
     }
 
@@ -124,13 +126,11 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
         }
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
+    @EventHandler
     public void onWorldInit(WorldInitEvent event) {
         try {
             if (initialized || !world.name().equals(event.getWorld().getName()))
                 return;
-            AutoClosing.closeContext();
-            INMS.get().removeCustomDimensions(event.getWorld());
             world.setRawWorldSeed(event.getWorld().getSeed());
             Engine engine = getEngine(event.getWorld());
             if (engine == null) {
@@ -186,6 +186,14 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
                 throw new RuntimeException("Missing Dimension: " + dimensionKey);
             }
         }
+        if (smartVanillaHeight) {
+            dimension.setSmartVanillaHeight(true);
+            try (FileWriter writer = new FileWriter(data.getDimensionLoader().fileFor(dimension))) {
+                writer.write(data.getGson().toJson(dimension));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }
 
         lastMode = StudioMode.NORMAL;
         engine = new IrisEngine(new EngineTarget(world, dimension, data), studio);

core/src/main/java/com/volmit/iris/engine/service/EngineMobHandlerSVC.java

@@ -1,340 +0,0 @@
-package com.volmit.iris.engine.service;
-
-import com.google.common.util.concurrent.AtomicDouble;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.container.Pair;
-import com.volmit.iris.engine.IrisWorldManager;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.math.BlockPosition;
-import com.volmit.iris.util.math.Position2;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.matter.MatterMarker;
-import com.volmit.iris.util.parallel.Sync;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import io.papermc.lib.PaperLib;
-import lombok.SneakyThrows;
-import org.bukkit.ChunkSnapshot;
-import org.bukkit.GameRule;
-import org.bukkit.World;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.player.PlayerChangedWorldEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.function.Predicate;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class EngineMobHandlerSVC extends IrisEngineService {
-    private static final List<String> CAVE_TAGS = List.of("cave_floor", "cave_ceiling");
-    private static final int SAFE_RADIUS = 16;
-    private static final int MAX_RADIUS = 128;
-
-    private final AtomicLong currentTick = new AtomicLong();
-    private final Sync<Long> sync = new Sync<>();
-    private final Set<Player> players = ConcurrentHashMap.newKeySet();
-    private final AtomicBoolean running = new AtomicBoolean(false);
-    private transient KList<Entity> entities = new KList<>();
-    private transient Thread asyncTicker = null;
-    private transient Thread entityCollector = null;
-    private transient boolean charge = false;
-    private transient int task = -1;
-
-    public EngineMobHandlerSVC(Engine engine) {
-        super(engine);
-    }
-
-    @Override
-    public void onEnable(boolean hotload) {
-        if (running.get()) {
-            running.set(false);
-            cancel(asyncTicker);
-            cancel(entityCollector);
-        }
-
-        running.set(true);
-        charge = hotload;
-        asyncTicker = Thread.ofPlatform()
-                .name("Iris Async Mob Spawning - " + engine.getWorld().name())
-                .priority(9)
-                .start(() -> {
-                    while (mayLoop()) {
-                        try {
-                            asyncTick();
-                        } catch (Throwable e) {
-                            if (isInterrupted(e))
-                                return;
-                            Iris.error("Error in async tick for " + engine.getWorld().name());
-                            e.printStackTrace();
-
-                            J.sleep(100);
-                        }
-                    }
-                });
-        entityCollector = Thread.ofVirtual()
-                .name("Iris Async Entity Collector - " + engine.getWorld().name())
-                .start(() -> {
-                    while (mayLoop()) {
-                        try {
-                            sync.next().get();
-                            var world = engine.getWorld().realWorld();
-                            if (world == null) continue;
-                            J.s(() -> entities = new KList<>(world.getEntities()));
-                        } catch (Throwable e) {
-                            if (isInterrupted(e))
-                                return;
-
-                            Iris.error("Error in async tick for " + engine.getWorld().name());
-                            e.printStackTrace();
-
-                            J.sleep(100);
-                        }
-                    }
-                });
-        if (task != -1) J.csr(task);
-        task = J.sr(() -> sync.advance(currentTick.getAndIncrement()), 0);
-    }
-
-    @Override
-    public void onDisable(boolean hotload) {
-        running.set(false);
-        cancel(asyncTicker);
-        cancel(entityCollector);
-        if (!hotload) J.csr(task);
-    }
-
-    private void asyncTick() throws Throwable {
-        long tick = sync.next().get();
-        var manager = (IrisWorldManager) engine.getWorldManager();
-        if (charge) {
-            manager.chargeEnergy();
-            charge = false;
-        }
-
-        var world = engine.getWorld().realWorld();
-        if (world == null
-                || noSpawning()
-                || Boolean.FALSE.equals(world.getGameRuleValue(GameRule.DO_MOB_SPAWNING))
-                || players.isEmpty()
-                || manager.getEnergy() < 100)
-            return;
-
-        var p = PrecisionStopwatch.start();
-        var entities = new KList<>(this.entities);
-
-        var conditionCache = new KMap<UUID, KMap<String, Boolean>>();
-        var data = engine.getData();
-        var invalid = data.getSpawnerLoader()
-                .streamAllPossible()
-                .filter(Predicate.not(spawner -> spawner.canSpawn(engine)
-                        && spawner.getConditions().check(conditionCache, entities)))
-                .map(IrisSpawner::getLoadKey)
-                .collect(Collectors.toSet());
-
-        var centers = players.stream()
-                .filter(Objects::nonNull)
-                .filter(Player::isOnline)
-                .map(Player::getLocation)
-                .map(BlockPosition::fromLocation)
-                .collect(KList.collector())
-                .shuffle();
-
-        if (centers.isEmpty())
-            return;
-
-        AtomicDouble delta = new AtomicDouble();
-        int actuallySpawned = 0;
-
-        KMap<Position2, Pair<Entity[], ChunkSnapshot>> cache = new KMap<>();
-        while (centers.isNotEmpty()) {
-            var center = centers.pop();
-            var spawned = trySpawn(world, invalid, cache, center, delta);
-            if (spawned == 0 && p.getMilliseconds() < 1000)
-                centers.add(center);
-            actuallySpawned += spawned;
-        }
-        manager.setEnergy(manager.getEnergy() - delta.get());
-        if (actuallySpawned > 0) {
-            Iris.info("Async Mob Spawning " + world.getName() + " used " + delta + " energy and took " + Form.duration((long) p.getMilliseconds()));
-        }
-    }
-
-    private int trySpawn(
-            World world,
-            Set<String> invalid,
-            KMap<Position2, Pair<Entity[], ChunkSnapshot>> cache,
-            BlockPosition center,
-            AtomicDouble delta
-    ) {
-        var pos = center.randomPoint(MAX_RADIUS, SAFE_RADIUS);
-        if (pos.getY() < world.getMinHeight() || pos.getY() >= world.getMaxHeight())
-            return 0;
-
-        var chunkPos = new Position2(center.getX() >> 4, center.getZ() >> 4);
-        var pair = cache.computeIfAbsent(chunkPos, cPos -> {
-            try {
-                return PaperLib.getChunkAtAsync(world, cPos.getX(), cPos.getZ(), false)
-                        .thenApply(c -> c != null ? new Pair<>(c.getEntities(), c.getChunkSnapshot(false, false, false)) : null)
-                        .get();
-            } catch (InterruptedException | ExecutionException e) {
-                throw new RuntimeException(e);
-            }
-        });
-        if (pair == null)
-            return 0;
-
-        var spawners = spawnersAt(pair.getB(), pos, invalid);
-        spawners.removeIf(i -> !i.canSpawn(engine, chunkPos.getX(), chunkPos.getZ()));
-
-        if (spawners.isEmpty())
-            return 0;
-
-        IrisPosition irisPos = new IrisPosition(pos.getX(), pos.getY(), pos.getZ());
-        for (var spawner : spawners) {
-            var spawns = spawner.getSpawns().copy();
-            spawns.removeIf(spawn -> !spawn.check(engine, irisPos, pair.getB()));
-
-            var entity = IRare.pick(spawns, RNG.r.nextDouble());
-            if (entity == null)
-                continue;
-
-            entity.setReferenceSpawner(spawner);
-            entity.setReferenceMarker(spawner.getReferenceMarker());
-            int spawned = entity.spawn(engine, irisPos, RNG.r);
-            if (spawned == 0)
-                continue;
-
-            delta.addAndGet(spawned * ((entity.getEnergyMultiplier() * spawner.getEnergyMultiplier() * 1)));
-            spawner.spawn(engine, chunkPos.getX(), chunkPos.getZ());
-            if (!spawner.canSpawn(engine))
-                invalid.add(spawner.getLoadKey());
-            return spawned;
-        }
-        return 0;
-    }
-
-    private KSet<IrisSpawner> spawnersAt(ChunkSnapshot chunk, BlockPosition pos, Set<String> invalid) {
-        KSet<IrisSpawner> spawners = markerAt(chunk, pos, invalid);
-
-        var loader = engine.getData().getSpawnerLoader();
-        int y = pos.getY() - engine.getWorld().minHeight();
-        Stream.concat(engine.getRegion(pos.getX(), pos.getZ())
-                                .getEntitySpawners()
-                                .stream(),
-                        engine.getBiomeOrMantle(pos.getX(), y, pos.getZ())
-                                .getEntitySpawners()
-                                .stream())
-                .filter(Predicate.not(invalid::contains))
-                .map(loader::load)
-                .forEach(spawners::add);
-
-        return spawners;
-    }
-
-    private KSet<IrisSpawner> markerAt(ChunkSnapshot chunk, BlockPosition pos, Set<String> invalid) {
-        if (!IrisSettings.get().getWorld().isMarkerEntitySpawningSystem())
-            return new KSet<>();
-
-        int y = pos.getY() - engine.getWorld().minHeight();
-        Mantle mantle = engine.getMantle().getMantle();
-        MatterMarker matter = mantle.get(pos.getX(), y, pos.getZ(), MatterMarker.class);
-        if (matter == null || CAVE_TAGS.contains(matter.getTag()))
-            return new KSet<>();
-        IrisData data = engine.getData();
-        IrisMarker mark = data.getMarkerLoader().load(matter.getTag());
-        if (mark == null)
-            return new KSet<>();
-
-        if (mark.isEmptyAbove()) {
-            int x = pos.getX() & 15, z = pos.getZ() & 15;
-            boolean remove = chunk.getBlockData(x, pos.getY() + 1, z).getMaterial().isSolid() || chunk.getBlockData(x, pos.getY() + 2, z).getMaterial().isSolid();
-            if (remove) {
-                mantle.remove(pos.getX(), y, pos.getZ(), MatterMarker.class);
-                return new KSet<>();
-            }
-        }
-
-        KSet<IrisSpawner> spawners = new KSet<>();
-        for (String key : mark.getSpawners()) {
-            if (invalid.contains(key))
-                continue;
-
-            IrisSpawner spawner = data.getSpawnerLoader().load(key);
-            if (spawner == null) {
-                Iris.error("Cannot load spawner: " + key + " for marker " + matter.getTag());
-                continue;
-            }
-
-            spawner.setReferenceMarker(mark);
-            spawners.add(spawner);
-        }
-        return spawners;
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void on(PlayerJoinEvent event) {
-        var player = event.getPlayer();
-        if (player.getWorld() != engine.getWorld().realWorld())
-            return;
-        players.add(player);
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void on(PlayerQuitEvent event) {
-        players.remove(event.getPlayer());
-    }
-
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    public void on(PlayerChangedWorldEvent event) {
-        var player = event.getPlayer();
-        if (player.getWorld() == engine.getWorld().realWorld())
-            players.add(player);
-        else
-            players.remove(player);
-    }
-
-    @SneakyThrows
-    private static void cancel(Thread thread) {
-        if (thread == null || !thread.isAlive()) return;
-        thread.interrupt();
-        thread.join();
-    }
-
-    private static boolean noSpawning() {
-        var world = IrisSettings.get().getWorld();
-        return !world.isMarkerEntitySpawningSystem() && !world.isAnbientEntitySpawningSystem();
-    }
-
-    private boolean mayLoop() {
-        return !engine.isClosed() && running.get() && !Thread.interrupted();
-    }
-
-    private static boolean isInterrupted(Throwable e) {
-        while (e != null) {
-            if (e instanceof InterruptedException)
-                return true;
-            e = e.getCause();
-        }
-        return false;
-    }
-}

core/src/main/java/com/volmit/iris/engine/service/EngineStatusSVC.java

@@ -1,65 +0,0 @@
-package com.volmit.iris.engine.service;
-
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisEngineService;
-import com.volmit.iris.util.collection.KList;
-
-public class EngineStatusSVC extends IrisEngineService {
-    private static final KList<EngineStatusSVC> INSTANCES = new KList<>();
-
-    public EngineStatusSVC(Engine engine) {
-        super(engine);
-    }
-
-    @Override
-    public void onEnable(boolean hotload) {
-        if (hotload) return;
-        synchronized (INSTANCES) {
-            INSTANCES.add(this);
-        }
-    }
-
-    @Override
-    public void onDisable(boolean hotload) {
-        if (hotload) return;
-
-        synchronized (INSTANCES) {
-            INSTANCES.remove(this);
-        }
-    }
-
-    public static int getEngineCount() {
-        return INSTANCES.size();
-    }
-
-    public static Status getStatus() {
-        synchronized (INSTANCES) {
-            long loadedChunks = 0;
-            long tectonicPlates = 0;
-            long activeTectonicPlates = 0;
-            long queuedTectonicPlates = 0;
-            long minTectonicUnloadDuration = Long.MAX_VALUE;
-            long maxTectonicUnloadDuration = Long.MIN_VALUE;
-
-            for (var service : INSTANCES) {
-                var world = service.engine.getWorld();
-                if (world.hasRealWorld())
-                    loadedChunks += world.realWorld().getLoadedChunks().length;
-
-                tectonicPlates += service.engine.getMantle().getLoadedRegionCount();
-                activeTectonicPlates += service.engine.getMantle().getNotQueuedLoadedRegions();
-                queuedTectonicPlates += service.engine.getMantle().getToUnload();
-                minTectonicUnloadDuration = Math.min(minTectonicUnloadDuration, (long) service.engine.getMantle().getTectonicDuration());
-                maxTectonicUnloadDuration = Math.max(maxTectonicUnloadDuration, (long) service.engine.getMantle().getTectonicDuration());
-            }
-            return new Status(INSTANCES.size(), loadedChunks, MantleCleanerSVC.getTectonicLimit(), tectonicPlates, activeTectonicPlates, queuedTectonicPlates, minTectonicUnloadDuration, maxTectonicUnloadDuration);
-        }
-    }
-
-    public record Status(int engineCount, long loadedChunks, int tectonicLimit,
-                         long tectonicPlates, long activeTectonicPlates,
-                         long queuedTectonicPlates,
-                         long minTectonicUnloadDuration,
-                         long maxTectonicUnloadDuration) {
-    }
-}

core/src/main/java/com/volmit/iris/engine/service/MantleCleanerSVC.java

@@ -1,127 +0,0 @@
-package com.volmit.iris.engine.service;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisEngineService;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.misc.getHardware;
-import com.volmit.iris.util.scheduling.Looper;
-import lombok.SneakyThrows;
-
-import java.io.PrintWriter;
-import java.io.StringWriter;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.LongSupplier;
-
-public class MantleCleanerSVC extends IrisEngineService {
-    private static final AtomicInteger tectonicLimit = new AtomicInteger(30);
-
-    static {
-        // todo: Redo this
-        tectonicLimit.set(2);
-        long t = getHardware.getProcessMemory();
-        while (t > 200) {
-            tectonicLimit.incrementAndGet();
-            t = t - 200;
-        }
-    }
-
-    private Ticker trimmer;
-    private Ticker unloader;
-
-    public MantleCleanerSVC(Engine engine) {
-        super(engine);
-    }
-
-    public static int getTectonicLimit() {
-        return tectonicLimit.get();
-    }
-
-    private static Ticker createTrimmer(Engine engine) {
-        return new Ticker(() -> {
-            if (engine.isClosed()) return -1;
-            long start = M.ms();
-            try {
-                engine.getMantle().trim(tectonicLimit.get() / getEngineCount());
-            } catch (Throwable e) {
-                Iris.debug(C.RED + "Mantle: Failed to trim.");
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-
-            if (engine.isClosed()) return -1;
-            int size = getEngineCount();
-            return Math.max(1000 / size - (M.ms() - start), 0);
-        }, "Iris Mantle Trimmer - " + engine.getWorld().name());
-    }
-
-    private static Ticker createUnloader(Engine engine) {
-        return new Ticker(() -> {
-            if (engine.isClosed()) return -1;
-            long start = M.ms();
-            try {
-                engine.getMantle().unloadTectonicPlate(tectonicLimit.get() / getEngineCount());
-            } catch (Throwable e) {
-                Iris.debug(C.RED + "Mantle: Failed to unload.");
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-
-            if (engine.isClosed()) return -1;
-            int size = getEngineCount();
-            return Math.max(1000 / size - (M.ms() - start), 0);
-        }, "Iris Mantle Unloader - " + engine.getWorld().name());
-    }
-
-    private static int getEngineCount() {
-        return Math.max(EngineStatusSVC.getEngineCount(), 1);
-    }
-
-    @Override
-    public void onEnable(boolean hotload) {
-        if (engine.isStudio() && !IrisSettings.get().getPerformance().trimMantleInStudio)
-            return;
-        if (trimmer == null || !trimmer.isAlive())
-            trimmer = createTrimmer(engine);
-        if (unloader == null || !unloader.isAlive())
-            unloader = createUnloader(engine);
-    }
-
-    @Override
-    public void onDisable(boolean hotload) {
-        if (hotload) return;
-        if (trimmer != null) trimmer.await();
-        if (unloader != null) unloader.await();
-    }
-
-    private static class Ticker extends Looper {
-        private final LongSupplier supplier;
-
-        private Ticker(LongSupplier supplier, String name) {
-            this.supplier = supplier;
-            setPriority(Thread.MIN_PRIORITY);
-            setName(name);
-            start();
-        }
-
-        @Override
-        protected long loop() {
-            try {
-                return supplier.getAsLong();
-            } catch (Throwable e) {
-                Iris.error("Exception in Looper " + getName());
-                StringWriter sw = new StringWriter();
-                e.printStackTrace(new PrintWriter(sw));
-                Iris.error(sw.toString());
-                return 3000;
-            }
-        }
-
-        @SneakyThrows
-        public void await() {
-            join();
-        }
-    }
-}

core/src/main/java/com/volmit/iris/util/collection/KList.java

@@ -26,8 +26,6 @@ import com.volmit.iris.util.math.RNG;
 import java.util.*;
 import java.util.function.Function;
 import java.util.function.Predicate;
-import java.util.stream.Collector;
-import java.util.stream.Collectors;
 
 @SuppressWarnings("ALL")
 public class KList<T> extends ArrayList<T> implements List<T> {
@@ -67,10 +65,6 @@ public class KList<T> extends ArrayList<T> implements List<T> {
         return s;
     }
 
-    public static <T> Collector<T, ?, KList<T>> collector() {
-        return Collectors.toCollection(KList::new);
-    }
-
     public static KList<String> asStringList(List<?> oo) {
         KList<String> s = new KList<String>();
 
@@ -493,7 +487,7 @@ public class KList<T> extends ArrayList<T> implements List<T> {
             return pop();
         }
 
-        return remove(rng.i(0, last()));
+        return remove(rng.i(0, size()));
     }
 
     public KList<T> sub(int f, int t) {

core/src/main/java/com/volmit/iris/util/data/B.java

@@ -22,9 +22,10 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.link.Identifier;
 import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.object.IrisCompat;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.registry.Materials;
+import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import it.unimi.dsi.fastutil.ints.*;
 import org.bukkit.Bukkit;
@@ -46,7 +47,7 @@ public class B {
     private static final KMap<String, BlockData> custom = new KMap<>();
 
     private static final Material AIR_MATERIAL = Material.AIR;
-    private static final Material SHORT_GRASS = Materials.GRASS;
+    private static final Material SHORT_GRASS = E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS");
     private static final BlockData AIR = AIR_MATERIAL.createBlockData();
     private static final IntSet foliageCache = buildFoliageCache();
     private static final IntSet deepslateCache = buildDeepslateCache();

core/src/main/java/com/volmit/iris/util/data/IrisBlockData.java

@@ -15,7 +15,7 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 @Data
-public class IrisCustomData implements BlockData {
+public class IrisBlockData implements BlockData {
 	private final @NonNull BlockData base;
 	private final @NotNull Identifier custom;
 
@@ -40,12 +40,12 @@ public class IrisCustomData implements BlockData {
 	@NotNull
 	@Override
 	public BlockData merge(@NotNull BlockData blockData) {
-		return new IrisCustomData(base.merge(blockData), custom);
+		return new IrisBlockData(base.merge(blockData), custom);
 	}
 
 	@Override
 	public boolean matches(@Nullable BlockData blockData) {
-		if (blockData instanceof IrisCustomData b)
+		if (blockData instanceof IrisBlockData b)
 			return custom.equals(b.custom) && base.matches(b.base);
 		return base.matches(blockData);
 	}
@@ -53,7 +53,7 @@ public class IrisCustomData implements BlockData {
 	@NotNull
 	@Override
 	public BlockData clone() {
-		return new IrisCustomData(base.clone(), custom);
+		return new IrisBlockData(base.clone(), custom);
 	}
 
 	@NotNull

core/src/main/java/com/volmit/iris/util/data/registry/Attributes.java

@@ -1,7 +0,0 @@
-package com.volmit.iris.util.data.registry;
-
-import org.bukkit.attribute.Attribute;
-
-public class Attributes {
-    public static final Attribute MAX_HEALTH = RegistryUtil.find(Attribute.class, "generic_max_health", "max_health");
-}

core/src/main/java/com/volmit/iris/util/data/registry/Materials.java

@@ -1,9 +0,0 @@
-package com.volmit.iris.util.data.registry;
-
-import org.bukkit.Material;
-
-import static com.volmit.iris.util.data.registry.RegistryUtil.find;
-
-public class Materials {
-    public static final Material GRASS = find(Material.class, "grass", "short_grass");
-}

core/src/main/java/com/volmit/iris/util/data/registry/Particles.java

@@ -1,11 +0,0 @@
-package com.volmit.iris.util.data.registry;
-
-import org.bukkit.Particle;
-
-import static com.volmit.iris.util.data.registry.RegistryUtil.find;
-
-public class Particles {
-    public static final Particle CRIT_MAGIC = find(Particle.class, "crit_magic", "crit");
-    public static final Particle REDSTONE = find(Particle.class,  "redstone", "dust");
-    public static final Particle ITEM = find(Particle.class,  "item_crack", "item");
-}

core/src/main/java/com/volmit/iris/util/data/registry/RegistryUtil.java

@@ -1,209 +0,0 @@
-package com.volmit.iris.util.data.registry;
-
-import com.volmit.iris.core.nms.container.Pair;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-import lombok.NonNull;
-import org.bukkit.Bukkit;
-import org.bukkit.Keyed;
-import org.bukkit.NamespacedKey;
-import org.bukkit.Registry;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.lang.reflect.Modifier;
-import java.lang.reflect.ParameterizedType;
-import java.lang.reflect.Type;
-import java.util.Arrays;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-
-@SuppressWarnings("unchecked")
-public class RegistryUtil {
-    private static final AtomicCache<RegistryLookup> registryLookup = new AtomicCache<>();
-    private static final Map<Class<?>, Map<NamespacedKey, Keyed>> KEYED_REGISTRY = new HashMap<>();
-    private static final Map<Class<?>, Map<NamespacedKey, Object>> ENUM_REGISTRY = new HashMap<>();
-    private static final Map<Class<?>, Registry<Keyed>> REGISTRY = new HashMap<>();
-
-    @NonNull
-    public static <T> T find(@NonNull Class<T> typeClass, @NonNull String... keys) {
-        return find(typeClass, defaultLookup(), keys);
-    }
-
-    @NonNull
-    public static <T> T find(@NonNull Class<T> typeClass, @Nullable Lookup<T> lookup, @NonNull String... keys) {
-        return find(typeClass, lookup, Arrays.stream(keys).map(NamespacedKey::minecraft).toArray(NamespacedKey[]::new));
-    }
-
-    public static <T> T find(@NonNull Class<T> typeClass, @NonNull NamespacedKey... keys) {
-        return find(typeClass, defaultLookup(), keys);
-    }
-
-    @NonNull
-    public static <T> T find(@NonNull Class<T> typeClass, @Nullable Lookup<T> lookup, @NonNull NamespacedKey... keys) {
-        if (keys.length == 0) throw new IllegalArgumentException("Need at least one key");
-        Registry<Keyed> registry = null;
-        if (Keyed.class.isAssignableFrom(typeClass)) {
-            registry = getRegistry(typeClass.asSubclass(Keyed.class));
-        }
-        if (registry == null) {
-            registry = REGISTRY.computeIfAbsent(typeClass, t -> Arrays.stream(Registry.class.getDeclaredFields())
-                    .filter(field -> Modifier.isStatic(field.getModifiers()) && Modifier.isPublic(field.getModifiers()))
-                    .filter(field -> Registry.class.isAssignableFrom(field.getType()))
-                    .filter(field -> ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0].equals(t))
-                    .map(field -> {
-                        try {
-                            return (Registry<Keyed>) field.get(null);
-                        } catch (IllegalAccessException e) {
-                            return null;
-                        }
-                    })
-                    .filter(Objects::nonNull)
-                    .findFirst()
-                    .orElse(null));
-        }
-
-        if (registry != null) {
-            for (NamespacedKey key : keys) {
-                Keyed value = registry.get(key);
-                if (value != null)
-                    return (T) value;
-            }
-        }
-
-        if (lookup != null)
-            return lookup.find(typeClass, keys);
-        throw new IllegalArgumentException("No element found for keys: " + Arrays.toString(keys));
-    }
-
-    @NonNull
-    public static <T> T findByField(@NonNull Class<T> typeClass, @NonNull NamespacedKey... keys) {
-        var values = KEYED_REGISTRY.computeIfAbsent(typeClass, RegistryUtil::getKeyedValues);
-        for (NamespacedKey key : keys) {
-            var value = values.get(key);
-            if (value != null)
-                return (T) value;
-        }
-        throw new IllegalArgumentException("No element found for keys: " + Arrays.toString(keys));
-    }
-
-    @NonNull
-    public static <T> T findByEnum(@NonNull Class<T> typeClass, @NonNull NamespacedKey... keys) {
-        var values = ENUM_REGISTRY.computeIfAbsent(typeClass, RegistryUtil::getEnumValues);
-        for (NamespacedKey key : keys) {
-            var value = values.get(key);
-            if (value != null)
-                return (T) value;
-        }
-        throw new IllegalArgumentException("No element found for keys: " + Arrays.toString(keys));
-    }
-
-    @NonNull
-    public static <T> Lookup<T> defaultLookup() {
-        return Lookup.combine(RegistryUtil::findByField, RegistryUtil::findByEnum);
-    }
-
-    private static Map<NamespacedKey, Keyed> getKeyedValues(@NonNull Class<?> typeClass) {
-        return Arrays.stream(typeClass.getDeclaredFields())
-                .filter(field -> Modifier.isPublic(field.getModifiers()) && Modifier.isStatic(field.getModifiers()))
-                .filter(field -> Keyed.class.isAssignableFrom(field.getType()))
-                .map(field -> {
-                    try {
-                        return (Keyed) field.get(null);
-                    } catch (Throwable e) {
-                        return null;
-                    }
-                })
-                .filter(Objects::nonNull)
-                .collect(Collectors.toMap(Keyed::getKey, Function.identity()));
-    }
-
-    private static Map<NamespacedKey, Object> getEnumValues(@NonNull Class<?> typeClass) {
-        return Arrays.stream(typeClass.getDeclaredFields())
-                .filter(field -> Modifier.isPublic(field.getModifiers()) && Modifier.isStatic(field.getModifiers()))
-                .filter(field -> typeClass.isAssignableFrom(field.getType()))
-                .map(field -> {
-                    try {
-                        return new Pair<>(NamespacedKey.minecraft(field.getName().toLowerCase()), field.get(null));
-                    } catch (Throwable e) {
-                        return null;
-                    }
-                })
-                .filter(Objects::nonNull)
-                .collect(Collectors.toMap(Pair::getA, Pair::getB));
-
-    }
-
-    @FunctionalInterface
-    public interface Lookup<T> {
-        @NonNull
-        T find(@NonNull Class<T> typeClass, @NonNull NamespacedKey... keys);
-
-        static <T> Lookup<T> combine(@NonNull Lookup<T>... lookups) {
-            if (lookups.length == 0) throw new IllegalArgumentException("Need at least one lookup");
-            return (typeClass, keys) -> {
-                for (Lookup<T> lookup : lookups) {
-                    try {
-                        return lookup.find(typeClass, keys);
-                    } catch (IllegalArgumentException ignored) {}
-                }
-                throw new IllegalArgumentException("No element found for keys: " + Arrays.toString(keys));
-            };
-        }
-    }
-
-    @Nullable
-    private static <T extends Keyed> Registry<T> getRegistry(@NotNull Class<T> type) {
-        RegistryLookup lookup = registryLookup.aquire(() -> {
-            RegistryLookup bukkit;
-            try {
-                bukkit = Bukkit::getRegistry;
-            } catch (Throwable ignored) {
-                bukkit = null;
-            }
-            return new DefaultRegistryLookup(bukkit);
-        });
-        return lookup.find(type);
-    }
-
-    private interface RegistryLookup {
-        @Nullable
-        <T extends Keyed> Registry<T> find(@NonNull Class<T> type);
-    }
-
-    private static class DefaultRegistryLookup implements RegistryLookup {
-        private final RegistryLookup bukkit;
-        private final Map<Type, Object> registries;
-
-        private DefaultRegistryLookup(RegistryLookup bukkit) {
-            this.bukkit = bukkit;
-            registries = Arrays.stream(Registry.class.getDeclaredFields())
-                    .filter(field -> Modifier.isPublic(field.getModifiers()) && Modifier.isStatic(field.getModifiers()))
-                    .filter(field -> Registry.class.isAssignableFrom(field.getType()))
-                    .map(field -> {
-                        var type = ((ParameterizedType) field.getGenericType()).getActualTypeArguments()[0];
-                        try {
-                            return new Pair<>(type, field.get(null));
-                        } catch (Throwable e) {
-                            return null;
-                        }
-                    })
-                    .filter(Objects::nonNull)
-                    .collect(Collectors.toMap(Pair::getA, Pair::getB, (a, b) -> a));
-        }
-
-        @Nullable
-        @Override
-        public <T extends Keyed> Registry<T> find(@NonNull Class<T> type) {
-            if (bukkit == null) return (Registry<T>) registries.get(type);
-            try {
-                return bukkit.find(type);
-            } catch (Throwable e) {
-                return (Registry<T>) registries.get(type);
-            }
-        }
-    }
-}