v+

fix HMCLeaves leave decay
fix ClassCastException when replacing to IrisBlockData
2026-01-03 22:26:25 +00:00 · 2024-04-15 11:43:09 -04:00 · 2024-04-04 23:46:14 +02:00 · 2024-04-04 23:45:25 +02:00 · 2024-04-03 03:03:32 -04:00 · 2024-04-02 19:03:25 +02:00
55 changed files with 2608 additions and 1164 deletions
--- a/build.gradle
+++ b/build.gradle
@@ -25,7 +25,7 @@ plugins {
    id "de.undercouch.download" version "5.0.1"
 }

-version '3.0.0-1.19.2-1.20.4'
+version '3.2.3-1.19.2-1.20.4'
 def specialSourceVersion = '1.11.0' //[NMS]

 // ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
@@ -37,7 +37,7 @@ registerCustomOutputTask('Coco', 'D://mcsm/plugins')
 registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
 registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
 registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
-registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.1 - Iris Coding/plugins')
+registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.4 - Iris Development/plugins')
 // ========================== UNIX ==============================
 registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
 registerCustomOutputTaskUnix('PsychoLT', '/Volumes/PRO-G40/Minecraft/MinecraftDevelopment/Server/plugins')
@@ -235,7 +235,7 @@ allprojects {
        implementation 'com.dfsek:Paralithic:0.4.0'
        implementation 'io.papermc:paperlib:1.0.5'
        implementation "net.kyori:adventure-text-minimessage:4.13.1"
-        implementation 'net.kyori:adventure-platform-bukkit:4.3.0'
+        implementation 'net.kyori:adventure-platform-bukkit:4.3.2'
        implementation 'net.kyori:adventure-api:4.13.1'
        compileOnly 'io.lumine:Mythic-Dist:5.2.1'

@@ -246,7 +246,7 @@ allprojects {
        compileOnly 'org.zeroturnaround:zt-zip:1.14'
        compileOnly 'com.google.code.gson:gson:2.9.0'
        compileOnly 'org.ow2.asm:asm:9.2'
-        compileOnly 'com.google.guava:guava:31.1-jre'
+        compileOnly 'com.google.guava:guava:33.0.0-jre'
        compileOnly 'bsf:bsf:2.4.0'
        compileOnly 'rhino:js:1.7R2'
        compileOnly 'com.github.ben-manes.caffeine:caffeine:3.0.6'
--- a/core/build.gradle
+++ b/core/build.gradle
@@ -33,6 +33,10 @@ compileJava {
    options.encoding = "UTF-8"
 }

+repositories {
+    maven { url 'https://nexus.phoenixdevt.fr/repository/maven-public/'}
+}
+
 /**
 * Dependencies.
 *
@@ -61,6 +65,7 @@ dependencies {
    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'
+    compileOnly 'net.Indyuce:MMOItems-API:6.9.5-SNAPSHOT'
    //implementation files('libs/CustomItems.jar')
 }

--- a/core/src/main/java/com/volmit/iris/Iris.java
+++ b/core/src/main/java/com/volmit/iris/Iris.java
@@ -128,6 +128,10 @@ public class Iris extends VolmitPlugin implements Listener {
    private KMap<Class<? extends IrisService>, IrisService> services;

    public static VolmitSender getSender() {
+        if (sender == null) {
+            sender = new VolmitSender(Bukkit.getConsoleSender());
+            sender.setTag(instance.getTag());
+        }
        return sender;
    }

@@ -194,10 +198,10 @@ public class Iris extends VolmitPlugin implements Listener {

    public static void msg(String string) {
        try {
-            sender.sendMessage(string);
+            getSender().sendMessage(string);
        } catch (Throwable e) {
            try {
-                System.out.println(instance.getTag() + string.replaceAll("(<([^>]+)>)", ""));
+                instance.getLogger().info(instance.getTag() + string.replaceAll("(<([^>]+)>)", ""));
            } catch (Throwable ignored1) {

            }
@@ -364,6 +368,13 @@ public class Iris extends VolmitPlugin implements Listener {
        return Integer.parseInt(version);
    }

+    public static String getJava() {
+        String javaRuntimeName = System.getProperty("java.vm.name");
+        String javaRuntimeVendor = System.getProperty("java.vendor");
+        String javaRuntimeVersion = System.getProperty("java.vm.version");
+        return String.format("%s %s (build %s)", javaRuntimeName, javaRuntimeVendor, javaRuntimeVersion);
+    }
+
    public static void reportErrorChunk(int x, int z, Throwable e, String extra) {
        if (IrisSettings.get().getGeneral().isDebug()) {
            File f = instance.getDataFile("debug", "chunk-errors", "chunk." + x + "." + z + ".txt");
@@ -426,7 +437,7 @@ public class Iris extends VolmitPlugin implements Listener {
            }

            pw.close();
-            System.out.println("DUMPED! See " + fi.getAbsolutePath());
+            Iris.info("DUMPED! See " + fi.getAbsolutePath());
        } catch (Throwable e) {
            e.printStackTrace();
        }
@@ -446,14 +457,12 @@ public class Iris extends VolmitPlugin implements Listener {
    private void enable() {
        instance = this;
        services = new KMap<>();
+        setupAudience();
        initialize("com.volmit.iris.core.service").forEach((i) -> services.put((Class<? extends IrisService>) i.getClass(), (IrisService) i));
        INMS.get();
        IO.delete(new File("iris"));
-        setupAudience();
        IrisSafeguard.IrisSafeguardSystem();
-        sender = new VolmitSender(Bukkit.getConsoleSender());
-        sender.setTag(getTag());
-        instance = this;
+        getSender().setTag(getTag());
        compat = IrisCompat.configured(getDataFile("compat.json"));
        linkMultiverseCore = new MultiverseCoreLink();
        linkMythicMobs = new MythicMobsLink();
@@ -526,7 +535,7 @@ public class Iris extends VolmitPlugin implements Listener {
            Iris.info("Starting up auto Studio!");
            try {
                Player r = new KList<>(getServer().getOnlinePlayers()).getRandom();
-                Iris.service(StudioSVC.class).open(r != null ? new VolmitSender(r) : sender, 1337, IrisSettings.get().getGenerator().getDefaultWorldType(), (w) -> {
+                Iris.service(StudioSVC.class).open(r != null ? new VolmitSender(r) : getSender(), 1337, IrisSettings.get().getGenerator().getDefaultWorldType(), (w) -> {
                    J.s(() -> {
                        for (Player i : getServer().getOnlinePlayers()) {
                            i.setGameMode(GameMode.SPECTATOR);
@@ -727,7 +736,7 @@ public class Iris extends VolmitPlugin implements Listener {
        File ff = new File(w.worldFolder(), "iris/pack");
        if (!ff.exists() || ff.listFiles().length == 0) {
            ff.mkdirs();
-            service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), w.worldFolder());
+            service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
        }

        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
@@ -804,6 +813,7 @@ public class Iris extends VolmitPlugin implements Listener {
        if (!passedserversoftware) {
            Iris.info("Server type & version: " + C.RED + Bukkit.getVersion());
        } else { Iris.info("Server type & version: " + Bukkit.getVersion()); }
+        Iris.info("Java: " + getJava());
        if (!instance.getServer().getVersion().contains("Purpur")) {
            if (instance.getServer().getVersion().contains("Spigot") && instance.getServer().getVersion().contains("Bukkit")) {
                 Iris.info(C.RED + " Iris requires paper or above to function properly..");
@@ -842,7 +852,6 @@ public class Iris extends VolmitPlugin implements Listener {
            Iris.warn("6GB+ Ram is recommended");
        }
        Iris.info("Bukkit version: " + Bukkit.getBukkitVersion());
-        Iris.info("Java version: " + getJavaVersion());
        Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
        setupChecks();
        printPacks();
--- a/core/src/main/java/com/volmit/iris/core/IrisSettings.java
+++ b/core/src/main/java/com/volmit/iris/core/IrisSettings.java
@@ -24,6 +24,7 @@ import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONException;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.ChronoLatch;
 import lombok.Data;

 import java.io.File;
@@ -135,7 +136,7 @@ public class IrisSettings {

    @Data
    public static class IrisSettingsPerformance {
-        public boolean trimMantleInStudio = false;
+        public boolean trimMantleInStudio = false; 
        public int mantleKeepAlive = 30;
        public int cacheSize = 4_096;
        public int resourceLoaderCacheSize = 1_024;
@@ -176,6 +177,7 @@ public class IrisSettings {
    public static class IrisSettingsGenerator {
        public String defaultWorldType = "overworld";
        public int maxBiomeChildDepth = 4;
+       // public boolean forceConvertTo320Height = false;
        public boolean preventLeafDecay = true;
    }

--- a/core/src/main/java/com/volmit/iris/core/ServerConfigurator.java
+++ b/core/src/main/java/com/volmit/iris/core/ServerConfigurator.java
@@ -24,6 +24,7 @@ import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.engine.object.IrisBiome;
 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.KSet;
 import com.volmit.iris.util.format.C;
@@ -94,6 +95,29 @@ public class ServerConfigurator {
    public static void installDataPacks(boolean fullInstall) {
        Iris.info("Checking Data Packs...");
        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();
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }

        if (packs.exists()) {
            for (File i : packs.listFiles()) {
@@ -113,7 +137,7 @@ public class ServerConfigurator {

                                Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
                                for (File dpack : getDatapacksFolder()) {
-                                    dim.installDataPack(() -> data, dpack);
+                                    dim.installDataPack(() -> data, dpack, ultimateMaxHeight, ultimateMinHeight);
                                }
                            }
                        }
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandDeepSearch.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandDeepSearch.java
@@ -74,7 +74,7 @@ public class CommandDeepSearch implements DecreeExecutor {
            }

            DeepSearchPregenerator.DeepSearchJob DeepSearchJob = DeepSearchPregenerator.DeepSearchJob.builder()
-                    .world(worldName)
+                    .world(world)
                    .radiusBlocks(radius)
                    .position(0)
                    .build();
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java
@@ -20,9 +20,18 @@ package com.volmit.iris.core.commands;

 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.v1X.NMSBinding1X;
 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.mantle.components.MantleObjectComponent;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisCave;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisEntity;
+import com.volmit.iris.util.data.Dimension;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -31,16 +40,25 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.mantle.TectonicPlate;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.plugin.VolmitSender;
+import io.lumine.mythic.bukkit.adapters.BukkitEntity;
 import net.jpountz.lz4.LZ4BlockInputStream;
 import net.jpountz.lz4.LZ4BlockOutputStream;
 import net.jpountz.lz4.LZ4FrameInputStream;
 import net.jpountz.lz4.LZ4FrameOutputStream;
 import org.apache.commons.lang.RandomStringUtils;
 import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.Location;
 import org.bukkit.World;
+import org.bukkit.entity.Creeper;
+import org.bukkit.entity.EntityType;

 import java.io.*;
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.zip.GZIPInputStream;
@@ -51,36 +69,133 @@ public class CommandDeveloper implements DecreeExecutor {
    private CommandTurboPregen turboPregen;

    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
-    public void EngineStatus(
-            @Param(description = "World")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
-            return;
+    public void EngineStatus() {
+        List<World> IrisWorlds = new ArrayList<>();
+        int TotalLoadedChunks = 0;
+        int TotalQueuedTectonicPlates = 0;
+        int TotalNotQueuedTectonicPlates = 0;
+        int TotalTectonicPlates = 0;
+
+        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
+            }
        }

-        Engine engine = IrisToolbelt.access(world).getEngine();
-        if(engine != null) {
-            long lastUseSize = engine.getMantle().getLastUseMapMemoryUsage();
-
-            Iris.info("-------------------------");
-            Iris.info(C.DARK_PURPLE + "Engine Status");
-            Iris.info(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + IrisEngineSVC.getTectonicLimit());
-            Iris.info(C.DARK_PURPLE + "Tectonic Loaded Plates: " + C.LIGHT_PURPLE + engine.getMantle().getLoadedRegionCount());
-            Iris.info(C.DARK_PURPLE + "Tectonic Plates: " + C.LIGHT_PURPLE + engine.getMantle().getNotClearedLoadedRegions());
-            Iris.info(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + engine.getMantle().getToUnload());
-            Iris.info(C.DARK_PURPLE + "Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration((long) engine.getMantle().getTectonicDuration()));
-            Iris.info(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
-            Iris.info(C.DARK_PURPLE + "LastUse Size: " + C.LIGHT_PURPLE + Form.mem(lastUseSize));
-            Iris.info("-------------------------");
-        } else {
-            Iris.info(C.RED + "Engine is null!");
+        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", origin = DecreeOrigin.BOTH)
-    public void test() {
-        Iris.info("Test Developer CMD Executed");
+
+    @Decree(description = "Test")
+    public void benchmarkMantle(
+            @Param(description = "The world to bench", aliases = {"world"})
+            World world
+    ) throws IOException, ClassNotFoundException {
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        int maxHeight = engine.getTarget().getHeight();
+        File folder = new File(Bukkit.getWorldContainer(), world.getName());
+        int c = 0;
+        //MCAUtil.read()
+
+        File tectonicplates = new File(folder, "mantle");
+        for (File i : Objects.requireNonNull(tectonicplates.listFiles())) {
+            TectonicPlate.read(maxHeight, i);
+            c++;
+            Iris.info("Loaded count: " + c );
+
+        }
+
+    }
+
+    @Decree(description = "Test")
+    public void packBenchmark(
+            @Param(description = "The pack to bench", aliases = {"pack"})
+            IrisDimension dimension
+    ) {
+        Iris.info("test");
+        IrisPackBenchmarking benchmark = new IrisPackBenchmarking(dimension, 1);
+
+    }
+
+    @Decree(description = "test")
+    public void test() throws NoSuchFieldException, IllegalAccessException {
+        IrisEngineSVC.instance.engineStatus();
+
+    }
+
+    @Decree(description = "UnloadChunks for good reasons.")
+    public void unloadchunks() {
+        List<World> IrisWorlds = new ArrayList<>();
+        int chunksUnloaded = 0;
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+
+        for (World world : IrisWorlds) {
+            for (Chunk chunk : world.getLoadedChunks()) {
+                if (chunk.isLoaded()) {
+                    chunk.unload();
+                    chunksUnloaded++;
+                }
+            }
+        }
+        Iris.info(C.IRIS + "Chunks Unloaded: " + chunksUnloaded);
+
+    }
+
+    @Decree(description = "Test", aliases = {"ip"})
+    public void network() {
+        try {
+            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
+            for (NetworkInterface ni : Collections.list(networkInterfaces)) {
+                Iris.info("Display Name: %s", ni.getDisplayName());
+                Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
+                for (InetAddress ia : Collections.list(inetAddresses)) {
+                    Iris.info("IP: %s", ia.getHostAddress());
+                }
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
    }

    @Decree(description = "Test the compression algorithms")
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandIris.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandIris.java
@@ -24,6 +24,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisBenchmarking;
 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.core.safeguard.UtilsSFG;
 import com.volmit.iris.engine.object.IrisWorld;
@@ -49,8 +50,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;

@@ -59,6 +62,7 @@ import static com.volmit.iris.core.service.EditSVC.deletingWorld;
 import static com.volmit.iris.core.tools.IrisBenchmarking.inProgress;
 import static com.volmit.iris.core.safeguard.IrisSafeguard.unstablemode;
 import static com.volmit.iris.core.safeguard.ServerBootSFG.incompatibilities;
+import static org.bukkit.Bukkit.getServer;

@Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
 public class CommandIris implements DecreeExecutor {
@@ -72,8 +76,6 @@ public class CommandIris implements DecreeExecutor {
    private CommandEdit edit;
    private CommandFind find;
    private CommandDeveloper developer;
-
-    public static @Getter String BenchDimension;
    public static boolean worldCreation = false;
    String WorldToLoad;
    String WorldEngine;
@@ -184,7 +186,7 @@ public class CommandIris implements DecreeExecutor {
    }

    /*
-    /todo Fix PREGEN
+    /todo
    @Decree(description = "Benchmark a pack", origin = DecreeOrigin.CONSOLE)
    public void packbenchmark(
            @Param(description = "Dimension to benchmark")
@@ -196,28 +198,16 @@ public class CommandIris implements DecreeExecutor {
        IrisPackBenchmarking.runBenchmark();
    } */

-    /*  /todo Different approach this feels useless atm
-    @Decree(description = "Check for instabilities", origin = DecreeOrigin.CONSOLE)
-    public void fixunstable() throws InterruptedException {
-        if (unstablemode){
-            sender().sendMessage(C.RED + "Incompatibilities are posted in console..");
-
-            Iris.info(C.RED + "Your server is experiencing an incompatibility with the Iris plugin.");
-            Iris.info(C.RED + "Please rectify this problem to avoid further complications.");
-            Iris.info(C.RED + "----------------------------------------------------------------");
-            Iris.info(C.RED + "Command ran: /iris fixunstable");
-            UtilsSFG.printIncompatibleWarnings();
-            Iris.info(C.RED + "----------------------------------------------------------------");
-     } else {
-            Iris.info(C.BLUE + "Iris is running stable..");
-            sender().sendMessage("Iris is running stable..");
-        }
-    } */
-
    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
    public void height() {
-        sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
-        sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
+            sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
+        } else {
+            World mainWorld = getServer().getWorlds().get(0);
+            Iris.info(C.GREEN + "" + mainWorld.getMinHeight() + " to " + mainWorld.getMaxHeight());
+            Iris.info(C.GREEN + "Total Height: " + (mainWorld.getMaxHeight() - mainWorld.getMinHeight()));
+        }
    }

    @Decree(description = "QOL command to open a overworld studio world.", sync = true)
@@ -226,6 +216,44 @@ public class CommandIris implements DecreeExecutor {
        Iris.service(StudioSVC.class).open(sender(), 1337, "overworld");
    }

+    @Decree(description = "Check if iris has access to that specific world")
+    public void hasAccess(
+            @Param(description = "The world to access", aliases = {"world"})
+            World world
+    ) {
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        if (engine != null) {
+            sender().sendMessage("Access granted successfully.");
+        } else {
+            sender().sendMessage(C.RED + "Failed to grant access.");
+        }
+    }
+
+    @Decree(description = "All Iris Worlds on the server.", aliases = {"worlds"})
+    public void irisworlds() {
+        List<World> IrisWorlds = new ArrayList<>();
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+        if (sender().isPlayer()) {
+            sender.sendMessage(C.IRIS + "Iris Worlds:");
+            for (World world : IrisWorlds) {
+                sender.sendMessage(C.GREEN + "- " + world.getName());
+            }
+        } else {
+            Iris.info(C.IRIS + "Iris Worlds:");
+            for (World world : IrisWorlds) {
+                sender.sendMessage(C.GREEN + "- " + world.getName());
+            }
+        }
+    }
+
    @Decree(description = "Remove an Iris world", aliases = {"del", "rm", "delete"}, sync = true)
    public void remove(
            @Param(description = "The world to remove")
@@ -234,7 +262,7 @@ public class CommandIris implements DecreeExecutor {
            boolean delete
    ) {
        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
            return;
        }
        sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
@@ -417,7 +445,7 @@ public class CommandIris implements DecreeExecutor {
            World world
    ) {
        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
            return;
        }
        sender().sendMessage(C.GREEN + "Unloading world: " + world.getName());
@@ -447,7 +475,7 @@ public class CommandIris implements DecreeExecutor {
        }
        WorldToLoad = world;
        File BUKKIT_YML = new File("bukkit.yml");
-        String pathtodim = world + "\\iris\\pack\\dimensions\\";
+        String pathtodim = world + File.separator +"iris"+File.separator +"pack"+File.separator +"dimensions"+File.separator;
        File directory = new File(Bukkit.getWorldContainer(), pathtodim);

        String dimension = null;
@@ -492,7 +520,7 @@ public class CommandIris implements DecreeExecutor {
            World world
    ) {
        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
            return;
        }
        sender().sendMessage(C.GREEN + "Evacuating world" + world.getName());
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandPregen.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandPregen.java
@@ -56,6 +56,7 @@ public class CommandPregen implements DecreeExecutor {
            IrisToolbelt.pregenerate(PregenTask
                    .builder()
                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                    .gui(true)
                    .width(w)
                    .height(w)
                    .build(), world);
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandStudio.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandStudio.java
@@ -26,6 +26,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.ConversionSVC;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
@@ -229,9 +230,9 @@ public class CommandStudio implements DecreeExecutor {
    @Decree(description = "Convert objects in the \"convert\" folder")
    public void convert() {
        Iris.service(ConversionSVC.class).check(sender());
+        //IrisConverter.convertSchematics(sender());
    }

-
    @Decree(description = "Execute a script", aliases = "run", origin = DecreeOrigin.PLAYER)
    public void execute(
            @Param(description = "The script to run")
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandWhat.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandWhat.java
@@ -22,7 +22,9 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.edit.BlockSignal;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisRegion;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
@@ -37,6 +39,7 @@ import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;

+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;

@Decree(name = "what", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris What?")
@@ -82,6 +85,19 @@ public class CommandWhat implements DecreeExecutor {
        }
    }

+    @Decree(description = "What region am i in?", origin = DecreeOrigin.PLAYER)
+    public void region() {
+        try {
+            Chunk chunk = world().getChunkAt(player().getLocation().getBlockZ() / 16, player().getLocation().getBlockZ() /  16);
+            IrisRegion r = engine().getRegion(chunk);
+            sender().sendMessage("IRegion: " + r.getLoadKey() + " (" + r.getName() + ")");
+
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
+        }
+    }
+
    @Decree(description = "What block am i looking at?", origin = DecreeOrigin.PLAYER)
    public void block() {
        BlockData bd;
@@ -147,7 +163,7 @@ public class CommandWhat implements DecreeExecutor {

            sender().sendMessage("Found " + v.get() + " Nearby Markers (" + marker + ")");
        } else {
-            sender().sendMessage("Iris worlds only.");
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
        }
    }
 }
--- a/core/src/main/java/com/volmit/iris/core/gui/PregeneratorJob.java
+++ b/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");
@@ -86,7 +89,7 @@ public class PregeneratorJob implements PregenListener {
            max.setZ(Math.max((zz << 5) + 31, max.getZ()));
        });

-        if (IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
+        if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
            open();
        }

--- a/core/src/main/java/com/volmit/iris/core/link/ExternalDataProvider.java
+++ b/core/src/main/java/com/volmit/iris/core/link/ExternalDataProvider.java
@@ -1,8 +1,10 @@
 package com.volmit.iris.core.link;

+import com.volmit.iris.engine.framework.Engine;
 import lombok.Getter;
 import lombok.RequiredArgsConstructor;
 import org.bukkit.Bukkit;
+import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.Plugin;
@@ -28,6 +30,7 @@ public abstract class ExternalDataProvider {
    public abstract BlockData getBlockData(Identifier blockId) throws MissingResourceException;

    public abstract ItemStack getItemStack(Identifier itemId) throws MissingResourceException;
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {};

    public abstract Identifier[] getBlockTypes();

--- a/core/src/main/java/com/volmit/iris/core/link/HMCLeavesDataProvider.java
+++ b/core/src/main/java/com/volmit/iris/core/link/HMCLeavesDataProvider.java
@@ -0,0 +1,135 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+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;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.Leaves;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.function.Supplier;
+
+public class HMCLeavesDataProvider extends ExternalDataProvider {
+	private Object apiInstance;
+	private WrappedReturningMethod<Object, Material> worldBlockType;
+	private WrappedReturningMethod<Object, Boolean> setCustomBlock;
+	private Map<String, Object> blockDataMap = Map.of();
+	private Map<String, Supplier<ItemStack>> itemDataField = Map.of();
+
+	public HMCLeavesDataProvider() {
+		super("HMCLeaves");
+	}
+
+	@Override
+	public String getPluginId() {
+		return "HMCLeaves";
+	}
+
+	@Override
+	public void init() {
+		try {
+			worldBlockType = new WrappedReturningMethod<>((Class<Object>) Class.forName("io.github.fisher2911.hmcleaves.data.BlockData"), "worldBlockType");
+			apiInstance = getApiInstance(Class.forName("io.github.fisher2911.hmcleaves.api.HMCLeavesAPI"));
+			setCustomBlock = new WrappedReturningMethod<>((Class<Object>) apiInstance.getClass(), "setCustomBlock", Location.class, String.class, boolean.class);
+			Object config = getLeavesConfig(apiInstance.getClass());
+			blockDataMap = getMap(config, "blockDataMap");
+			itemDataField = getMap(config, "itemSupplierMap");
+		} catch (Throwable e) {
+			Iris.error("Failed to initialize HMCLeavesDataProvider: " + e.getMessage());
+		}
+	}
+
+	@Override
+	public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+		Object o = blockDataMap.get(blockId.key());
+		if (o == null)
+			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+		Material material = worldBlockType.invoke(o, new Object[0]);
+		if (material == null)
+			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+		BlockData blockData = Bukkit.createBlockData(material);
+		if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
+			leaves.setPersistent(true);
+		return new IrisBlockData(blockData, blockId);
+	}
+
+	@Override
+	public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+		if (!itemDataField.containsKey(itemId.key()))
+			throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+		return itemDataField.get(itemId.key()).get();
+	}
+
+	@Override
+	public void processUpdate(Engine engine, Block block, Identifier blockId) {
+		Boolean result = setCustomBlock.invoke(apiInstance, new Object[]{block.getLocation(), blockId.key(), false});
+		if (result == null || !result)
+			Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
+		else if (IrisSettings.get().getGenerator().preventLeafDecay) {
+			BlockData blockData = block.getBlockData();
+			if (blockData instanceof Leaves leaves)
+				leaves.setPersistent(true);
+		}
+	}
+
+	@Override
+	public Identifier[] getBlockTypes() {
+		KList<Identifier> names = new KList<>();
+		for (String name : blockDataMap.keySet()) {
+			try {
+				Identifier key = new Identifier("hmcleaves", name);
+				if (getBlockData(key) != null)
+					names.add(key);
+			} catch (MissingResourceException ignored) {
+			}
+		}
+
+		return names.toArray(new Identifier[0]);
+	}
+
+	@Override
+	public Identifier[] getItemTypes() {
+		KList<Identifier> names = new KList<>();
+		for (String name : itemDataField.keySet()) {
+			try {
+				Identifier key = new Identifier("hmcleaves", name);
+				if (getItemStack(key) != null)
+					names.add(key);
+			} catch (MissingResourceException ignored) {
+			}
+		}
+
+		return names.toArray(new Identifier[0]);
+	}
+
+	@Override
+	public boolean isValidProvider(Identifier id, boolean isItem) {
+		return (isItem ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
+	}
+
+	private <C, T> Map<String, T> getMap(C config, String name) {
+		WrappedField<C, Map<String, T>> field = new WrappedField<>((Class<C>) config.getClass(), name);
+		return field.get(config);
+	}
+
+	private <A> A getApiInstance(Class<A> apiClass) {
+		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+		return instance.invoke();
+	}
+
+	private <A, C> C getLeavesConfig(Class<A> apiClass) {
+		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+		WrappedField<A, C> config = new WrappedField<>(apiClass, "config");
+		return config.get(instance.invoke());
+	}
+}
--- a/core/src/main/java/com/volmit/iris/core/link/MMOItemsDataProvider.java
+++ b/core/src/main/java/com/volmit/iris/core/link/MMOItemsDataProvider.java
@@ -0,0 +1,106 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.scheduling.J;
+import net.Indyuce.mmoitems.MMOItems;
+import net.Indyuce.mmoitems.api.Type;
+import net.Indyuce.mmoitems.api.block.CustomBlock;
+import org.bukkit.Bukkit;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class MMOItemsDataProvider extends ExternalDataProvider {
+
+    public MMOItemsDataProvider() {
+        super("MMOItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up MMOItems Link...");
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+        int id = -1;
+        try {
+            id = Integer.parseInt(blockId.key());
+        } catch (NumberFormatException ignored) {}
+        CustomBlock block = api().getCustomBlocks().getBlock(id);
+        if (block == null) throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        return block.getState().getBlockData();
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+        String[] parts = itemId.namespace().split("_", 2);
+        if (parts.length != 2)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        CompletableFuture<ItemStack> future = new CompletableFuture<>();
+        Runnable run = () -> future.complete(api().getItem(parts[1], itemId.key()));
+        if (Bukkit.isPrimaryThread()) run.run();
+        else J.s(run);
+        ItemStack item = null;
+        try {
+            item = future.get();
+        } catch (InterruptedException | ExecutionException ignored) {}
+        if (item == null)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        return item;
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> names = new KList<>();
+        for (Integer id : api().getCustomBlocks().getBlockIds()) {
+            try {
+                Identifier key = new Identifier("mmoitems", String.valueOf(id));
+                if (getBlockData(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        Runnable run = () -> {
+            for (Type type : api().getTypes().getAll()) {
+                for (String name : api().getTemplates().getTemplateNames(type)) {
+                    try {
+                        Identifier key = new Identifier("mmoitems_" + type.getId(), name);
+                        if (getItemStack(key) != null)
+                            names.add(key);
+                    } catch (MissingResourceException ignored) {
+                    }
+                }
+            }
+        };
+        if (Bukkit.isPrimaryThread()) run.run();
+        else {
+            try {
+                J.sfut(run).get();
+            } catch (InterruptedException | ExecutionException e) {
+                Iris.error("Failed getting MMOItems item types!");
+                Iris.reportError(e);
+            }
+        }
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier id, boolean isItem) {
+        return isItem ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
+    }
+
+    private MMOItems api() {
+        return MMOItems.plugin;
+    }
+}
--- a/core/src/main/java/com/volmit/iris/core/link/OraxenDataProvider.java
+++ b/core/src/main/java/com/volmit/iris/core/link/OraxenDataProvider.java
@@ -19,18 +19,25 @@
 package com.volmit.iris.core.link;

 import com.volmit.iris.Iris;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.reflect.WrappedField;
 import io.th0rgal.oraxen.api.OraxenItems;
 import io.th0rgal.oraxen.items.ItemBuilder;
+import io.th0rgal.oraxen.mechanics.Mechanic;
 import io.th0rgal.oraxen.mechanics.MechanicFactory;
 import io.th0rgal.oraxen.mechanics.MechanicsManager;
 import io.th0rgal.oraxen.mechanics.provided.gameplay.block.BlockMechanic;
 import io.th0rgal.oraxen.mechanics.provided.gameplay.block.BlockMechanicFactory;
+import io.th0rgal.oraxen.mechanics.provided.gameplay.furniture.FurnitureFactory;
+import io.th0rgal.oraxen.mechanics.provided.gameplay.furniture.FurnitureMechanic;
 import io.th0rgal.oraxen.mechanics.provided.gameplay.noteblock.NoteBlockMechanicFactory;
 import io.th0rgal.oraxen.mechanics.provided.gameplay.stringblock.StringBlockMechanicFactory;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.MultipleFacing;
 import org.bukkit.inventory.ItemStack;
@@ -69,6 +76,8 @@ public class OraxenDataProvider extends ExternalDataProvider {
            return newBlockData;
        } else if (factory instanceof StringBlockMechanicFactory f) {
            return f.createTripwireData(blockId.key());
+        } else if (factory instanceof FurnitureFactory) {
+            return new IrisBlockData(B.getAir(), blockId);
        } else
            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
    }
@@ -79,6 +88,14 @@ public class OraxenDataProvider extends ExternalDataProvider {
        return opt.orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key())).build();
    }

+    @Override
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {
+        Mechanic mechanic = getFactory(blockId).getMechanic(blockId.key());
+        if (mechanic instanceof FurnitureMechanic f) {
+            f.place(block.getLocation());
+        }
+    }
+
    @Override
    public Identifier[] getBlockTypes() {
        KList<Identifier> names = new KList<>();
--- a/core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java
+++ b/core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java
@@ -19,9 +19,11 @@
 package com.volmit.iris.core.nms;

 import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisEntity;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
@@ -32,6 +34,9 @@ import org.bukkit.WorldCreator;
 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.event.entity.EntitySpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.inventory.ItemStack;

@@ -103,4 +108,8 @@ public interface INMSBinding {
    void setTreasurePos(Dolphin dolphin, com.volmit.iris.core.nms.container.BlockPos pos);

    void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException;
+
+    Vector3d getBoundingbox(org.bukkit.entity.EntityType entity);
+    
+    Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason);
 }
--- a/core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java
+++ b/core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java
@@ -25,6 +25,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.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
@@ -34,6 +35,8 @@ import org.bukkit.World;
 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.inventory.ItemStack;

@@ -85,6 +88,15 @@ public class NMSBinding1X implements INMSBinding {

    }

+    public Vector3d getBoundingbox() {
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return location.getWorld().spawnEntity(location, type);
+    }
+
    @Override
    public void deserializeTile(CompoundTag s, Location newPosition) {

@@ -203,6 +215,11 @@ public class NMSBinding1X implements INMSBinding {

    }

+    @Override
+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+      return null;
+    }
+
    @Override
    public MCAPaletteAccess createPalette() {
        Iris.error("Cannot use the global data palette! Iris is incapable of using MCA generation on this version of minecraft!");
--- a/core/src/main/java/com/volmit/iris/core/pregenerator/DeepSearchPregenerator.java
+++ b/core/src/main/java/com/volmit/iris/core/pregenerator/DeepSearchPregenerator.java
@@ -5,18 +5,16 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RollingSequence;
 import com.volmit.iris.util.math.Spiraler;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import io.papermc.lib.PaperLib;
 import lombok.Builder;
 import lombok.Data;
 import lombok.Getter;
@@ -33,7 +31,6 @@ import java.io.IOException;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
-import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -56,10 +53,12 @@ public class DeepSearchPregenerator extends Thread implements Listener {
    private final RollingSequence chunksPerMinute;
    private final AtomicInteger chunkCachePos;
    private final AtomicInteger chunkCacheSize;
+    private int pos;
    private final AtomicInteger foundCacheLast;
    private final AtomicInteger foundCache;
    private LinkedHashMap<Integer, Position2> chunkCache;
-    private final ReentrantLock cacheLock = new ReentrantLock();
+    private KList<Position2> chunkQueue;
+    private final ReentrantLock cacheLock;

    private static final Map<String, DeepSearchJob> jobs = new HashMap<>();

@@ -69,11 +68,13 @@ public class DeepSearchPregenerator extends Thread implements Listener {
        this.chunkCachePos = new AtomicInteger(1000);
        this.foundCacheLast = new AtomicInteger();
        this.foundCache = new AtomicInteger();
+        this.cacheLock = new ReentrantLock();
        this.destination = destination;
-        this.chunkCache = new LinkedHashMap();
+        this.chunkCache = new LinkedHashMap<>();
        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
        }).count();
-        this.world = Bukkit.getWorld(job.getWorld());
+        this.world = Bukkit.getWorld(job.getWorld().getUID());
+        this.chunkQueue = new KList<>();
        this.latch = new ChronoLatch(3000);
        this.startTime = new AtomicLong(M.ms());
        this.chunksPerSecond = new RollingSequence(10);
@@ -81,7 +82,9 @@ public class DeepSearchPregenerator extends Thread implements Listener {
        foundChunks = new AtomicInteger(0);
        this.foundLast = new AtomicInteger(0);
        this.foundTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
-        jobs.put(job.getWorld(), job);
+
+        this.pos = 0;
+        jobs.put(job.getWorld().getName(), job);
        DeepSearchPregenerator.instance = this;
    }

@@ -108,29 +111,22 @@ public class DeepSearchPregenerator extends Thread implements Listener {
       // chunkCache(); //todo finish this
        if (latch.flip() && !job.paused) {
            if (cacheLock.isLocked()) {
-
                Iris.info("DeepFinder: Caching: " + chunkCachePos.get() + " Of " + chunkCacheSize.get());
+            } else {
+                long eta = computeETA();
+                save();
+                int secondGenerated = foundChunks.get() - foundLast.get();
+                foundLast.set(foundChunks.get());
+                secondGenerated = secondGenerated / 3;
+                chunksPerSecond.put(secondGenerated);
+                chunksPerMinute.put(secondGenerated * 60);
+                Iris.info("DeepFinder: " + C.IRIS + world.getName() + C.RESET + " Searching: " + Form.f(foundChunks.get()) + " of " + Form.f(foundTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
            }
-            long eta = computeETA();
-            save();
-            int secondGenerated = foundChunks.get() - foundLast.get();
-            foundLast.set(foundChunks.get());
-            secondGenerated = secondGenerated / 3;
-            chunksPerSecond.put(secondGenerated);
-            chunksPerMinute.put(secondGenerated * 60);
-            Iris.info("deepFinder: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(foundChunks.get()) + " of " + Form.f(foundTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));

        }
-
        if (foundChunks.get() >= foundTotalChunks.get()) {
            Iris.info("Completed DeepSearch!");
            interrupt();
-        } else {
-            int pos = job.getPosition() + 1;
-            job.setPosition(pos);
-            if (!job.paused) {
-                tickSearch(getChunk(pos));
-            }
        }
    }

@@ -141,22 +137,18 @@ public class DeepSearchPregenerator extends Thread implements Listener {

    private final ExecutorService executorService = Executors.newSingleThreadExecutor();

-    private void tickSearch(Position2 chunk) {
-        executorService.submit(() -> {
-            CountDownLatch latch = new CountDownLatch(1);
-            try {
-                findInChunk(world, chunk.getX(), chunk.getZ());
-            } catch (IOException e) {
-                throw new RuntimeException(e);
+    private void queueSystem(Position2 chunk) {
+        if (chunkQueue.isEmpty()) {
+            for (int limit = 512; limit != 0; limit--) {
+                pos = job.getPosition() + 1;
+                chunkQueue.add(getChunk(pos));
            }
-            Iris.verbose("Generated Async " + chunk);
-            latch.countDown();
+        } else {
+            //MCAUtil.read();
+
+        }
+

-            try {
-                latch.await();
-            } catch (InterruptedException ignored) {}
-            foundChunks.addAndGet(1);
-        });
    }

    private void findInChunk(World world, int x, int z) throws IOException {
@@ -271,7 +263,7 @@ public class DeepSearchPregenerator extends Thread implements Listener {
    @Data
    @Builder
    public static class DeepSearchJob {
-        private String world;
+        private World world;
        @Builder.Default
        private int radiusBlocks = 5000;
        @Builder.Default
--- a/core/src/main/java/com/volmit/iris/core/pregenerator/IrisPregenerator.java
+++ b/core/src/main/java/com/volmit/iris/core/pregenerator/IrisPregenerator.java
@@ -19,7 +19,9 @@
 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;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
@@ -30,15 +32,12 @@ import com.volmit.iris.util.math.RollingSequence;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.Looper;
-import lombok.Getter;
-import lombok.Setter;

 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;

-import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmark;

 public class IrisPregenerator {
    private final PregenTask task;
@@ -50,6 +49,7 @@ public class IrisPregenerator {
    private final RollingSequence chunksPerSecond;
    private final RollingSequence chunksPerMinute;
    private final RollingSequence regionsPerMinute;
+    private final KList<Integer> chunksPerSecondHistory;
    private static AtomicInteger generated;
    private final AtomicInteger generatedLast;
    private final AtomicInteger generatedLastMinute;
@@ -62,8 +62,6 @@ public class IrisPregenerator {
    private final KSet<Position2> net;
    private final ChronoLatch cl;
    private final ChronoLatch saveLatch = new ChronoLatch(30000);
-    static long long_generatedChunks = 0;
-    static long long_totalChunks = 0;

    public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
        this.listener = listenify(listener);
@@ -80,6 +78,7 @@ public class IrisPregenerator {
        chunksPerSecond = new RollingSequence(10);
        chunksPerMinute = new RollingSequence(10);
        regionsPerMinute = new RollingSequence(10);
+        chunksPerSecondHistory = new KList<>();
        generated = new AtomicInteger(0);
        generatedLast = new AtomicInteger(0);
        generatedLastMinute = new AtomicInteger(0);
@@ -93,6 +92,7 @@ public class IrisPregenerator {
                int secondGenerated = generated.get() - generatedLast.get();
                generatedLast.set(generated.get());
                chunksPerSecond.put(secondGenerated);
+                chunksPerSecondHistory.add(secondGenerated);

                if (minuteLatch.flip()) {
                    int minuteGenerated = generated.get() - generatedLastMinute.get();
@@ -100,8 +100,6 @@ public class IrisPregenerator {
                    chunksPerMinute.put(minuteGenerated);
                    regionsPerMinute.put((double) minuteGenerated / 1024D);
                }
-                long_generatedChunks = generated.get();
-                long_totalChunks = totalChunks.get();

                listener.onTick(chunksPerSecond.getAverage(), chunksPerMinute.getAverage(),
                        regionsPerMinute.getAverage(),
@@ -112,10 +110,10 @@ public class IrisPregenerator {

                if (cl.flip()) {
                    double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
-                    if(benchmark) {
-                        Iris.info(C.GREEN +"Benchmark: " + C.WHITE + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2), percentage);
+                    if (!IrisPackBenchmarking.benchmarkInProgress) {
+                        Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
                    } else {
-                        Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2), percentage);
+                        Iris.info("Benchmarking: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
                    }
                }
                return 1000;
@@ -128,17 +126,10 @@ public class IrisPregenerator {
                // If yes, use smooth function (which gets more accurate over time since its less sensitive to outliers)
                ((totalChunks.get() - generated.get()) * ((double) (M.ms() - startTime.get()) / (double) generated.get())) :
                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
-                ((totalChunks.get() - generated.get()) / chunksPerSecond.getAverage()) * 1000 //
+                ((totalChunks.get() - generated.get()) / chunksPerSecond.getAverage()) * 1000
        );
    }

-    public static long getLongGeneratedChunks() {
-        return long_generatedChunks;
-    }
-    public static long getLongTotalChunks() {
-        return long_totalChunks;
-    }
-

    public void close() {
        shutdown.set(true);
@@ -151,6 +142,11 @@ public class IrisPregenerator {
        task.iterateRegions((x, z) -> visitRegion(x, z, true));
        task.iterateRegions((x, z) -> visitRegion(x, z, false));
        shutdown();
+        if (!IrisPackBenchmarking.benchmarkInProgress) {
+            Iris.info(C.IRIS + "Pregen stopped.");
+        } else {
+            IrisPackBenchmarking.instance.finishedBenchmark(chunksPerSecondHistory);
+        }
    }

    private void checkRegions() {
@@ -167,7 +163,10 @@ public class IrisPregenerator {
        generator.close();
        ticker.interrupt();
        listener.onClose();
-        getMantle().trim(0, 0);
+        Mantle mantle = getMantle();
+        if (mantle != null) {
+            mantle.trim(0, 0);
+        }
    }

    private void visitRegion(int x, int z, boolean regions) {
--- a/core/src/main/java/com/volmit/iris/core/pregenerator/PregenTask.java
+++ b/core/src/main/java/com/volmit/iris/core/pregenerator/PregenTask.java
@@ -35,6 +35,8 @@ public class PregenTask {
    private static final KList<Position2> ORDER_CENTER = computeChunkOrder();
    private static final KMap<Position2, KList<Position2>> ORDERS = new KMap<>();

+    @Builder.Default
+    private boolean gui = false;
    @Builder.Default
    private Position2 center = new Position2(0, 0);
    @Builder.Default
--- a/core/src/main/java/com/volmit/iris/core/safeguard/ServerBootSFG.java
+++ b/core/src/main/java/com/volmit/iris/core/safeguard/ServerBootSFG.java
@@ -3,11 +3,11 @@ 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 org.apache.logging.log4j.core.util.ExecutorServices;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;

-import javax.print.attribute.standard.Severity;
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
 import java.io.File;
 import java.nio.channels.FileChannel;
 import java.nio.file.Files;
@@ -17,9 +17,6 @@ import java.nio.file.StandardOpenOption;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.StringJoiner;
-import java.util.concurrent.Executor;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;

 import static com.volmit.iris.Iris.getJavaVersion;
 import static com.volmit.iris.Iris.instance;
@@ -128,25 +125,15 @@ public class ServerBootSFG {
        }
    }

-    public static boolean isJDK() {
-        String path = System.getProperty("sun.boot.library.path");
-        if (path != null) {
-            String javacPath = "";
-            if (path.endsWith(File.separator + "bin")) {
-                javacPath = path;
-            } else {
-                int libIndex = path.lastIndexOf(File.separator + "lib");
-                if (libIndex > 0) {
-                    javacPath = path.substring(0, libIndex) + File.separator + "bin";
-                }
-            }
-            if (checkJavac(javacPath))
-                return true;
-        }
-        path = System.getProperty("java.home");
-        return path != null && checkJavac(path + File.separator + "bin");
-    }

+    public static boolean isJDK() {
+        try {
+            JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
+            // If the compiler is null, it means this is a JRE environment, not a JDK.
+            return compiler != null;
+        } catch (Exception ignored) {}
+        return false;
+    }
    public static boolean hasPrivileges() {
        Path pv = Paths.get(Bukkit.getWorldContainer() + "iristest.json");
        try (FileChannel fc = FileChannel.open(pv, StandardOpenOption.CREATE, StandardOpenOption.DELETE_ON_CLOSE, StandardOpenOption.READ, StandardOpenOption.WRITE)) {
--- a/core/src/main/java/com/volmit/iris/core/service/ExternalDataSVC.java
+++ b/core/src/main/java/com/volmit/iris/core/service/ExternalDataSVC.java
@@ -1,119 +1,138 @@
-/*
- * 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.core.service;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.*;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.plugin.IrisService;
-import lombok.Data;
-import org.bukkit.Bukkit;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.server.PluginEnableEvent;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.MissingResourceException;
-import java.util.Optional;
-
-@Data
-public class ExternalDataSVC implements IrisService {
-
-    private KList<ExternalDataProvider> providers = new KList<>(), activeProviders = new KList<>();
-
-    @Override
-    public void onEnable() {
-        Iris.info("Loading ExternalDataProvider...");
-        Bukkit.getPluginManager().registerEvents(this, Iris.instance);
-
-        providers.add(new OraxenDataProvider());
-        if (Bukkit.getPluginManager().getPlugin("Oraxen") != null) {
-            Iris.info("Oraxen found, loading OraxenDataProvider...");
-        }
-        providers.add(new ItemAdderDataProvider());
-        if (Bukkit.getPluginManager().getPlugin("ItemAdder") != null) {
-            Iris.info("ItemAdder found, loading ItemAdderDataProvider...");
-        }
-        providers.add(new ExecutableItemsDataProvider());
-        if (Bukkit.getPluginManager().getPlugin("ExecutableItems") != null) {
-            Iris.info("ExecutableItems found, loading ExecutableItemsDataProvider...");
-        }
-
-        for (ExternalDataProvider p : providers) {
-            if (p.isReady()) {
-                activeProviders.add(p);
-                p.init();
-                Iris.info("Enabled ExternalDataProvider for %s.", p.getPluginId());
-            }
-        }
-    }
-
-    @Override
-    public void onDisable() {
-    }
-
-    @EventHandler
-    public void onPluginEnable(PluginEnableEvent e) {
-        if (activeProviders.stream().noneMatch(p -> p.getPlugin().equals(e.getPlugin()))) {
-            providers.stream().filter(p -> p.isReady() && p.getPlugin().equals(e.getPlugin())).findFirst().ifPresent(edp -> {
-                activeProviders.add(edp);
-                edp.init();
-                Iris.info("Enabled ExternalDataProvider for %s.", edp.getPluginId());
-            });
-        }
-    }
-
-    public Optional<BlockData> getBlockData(Identifier key) {
-        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(key, false)).findFirst();
-        if (provider.isEmpty())
-            return Optional.empty();
-        try {
-            return Optional.of(provider.get().getBlockData(key));
-        } catch (MissingResourceException e) {
-            Iris.error(e.getMessage() + " - [" + e.getClassName() + ":" + e.getKey() + "]");
-            return Optional.empty();
-        }
-    }
-
-    public Optional<ItemStack> getItemStack(Identifier key) {
-        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(key, true)).findFirst();
-        if (provider.isEmpty()) {
-            Iris.warn("No matching Provider found for modded material \"%s\"!", key);
-            return Optional.empty();
-        }
-        try {
-            return Optional.of(provider.get().getItemStack(key));
-        } catch (MissingResourceException e) {
-            Iris.error(e.getMessage() + " - [" + e.getClassName() + ":" + e.getKey() + "]");
-            return Optional.empty();
-        }
-    }
-
-    public Identifier[] getAllBlockIdentifiers() {
-        KList<Identifier> names = new KList<>();
-        activeProviders.forEach(p -> names.add(p.getBlockTypes()));
-        return names.toArray(new Identifier[0]);
-    }
-
-    public Identifier[] getAllItemIdentifiers() {
-        KList<Identifier> names = new KList<>();
-        activeProviders.forEach(p -> names.add(p.getItemTypes()));
-        return names.toArray(new Identifier[0]);
-    }
-}
+/*
+ * 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.core.service;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.*;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.plugin.IrisService;
+import lombok.Data;
+import org.bukkit.Bukkit;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.server.PluginEnableEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+import java.util.Optional;
+
+@Data
+public class ExternalDataSVC implements IrisService {
+
+    private KList<ExternalDataProvider> providers = new KList<>(), activeProviders = new KList<>();
+
+    @Override
+    public void onEnable() {
+        Iris.info("Loading ExternalDataProvider...");
+        Bukkit.getPluginManager().registerEvents(this, Iris.instance);
+
+        providers.add(new OraxenDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("Oraxen") != null) {
+            Iris.info("Oraxen found, loading OraxenDataProvider...");
+        }
+        providers.add(new ItemAdderDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("ItemAdder") != null) {
+            Iris.info("ItemAdder found, loading ItemAdderDataProvider...");
+        }
+        providers.add(new ExecutableItemsDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("ExecutableItems") != null) {
+            Iris.info("ExecutableItems found, loading ExecutableItemsDataProvider...");
+        }
+        providers.add(new HMCLeavesDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("HMCLeaves") != null) {
+            Iris.info("BlockAdder found, loading HMCLeavesDataProvider...");
+        }
+        providers.add(new MMOItemsDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("MMOItems") != null) {
+            Iris.info("MMOItems found, loading MMOItemsDataProvider...");
+        }
+
+        for (ExternalDataProvider p : providers) {
+            if (p.isReady()) {
+                activeProviders.add(p);
+                p.init();
+                Iris.info("Enabled ExternalDataProvider for %s.", p.getPluginId());
+            }
+        }
+    }
+
+    @Override
+    public void onDisable() {
+    }
+
+    @EventHandler
+    public void onPluginEnable(PluginEnableEvent e) {
+        if (activeProviders.stream().noneMatch(p -> p.getPlugin().equals(e.getPlugin()))) {
+            providers.stream().filter(p -> p.isReady() && p.getPlugin().equals(e.getPlugin())).findFirst().ifPresent(edp -> {
+                activeProviders.add(edp);
+                edp.init();
+                Iris.info("Enabled ExternalDataProvider for %s.", edp.getPluginId());
+            });
+        }
+    }
+
+    public Optional<BlockData> getBlockData(Identifier key) {
+        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(key, false)).findFirst();
+        if (provider.isEmpty())
+            return Optional.empty();
+        try {
+            return Optional.of(provider.get().getBlockData(key));
+        } catch (MissingResourceException e) {
+            Iris.error(e.getMessage() + " - [" + e.getClassName() + ":" + e.getKey() + "]");
+            return Optional.empty();
+        }
+    }
+
+    public Optional<ItemStack> getItemStack(Identifier key) {
+        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(key, true)).findFirst();
+        if (provider.isEmpty()) {
+            Iris.warn("No matching Provider found for modded material \"%s\"!", key);
+            return Optional.empty();
+        }
+        try {
+            return Optional.of(provider.get().getItemStack(key));
+        } catch (MissingResourceException e) {
+            Iris.error(e.getMessage() + " - [" + e.getClassName() + ":" + e.getKey() + "]");
+            return Optional.empty();
+        }
+    }
+
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {
+        Optional<ExternalDataProvider> provider = activeProviders.stream().filter(p -> p.isValidProvider(blockId, false)).findFirst();
+        if (provider.isEmpty()) {
+            Iris.warn("No matching Provider found for modded material \"%s\"!", blockId);
+            return;
+        }
+        provider.get().processUpdate(engine, block, blockId);
+    }
+
+    public Identifier[] getAllBlockIdentifiers() {
+        KList<Identifier> names = new KList<>();
+        activeProviders.forEach(p -> names.add(p.getBlockTypes()));
+        return names.toArray(new Identifier[0]);
+    }
+
+    public Identifier[] getAllItemIdentifiers() {
+        KList<Identifier> names = new KList<>();
+        activeProviders.forEach(p -> names.add(p.getItemTypes()));
+        return names.toArray(new Identifier[0]);
+    }
+}
--- a/core/src/main/java/com/volmit/iris/core/service/IrisEngineSVC.java
+++ b/core/src/main/java/com/volmit/iris/core/service/IrisEngineSVC.java
@@ -1,35 +1,76 @@
 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.ArrayList;
-import java.util.List;
+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 final ReentrantLock lastUseLock = new ReentrantLock();
-    private final KMap<World, Long> lastUse = new KMap<>();
+    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) {
@@ -37,15 +78,70 @@ public class IrisEngineSVC implements IrisService {
            t = t - 200;
        }
        this.setup();
+        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();
    }

+    public void EngineReport() {
+        Iris.info(C.RED + "CRITICAL ENGINE FAILURE! The Tectonic Trim subsystem has not responded for: " + Form.duration(trimAlive.getMillis()) + ".");
+    }
+
+    @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
@@ -57,7 +153,7 @@ public class IrisEngineSVC implements IrisService {
                        Long last = lastUse.get(key);
                        if (last == null)
                            continue;
-                        if (now - last > 60000) { // 1 minute
+                        if (now - last > 60000) {
                            lastUse.remove(key);
                        }
                    }
@@ -67,11 +163,55 @@ public class IrisEngineSVC implements IrisService {
                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.IRIS + "TrimTicker found dead! Booting it up!");
+                            try {
+                                trimTicker.start();
+                            } catch (Exception e) {
+                                Iris.error("What happened?");
+                                e.printStackTrace();
+                            }
+                        }
+
+                        if (!unloadTicker.isAlive()) {
+                            Iris.info(C.IRIS + "UnloadTicker found dead! Booting it up!");
+                            try {
+                                unloadTicker.start();
+                            } catch (Exception e) {
+                                Iris.error("What happened?");
+                                e.printStackTrace();
+                            }
+                        }
+                    }
+
+                } catch (Exception e) {
+                    return -1;
+                }
+                return 1000;
+            }
+        };
+
        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) {
@@ -79,7 +219,9 @@ public class IrisEngineSVC implements IrisService {
                    }
                } catch (Throwable e) {
                    Iris.reportError(e);
-                 //   return -1;
+                    Iris.info(C.RED + "EngineSVC: Failed to trim. Please contact support!");
+                    e.printStackTrace();
+                    return -1;
                }

                int size = lastUse.size();
@@ -96,6 +238,7 @@ public class IrisEngineSVC implements IrisService {
            @Override
            protected long loop() {
                long start = System.currentTimeMillis();
+                unloadAlive.reset();
                try {
                    Engine engine = supplier.get();
                    if (engine != null) {
@@ -107,6 +250,8 @@ public class IrisEngineSVC implements IrisService {
                    }
                } catch (Throwable e) {
                    Iris.reportError(e);
+                    Iris.info(C.RED + "EngineSVC: Failed to unload.");
+                    e.printStackTrace();
                    return -1;
                }

@@ -136,7 +281,7 @@ public class IrisEngineSVC implements IrisService {

                    if (generator != null) {
                        Engine engine = generator.getEngine();
-                        if (engine != null) {
+                        if (engine != null && !engine.isStudio()) {
                            lastUseLock.lock();
                            lastUse.put(world, System.currentTimeMillis());
                            lastUseLock.unlock();
@@ -145,6 +290,8 @@ public class IrisEngineSVC implements IrisService {
                    }
                }
            } catch (Throwable e) {
+                Iris.info(C.RED + "EngineSVC: Failed to create supplier.");
+                e.printStackTrace();
                Iris.reportError(e);
            }
            return null;
--- a/core/src/main/java/com/volmit/iris/core/service/WorldLoadSFG.java
+++ b/core/src/main/java/com/volmit/iris/core/service/WorldLoadSFG.java
@@ -1,31 +0,0 @@
-package com.volmit.iris.core.service;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.plugin.IrisService;
-import org.bukkit.World;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.world.WorldLoadEvent;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import static java.lang.System.getLogger;
-
-public class WorldLoadSFG implements IrisService {
-    private JavaPlugin plugin;
-    @EventHandler
-    public void onWorldLoad(WorldLoadEvent event) {
-        World world = event.getWorld();
-
-    }
-
-    @Override
-    public void onEnable() {
-        this.plugin = Iris.instance;
-        plugin.getServer().getPluginManager().registerEvents(this, plugin);
-    }
-
-    @Override
-    public void onDisable() {
-
-    }
-}
--- a/core/src/main/java/com/volmit/iris/core/tools/IrisConverter.java
+++ b/core/src/main/java/com/volmit/iris/core/tools/IrisConverter.java
@@ -0,0 +1,395 @@
+package com.volmit.iris.core.tools;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.nbt.io.NBTUtil;
+import com.volmit.iris.util.nbt.io.NamedTag;
+import com.volmit.iris.util.nbt.tag.*;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.reflect.V;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+import org.bukkit.Bukkit;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class IrisConverter {
+    public static void convertSchematics(VolmitSender sender) {
+        File folder = Iris.instance.getDataFolder("convert");
+
+        FilenameFilter filter = (dir, name) -> name.endsWith(".schem");
+        File[] fileList = folder.listFiles(filter);
+        ExecutorService executorService = Executors.newFixedThreadPool(1);
+        executorService.submit(() -> {
+        for (File schem : fileList) {
+            try {
+                    PrecisionStopwatch p = new PrecisionStopwatch();
+                    boolean largeObject = false;
+                    NamedTag tag = null;
+                    try {
+                        tag = NBTUtil.read(schem);
+                    } catch (IOException e) {
+                        Iris.info(C.RED + "Failed to read: " + schem.getName());
+                        throw new RuntimeException(e);
+                    }
+                    CompoundTag compound = (CompoundTag) tag.getTag();
+
+                if (compound.containsKey("Palette") && compound.containsKey("Width") && compound.containsKey("Height") && compound.containsKey("Length")) {
+                    int objW = ((ShortTag) compound.get("Width")).getValue();
+                    int objH = ((ShortTag) compound.get("Height")).getValue();
+                    int objD = ((ShortTag) compound.get("Length")).getValue();
+                    int mv = objW * objH * objD;
+                    AtomicInteger v = new AtomicInteger(0);
+                    AtomicInteger fv = new AtomicInteger(0);
+                    if (mv > 500_000) {
+                        largeObject = true;
+                        Iris.info(C.GRAY + "Converting.. "+ schem.getName() + " -> " + schem.getName().replace(".schem", ".iob"));
+                        Iris.info(C.GRAY + "- It may take a while");
+                        if (sender.isPlayer()) {
+                            J.a(() -> {
+//                                while (v.get() != mv) {
+//                                    double pr = ((double) v.get() / (double ) mv);
+//                                    sender.sendProgress(pr, "Converting");
+//                                    J.sleep(16);
+//                                }
+                            });
+                        }
+                    }
+
+                    CompoundTag paletteTag = (CompoundTag) compound.get("Palette");
+                    Map<Integer, BlockData> blockmap = new HashMap<>(paletteTag.size(), 0.9f);
+                    for (Map.Entry<String, Tag<?>> entry : paletteTag.getValue().entrySet()) {
+                        String blockName = entry.getKey();
+                        BlockData bd = Bukkit.createBlockData(blockName);
+                        Tag<?> blockTag = entry.getValue();
+                        int blockId = ((IntTag) blockTag).getValue();
+                        blockmap.put(blockId, bd);
+                    }
+
+                    ByteArrayTag byteArray = (ByteArrayTag) compound.get("BlockData");
+                    byte[] originalBlockArray = byteArray.getValue();
+                    int b = 0;
+                    int a = 0;
+                    Map<Integer, Byte> y = new HashMap<>();
+                    Map<Integer, Byte> x = new HashMap<>();
+                    Map<Integer, Byte> z = new HashMap<>();
+
+                    // Height adjustments
+                    for (int h = 0; h < objH; h++) {
+                        if (b == 0) {
+                            y.put(h, (byte) 0);
+                        }
+                        if (b > 0) {
+                            y.put(h, (byte) 1);
+                        }
+                        a = 0;
+                        b = 0;
+                        for (int d = 0; d < objD; d++) {
+                            for (int w = 0; w < objW; w++) {
+                                BlockData db = blockmap.get((int) originalBlockArray[fv.get()]);
+                                if(db.getAsString().contains("minecraft:air")) {
+                                    a++;
+                                } else {
+                                    b++;
+                                }
+                                fv.getAndAdd(1);
+                            }
+                        }
+                    }
+                    fv.set(0);
+
+                    // Width adjustments
+                    for (int w = 0; w < objW; w++) {
+                        if (b == 0) {
+                            x.put(w, (byte) 0);
+                        }
+                        if (b > 0) {
+                            x.put(w, (byte) 1);
+                        }
+                        a = 0;
+                        b = 0;
+                        for (int h = 0; h < objH; h++) {
+                            for (int d = 0; d < objD; d++) {
+                                BlockData db = blockmap.get((int) originalBlockArray[fv.get()]);
+                                if(db.getAsString().contains("minecraft:air")) {
+                                    a++;
+                                } else {
+                                    b++;
+                                }
+                                fv.getAndAdd(1);
+                            }
+                        }
+                    }
+                    fv.set(0);
+
+                    // Depth adjustments
+                    for (int d = 0; d < objD; d++) {
+                        if (b == 0) {
+                            z.put(d, (byte) 0);
+                        }
+                        if (b > 0) {
+                            z.put(d, (byte) 1);
+                        }
+                        a = 0;
+                        b = 0;
+                        for (int h = 0; h < objH; h++) {
+                            for (int w = 0; w < objW; w++) {
+                                BlockData db = blockmap.get((int) originalBlockArray[fv.get()]);
+                                if(db.getAsString().contains("minecraft:air")) {
+                                    a++;
+                                } else {
+                                    b++;
+                                }
+                                fv.getAndAdd(1);
+                            }
+                        }
+                    }
+                    fv.set(0);
+                    int CorrectObjH = getCorrectY(y, objH);
+                    int CorrectObjW = getCorrectX(x, objW);
+                    int CorrectObjD = getCorrectZ(z, objD);
+
+                    //IrisObject object = new IrisObject(CorrectObjW, CorrectObjH, CorrectObjH);
+                    IrisObject object = new IrisObject(objW, objH, objD);
+                    Vector originalVector = new Vector(objW,objH,objD);
+
+
+                    int[] yc = null;
+                    int[] xc = null;
+                    int[] zc = null;
+
+
+                    int fo = 0;
+                    int so = 0;
+                    int o = 0;
+                    int c = 0;
+                    for (Integer i : y.keySet()) {
+                        if (y.get(i) == 0) {
+                            o++;
+                        }
+                        if (y.get(i) == 1) {
+                            c++;
+                            if (c == 1) {
+                                fo = o;
+                            }
+                            o = 0;
+                        }
+                    }
+                    so = o;
+                    yc = new int[]{fo, so};
+
+                    fo = 0;
+                    so = 0;
+                    o = 0;
+                    c = 0;
+                    for (Integer i : x.keySet()) {
+                        if (x.get(i) == 0) {
+                            o++;
+                        }
+                        if (x.get(i) == 1) {
+                            c++;
+                            if (c == 1) {
+                                fo = o;
+                            }
+                            o = 0;
+                        }
+                    }
+                    so = o;
+                    xc = new int[]{fo, so};
+
+                    fo = 0;
+                    so = 0;
+                    o = 0;
+                    c = 0;
+                    for (Integer i : z.keySet()) {
+                        if (z.get(i) == 0) {
+                            o++;
+                        }
+                        if (z.get(i) == 1) {
+                            c++;
+                            if (c == 1) {
+                                fo = o;
+                            }
+                            o = 0;
+                        }
+                    }
+                    so = o;
+                    zc = new int[]{fo, so};
+
+                    int h1, h2, w1, w2, v1 = 0, volume = objW * objH * objD;
+                    Map<Integer, Integer> blockLocationMap = new LinkedHashMap<>();
+                    boolean hasAir = false;
+                    int pos = 0;
+                    for (int i : originalBlockArray) {
+                        blockLocationMap.put(pos, i);
+                        pos++;
+                    }
+
+
+
+                    for (int h = 0; h < objH; h++) {
+                        for (int d = 0; d < objD; d++) {
+                            for (int w = 0; w < objW; w++) {
+                                BlockData bd = blockmap.get((int) originalBlockArray[v.get()]);
+                                if (!bd.getMaterial().isAir()) {
+                                    object.setUnsigned(w, h, d, bd);
+                                }
+                                v.getAndAdd(1);
+                            }
+                        }
+                    }
+
+
+                    try {
+                        object.write(new File(folder, schem.getName().replace(".schem", ".iob")));
+                    } catch (IOException e) {
+                        Iris.info(C.RED + "Failed to save: " + schem.getName());
+                        throw new RuntimeException(e);
+                    }
+                    if (sender.isPlayer()) {
+                        if (largeObject) {
+                            sender.sendMessage(C.IRIS + "Converted "+ schem.getName() + " -> " + schem.getName().replace(".schem", ".iob") + " in " + Form.duration(p.getMillis()));
+                        } else {
+                            sender.sendMessage(C.IRIS + "Converted " + schem.getName() + " -> " + schem.getName().replace(".schem", ".iob"));
+                        }
+                    }
+                    if (largeObject) {
+                        Iris.info(C.GRAY + "Converted "+ schem.getName() + " -> " + schem.getName().replace(".schem", ".iob") + " in " + Form.duration(p.getMillis()));
+                    } else {
+                        Iris.info(C.GRAY + "Converted " + schem.getName() + " -> " + schem.getName().replace(".schem", ".iob"));
+                    }
+                  //  schem.delete();
+                }
+            } catch (Exception e) {
+                Iris.info(C.RED + "Failed to convert: " + schem.getName());
+                if (sender.isPlayer()) {
+                    sender.sendMessage(C.RED + "Failed to convert: " + schem.getName());
+                }
+                e.printStackTrace();
+                Iris.reportError(e);
+            }
+        }
+        });
+    }
+
+    public static boolean isNewPointFurther(int[] originalPoint, int[] oldPoint, int[] newPoint) {
+        int oX = oldPoint[1];
+        int oY = oldPoint[2];
+        int oZ = oldPoint[3];
+
+        int nX = newPoint[1];
+        int nY = newPoint[2];
+        int nZ = newPoint[3];
+
+        int orX = originalPoint[1];
+        int orY = originalPoint[2];
+        int orZ = originalPoint[3];
+
+        double oldDistance = Math.sqrt(Math.pow(oX - orX, 2) + Math.pow(oY - orY, 2) + Math.pow(oZ - orZ, 2));
+        double newDistance = Math.sqrt(Math.pow(nX - orX, 2) + Math.pow(nY - orY, 2) + Math.pow(nZ - orZ, 2));
+
+        if (newDistance > oldDistance) {
+            return true;
+        }
+        return false;
+    }
+
+    public static int[] getCoordinates(int pos, int obX, int obY, int obZ) {
+        int z = 0;
+        int[] coords = new int[4];
+        for (int h = 0; h < obY; h++) {
+            for (int d = 0; d < obZ; d++) {
+                for (int w = 0; w < obX; w++) {
+                    if (z == pos) {
+                        coords[1] = w;
+                        coords[2] = h;
+                        coords[3] = d;
+                        return coords;
+                    }
+                    z++;
+                }
+            }
+        }
+        return null;
+    }
+
+    public static int getCorrectY(Map<Integer, Byte> y, int H) {
+        int fo = 0;
+        int so = 0;
+        int o = 0;
+        int c = 0;
+        for (Integer i : y.keySet()) {
+            if (y.get(i) == 0) {
+                o++;
+            }
+            if (y.get(i) == 1) {
+                c++;
+                if(c == 1){
+                    fo = o;
+                }
+                o = 0;
+            }
+        }
+        so = o;
+        return H = H - (fo + so);
+    }
+
+    public static int getCorrectX(Map<Integer, Byte> x, int W) {
+        int fo = 0;
+        int so = 0;
+        int o = 0;
+        int c = 0;
+        for (Integer i : x.keySet()) {
+            if (x.get(i) == 0) {
+                o++;
+            }
+            if (x.get(i) == 1) {
+                c++;
+                if(c == 1){
+                    fo = o;
+                }
+                o = 0;
+            }
+        }
+        so = o;
+        return W = W - (fo + so);
+    }
+
+    public static int getCorrectZ(Map<Integer, Byte> z, int D) {
+        int fo = 0;
+        int so = 0;
+        int o = 0;
+        int c = 0;
+        for (Integer i : z.keySet()) {
+            if (z.get(i) == 0) {
+                o++;
+            }
+            if (z.get(i) == 1) {
+                c++;
+                if(c == 1){
+                    fo = o;
+                }
+                o = 0;
+            }
+        }
+        so = o;
+        return D = D - (fo + so);
+    }
+}
+
+
+
--- a/core/src/main/java/com/volmit/iris/core/tools/IrisCreator.java
+++ b/core/src/main/java/com/volmit/iris/core/tools/IrisCreator.java
@@ -46,10 +46,6 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmark;
 import static com.volmit.iris.core.safeguard.IrisSafeguard.unstablemode;

 /**
@@ -86,6 +82,10 @@ public class IrisCreator {
     * the world itself. Studio worlds are deleted when they are unloaded.
     */
    private boolean studio = false;
+    /**
+     * Benchmark mode
+     */
+    private boolean benchmark = false;

    public static boolean removeFromBukkitYml(String name) throws IOException {
        YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
@@ -110,7 +110,7 @@ public class IrisCreator {
     * @return the IrisAccess
     * @throws IrisException shit happens
     */
-    IrisPackBenchmarking PackBench = new IrisPackBenchmarking();
+
    public World create() throws IrisException {
        if (unstablemode){
            Iris.info(C.RED + "Your server is experiencing an incompatibility with the Iris plugin. Please rectify this problem to avoid further complications.");
@@ -193,7 +193,7 @@ public class IrisCreator {

        done.set(true);

-        if (sender.isPlayer()) {
+        if (sender.isPlayer() && !benchmark) {
            J.s(() -> {
                sender.player().teleport(new Location(world.get(), 0, world.get().getHighestBlockYAt(0, 0), 0));
            });
--- a/core/src/main/java/com/volmit/iris/core/tools/IrisPackBenchmarking.java
+++ b/core/src/main/java/com/volmit/iris/core/tools/IrisPackBenchmarking.java
@@ -2,169 +2,200 @@ package com.volmit.iris.core.tools;


 import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.IrisPregenerator;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
 import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.exceptions.IrisException;
-import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.math.Position2;

 import com.volmit.iris.util.scheduling.J;
-import org.apache.commons.io.FileUtils;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import lombok.Getter;
 import org.bukkit.Bukkit;

 import java.io.File;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-
-import static com.volmit.iris.core.commands.CommandIris.BenchDimension;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.nio.file.FileVisitResult;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.SimpleFileVisitor;
+import java.nio.file.attribute.BasicFileAttributes;
+import java.time.Clock;
+import java.time.LocalDateTime;
+import java.util.Collections;
+import java.util.concurrent.*;


 public class IrisPackBenchmarking {
-    public static boolean loaded = false;
-    public static boolean benchmark = false;
-    static boolean cancelled = false;
-    static boolean pregenInProgress = false;
-    static long startTime;
-    static long totalChunks;
-    static long generatedChunks;
-    static double elapsedTimeNs;
+    @Getter
+    public static IrisPackBenchmarking instance;
+     public static boolean benchmarkInProgress = false;
+     private IrisDimension IrisDimension;
+     private int radius;
+     private boolean finished = false;
+    PrecisionStopwatch stopwatch;

-    public static void runBenchmark() {
-        // IrisPackBenchmarking IrisPackBenchmarking = new IrisPackBenchmarking();
-        benchmark = true;
-        Iris.info(C.BLUE + "Benchmarking Dimension: " + C.AQUA + BenchDimension);
-        //progress();
-        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
-            Iris.info(C.GOLD + "Setting everything up..");
-            try {
-                String BenchmarkFolder = "\\Benchmark";
-                File folder = new File(BenchmarkFolder);
-                if (folder.exists() && folder.isDirectory()) {
-                    FileUtils.deleteDirectory(folder);
-                    Iris.debug("Deleted old Benchmark");
-                } else {
-                    Iris.info(C.GOLD + "Old Benchmark not found!");
-                    if(folder.exists()){
-                        Iris.info(C.RED + "FAILED To remove old Benchmark!");
-                        //cancelled = true;
+    public IrisPackBenchmarking(IrisDimension dimension, int r) {
+        instance = this;
+        this.IrisDimension = dimension;
+        this.radius = r;
+        runBenchmark();
+    }

-                    }
+    private void runBenchmark() {
+        this.stopwatch = new PrecisionStopwatch();
+        ExecutorService service = Executors.newSingleThreadExecutor();
+        service.submit(() -> {
+            Iris.info("Setting up benchmark environment ");
+            benchmarkInProgress = true;
+            File file = new File("benchmark");
+            if (file.exists()) {
+                deleteDirectory(file.toPath());
+            }
+            createBenchmark();
+            while (!IrisToolbelt.isIrisWorld(Bukkit.getWorld("benchmark"))) {
+                J.sleep(1000);
+                Iris.debug("Iris PackBenchmark: Waiting...");
+            }
+            Iris.info("Starting Benchmark!");
+            stopwatch.begin();
+            startBenchmark();
+        });
+
+    }
+
+    public boolean getBenchmarkInProgress() {
+        return benchmarkInProgress;
+    }
+
+    public void finishedBenchmark(KList<Integer> cps) {
+        try {
+            String time = Form.duration(stopwatch.getMillis());
+            Engine engine = IrisToolbelt.access(Bukkit.getWorld("benchmark")).getEngine();
+            Iris.info("-----------------");
+            Iris.info("Results:");
+            Iris.info("- Total time: " + time);
+            Iris.info("- Average CPS: " + calculateAverage(cps));
+            Iris.info("  - Median CPS: " + calculateMedian(cps));
+            Iris.info("  - Highest CPS: " + findHighest(cps));
+            Iris.info("  - Lowest CPS: " + findLowest(cps));
+            Iris.info("-----------------");
+            Iris.info("Creating a report..");
+            File profilers = new File("plugins" + File.separator + "Iris" + File.separator + "packbenchmarks");
+            profilers.mkdir();
+
+            File results = new File("plugins " + File.separator + "Iris", IrisDimension.getName() + LocalDateTime.now(Clock.systemDefaultZone()) + ".txt");
+            results.createNewFile();
+            KMap<String, Double> metrics = engine.getMetrics().pull();
+            try (FileWriter writer = new FileWriter(results)) {
+                writer.write("-----------------\n");
+                writer.write("Results:\n");
+                writer.write("Dimension: " + IrisDimension.getName() + "\n");
+                writer.write("- Date of Benchmark: " +  LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
+                writer.write("\n");
+                writer.write("Metrics");
+                for (String m : metrics.k()) {
+                    double i = metrics.get(m);
+                    writer.write("- " + m + ": " + i);
                }
-            } catch (Exception e) {
-                throw new RuntimeException();
+                writer.write("- " + metrics);
+                writer.write("Benchmark: " +  LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
+                writer.write("- Total time: " + time + "\n");
+                writer.write("- Average CPS: " + calculateAverage(cps) + "\n");
+                writer.write("  - Median CPS: " + calculateMedian(cps) + "\n");
+                writer.write("  - Highest CPS: " + findHighest(cps) + "\n");
+                writer.write("  - Lowest CPS: " + findLowest(cps) + "\n");
+                writer.write("-----------------\n");
+                Iris.info("Finished generating a report!");
+            } catch (IOException e) {
+                Iris.error("An error occurred writing to the file.");
+                e.printStackTrace();
            }

-        }).thenRun(() -> {
-            Iris.info(C.GOLD + "Creating Benchmark Environment");
-            createBenchmark();
-
-        }).thenRun(() -> {
-            Iris.info( C.BLUE + "Benchmark Started!");
-            boolean done = false;
-            startBenchmarkTimer();
-            startBenchmark();
-            basicScheduler();
-        }).thenRun(() -> {
-
-        });
-       // cancelled = future.cancel(true);
-        try {
-            future.get();
-        } catch (InterruptedException | ExecutionException e) {
+            Bukkit.getServer().unloadWorld("benchmark", true);
+            stopwatch.end();
+        } catch (Exception e) {
+            Iris.error("Something has gone wrong!");
            e.printStackTrace();
        }
    }
-
-    private static void results(){
-        double averageCps = calculateAverageCPS();
-        Iris.info("Benchmark Dimension: " + BenchDimension);
-        Iris.info("Speeds");
-        Iris.info("- Average CPS: " + roundToTwoDecimalPlaces(averageCps));
-        Iris.info("Duration: " +  roundToTwoDecimalPlaces(elapsedTimeNs));
-
-    }
-    private static void basicScheduler() {
-        while (true) {
-            totalChunks = IrisPregenerator.getLongTotalChunks();
-            generatedChunks = IrisPregenerator.getLongGeneratedChunks();
-            if(totalChunks > 0) {
-                if (generatedChunks >= totalChunks) {
-                    Iris.info("Benchmark Completed!");
-                    elapsedTimeNs = stopBenchmarkTimer();
-                    results();
-                    break;
-                }
-            }
-            //J.sleep(100); test
-        }
-    }
-     static void createBenchmark(){
+     private void createBenchmark(){
        try {
            IrisToolbelt.createWorld()
-                    .dimension(BenchDimension)
-                    .name("Benchmark")
+                    .dimension(IrisDimension.getName())
+                    .name("benchmark")
                    .seed(1337)
                    .studio(false)
+                    .benchmark(true)
                    .create();
        } catch (IrisException e) {
            throw new RuntimeException(e);
        }
    }
-     static void startBenchmark(){
+
+     private void startBenchmark(){
        int x = 0;
        int z = 0;
            IrisToolbelt.pregenerate(PregenTask
                    .builder()
+                    .gui(false)
                    .center(new Position2(x, z))
                    .width(5)
                    .height(5)
-                    .build(), Bukkit.getWorld("Benchmark")
+                    .build(), Bukkit.getWorld("benchmark")
            );
    }
-    static void startLazyBenchmark(){
-        int x = 0;
-        int z = 0;
-        LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
-                //.world("Benchmark")
-                .healingPosition(0)
-                .healing(false)
-                .chunksPerMinute(3200)
-                .radiusBlocks(5000)
-                .position(0)
-                .build();

-        LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, new File("plugins/Iris/lazygen.json"));
-        pregenerator.start();
-    }
-    public static double calculateAverageCPS() {
-        double elapsedTimeSec = elapsedTimeNs / 1_000_000_000.0;  // Convert to seconds
-        return generatedChunks / elapsedTimeSec;
-    }
-
-    private static void startBenchmarkTimer() {
-        startTime = System.nanoTime();
-    }
-
-    private static double stopBenchmarkTimer() {
-        long endTime = System.nanoTime();
-        return (endTime - startTime) / 1_000_000_000.0;
-    }
-
-    public static void deleteDirectory(File dir) {
-        File[] files = dir.listFiles();
-        if(files != null) {
-            for(File file: files) {
-                if(file.isDirectory()) {
-                    deleteDirectory(file);
-                } else {
-                    file.delete();
-                }
-            }
+    private double calculateAverage(KList<Integer> list) {
+        double sum = 0;
+        for (int num : list) {
+            sum += num;
        }
-        dir.delete();
+        return sum / list.size();
    }
-    private static double roundToTwoDecimalPlaces(double value) {
-        return Double.parseDouble(String.format("%.2f", value));
+
+    private double calculateMedian(KList<Integer> list) {
+        Collections.sort(list);
+        int middle = list.size() / 2;
+
+        if (list.size() % 2 == 1) {
+            return list.get(middle);
+        } else {
+            return (list.get(middle - 1) + list.get(middle)) / 2.0;
+        }
+    }
+
+    private int findLowest(KList<Integer> list) {
+        return Collections.min(list);
+    }
+
+    private int findHighest(KList<Integer> list) {
+        return Collections.max(list);
+    }
+
+    private boolean deleteDirectory(Path dir) {
+        try {
+            Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
+                @Override
+                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
+                    Files.delete(file);
+                    return FileVisitResult.CONTINUE;
+                }
+
+                @Override
+                public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
+                    Files.delete(dir);
+                    return FileVisitResult.CONTINUE;
+                }
+            });
+            return true;
+        } catch (IOException e) {
+            e.printStackTrace();
+            return false;
+        }
    }
 }
--- a/core/src/main/java/com/volmit/iris/engine/IrisEngineMantle.java
+++ b/core/src/main/java/com/volmit/iris/engine/IrisEngineMantle.java
@@ -19,8 +19,6 @@
 package com.volmit.iris.engine;

 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.mantle.EngineMantle;
@@ -47,9 +45,6 @@ import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;

-import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmark;
-import static com.volmit.iris.core.safeguard.PerformanceSFG.*;
-
@Data
@EqualsAndHashCode(exclude = "engine")
@ToString(exclude = "engine")
@@ -290,17 +285,10 @@ public class IrisEngineMantle implements EngineMantle {
        x = Math.max(x, c);
        x = (Math.max(x, 16) + 16) >> 4;
        x = x % 2 == 0 ? x + 1 : x;
-        if (benchmark){
-            x = 4;
-            Iris.info("Mantle Size: " + x + " Chunks " + C.BLUE + "BENCHMARK MODE");
-        } else {
-            Iris.info("Mantle Size: " + x + " Chunks");
-            Iris.info("  Object Mantle Size: " + u + " (" + ((Math.max(u, 16) + 16) >> 4) + ")");
-            Iris.info("  Jigsaw Mantle Size: " + jig + " (" + ((Math.max(jig, 16) + 16) >> 4) + ")");
-            Iris.info("  Carving Mantle Size: " + c + " (" + ((Math.max(c, 16) + 16) >> 4) + ")");
-        }
-
-
+        Iris.info("Mantle Size: " + x + " Chunks");
+        Iris.info("  Object Mantle Size: " + u + " (" + ((Math.max(u, 16) + 16) >> 4) + ")");
+        Iris.info("  Jigsaw Mantle Size: " + jig + " (" + ((Math.max(jig, 16) + 16) >> 4) + ")");
+        Iris.info("  Carving Mantle Size: " + c + " (" + ((Math.max(c, 16) + 16) >> 4) + ")");
        return x;
    }

--- a/core/src/main/java/com/volmit/iris/engine/data/chunk/LinkedTerrainChunk.java
+++ b/core/src/main/java/com/volmit/iris/engine/data/chunk/LinkedTerrainChunk.java
@@ -21,6 +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.IrisBlockData;
 import lombok.Setter;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -120,6 +121,8 @@ public class LinkedTerrainChunk implements TerrainChunk {

    @Override
    public synchronized void setBlock(int x, int y, int z, BlockData blockData) {
+        if (blockData instanceof IrisBlockData d)
+            blockData = d.getBase();
        rawChunkData.setBlock(x, y, z, blockData);
    }

--- a/core/src/main/java/com/volmit/iris/engine/data/chunk/MCATerrainChunk.java
+++ b/core/src/main/java/com/volmit/iris/engine/data/chunk/MCATerrainChunk.java
@@ -20,6 +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.IrisBlockData;
 import com.volmit.iris.util.nbt.mca.Chunk;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import lombok.AllArgsConstructor;
@@ -88,6 +89,8 @@ public class MCATerrainChunk implements TerrainChunk {
        if (blockData == null) {
            Iris.error("NULL BD");
        }
+        if (blockData instanceof IrisBlockData data)
+            blockData = data.getBase();

        mcaChunk.setBlockStateAt(xx, y, zz, NBTWorld.getCompound(blockData), false);
    }
--- a/core/src/main/java/com/volmit/iris/engine/framework/Engine.java
+++ b/core/src/main/java/com/volmit/iris/engine/framework/Engine.java
@@ -22,10 +22,12 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.components.RenderType;
 import com.volmit.iris.core.gui.components.Renderer;
+import com.volmit.iris.core.link.Identifier;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.core.service.ExternalDataSVC;
 import com.volmit.iris.engine.IrisComplex;
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.data.chunk.TerrainChunk;
@@ -38,6 +40,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.IrisBlockData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.format.C;
@@ -254,6 +257,11 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
        if (B.isUpdatable(data)) {
            getMantle().updateBlock(x, y, z);
        }
+        if (data instanceof IrisBlockData d) {
+            getMantle().getMantle().set(x, y, z, d.getCustom());
+        } else {
+            getMantle().getMantle().remove(x, y, z, Identifier.class);
+        }
    }

    void blockUpdatedMetric();
@@ -277,6 +285,11 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
                        Iris.warn("Failed to set tile entity data at [%d %d %d | %s] for tile %s!", x, betterY, z, c.getBlock(x, betterY, z).getBlockData().getMaterial().getKey(), tile.getData().getTileId());
                });
            }));
+            getMantle().getMantle().raiseFlag(c.getX(), c.getZ(), MantleFlag.CUSTOM, () -> J.s(() -> {
+                getMantle().getMantle().iterateChunk(c.getX(), c.getZ(), Identifier.class, (x, y, z, v) -> {
+                    Iris.service(ExternalDataSVC.class).processUpdate(this, c.getBlock(x & 15, y + getWorld().minHeight(), z & 15), v);
+                });
+            }));

            getMantle().getMantle().raiseFlag(c.getX(), c.getZ(), MantleFlag.UPDATE, () -> J.s(() -> {
                PrecisionStopwatch p = PrecisionStopwatch.start();
--- a/core/src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java
+++ b/core/src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java
@@ -28,7 +28,6 @@ import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.matter.slices.JigsawPieceMatter;
 import com.volmit.iris.util.matter.slices.container.JigsawPieceContainer;
 import lombok.Data;
 import org.bukkit.Axis;
@@ -75,7 +74,7 @@ public class PlannedStructure {
        }
    }

-    public void place(MantleWriter placer, Mantle e, Engine eng) {
+    public void place(IObjectPlacer placer, Mantle e, Engine eng) {
        IrisObjectPlacement options = new IrisObjectPlacement();
        options.getRotation().setEnabled(false);
        int startHeight = pieces.get(0).getPosition().getY();
@@ -85,7 +84,7 @@ public class PlannedStructure {
        }
    }

-    public void place(PlannedPiece i, int startHeight, IrisObjectPlacement o, MantleWriter placer, Mantle e, Engine eng) {
+    public void place(PlannedPiece i, int startHeight, IrisObjectPlacement o, IObjectPlacer placer, Mantle e, Engine eng) {
        IrisObjectPlacement options = o;

        if (i.getPiece().getPlacementOptions() != null) {
@@ -123,69 +122,10 @@ public class PlannedStructure {

        int id = rng.i(0, Integer.MAX_VALUE);
        JigsawPieceContainer container = JigsawPieceContainer.toContainer(i.getPiece());
-        vo.place(xx, height, zz, new IObjectPlacer() {
-            @Override
-            public int getHighest(int x, int z, IrisData data) {
-                return placer.getHighest(x, z, data);
-            }
-
-            @Override
-            public int getHighest(int x, int z, IrisData data, boolean ignoreFluid) {
-                return placer.getHighest(x, z, data, ignoreFluid);
-            }
-
-            @Override
-            public void set(int x, int y, int z, BlockData d) {
-                placer.setData(x, y, z, container);
-                placer.set(x, y, z, d);
-            }
-
-            @Override
-            public BlockData get(int x, int y, int z) {
-                placer.setData(x, y, z, container);
-                return placer.get(x, y, z);
-            }
-
-            @Override
-            public boolean isPreventingDecay() {
-                return placer.isPreventingDecay();
-            }
-
-            @Override
-            public boolean isCarved(int x, int y, int z) {
-                return placer.isCarved(x, y, z);
-            }
-
-            @Override
-            public boolean isSolid(int x, int y, int z) {
-                return placer.isSolid(x, y, z);
-            }
-
-            @Override
-            public boolean isUnderwater(int x, int z) {
-                return placer.isUnderwater(x, z);
-            }
-
-            @Override
-            public int getFluidHeight() {
-                return placer.getFluidHeight();
-            }
-
-            @Override
-            public boolean isDebugSmartBore() {
-                return placer.isDebugSmartBore();
-            }
-
-            @Override
-            public void setTile(int xx, int yy, int zz, TileData<? extends TileState> tile) {
-                placer.setTile(xx, yy, zz, tile);
-            }
-
-            @Override
-            public Engine getEngine() {
-                return placer.getEngine();
-            }
-        }, options, rng, (b, data) -> e.set(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id), null, getData());
+        vo.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);
+        }, null, getData());
    }

    public void place(World world) {
@@ -361,10 +301,6 @@ public class PlannedStructure {

    public boolean collidesWith(PlannedPiece piece, PlannedPiece ignore) {
        for (PlannedPiece i : pieces) {
-            if (i.equals(ignore)) {
-                continue;
-            }
-
            if (i.collidesWith(piece)) {
                return true;
            }
--- a/core/src/main/java/com/volmit/iris/engine/mantle/EngineMantle.java
+++ b/core/src/main/java/com/volmit/iris/engine/mantle/EngineMantle.java
@@ -23,6 +23,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.engine.IrisComplex;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineTarget;
+import com.volmit.iris.engine.framework.SeedManager;
 import com.volmit.iris.engine.mantle.components.MantleJigsawComponent;
 import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
 import com.volmit.iris.engine.object.IObjectPlacer;
@@ -298,7 +299,7 @@ public interface EngineMantle extends IObjectPlacer {
    default long getToUnload(){
        return getMantle().getToUnload().size();
    }
-    default long getNotClearedLoadedRegions(){
+    default long getNotQueuedLoadedRegions(){
        return getMantle().getLoadedRegions().size() - getMantle().getToUnload().size();
    }
    default double getTectonicDuration(){
--- a/core/src/main/java/com/volmit/iris/engine/mantle/components/MantleJigsawComponent.java
+++ b/core/src/main/java/com/volmit/iris/engine/mantle/components/MantleJigsawComponent.java
@@ -23,6 +23,7 @@ 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.*;
+import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
@@ -53,8 +54,6 @@ public class MantleJigsawComponent extends IrisMantleComponent {

    @ChunkCoordinates
    private void generateJigsaw(MantleWriter writer, RNG rng, int x, int z, IrisBiome biome, IrisRegion region) {
-        boolean placed = false;
-
        if (getDimension().getStronghold() != null) {
            List<Position2> poss = getDimension().getStrongholds(seed());

@@ -63,43 +62,30 @@ public class MantleJigsawComponent extends IrisMantleComponent {
                    if (x == pos.getX() >> 4 && z == pos.getZ() >> 4) {
                        IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(getDimension().getStronghold());
                        place(writer, pos.toIris(), structure, rng);
-                        placed = true;
+                        return;
                    }
                }
            }
        }

-        if (!placed) {
-            for (IrisJigsawStructurePlacement i : biome.getJigsawStructures()) {
-                if (rng.nextInt(i.getRarity()) == 0) {
-                    IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
-                    IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
-                    place(writer, position, structure, rng);
-                    placed = true;
-                }
-            }
-        }
+        boolean placed = placeStructures(writer, rng, x, z, biome.getJigsawStructures());
+        if (!placed)
+            placed = placeStructures(writer, rng, x, z, region.getJigsawStructures());
+        if (!placed)
+            placeStructures(writer, rng, x, z, getDimension().getJigsawStructures());
+    }

-        if (!placed) {
-            for (IrisJigsawStructurePlacement i : region.getJigsawStructures()) {
-                if (rng.nextInt(i.getRarity()) == 0) {
-                    IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
-                    IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
-                    place(writer, position, structure, rng);
-                    placed = true;
-                }
-            }
-        }
-
-        if (!placed) {
-            for (IrisJigsawStructurePlacement i : getDimension().getJigsawStructures()) {
-                if (rng.nextInt(i.getRarity()) == 0) {
-                    IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
-                    IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
-                    place(writer, position, structure, rng);
-                }
+    @ChunkCoordinates
+    private boolean placeStructures(MantleWriter writer, RNG rng, int x, int z, KList<IrisJigsawStructurePlacement> structures) {
+        for (IrisJigsawStructurePlacement i : structures) {
+            if (rng.nextInt(i.getRarity()) == 0) {
+                IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
+                IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
+                place(writer, position, structure, rng);
+                return true;
            }
        }
+        return false;
    }

    @ChunkCoordinates
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisBiomeGeneratorLink.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisBiomeGeneratorLink.java
@@ -18,6 +18,7 @@

 package com.volmit.iris.engine.object;

+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.data.DataProvider;
@@ -69,6 +70,17 @@ public class IrisBiomeGeneratorLink {
        double g = getCachedGenerator(xg).getHeight(x, z, seed);
        g = g < 0 ? 0 : g;
        g = g > 1 ? 1 : g;
+//        if (IrisSettings.get().getGenerator().forceConvertTo320Height) {
+//           if (max > 320 || min > 320) {
+//                double scaleFactor = 320.0 / Math.max(max, min);
+//                min *= (int) scaleFactor;
+//                max *= (int) scaleFactor;
+//                if (min < 0) {
+//
+//                }
+//            }
+//        }
+        // todo This

        return IrisInterpolation.lerp(min, max, g);
    }
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisCavePlacer.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisCavePlacer.java
@@ -82,13 +82,17 @@ public class IrisCavePlacer implements IRare {
        }

        if (y == -1) {
-            int h = (int) caveStartHeight.get(rng, x, z, data);
-            int ma = breakSurface ? h : (int) (engine.getComplex().getHeightStream().get(x, z) - 9);
-            y = Math.min(h, ma);
+            if(!breakSurface) {
+                int eH = engine.getHeight(x, z);
+                if (caveStartHeight.getMax() > eH) {
+                    caveStartHeight.setMax(eH);
+                }
+            }
+            y = (int) caveStartHeight.get(rng, x, z, data);
        }

        try {
-            cave.generate(mantle, rng, engine, x + rng.nextInt(15), y, z + rng.nextInt(15), waterHint);
+             cave.generate(mantle, rng, engine, x + rng.nextInt(15), y, z + rng.nextInt(15), waterHint);
        } catch (Throwable e) {
            e.printStackTrace();
            fail.set(true);
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisDimension.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisDimension.java
@@ -22,9 +22,11 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 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.collection.KList;
 import com.volmit.iris.util.data.DataProvider;
+import com.volmit.iris.util.data.Dimension;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.math.Position2;
@@ -40,6 +42,7 @@ import org.bukkit.Material;
 import org.bukkit.World.Environment;
 import org.bukkit.block.data.BlockData;

+import java.io.DataInput;
 import java.io.File;
 import java.io.IOException;

@@ -439,7 +442,7 @@ public class IrisDimension extends IrisRegistrant {
        return landBiomeStyle;
    }

-    public boolean installDataPack(DataProvider data, File datapacks) {
+    public boolean installDataPack(DataProvider data, File datapacks, double ultimateMaxHeight, double ultimateMinHeight) {
        boolean write = false;
        boolean changed = false;

@@ -470,6 +473,8 @@ public class IrisDimension extends IrisRegistrant {

        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(changed, datapacks);
        }

--- a/core/src/main/java/com/volmit/iris/engine/object/IrisEntity.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisEntity.java
@@ -21,6 +21,7 @@ package com.volmit.iris.engine.object;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.loader.IrisRegistrant;
+import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.collection.KList;
@@ -41,6 +42,7 @@ import org.bukkit.*;
 import org.bukkit.attribute.Attributable;
 import org.bukkit.entity.*;
 import org.bukkit.entity.Panda.Gene;
+import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.loot.LootContext;
@@ -67,6 +69,9 @@ public class IrisEntity extends IrisRegistrant {
    @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;

+    @Desc("The SpawnReason to spawn the entity with.")
+    private CreatureSpawnEvent.SpawnReason reason = CreatureSpawnEvent.SpawnReason.NATURAL;
+
    @Desc("The custom name of this entity")
    private String customName = "";

@@ -457,7 +462,7 @@ public class IrisEntity extends IrisRegistrant {
        }


-        return at.getWorld().spawnEntity(at, getType());
+        return INMS.get().spawnEntity(at, getType(), getReason());
    }

    public boolean isCitizens() {
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisEntitySpawn.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisEntitySpawn.java
@@ -19,21 +19,28 @@
 package com.volmit.iris.engine.object;

 import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMS;
 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.format.C;
 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.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)
@@ -165,12 +172,19 @@ public class IrisEntitySpawn implements IRare {
                return null;
            }

-            Entity e = irisEntity.spawn(g, at.add(0.5, 0, 0.5), rng.aquire(() -> new RNG(g.getSeedManager().getEntity())));
+            Vector3d boundingBox = INMS.get().getBoundingbox(irisEntity.getType());
+            if (!ignoreSurfaces && boundingBox != null) {
+                boolean isClearForSpawn = isAreaClearForSpawn(at, boundingBox);
+                if (!isClearForSpawn) {
+                    return null;
+                }
+            }
+
+            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());
            }

-
            return e;
        } catch (Throwable e) {
            Iris.reportError(e);
@@ -179,4 +193,25 @@ public class IrisEntitySpawn implements IRare {
            return null;
        }
    }
+
+    private boolean isAreaClearForSpawn(Location center, Vector3d boundingBox) {
+        World world = center.getWorld();
+        int startX = center.getBlockX() - (int) (boundingBox.x / 2);
+        int endX = center.getBlockX() + (int) (boundingBox.x / 2);
+        int startY = center.getBlockY();
+        int endY = center.getBlockY() + (int) boundingBox.y;
+        int startZ = center.getBlockZ() - (int) (boundingBox.z / 2);
+        int endZ = center.getBlockZ() + (int) (boundingBox.z / 2);
+
+        for (int x = startX; x <= endX; x++) {
+            for (int y = startY; y <= endY; y++) {
+                for (int z = startZ; z <= endZ; z++) {
+                    if (world.getBlockAt(x, y, z).getType() != Material.AIR) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
 }
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisObject.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisObject.java
@@ -23,11 +23,13 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.PlacedObject;
 import com.volmit.iris.engine.framework.placer.HeightmapObjectPlacer;
 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.IrisBlockData;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.interpolation.IrisInterpolation;
 import com.volmit.iris.util.json.JSONObject;
@@ -698,12 +700,15 @@ public class IrisObject extends IrisRegistrant {

        if (!config.getAllowedCollisions().isEmpty() || !config.getForbiddenCollisions().isEmpty()) {
            Engine engine = rdata.getEngine();
-            String key;
            BlockVector offset = new BlockVector(config.getTranslate().getX(), config.getTranslate().getY(), config.getTranslate().getZ());
            for (int i = x - Math.floorDiv(w, 2) + (int) offset.getX(); i <= x + Math.floorDiv(w, 2) - (w % 2 == 0 ? 1 : 0) + (int) offset.getX(); i++) {
                for (int j = y - Math.floorDiv(h, 2)  + (int) offset.getY(); j <= y + Math.floorDiv(h, 2) - (h % 2 == 0 ? 1 : 0) + (int) offset.getY(); j++) {
                    for (int k = z - Math.floorDiv(d, 2) + (int) offset.getZ(); k <= z + Math.floorDiv(d, 2) - (d % 2 == 0 ? 1 : 0) + (int) offset.getX(); k++) {
-                        key = engine.getObjectPlacementKey(i, j, k);
+                        PlacedObject p = engine.getObjectPlacement(i, j, k);
+                        if (p == null) continue;
+                        IrisObject o = p.getObject();
+                        if (o == null) continue;
+                        String key = o.getLoadKey();
                        if (key != null) {
                            if (config.getForbiddenCollisions().contains(key) && !config.getAllowedCollisions().contains(key)) {
                                // Iris.debug("%s collides with %s (%s / %s / %s)", getLoadKey(), key, i, j, k);
@@ -807,7 +812,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())
+                                if (newData.getMaterial() == data.getMaterial() && !(newData instanceof IrisBlockData || data instanceof IrisBlockData))
                                    data = data.merge(newData);
                                else
                                    data = newData;
--- a/core/src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java
+++ b/core/src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java
@@ -1,413 +1,432 @@
-/*
- * 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.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.service.StudioSVC;
-import com.volmit.iris.engine.IrisEngine;
-import com.volmit.iris.engine.data.chunk.TerrainChunk;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.framework.EngineTarget;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisWorld;
-import com.volmit.iris.engine.object.StudioMode;
-import com.volmit.iris.engine.platform.studio.StudioGenerator;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.data.IrisBiomeStorage;
-import com.volmit.iris.util.hunk.Hunk;
-import com.volmit.iris.util.hunk.view.BiomeGridHunkHolder;
-import com.volmit.iris.util.hunk.view.ChunkDataHunkHolder;
-import com.volmit.iris.util.io.ReactiveFolder;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.Looper;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.Setter;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-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.Listener;
-import org.bukkit.event.world.WorldInitEvent;
-import org.bukkit.generator.BiomeProvider;
-import org.bukkit.generator.BlockPopulator;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.generator.WorldInfo;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.lang.reflect.Field;
-import java.util.List;
-import java.util.Random;
-import java.util.concurrent.Semaphore;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Consumer;
-
-@EqualsAndHashCode(callSuper = true)
-@Data
-public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChunkGenerator, Listener {
-    private static final int LOAD_LOCKS = Runtime.getRuntime().availableProcessors() * 4;
-    private final Semaphore loadLock;
-    private final IrisWorld world;
-    private final File dataLocation;
-    private final String dimensionKey;
-    private final ReactiveFolder folder;
-    private final ReentrantLock lock = new ReentrantLock();
-    private final KList<BlockPopulator> populators;
-    private final ChronoLatch hotloadChecker;
-    private final AtomicBoolean setup;
-    private final boolean studio;
-    private final AtomicInteger a = new AtomicInteger(0);
-    private Engine engine;
-    private Looper hotloader;
-    private StudioMode lastMode;
-    private DummyBiomeProvider dummyBiomeProvider;
-    @Setter
-    private StudioGenerator studioGenerator;
-
-    private boolean initialized = false;
-
-    public BukkitChunkGenerator(IrisWorld world, boolean studio, File dataLocation, String dimensionKey) {
-        setup = new AtomicBoolean(false);
-        studioGenerator = null;
-        dummyBiomeProvider = new DummyBiomeProvider();
-        populators = new KList<>();
-        loadLock = new Semaphore(LOAD_LOCKS);
-        this.world = world;
-        this.hotloadChecker = new ChronoLatch(1000, false);
-        this.studio = studio;
-        this.dataLocation = dataLocation;
-        this.dimensionKey = dimensionKey;
-        this.folder = new ReactiveFolder(dataLocation, (_a, _b, _c) -> hotload());
-        Bukkit.getServer().getPluginManager().registerEvents(this, Iris.instance);
-    }
-
-    private static Field getField(Class clazz, String fieldName)
-            throws NoSuchFieldException {
-        try {
-            return clazz.getDeclaredField(fieldName);
-        } catch (NoSuchFieldException e) {
-            Class superClass = clazz.getSuperclass();
-            if (superClass == null) {
-                throw e;
-            } else {
-                return getField(superClass, fieldName);
-            }
-        }
-    }
-
-    @EventHandler
-    public void onWorldInit(WorldInitEvent event) {
-        try {
-            if (!initialized) {
-                world.setRawWorldSeed(event.getWorld().getSeed());
-                if (world.name().equals(event.getWorld().getName())) {
-                    INMS.get().inject(event.getWorld().getSeed(), getEngine(event.getWorld()), event.getWorld());
-                    Iris.info("Injected Iris Biome Source into " + event.getWorld().getName());
-                    initialized = true;
-                }
-            }
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    private void setupEngine() {
-        IrisData data = IrisData.get(dataLocation);
-        IrisDimension dimension = data.getDimensionLoader().load(dimensionKey);
-
-        if (dimension == null) {
-            Iris.error("Oh No! There's no pack in " + data.getDataFolder().getPath() + " or... there's no dimension for the key " + dimensionKey);
-            IrisDimension test = IrisData.loadAnyDimension(dimensionKey);
-
-            if (test != null) {
-                Iris.warn("Looks like " + dimensionKey + " exists in " + test.getLoadFile().getPath() + " ");
-                Iris.service(StudioSVC.class).installIntoWorld(Iris.getSender(), dimensionKey, dataLocation.getParentFile().getParentFile());
-                Iris.warn("Attempted to install into " + data.getDataFolder().getPath());
-                data.dump();
-                data.clearLists();
-                test = data.getDimensionLoader().load(dimensionKey);
-
-                if (test != null) {
-                    Iris.success("Woo! Patched the Engine!");
-                    dimension = test;
-                } else {
-                    Iris.error("Failed to patch dimension!");
-                    throw new RuntimeException("Missing Dimension: " + dimensionKey);
-                }
-            } else {
-                Iris.error("Nope, you don't have an installation containing " + dimensionKey + " try downloading it?");
-                throw new RuntimeException("Missing Dimension: " + dimensionKey);
-            }
-        }
-
-        lastMode = StudioMode.NORMAL;
-        engine = new IrisEngine(new EngineTarget(world, dimension, data), studio);
-        populators.clear();
-    }
-
-    @Override
-    public void injectChunkReplacement(World world, int x, int z, Consumer<Runnable> jobs) {
-        try {
-            loadLock.acquire();
-            IrisBiomeStorage st = new IrisBiomeStorage();
-            TerrainChunk tc = TerrainChunk.createUnsafe(world, st);
-            Hunk<BlockData> blocks = Hunk.view(tc);
-            Hunk<Biome> biomes = Hunk.view(tc, tc.getMinHeight(), tc.getMaxHeight());
-            this.world.bind(world);
-            getEngine().generate(x << 4, z << 4, blocks, biomes, true);
-            Iris.debug("Regenerated " + x + " " + z);
-            int t = 0;
-            for (int i = getEngine().getHeight() >> 4; i >= 0; i--) {
-                if (!world.isChunkLoaded(x, z)) {
-                    continue;
-                }
-
-                Chunk c = world.getChunkAt(x, z);
-                for (Entity ee : c.getEntities()) {
-                    if (ee instanceof Player) {
-                        continue;
-                    }
-
-                    J.s(ee::remove);
-                }
-
-                J.s(() -> engine.getWorldManager().onChunkLoad(c, false));
-
-                int finalI = i;
-                jobs.accept(() -> {
-
-                    for (int xx = 0; xx < 16; xx++) {
-                        for (int yy = 0; yy < 16; yy++) {
-                            for (int zz = 0; zz < 16; zz++) {
-                                if (yy + (finalI << 4) >= engine.getHeight() || yy + (finalI << 4) < 0) {
-                                    continue;
-                                }
-                                c.getBlock(xx, yy + (finalI << 4) + world.getMinHeight(), zz)
-                                        .setBlockData(tc.getBlockData(xx, yy + (finalI << 4) + world.getMinHeight(), zz), false);
-                            }
-                        }
-                    }
-                });
-            }
-
-            loadLock.release();
-        } catch (Throwable e) {
-            loadLock.release();
-            Iris.error("======================================");
-            e.printStackTrace();
-            Iris.reportErrorChunk(x, z, e, "CHUNK");
-            Iris.error("======================================");
-
-            ChunkData d = Bukkit.createChunkData(world);
-
-            for (int i = 0; i < 16; i++) {
-                for (int j = 0; j < 16; j++) {
-                    d.setBlock(i, 0, j, Material.RED_GLAZED_TERRACOTTA.createBlockData());
-                }
-            }
-        }
-    }
-
-    private Engine getEngine(WorldInfo world) {
-        if (setup.get()) {
-            return getEngine();
-        }
-
-        lock.lock();
-
-        if (setup.get()) {
-            return getEngine();
-        }
-
-
-        setup.set(true);
-        getWorld().setRawWorldSeed(world.getSeed());
-        setupEngine();
-        this.hotloader = studio ? new Looper() {
-            @Override
-            protected long loop() {
-                if (hotloadChecker.flip()) {
-                    folder.check();
-                }
-
-                return 250;
-            }
-        } : null;
-
-        if (studio) {
-            hotloader.setPriority(Thread.MIN_PRIORITY);
-            hotloader.start();
-            hotloader.setName(getTarget().getWorld().name() + " Hotloader");
-        }
-
-        lock.unlock();
-
-        return engine;
-    }
-
-    @Override
-    public void close() {
-        withExclusiveControl(() -> {
-            if (isStudio()) {
-                hotloader.interrupt();
-            }
-
-            getEngine().close();
-            folder.clear();
-            populators.clear();
-
-        });
-    }
-
-    @Override
-    public boolean isStudio() {
-        return studio;
-    }
-
-    @Override
-    public void hotload() {
-        if (!isStudio()) {
-            return;
-        }
-
-        withExclusiveControl(() -> getEngine().hotload());
-    }
-
-    public void withExclusiveControl(Runnable r) {
-        J.a(() -> {
-            try {
-                loadLock.acquire(LOAD_LOCKS);
-                r.run();
-                loadLock.release(LOAD_LOCKS);
-            } catch (Throwable e) {
-                Iris.reportError(e);
-            }
-        });
-    }
-
-    @Override
-    public void touch(World world) {
-        getEngine(world);
-    }
-
-    @Override
-    public void generateNoise(@NotNull WorldInfo world, @NotNull Random random, int x, int z, @NotNull ChunkGenerator.ChunkData d) {
-        try {
-            getEngine(world);
-            computeStudioGenerator();
-            TerrainChunk tc = TerrainChunk.create(d, new IrisBiomeStorage());
-            this.world.bind(world);
-            if (studioGenerator != null) {
-                studioGenerator.generateChunk(getEngine(), tc, x, z);
-            } else {
-                ChunkDataHunkHolder blocks = new ChunkDataHunkHolder(tc);
-                BiomeGridHunkHolder biomes = new BiomeGridHunkHolder(tc, tc.getMinHeight(), tc.getMaxHeight());
-                getEngine().generate(x << 4, z << 4, blocks, biomes, false);
-                blocks.apply();
-                biomes.apply();
-            }
-
-            Iris.debug("Generated " + x + " " + z);
-        } catch (Throwable e) {
-            Iris.error("======================================");
-            e.printStackTrace();
-            Iris.reportErrorChunk(x, z, e, "CHUNK");
-            Iris.error("======================================");
-
-            for (int i = 0; i < 16; i++) {
-                for (int j = 0; j < 16; j++) {
-                    d.setBlock(i, 0, j, Material.RED_GLAZED_TERRACOTTA.createBlockData());
-                }
-            }
-        }
-    }
-
-    @Override
-    public int getBaseHeight(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z, @NotNull HeightMap heightMap) {
-        return 4;
-    }
-
-    private void computeStudioGenerator() {
-        if (!getEngine().getDimension().getStudioMode().equals(lastMode)) {
-            lastMode = getEngine().getDimension().getStudioMode();
-            getEngine().getDimension().getStudioMode().inject(this);
-        }
-    }
-
-    @NotNull
-    @Override
-    public List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
-        return populators;
-    }
-
-    @Override
-    public boolean isParallelCapable() {
-        return true;
-    }
-
-    @Override
-    public boolean shouldGenerateCaves() {
-        return false;
-    }
-
-    @Override
-    public boolean shouldGenerateDecorations() {
-        return false;
-    }
-
-    @Override
-    public boolean shouldGenerateMobs() {
-        return false;
-    }
-
-    @Override
-    public boolean shouldGenerateStructures() {
-        return false;
-    }
-
-    @Override
-    public boolean shouldGenerateNoise() {
-        return false;
-    }
-
-    @Override
-    public boolean shouldGenerateSurface() {
-        return false;
-    }
-
-    @Override
-    public boolean shouldGenerateBedrock() {
-        return false;
-    }
-
-    @Nullable
-    @Override
-    public BiomeProvider getDefaultBiomeProvider(@NotNull WorldInfo worldInfo) {
-        return dummyBiomeProvider;
-    }
-}
+/*
+ * 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.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.service.StudioSVC;
+import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.data.chunk.TerrainChunk;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.framework.EngineTarget;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.engine.object.StudioMode;
+import com.volmit.iris.engine.platform.studio.StudioGenerator;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.data.IrisBiomeStorage;
+import com.volmit.iris.util.hunk.Hunk;
+import com.volmit.iris.util.hunk.view.BiomeGridHunkHolder;
+import com.volmit.iris.util.hunk.view.ChunkDataHunkHolder;
+import com.volmit.iris.util.io.ReactiveFolder;
+import com.volmit.iris.util.scheduling.ChronoLatch;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.Looper;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.Setter;
+import org.bukkit.*;
+import org.bukkit.block.Biome;
+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.Listener;
+import org.bukkit.event.world.WorldInitEvent;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.BlockPopulator;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.generator.WorldInfo;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.lang.reflect.Field;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.Semaphore;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.locks.ReentrantLock;
+import java.util.function.Consumer;
+
+@EqualsAndHashCode(callSuper = true)
+@Data
+public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChunkGenerator, Listener {
+    private static final int LOAD_LOCKS = Runtime.getRuntime().availableProcessors() * 4;
+    private final Semaphore loadLock;
+    private final IrisWorld world;
+    private final File dataLocation;
+    private final String dimensionKey;
+    private final ReactiveFolder folder;
+    private final ReentrantLock lock = new ReentrantLock();
+    private final KList<BlockPopulator> populators;
+    private final ChronoLatch hotloadChecker;
+    private final AtomicBoolean setup;
+    private final boolean studio;
+    private final AtomicInteger a = new AtomicInteger(0);
+    private Engine engine;
+    private Looper hotloader;
+    private StudioMode lastMode;
+    private DummyBiomeProvider dummyBiomeProvider;
+    @Setter
+    private StudioGenerator studioGenerator;
+
+    private boolean initialized = false;
+
+    public BukkitChunkGenerator(IrisWorld world, boolean studio, File dataLocation, String dimensionKey) {
+        setup = new AtomicBoolean(false);
+        studioGenerator = null;
+        dummyBiomeProvider = new DummyBiomeProvider();
+        populators = new KList<>();
+        loadLock = new Semaphore(LOAD_LOCKS);
+        this.world = world;
+        this.hotloadChecker = new ChronoLatch(1000, false);
+        this.studio = studio;
+        this.dataLocation = dataLocation;
+        this.dimensionKey = dimensionKey;
+        this.folder = new ReactiveFolder(dataLocation, (_a, _b, _c) -> hotload());
+        Bukkit.getServer().getPluginManager().registerEvents(this, Iris.instance);
+    }
+
+    private static Field getField(Class clazz, String fieldName)
+            throws NoSuchFieldException {
+        try {
+            return clazz.getDeclaredField(fieldName);
+        } catch (NoSuchFieldException e) {
+            Class superClass = clazz.getSuperclass();
+            if (superClass == null) {
+                throw e;
+            } else {
+                return getField(superClass, fieldName);
+            }
+        }
+    }
+
+    @EventHandler
+    public void onWorldInit(WorldInitEvent event) {
+        try {
+            if (!initialized) {
+                world.setRawWorldSeed(event.getWorld().getSeed());
+                if (world.name().equals(event.getWorld().getName())) {
+                    Engine engine = getEngine(event.getWorld());
+                    if (engine == null) {
+                        Iris.warn("Failed to get Engine!");
+                        J.s(() -> {
+                            Engine engine1 = getEngine(event.getWorld());
+                            if (engine1 != null) {
+								try {
+									INMS.get().inject(event.getWorld().getSeed(), engine1, event.getWorld());
+                                    Iris.info("Injected Iris Biome Source into " + event.getWorld().getName());
+                                    initialized = true;
+								} catch (Throwable e) {
+									e.printStackTrace();
+								}
+							}
+                        }, 10);
+                    } else {
+                        INMS.get().inject(event.getWorld().getSeed(), engine, event.getWorld());
+                        Iris.info("Injected Iris Biome Source into " + event.getWorld().getName());
+                        initialized = true;
+                    }
+                }
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void setupEngine() {
+        IrisData data = IrisData.get(dataLocation);
+        IrisDimension dimension = data.getDimensionLoader().load(dimensionKey);
+
+        if (dimension == null) {
+            Iris.error("Oh No! There's no pack in " + data.getDataFolder().getPath() + " or... there's no dimension for the key " + dimensionKey);
+            IrisDimension test = IrisData.loadAnyDimension(dimensionKey);
+
+            if (test != null) {
+                Iris.warn("Looks like " + dimensionKey + " exists in " + test.getLoadFile().getPath() + " ");
+                Iris.service(StudioSVC.class).installIntoWorld(Iris.getSender(), dimensionKey, dataLocation.getParentFile().getParentFile());
+                Iris.warn("Attempted to install into " + data.getDataFolder().getPath());
+                data.dump();
+                data.clearLists();
+                test = data.getDimensionLoader().load(dimensionKey);
+
+                if (test != null) {
+                    Iris.success("Woo! Patched the Engine!");
+                    dimension = test;
+                } else {
+                    Iris.error("Failed to patch dimension!");
+                    throw new RuntimeException("Missing Dimension: " + dimensionKey);
+                }
+            } else {
+                Iris.error("Nope, you don't have an installation containing " + dimensionKey + " try downloading it?");
+                throw new RuntimeException("Missing Dimension: " + dimensionKey);
+            }
+        }
+
+        lastMode = StudioMode.NORMAL;
+        engine = new IrisEngine(new EngineTarget(world, dimension, data), studio);
+        populators.clear();
+    }
+
+    @Override
+    public void injectChunkReplacement(World world, int x, int z, Consumer<Runnable> jobs) {
+        try {
+            loadLock.acquire();
+            IrisBiomeStorage st = new IrisBiomeStorage();
+            TerrainChunk tc = TerrainChunk.createUnsafe(world, st);
+            Hunk<BlockData> blocks = Hunk.view(tc);
+            Hunk<Biome> biomes = Hunk.view(tc, tc.getMinHeight(), tc.getMaxHeight());
+            this.world.bind(world);
+            getEngine().generate(x << 4, z << 4, blocks, biomes, true);
+            Iris.debug("Regenerated " + x + " " + z);
+            int t = 0;
+            for (int i = getEngine().getHeight() >> 4; i >= 0; i--) {
+                if (!world.isChunkLoaded(x, z)) {
+                    continue;
+                }
+
+                Chunk c = world.getChunkAt(x, z);
+                for (Entity ee : c.getEntities()) {
+                    if (ee instanceof Player) {
+                        continue;
+                    }
+
+                    J.s(ee::remove);
+                }
+
+                J.s(() -> engine.getWorldManager().onChunkLoad(c, false));
+
+                int finalI = i;
+                jobs.accept(() -> {
+
+                    for (int xx = 0; xx < 16; xx++) {
+                        for (int yy = 0; yy < 16; yy++) {
+                            for (int zz = 0; zz < 16; zz++) {
+                                if (yy + (finalI << 4) >= engine.getHeight() || yy + (finalI << 4) < 0) {
+                                    continue;
+                                }
+                                c.getBlock(xx, yy + (finalI << 4) + world.getMinHeight(), zz)
+                                        .setBlockData(tc.getBlockData(xx, yy + (finalI << 4) + world.getMinHeight(), zz), false);
+                            }
+                        }
+                    }
+                });
+            }
+
+            loadLock.release();
+        } catch (Throwable e) {
+            loadLock.release();
+            Iris.error("======================================");
+            e.printStackTrace();
+            Iris.reportErrorChunk(x, z, e, "CHUNK");
+            Iris.error("======================================");
+
+            ChunkData d = Bukkit.createChunkData(world);
+
+            for (int i = 0; i < 16; i++) {
+                for (int j = 0; j < 16; j++) {
+                    d.setBlock(i, 0, j, Material.RED_GLAZED_TERRACOTTA.createBlockData());
+                }
+            }
+        }
+    }
+
+    private Engine getEngine(WorldInfo world) {
+        if (setup.get()) {
+            return getEngine();
+        }
+
+        lock.lock();
+
+        try {
+            if (setup.get()) {
+                return getEngine();
+            }
+
+
+            getWorld().setRawWorldSeed(world.getSeed());
+            setupEngine();
+            setup.set(true);
+            this.hotloader = studio ? new Looper() {
+                @Override
+                protected long loop() {
+                    if (hotloadChecker.flip()) {
+                        folder.check();
+                    }
+
+                    return 250;
+                }
+            } : null;
+
+            if (studio) {
+                hotloader.setPriority(Thread.MIN_PRIORITY);
+                hotloader.start();
+                hotloader.setName(getTarget().getWorld().name() + " Hotloader");
+            }
+
+            return engine;
+        } finally {
+            lock.unlock();
+        }
+    }
+
+    @Override
+    public void close() {
+        withExclusiveControl(() -> {
+            if (isStudio()) {
+                hotloader.interrupt();
+            }
+
+            getEngine().close();
+            folder.clear();
+            populators.clear();
+
+        });
+    }
+
+    @Override
+    public boolean isStudio() {
+        return studio;
+    }
+
+    @Override
+    public void hotload() {
+        if (!isStudio()) {
+            return;
+        }
+
+        withExclusiveControl(() -> getEngine().hotload());
+    }
+
+    public void withExclusiveControl(Runnable r) {
+        J.a(() -> {
+            try {
+                loadLock.acquire(LOAD_LOCKS);
+                r.run();
+                loadLock.release(LOAD_LOCKS);
+            } catch (Throwable e) {
+                Iris.reportError(e);
+            }
+        });
+    }
+
+    @Override
+    public void touch(World world) {
+        getEngine(world);
+    }
+
+    @Override
+    public void generateNoise(@NotNull WorldInfo world, @NotNull Random random, int x, int z, @NotNull ChunkGenerator.ChunkData d) {
+        try {
+            getEngine(world);
+            computeStudioGenerator();
+            TerrainChunk tc = TerrainChunk.create(d, new IrisBiomeStorage());
+            this.world.bind(world);
+            if (studioGenerator != null) {
+                studioGenerator.generateChunk(getEngine(), tc, x, z);
+            } else {
+                ChunkDataHunkHolder blocks = new ChunkDataHunkHolder(tc);
+                BiomeGridHunkHolder biomes = new BiomeGridHunkHolder(tc, tc.getMinHeight(), tc.getMaxHeight());
+                getEngine().generate(x << 4, z << 4, blocks, biomes, false);
+                blocks.apply();
+                biomes.apply();
+            }
+
+            Iris.debug("Generated " + x + " " + z);
+        } catch (Throwable e) {
+            Iris.error("======================================");
+            e.printStackTrace();
+            Iris.reportErrorChunk(x, z, e, "CHUNK");
+            Iris.error("======================================");
+
+            for (int i = 0; i < 16; i++) {
+                for (int j = 0; j < 16; j++) {
+                    d.setBlock(i, 0, j, Material.RED_GLAZED_TERRACOTTA.createBlockData());
+                }
+            }
+        }
+    }
+
+    @Override
+    public int getBaseHeight(@NotNull WorldInfo worldInfo, @NotNull Random random, int x, int z, @NotNull HeightMap heightMap) {
+        return 4;
+    }
+
+    private void computeStudioGenerator() {
+        if (!getEngine().getDimension().getStudioMode().equals(lastMode)) {
+            lastMode = getEngine().getDimension().getStudioMode();
+            getEngine().getDimension().getStudioMode().inject(this);
+        }
+    }
+
+    @NotNull
+    @Override
+    public List<BlockPopulator> getDefaultPopulators(@NotNull World world) {
+        return populators;
+    }
+
+    @Override
+    public boolean isParallelCapable() {
+        return true;
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateNoise() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateSurface() {
+        return false;
+    }
+
+    @Override
+    public boolean shouldGenerateBedrock() {
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public BiomeProvider getDefaultBiomeProvider(@NotNull WorldInfo worldInfo) {
+        return dummyBiomeProvider;
+    }
+}
--- a/core/src/main/java/com/volmit/iris/util/data/IrisBlockData.java
+++ b/core/src/main/java/com/volmit/iris/util/data/IrisBlockData.java
@@ -0,0 +1,127 @@
+package com.volmit.iris.util.data;
+
+import com.volmit.iris.core.link.Identifier;
+import lombok.Data;
+import lombok.NonNull;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.SoundGroup;
+import org.bukkit.block.*;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.structure.Mirror;
+import org.bukkit.block.structure.StructureRotation;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+@Data
+public class IrisBlockData implements BlockData{
+	private final @NonNull BlockData base;
+	private final @NotNull Identifier custom;
+
+	@NotNull
+	@Override
+	public Material getMaterial() {
+		return base.getMaterial();
+	}
+
+	@NotNull
+	@Override
+	public String getAsString() {
+		return base.getAsString();
+	}
+
+	@NotNull
+	@Override
+	public String getAsString(boolean b) {
+		return base.getAsString(b);
+	}
+
+	@NotNull
+	@Override
+	public BlockData merge(@NotNull BlockData blockData) {
+		return new IrisBlockData(base.merge(blockData), custom);
+	}
+
+	@Override
+	public boolean matches(@Nullable BlockData blockData) {
+		if (blockData instanceof IrisBlockData b)
+			return custom.equals(b.custom) && base.matches(b.base);
+		return base.matches(blockData);
+	}
+
+	@NotNull
+	@Override
+	public BlockData clone() {
+		return new IrisBlockData(base.clone(), custom);
+	}
+
+	@NotNull
+	@Override
+	public SoundGroup getSoundGroup() {
+		return base.getSoundGroup();
+	}
+
+	@Override
+	public int getLightEmission() {
+		return base.getLightEmission();
+	}
+
+	@Override
+	public boolean isOccluding() {
+		return base.isOccluding();
+	}
+
+	@Override
+	public boolean requiresCorrectToolForDrops() {
+		return base.requiresCorrectToolForDrops();
+	}
+
+	@Override
+	public boolean isPreferredTool(@NotNull ItemStack itemStack) {
+		return base.isPreferredTool(itemStack);
+	}
+
+	@NotNull
+	@Override
+	public PistonMoveReaction getPistonMoveReaction() {
+		return base.getPistonMoveReaction();
+	}
+
+	@Override
+	public boolean isSupported(@NotNull Block block) {
+		return base.isSupported(block);
+	}
+
+	@Override
+	public boolean isSupported(@NotNull Location location) {
+		return base.isSupported(location);
+	}
+
+	@Override
+	public boolean isFaceSturdy(@NotNull BlockFace blockFace, @NotNull BlockSupport blockSupport) {
+		return base.isFaceSturdy(blockFace, blockSupport);
+	}
+
+	@NotNull
+	@Override
+	public Material getPlacementMaterial() {
+		return base.getPlacementMaterial();
+	}
+
+	@Override
+	public void rotate(@NotNull StructureRotation structureRotation) {
+		base.rotate(structureRotation);
+	}
+
+	@Override
+	public void mirror(@NotNull Mirror mirror) {
+		base.mirror(mirror);
+	}
+
+	@NotNull
+	@Override
+	public BlockState createBlockState() {
+		return base.createBlockState();
+	}
+}
--- a/core/src/main/java/com/volmit/iris/util/hunk/view/ChunkDataHunkView.java
+++ b/core/src/main/java/com/volmit/iris/util/hunk/view/ChunkDataHunkView.java
@@ -19,6 +19,7 @@
 package com.volmit.iris.util.hunk.view;

 import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.hunk.Hunk;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.generator.ChunkGenerator.ChunkData;
@@ -72,7 +73,8 @@ public class ChunkDataHunkView implements Hunk<BlockData> {
        }

        try {
-
+            if (t instanceof IrisBlockData d)
+                t = d.getBase();
            chunk.setBlock(x, y + chunk.getMinHeight(), z, t);
        } catch (Throwable ignored) {

--- a/core/src/main/java/com/volmit/iris/util/mantle/Mantle.java
+++ b/core/src/main/java/com/volmit/iris/util/mantle/Mantle.java
@@ -21,6 +21,7 @@ package com.volmit.iris.util.mantle;
 import com.google.common.util.concurrent.AtomicDouble;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.service.IrisEngineSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
@@ -59,6 +60,7 @@ import java.util.concurrent.locks.ReentrantLock;
 */

 public class Mantle {
+    private static final boolean disableClear = System.getProperty("disableClear", "false").equals("true");
    private final File dataFolder;
    @Getter
    private final int worldHeight;
@@ -423,17 +425,17 @@ public class Mantle {
        ioTrim.set(true);
        unloadLock.lock();
        try {
-            if (lastUse != null) {
+            if (lastUse != null && IrisEngineSVC.instance != null) {
                if (!lastUse.isEmpty()) {
                    Iris.debug("Trimming Tectonic Plates older than " + Form.duration(adjustedIdleDuration.get(), 0));
-                    for (Long i : new ArrayList<>(lastUse.keySet())) {
+                    for (long i : new ArrayList<>(lastUse.keySet())) {
                        double finalAdjustedIdleDuration = adjustedIdleDuration.get();
                        hyperLock.withLong(i, () -> {
                            Long lastUseTime = lastUse.get(i);
                            if (lastUseTime != null && M.ms() - lastUseTime >= finalAdjustedIdleDuration) {
                                toUnload.add(i);
                                Iris.debug("Tectonic Region added to unload");
-                                //Iris.panic();
+                                IrisEngineSVC.instance.trimActiveAlive.reset();
                            }
                        });
                    }
@@ -452,37 +454,47 @@ public class Mantle {
        AtomicInteger i = new AtomicInteger();
        unloadLock.lock();
        BurstExecutor burst = null;
-        try {
-            KList<Long> copy = toUnload.copy();
-            burst = MultiBurst.burst.burst(copy.size());
-            burst.setMulticore(copy.size() > tectonicLimit);
-            for (long id : copy) {
-                burst.queue(() ->
-                        hyperLock.withLong(id, () -> {
-                            TectonicPlate m = loadedRegions.get(id);
-                            if (m != null) {
-                                try {
-                                    m.write(fileForRegion(dataFolder, id));
-                                    loadedRegions.remove(id);
-                                    lastUse.remove(id);
-                                    toUnload.remove(id);
-                                    i.incrementAndGet();
-                                    Iris.debug("Unloaded Tectonic Plate " + C.DARK_GREEN + Cache.keyX(id) + " " + Cache.keyZ(id));
-                                } catch (IOException e) {
-                                    Iris.reportError(e);
-                                }
-                            }
-                        }));
+        if (IrisEngineSVC.instance != null) {
+            try {
+                KList<Long> copy = toUnload.copy();
+                if (!disableClear) toUnload.clear();
+                burst = MultiBurst.burst.burst(copy.size());
+                burst.setMulticore(copy.size() > tectonicLimit);
+                for (int j = 0; j < copy.size(); j++) {
+                    Long id = copy.get(j);
+                    if (id == null) {
+                        Iris.error("Null id in unloadTectonicPlate at index " + j);
+                        continue;
+                    }

-            }
-            burst.complete();
-        } catch (Throwable e) {
-            e.printStackTrace();
-            if (burst != null)
+                    burst.queue(() ->
+                            hyperLock.withLong(id, () -> {
+                                TectonicPlate m = loadedRegions.get(id);
+                                if (m != null) {
+                                    try {
+                                        m.write(fileForRegion(dataFolder, id));
+                                        loadedRegions.remove(id);
+                                        lastUse.remove(id);
+                                        if (disableClear) toUnload.remove(id);
+                                        i.incrementAndGet();
+                                        Iris.debug("Unloaded Tectonic Plate " + C.DARK_GREEN + Cache.keyX(id) + " " + Cache.keyZ(id));
+                                        IrisEngineSVC.instance.unloadActiveAlive.reset();
+                                    } catch (IOException e) {
+                                        Iris.reportError(e);
+                                    }
+                                }
+                            }));
+                }
                burst.complete();
-        } finally {
-            unloadLock.unlock();
-            ioTectonicUnload.set(true);
+            } catch (Throwable e) {
+                e.printStackTrace();
+                if (burst != null)
+                    burst.complete();
+            } finally {
+                unloadLock.unlock();
+                ioTectonicUnload.set(true);
+            }
+            return i.get();
        }
        return i.get();
    }
--- a/core/src/main/java/com/volmit/iris/util/mantle/MantleFlag.java
+++ b/core/src/main/java/com/volmit/iris/util/mantle/MantleFlag.java
@@ -33,7 +33,8 @@ public enum MantleFlag {
    CLEANED,
    PLANNED,
    ETCHED,
-    TILE;
+    TILE,
+    CUSTOM;

    static StateList getStateList() {
        return new StateList(MantleFlag.values());
--- a/core/src/main/java/com/volmit/iris/util/matter/slices/BlockMatter.java
+++ b/core/src/main/java/com/volmit/iris/util/matter/slices/BlockMatter.java
@@ -18,6 +18,7 @@

 package com.volmit.iris.util.matter.slices;

+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.data.palette.Palette;
 import com.volmit.iris.util.matter.Sliced;
 import org.bukkit.Bukkit;
@@ -39,7 +40,11 @@ public class BlockMatter extends RawMatter<BlockData> {

    public BlockMatter(int width, int height, int depth) {
        super(width, height, depth, BlockData.class);
-        registerWriter(World.class, ((w, d, x, y, z) -> w.getBlockAt(x, y, z).setBlockData(d)));
+        registerWriter(World.class, ((w, d, x, y, z) -> {
+            if (d instanceof IrisBlockData c)
+                w.getBlockAt(x, y, z).setBlockData(c.getBase());
+            else w.getBlockAt(x, y, z).setBlockData(d);
+        }));
        registerReader(World.class, (w, x, y, z) -> {
            BlockData d = w.getBlockAt(x, y, z).getBlockData();
            return d.getMaterial().isAir() ? null : d;
--- a/core/src/main/java/com/volmit/iris/util/matter/slices/IdentifierMatter.java
+++ b/core/src/main/java/com/volmit/iris/util/matter/slices/IdentifierMatter.java
@@ -0,0 +1,36 @@
+package com.volmit.iris.util.matter.slices;
+
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.util.data.palette.Palette;
+import com.volmit.iris.util.matter.Sliced;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+@Sliced
+public class IdentifierMatter extends RawMatter<Identifier> {
+
+	public IdentifierMatter() {
+		this(1, 1, 1);
+	}
+
+	public IdentifierMatter(int width, int height, int depth) {
+		super(width, height, depth, Identifier.class);
+	}
+
+	@Override
+	public Palette<Identifier> getGlobalPalette() {
+		return null;
+	}
+
+	@Override
+	public void writeNode(Identifier b, DataOutputStream dos) throws IOException {
+		dos.writeUTF(b.toString());
+	}
+
+	@Override
+	public Identifier readNode(DataInputStream din) throws IOException {
+		return Identifier.fromString(din.readUTF());
+	}
+}
--- a/core/src/main/java/com/volmit/iris/util/plugin/Command.java
+++ b/core/src/main/java/com/volmit/iris/util/plugin/Command.java
@@ -18,6 +18,8 @@

 package com.volmit.iris.util.plugin;

+import com.volmit.iris.util.format.C;
+
 import java.lang.annotation.Retention;
 import java.lang.annotation.Target;

@@ -28,4 +30,5 @@ import static java.lang.annotation.RetentionPolicy.RUNTIME;
@Target(FIELD)
 public @interface Command {
    String value() default "";
+
 }
--- a/nms/v1_19_R1/src/main/java/com/volmit/iris/core/nms/v1_19_R1/NMSBinding.java
+++ b/nms/v1_19_R1/src/main/java/com/volmit/iris/core/nms/v1_19_R1/NMSBinding.java
@@ -1,5 +1,34 @@
 package com.volmit.iris.core.nms.v1_19_R1;

+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.bukkit.*;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.craftbukkit.v1_19_R1.CraftChunk;
+import org.bukkit.craftbukkit.v1_19_R1.CraftServer;
+import org.bukkit.craftbukkit.v1_19_R1.CraftWorld;
+import org.bukkit.craftbukkit.v1_19_R1.block.CraftBlock;
+import org.bukkit.craftbukkit.v1_19_R1.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.v1_19_R1.entity.CraftDolphin;
+import org.bukkit.craftbukkit.v1_19_R1.inventory.CraftItemStack;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
@@ -10,11 +39,13 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.matter.MatterBiomeInject;
 import com.volmit.iris.util.nbt.io.NBTUtil;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import com.volmit.iris.util.nbt.mca.palette.*;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
+
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
@@ -24,40 +55,15 @@ import net.minecraft.nbt.NbtIo;
 import net.minecraft.nbt.TagParser;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntity;
 import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.LevelChunk;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-import org.bukkit.craftbukkit.v1_19_R1.CraftChunk;
-import org.bukkit.craftbukkit.v1_19_R1.CraftServer;
-import org.bukkit.craftbukkit.v1_19_R1.CraftWorld;
-import org.bukkit.craftbukkit.v1_19_R1.block.CraftBlock;
-import org.bukkit.craftbukkit.v1_19_R1.block.data.CraftBlockData;
-import org.bukkit.craftbukkit.v1_19_R1.entity.CraftDolphin;
-import org.bukkit.craftbukkit.v1_19_R1.inventory.CraftItemStack;
-import org.bukkit.entity.Dolphin;
-import org.bukkit.entity.Entity;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 import sun.misc.Unsafe;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
 public class NMSBinding implements INMSBinding {
    private final KMap<Biome, Object> baseBiomeCache = new KMap<>();
    private final BlockData AIR = Material.AIR.createBlockData();
@@ -483,6 +489,34 @@ public class NMSBinding implements INMSBinding {
        biomeSource.set(serverLevel.getChunkSource().chunkMap.generator, customBiomeSource);
    }

+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        Field[] fields = EntityType.class.getDeclaredFields();
+        for (Field field : fields) {
+            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(EntityType.class)) {
+                try {
+                    EntityType entityType = (EntityType) field.get(null);
+                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
+                        Vector<Float> v1 = new Vector<>();
+                        v1.add(entityType.getHeight());
+                        entityType.getDimensions();
+                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
+                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
+                        return box;
+                    }
+                } catch (IllegalAccessException e) {
+                    Iris.error("Unable to get entity dimensions!");
+                    e.printStackTrace();
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
+    }
+
    private static Field getField(Class<?> clazz, Class<?> fieldType) throws NoSuchFieldException {
        try {
            for (Field f : clazz.getDeclaredFields()) {
--- a/nms/v1_19_R2/src/main/java/com/volmit/iris/core/nms/v1_19_R2/NMSBinding.java
+++ b/nms/v1_19_R2/src/main/java/com/volmit/iris/core/nms/v1_19_R2/NMSBinding.java
@@ -1,36 +1,17 @@
 package com.volmit.iris.core.nms.v1_19_R2;

-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.nms.INMSBinding;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-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.hunk.Hunk;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.matter.MatterBiomeInject;
-import com.volmit.iris.util.nbt.io.NBTUtil;
-import com.volmit.iris.util.nbt.mca.NBTWorld;
-import com.volmit.iris.util.nbt.mca.palette.*;
-import com.volmit.iris.util.nbt.tag.CompoundTag;
-import it.unimi.dsi.fastutil.objects.Object2IntMap;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Holder;
-import net.minecraft.core.Registry;
-import net.minecraft.core.RegistryAccess;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.nbt.NbtIo;
-import net.minecraft.nbt.TagParser;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.biome.BiomeSource;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.chunk.ChunkAccess;
-import net.minecraft.world.level.chunk.LevelChunk;
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.atomic.AtomicInteger;
+
 import org.bukkit.*;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
@@ -43,20 +24,46 @@ import org.bukkit.craftbukkit.v1_19_R2.entity.CraftDolphin;
 import org.bukkit.craftbukkit.v1_19_R2.inventory.CraftItemStack;
 import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
+import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
-import sun.misc.Unsafe;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMSBinding;
+import com.volmit.iris.engine.data.cache.AtomicCache;
+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.hunk.Hunk;
+import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
+import com.volmit.iris.util.matter.MatterBiomeInject;
+import com.volmit.iris.util.nbt.io.NBTUtil;
+import com.volmit.iris.util.nbt.mca.NBTWorld;
+import com.volmit.iris.util.nbt.mca.palette.*;
+import com.volmit.iris.util.nbt.tag.CompoundTag;
+
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Holder;
+import net.minecraft.core.Registry;
+import net.minecraft.core.RegistryAccess;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.nbt.NbtIo;
+import net.minecraft.nbt.TagParser;
+import net.minecraft.resources.ResourceLocation;
+import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.level.biome.BiomeSource;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.entity.BlockEntity;
+import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.world.level.chunk.ChunkAccess;
+import net.minecraft.world.level.chunk.LevelChunk;
+import sun.misc.Unsafe;

 public class NMSBinding implements INMSBinding {
    private final KMap<Biome, Object> baseBiomeCache = new KMap<>();
@@ -483,6 +490,35 @@ public class NMSBinding implements INMSBinding {
        biomeSource.set(serverLevel.getChunkSource().chunkMap.generator, customBiomeSource);
    }

+
+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        Field[] fields = EntityType.class.getDeclaredFields();
+        for (Field field : fields) {
+            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(EntityType.class)) {
+                try {
+                    EntityType entityType = (EntityType) field.get(null);
+                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
+                        Vector<Float> v1 = new Vector<>();
+                        v1.add(entityType.getHeight());
+                        entityType.getDimensions();
+                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
+                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
+                        return box;
+                    }
+                } catch (IllegalAccessException e) {
+                    Iris.error("Unable to get entity dimensions!");
+                    e.printStackTrace();
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location,  org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
+    }
+
    private static Field getField(Class<?> clazz, Class<?> fieldType) throws NoSuchFieldException {
        try {
            for (Field f : clazz.getDeclaredFields()) {
--- a/nms/v1_19_R3/src/main/java/com/volmit/iris/core/nms/v1_19_R3/NMSBinding.java
+++ b/nms/v1_19_R3/src/main/java/com/volmit/iris/core/nms/v1_19_R3/NMSBinding.java
@@ -1,5 +1,34 @@
 package com.volmit.iris.core.nms.v1_19_R3;

+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.bukkit.*;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.craftbukkit.v1_19_R3.CraftChunk;
+import org.bukkit.craftbukkit.v1_19_R3.CraftServer;
+import org.bukkit.craftbukkit.v1_19_R3.CraftWorld;
+import org.bukkit.craftbukkit.v1_19_R3.block.CraftBlock;
+import org.bukkit.craftbukkit.v1_19_R3.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.v1_19_R3.entity.CraftDolphin;
+import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftItemStack;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
@@ -10,11 +39,13 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.matter.MatterBiomeInject;
 import com.volmit.iris.util.nbt.io.NBTUtil;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import com.volmit.iris.util.nbt.mca.palette.*;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
+
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
@@ -25,6 +56,7 @@ import net.minecraft.nbt.NbtIo;
 import net.minecraft.nbt.TagParser;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntity;
@@ -32,34 +64,8 @@ import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.chunk.LevelChunk;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-import org.bukkit.craftbukkit.v1_19_R3.CraftChunk;
-import org.bukkit.craftbukkit.v1_19_R3.CraftServer;
-import org.bukkit.craftbukkit.v1_19_R3.CraftWorld;
-import org.bukkit.craftbukkit.v1_19_R3.block.CraftBlock;
-import org.bukkit.craftbukkit.v1_19_R3.block.data.CraftBlockData;
-import org.bukkit.craftbukkit.v1_19_R3.entity.CraftDolphin;
-import org.bukkit.craftbukkit.v1_19_R3.inventory.CraftItemStack;
-import org.bukkit.entity.Dolphin;
-import org.bukkit.entity.Entity;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 import sun.misc.Unsafe;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
 public class NMSBinding implements INMSBinding {
    private final KMap<Biome, Object> baseBiomeCache = new KMap<>();
    private final BlockData AIR = Material.AIR.createBlockData();
@@ -276,7 +282,7 @@ public class NMSBinding implements INMSBinding {

    @Override
    public KList<Biome> getBiomes() {
-        return new KList<>(Biome.values()).qadd(Biome.CHERRY_GROVE).qdel(Biome.CUSTOM);
+        return new KList<>(Biome.values()).qdel(Biome.CHERRY_GROVE).qdel(Biome.CUSTOM);
    }

    @Override
@@ -486,6 +492,37 @@ public class NMSBinding implements INMSBinding {
        biomeSource.set(serverLevel.getChunkSource().chunkMap.generator, customBiomeSource);
    }

+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        Field[] fields = EntityType.class.getDeclaredFields();
+        for (Field field : fields) {
+            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(EntityType.class)) {
+                try {
+                    EntityType entityType = (EntityType) field.get(null);
+                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
+                        Vector<Float> v1 = new Vector<>();
+                        v1.add(entityType.getHeight());
+                        entityType.getDimensions();
+                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
+                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
+                        return box;
+                    }
+                } catch (IllegalAccessException e) {
+                    Iris.error("Unable to get entity dimensions!");
+                    e.printStackTrace();
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location, org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        if (type ==  org.bukkit.entity.EntityType.CAMEL) {
+            return null;
+        }
+        return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
+    }
+
    private static Field getField(Class<?> clazz, Class<?> fieldType) throws NoSuchFieldException {
        try {
            for (Field f : clazz.getDeclaredFields()) {
--- a/nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java
+++ b/nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java
@@ -10,6 +10,7 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.matter.MatterBiomeInject;
 import com.volmit.iris.util.nbt.io.NBTUtil;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
@@ -25,6 +26,7 @@ import net.minecraft.nbt.NbtIo;
 import net.minecraft.nbt.TagParser;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityDimensions;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntity;
@@ -45,6 +47,9 @@ import org.bukkit.craftbukkit.v1_20_R1.entity.CraftDolphin;
 import org.bukkit.craftbukkit.v1_20_R1.inventory.CraftItemStack;
 import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.entity.EntityType;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.inventory.ItemStack;
 import org.jetbrains.annotations.NotNull;
@@ -56,8 +61,10 @@ import java.io.DataInputStream;
 import java.io.DataOutputStream;
 import java.lang.reflect.Field;
 import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
 import java.util.Iterator;
 import java.util.List;
+import java.util.Vector;
 import java.util.concurrent.atomic.AtomicInteger;

 public class NMSBinding implements INMSBinding {
@@ -474,6 +481,34 @@ public class NMSBinding implements INMSBinding {
        cd.getHandle().setGotFish(true);
    }

+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        Field[] fields = net.minecraft.world.entity.EntityType.class.getDeclaredFields();
+        for (Field field : fields) {
+            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(net.minecraft.world.entity.EntityType.class)) {
+                try {
+                    net.minecraft.world.entity.EntityType entityType = (net.minecraft.world.entity.EntityType) field.get(null);
+                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
+                        Vector<Float> v1 = new Vector<>();
+                        v1.add(entityType.getHeight());
+                        entityType.getDimensions();
+                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
+                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
+                        return box;
+                    }
+                } catch (IllegalAccessException e) {
+                    Iris.error("Unable to get entity dimensions!");
+                    e.printStackTrace();
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location,  org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
+    }
+
    public void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException {
        ServerLevel serverLevel = ((CraftWorld)world).getHandle();
        Class<?> clazz = serverLevel.getChunkSource().chunkMap.generator.getClass();
--- a/nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java
+++ b/nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java
@@ -1,5 +1,34 @@
 package com.volmit.iris.core.nms.v1_20_R2;

+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.bukkit.*;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.craftbukkit.v1_20_R2.CraftChunk;
+import org.bukkit.craftbukkit.v1_20_R2.CraftServer;
+import org.bukkit.craftbukkit.v1_20_R2.CraftWorld;
+import org.bukkit.craftbukkit.v1_20_R2.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.v1_20_R2.entity.CraftDolphin;
+import org.bukkit.craftbukkit.v1_20_R2.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.v1_20_R2.util.CraftNamespacedKey;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
@@ -10,11 +39,13 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.matter.MatterBiomeInject;
 import com.volmit.iris.util.nbt.io.NBTUtil;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import com.volmit.iris.util.nbt.mca.palette.*;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
+
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
@@ -26,6 +57,7 @@ import net.minecraft.nbt.TagParser;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntity;
@@ -33,34 +65,8 @@ import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.chunk.LevelChunk;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-import org.bukkit.craftbukkit.v1_20_R2.CraftChunk;
-import org.bukkit.craftbukkit.v1_20_R2.CraftServer;
-import org.bukkit.craftbukkit.v1_20_R2.CraftWorld;
-import org.bukkit.craftbukkit.v1_20_R2.block.data.CraftBlockData;
-import org.bukkit.craftbukkit.v1_20_R2.entity.CraftDolphin;
-import org.bukkit.craftbukkit.v1_20_R2.inventory.CraftItemStack;
-import org.bukkit.craftbukkit.v1_20_R2.util.CraftNamespacedKey;
-import org.bukkit.entity.Dolphin;
-import org.bukkit.entity.Entity;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 import sun.misc.Unsafe;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
 public class NMSBinding implements INMSBinding {
    private final KMap<Biome, Object> baseBiomeCache = new KMap<>();
    private final BlockData AIR = Material.AIR.createBlockData();
@@ -486,6 +492,34 @@ public class NMSBinding implements INMSBinding {
        biomeSource.set(serverLevel.getChunkSource().chunkMap.generator, customBiomeSource);
    }

+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        Field[] fields = EntityType.class.getDeclaredFields();
+        for (Field field : fields) {
+            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(EntityType.class)) {
+                try {
+                    EntityType entityType = (EntityType) field.get(null);
+                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
+                        Vector<Float> v1 = new Vector<>();
+                        v1.add(entityType.getHeight());
+                        entityType.getDimensions();
+                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
+                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
+                        return box;
+                    }
+                } catch (IllegalAccessException e) {
+                    Iris.error("Unable to get entity dimensions!");
+                    e.printStackTrace();
+                }
+            }
+        }
+        return null;
+    }
+
+    @Override
+    public Entity spawnEntity(Location location,  org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
+    }
+
    private static Field getField(Class<?> clazz, Class<?> fieldType) throws NoSuchFieldException {
        try {
            for (Field f : clazz.getDeclaredFields()) {
--- a/nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java
+++ b/nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java
@@ -1,5 +1,34 @@
 package com.volmit.iris.core.nms.v1_20_R3;

+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.lang.reflect.Modifier;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Vector;
+import java.util.concurrent.atomic.AtomicInteger;
+
+import org.bukkit.*;
+import org.bukkit.block.Biome;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.craftbukkit.v1_20_R3.CraftChunk;
+import org.bukkit.craftbukkit.v1_20_R3.CraftServer;
+import org.bukkit.craftbukkit.v1_20_R3.CraftWorld;
+import org.bukkit.craftbukkit.v1_20_R3.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.v1_20_R3.entity.CraftDolphin;
+import org.bukkit.craftbukkit.v1_20_R3.inventory.CraftItemStack;
+import org.bukkit.craftbukkit.v1_20_R3.util.CraftNamespacedKey;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
 import com.mojang.brigadier.exceptions.CommandSyntaxException;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
@@ -10,11 +39,13 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.mantle.Mantle;
+import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.matter.MatterBiomeInject;
 import com.volmit.iris.util.nbt.io.NBTUtil;
 import com.volmit.iris.util.nbt.mca.NBTWorld;
 import com.volmit.iris.util.nbt.mca.palette.*;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
+
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import net.minecraft.core.BlockPos;
 import net.minecraft.core.Holder;
@@ -26,6 +57,7 @@ import net.minecraft.nbt.TagParser;
 import net.minecraft.resources.ResourceKey;
 import net.minecraft.resources.ResourceLocation;
 import net.minecraft.server.level.ServerLevel;
+import net.minecraft.world.entity.EntityType;
 import net.minecraft.world.level.biome.BiomeSource;
 import net.minecraft.world.level.block.Block;
 import net.minecraft.world.level.block.entity.BlockEntity;
@@ -33,34 +65,8 @@ import net.minecraft.world.level.block.state.BlockState;
 import net.minecraft.world.level.chunk.ChunkAccess;
 import net.minecraft.world.level.chunk.ChunkStatus;
 import net.minecraft.world.level.chunk.LevelChunk;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-import org.bukkit.craftbukkit.v1_20_R3.CraftChunk;
-import org.bukkit.craftbukkit.v1_20_R3.CraftServer;
-import org.bukkit.craftbukkit.v1_20_R3.CraftWorld;
-import org.bukkit.craftbukkit.v1_20_R3.block.data.CraftBlockData;
-import org.bukkit.craftbukkit.v1_20_R3.entity.CraftDolphin;
-import org.bukkit.craftbukkit.v1_20_R3.inventory.CraftItemStack;
-import org.bukkit.craftbukkit.v1_20_R3.util.CraftNamespacedKey;
-import org.bukkit.entity.Dolphin;
-import org.bukkit.entity.Entity;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 import sun.misc.Unsafe;

-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Iterator;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicInteger;
-
 public class NMSBinding implements INMSBinding {
    private final KMap<Biome, Object> baseBiomeCache = new KMap<>();
    private final BlockData AIR = Material.AIR.createBlockData();
@@ -486,6 +492,35 @@ public class NMSBinding implements INMSBinding {
        biomeSource.set(serverLevel.getChunkSource().chunkMap.generator, customBiomeSource);
    }

+    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
+        Field[] fields = EntityType.class.getDeclaredFields();
+        for (Field field : fields) {
+            if (Modifier.isStatic(field.getModifiers()) && field.getType().equals(EntityType.class)) {
+                try {
+                    EntityType entityType = (EntityType) field.get(null);
+                    if (entityType.getDescriptionId().equals("entity.minecraft." + entity.name().toLowerCase())) {
+                        Vector<Float> v1 = new Vector<>();
+                        v1.add(entityType.getHeight());
+                        entityType.getDimensions();
+                        Vector3d box = new Vector3d( entityType.getWidth(), entityType.getHeight(),  entityType.getWidth());
+                        //System.out.println("Entity Type: " + entityType.getDescriptionId() + ", " + "Height: " + height + ", Width: " + width);
+                        return box;
+                    }
+                } catch (IllegalAccessException e) {
+                    Iris.error("Unable to get entity dimensions!");
+                    e.printStackTrace();
+                }
+            }
+        }
+        return null;
+    }
+
+
+    @Override
+    public Entity spawnEntity(Location location,  org.bukkit.entity.EntityType type, CreatureSpawnEvent.SpawnReason reason) {
+        return ((CraftWorld) location.getWorld()).spawn(location, type.getEntityClass(), null, reason);
+    }
+
    private static Field getField(Class<?> clazz, Class<?> fieldType) throws NoSuchFieldException {
        try {
            for (Field f : clazz.getDeclaredFields()) {
Author	SHA1	Message	Date
Brian Neumann-Fopiano	9ac4024e4e	v+	2024-04-15 11:43:09 -04:00
CrazyDev22	16affd11cc	fix HMCLeaves leave decay	2024-04-04 23:46:14 +02:00
CrazyDev22	33b0dec9da	fix ClassCastException when replacing to IrisBlockData	2024-04-04 23:45:25 +02:00
Brian Neumann-Fopiano	121a463788	v+ Woot	2024-04-03 03:03:32 -04:00
Julian Krings	3625e70948	Merge pull request #1085 from VolmitDev/impl_mmoitem Impl MMOItems	2024-04-02 19:03:25 +02:00
CrazyDev22	3d90207172	make MMOItems getItemTypes synchronous to reduce lag	2024-04-02 12:03:00 +02:00
CrazyDev22	ca7dc19c81	make mmoitems item creation synchronous	2024-04-01 23:20:11 +02:00
CrazyDev22	d0f16dbbc4	fix using Type::toString instead of Type::getId for mmoitems	2024-04-01 23:18:41 +02:00
CrazyDev22	fd91c223b7	add unload debug tools	2024-04-01 22:08:28 +02:00
CrazyDev22	93690b766c	implement MMOItemsDataProvider	2024-04-01 17:26:33 +02:00
CrazyDev22	cc4af9950b	fix scanning for item provider instead of block provider to processUpdate	2024-04-01 17:26:10 +02:00
Brian Fopiano	a6281483dd	Merge pull request #1084 from RePixelatedMC/PixelatedDev Pixelated dev	2024-03-31 12:45:06 -04:00
RePixelatedMC	f587816b30	merges	2024-03-31 18:33:35 +02:00
RePixelatedMC	eea3c3ab0b	Merge remote-tracking branch 'origin/master' into PixelatedDev # Conflicts: # core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java # nms/v1_19_R1/src/main/java/com/volmit/iris/core/nms/v1_19_R1/NMSBinding.java # nms/v1_19_R2/src/main/java/com/volmit/iris/core/nms/v1_19_R2/NMSBinding.java # nms/v1_19_R3/src/main/java/com/volmit/iris/core/nms/v1_19_R3/NMSBinding.java # nms/v1_20_R1/src/main/java/com/volmit/iris/core/nms/v1_20_R1/NMSBinding.java # nms/v1_20_R2/src/main/java/com/volmit/iris/core/nms/v1_20_R2/NMSBinding.java # nms/v1_20_R3/src/main/java/com/volmit/iris/core/nms/v1_20_R3/NMSBinding.java	2024-03-31 18:25:26 +02:00
RePixelatedMC	ba68ab9e06	f	2024-03-31 17:58:47 +02:00
RePixelatedMC	eb94d97ea4	- Fixed caves breaksurface - changes	2024-03-31 17:53:10 +02:00
Brian Neumann-Fopiano	04ad02719c	d	2024-03-30 18:48:00 -04:00
Brian Fopiano	f68f25b92f	Merge pull request #1083 from VolmitDev/fix_object_collision_check fix object collision check	2024-03-30 17:51:40 -04:00
Brian Fopiano	767cca36c8	Merge pull request #1080 from svdgoor/no-camel-1-19-R3 Cancels Camel spawns on 1-19-R3	2024-03-30 17:50:44 -04:00
Brian Fopiano	b30172fe89	Merge pull request #1082 from VolmitDev/shut_up_spigot Remove usage of System.out	2024-03-30 17:49:31 -04:00
CrazyDev22	b2934b0cc2	fix object collision check	2024-03-27 19:02:20 +01:00
RePixelatedMC	50686795d0	- Added /iris what region - Sort of Fixed EngineStatus - Added /iris hasAccess - Added /iris irisworlds/worlds - Added Some dev commands - Redid / improved the mantle tectonic unload - Convert still not working so ignore that - Cleaned Iris of IrisPackBenchmarking.java im redoing it on second thought. - Adjusted build.gradle - Renamed some tectonic stuff - Fixed Eta - Fixed entities spawning inside blocks or at least it should. - Lib update fixes all the iris titles/actionbars - Cave spawning adjustments, now they get engine height if caveStartHeight is too large. <optional> - Perhaps more?	2024-03-20 11:32:44 +01:00
CrazyDev22	5561a4dc2f	fix wrong color bug	2024-03-20 08:46:56 +01:00
CrazyDev22	15b8780e17	remove usage of System.out	2024-03-20 08:44:00 +01:00
svdgoor	15c4d312cb	Merge remote-tracking branch 'origin/master'	2024-03-18 17:29:02 +01:00
svdgoor	ccbea89253	prevent spawning camels on 1.19.R3	2024-03-18 17:28:08 +01:00
RePixelatedMC	7b1e666b3b	- No studio tectonic clearing.	2024-03-18 11:22:35 +01:00
RePixelatedMC	8af212fca8	- Fixed entities spawning inside blocks or at least it should.	2024-03-17 17:55:08 +01:00
Brian Fopiano	352ee7a622	Merge pull request #1079 from VolmitDev/better_plugin_compat Better plugin compat	2024-03-17 02:55:19 -04:00
Brian Fopiano	f26d0fac0b	Merge pull request #1078 from VolmitDev/fix_v1_19_R3 Remove Cherry Grove from 1.19.4 biomes list	2024-03-17 02:55:03 -04:00
RePixelatedMC	9612fef2a4	- Added /iris what region - Sort of Fixed EngineStatus - Added /iris hasAccess - Added /iris irisworlds/worlds - Added Some dev commands - Redid / improved the mantle tectonic unload - Convert still not working so ignore that - Cleaned Iris of IrisPackBenchmarking.java im redoing it on second thought. - Adjusted build.gradle - Renamed some tectonic stuff - Perhaps more?	2024-03-16 12:40:40 +01:00
CrazyDev22	a691d49abc	fix only the 0 0 chunk being updated	2024-03-08 19:35:07 +01:00
CrazyDev22	289eca35ec	fix missing method parameter types	2024-03-07 19:41:28 +01:00
CrazyDev22	e9ca30257c	woops	2024-03-07 18:48:09 +01:00
Julian Krings	6b21997baa	Merge branch 'VolmitSoftware:master' into better_plugin_compat	2024-03-07 17:24:59 +01:00
CrazyDev22	6d3dbf84ef	add HMCLeaves compatibility	2024-03-07 17:24:09 +01:00
CrazyDev22	eb45339c81	add oraxen furniture support	2024-03-07 17:23:32 +01:00
CrazyDev22	65e3fdd26c	make implementing blocks that need world context possible	2024-03-07 17:23:00 +01:00
RePixelatedMC	34cad85942	- Fixed Eta	2024-03-01 12:32:53 +01:00
RePixelatedMC	e407679d2b	- Improved eta calculation	2024-03-01 11:44:00 +01:00
Julian Krings	8a08a3e148	Remove Cherry Grove from 1.19.4 biomes list	2024-02-27 11:30:40 +01:00
Brian Fopiano	a01d27d273	Merge pull request #1075 from VolmitDev/fix_pregen Fix Pregen oversight	2024-02-22 18:42:16 -05:00
Brian Fopiano	43f642ae8b	Merge pull request #1076 from VolmitDev/custom-spawn-reason Add implement custom spawn reason	2024-02-22 18:41:59 -05:00
CrazyDev22	93c1265de9	Add implement custom spawn reason	2024-02-22 21:25:37 +01:00
CrazyDev22	d08600fbaa	Fix Pregen oversight	2024-02-22 17:27:38 +01:00
RePixelatedMC	fb9f8d28f4	- Lib update fixes all the iris titles/actionbars - Iris .schem Converter	2024-02-21 21:24:35 +01:00
Brian Fopiano	cd3e9f772d	Merge pull request #1074 from MoritzR200/master Fixed file separators in '/iris import'	2024-02-17 09:54:59 -05:00
Brian Fopiano	7a95441799	Merge pull request #1071 from VolmitDev/fix_nullpointer Fix nullpointer	2024-02-17 09:54:40 -05:00
Brian Fopiano	9345828c97	Merge pull request #1073 from RePixelatedMC/PixelatedDev Fixes?	2024-02-17 09:54:14 -05:00
MoritzR200	58d88dd079	Fixed backslashes being used as file separators regardless of platform (in /iris import)).	2024-02-17 13:31:00 +01:00
RePixelatedMC	6cbc2374b3	whoopsies	2024-02-15 20:43:29 +01:00
RePixelatedMC	12bd11386d	Merge remote-tracking branch 'CrazyDev/jigsaw_placement_fix' into PixelatedDev	2024-02-14 09:13:37 +01:00
RePixelatedMC	0497045388	- Fixed /Iris height when ran in console - Added Dynamic worldHeight	2024-02-13 08:51:48 +01:00
Julian Krings	d3f1640855	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2024-02-12 21:30:19 +01:00
CrazyDev22	960e2fcc61	try again if engine setup fails	2024-02-12 11:43:21 +01:00
CrazyDev22	6a012cf400	fix setup being set before engine setup	2024-02-12 11:42:47 +01:00
Brian Neumann-Fopiano	d658ec2099	oops	2024-02-04 17:37:00 -05:00
Julian Krings	ccb7855d7d	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2024-01-20 15:10:05 +01:00
Julian Krings	27f8ad982a	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2023-12-31 19:15:39 +01:00
Julian Krings	387cf566c9	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2023-12-30 11:25:33 +01:00
Julian Krings	683a90ed09	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2023-12-23 20:52:13 +01:00
Julian Krings	d5f74631cd	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2023-12-23 18:37:59 +01:00
Julian Krings	3fe73af5e8	Merge branch 'VolmitSoftware:master' into jigsaw_placement_fix	2023-12-23 10:20:30 +01:00
Julian Krings	7263d102c7	cleanup / possibly fix a bug	2023-11-29 14:34:00 +01:00
Julian Krings	b098c210ce	removed unnecessary code	2023-11-24 17:03:32 +01:00
Julian Krings	9843f18c96	Fix jigsaw piece collision/merging	2023-11-22 13:45:55 +01:00