v+

Woot

.github/ISSUE_TEMPLATE/bug.yml

@@ -39,6 +39,10 @@ body:
         - 1.17
         - 1.17.1
         - 1.18
+        - 1.19
+        - 1.20
+        - 1.21
+        - 1.22
     validations:
       required: true
   - type: input

.gitignore

@@ -1,8 +1,13 @@
 
 build/
+libs/
 
 .gradle/
 
 .idea/
 
 .DS_Store
+
+collection/
+
+/core/src/main/java/com/volmit/iris/util/uniques/

README.md

@@ -11,6 +11,8 @@ development.
 
 Consider supporting our development by buying Iris on spigot! We work hard to make Iris the best it can be for everyone.
 
+## Preface: if you need help compiling and you are a developer / intend to help out in the community or with development we would love to help you regardless in the discord! however do not come to the discord asking for free copies, or a tutorial on how to compile.
+
 ### Command Line Builds
 
 1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)

build.gradle

@@ -1,316 +1,347 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 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/>.
- */
-
-plugins {
-    id 'java'
-    id 'java-library'
-    id "io.freefair.lombok" version "6.3.0"
-    id "com.github.johnrengelman.shadow" version "7.1.2"
-    id "de.undercouch.download" version "5.0.1"
-}
-
-version '2.0.5-1.18.2' // Needs to be version specific
-def nmsVersion = "1.18.2"
-def apiVersion = '1.18'
-def spigotJarVersion = '1.18.2-R0.1-SNAPSHOT'
-def name = getRootProject().getName() // Defined in settings.gradle
-def main = 'com.volmit.iris.Iris'
-
-// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
-// ======================== WINDOWS =============================
-registerCustomOutputTask('Cyberpwn', 'C://Users/cyberpwn/Documents/development/server/plugins')
-registerCustomOutputTask('Psycho', 'D://Dan/MinecraftDevelopment/server/plugins')
-registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
-registerCustomOutputTask('Coco', 'D://Documents/MC/plugins')
-registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
-registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.18.2/plugins')
-// ========================== UNIX ==============================
-registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/Documents/development/server/plugins')
-registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Desktop/REMOTES/RemoteMinecraft/plugins')
-// ==============================================================
-
-/**
- * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.
- */
-file(jar.archiveFile.get().getAsFile().getParentFile().getParentFile().getParentFile().getAbsolutePath() + '/build/resources/main/plugin.yml').delete()
-
-/**
- * Expand properties into plugin yml
- */
-processResources {
-    filesMatching('**/plugin.yml') {
-        expand(
-                'name': name.toString(),
-                'version': version.toString(),
-                'main': main.toString(),
-                'apiversion': apiVersion.toString()
-        )
-    }
-}
-
-/**
- * Unified repo
- */
-repositories {
-    mavenLocal {
-        content {
-            includeGroup("org.bukkit")
-            includeGroup("org.spigotmc")
-        }
-    }
-    maven { url "https://dl.cloudsmith.io/public/arcane/archive/maven/" }
-    mavenCentral()
-    mavenLocal()
-}
-
-/**
- * We need parameter meta for the decree command system
- */
-compileJava {
-    options.compilerArgs << '-parameters'
-}
-
-/**
- * Configure Iris for shading
- */
-shadowJar {
-    //minimize()
-    append("plugin.yml")
-    relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
-    relocate 'io.papermc.lib', 'com.volmit.iris.util.paper'
-    relocate 'net.kyori', 'com.volmit.iris.util.kyori'
-    dependencies {
-        include(dependency('io.papermc:paperlib'))
-        include(dependency('com.dfsek:Paralithic'))
-        include(dependency('net.kyori:'))
-    }
-}
-
-configurations.all {
-    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
-    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
-}
-
-/**
- * Dependencies.
- *
- * Provided or classpath dependencies are not shaded and are available on the runtime classpath
- *
- * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
- * need to be shaded into the jar (increasing binary size)
- *
- * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
- * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
- * these dependencies if they are available on mvn central.
- */
-dependencies {
-    // Provided or Classpath
-    compileOnly 'org.projectlombok:lombok:1.18.22'
-    annotationProcessor 'org.projectlombok:lombok:1.18.22'
-    implementation 'org.spigotmc:spigot-api:1.18.2-R0.1-SNAPSHOT'
-    implementation 'me.clip:placeholderapi:2.11.1'
-    implementation 'io.th0rgal:oraxen:1.94.0'
-    implementation 'org.bukkit:craftbukkit:1.18.2-R0.1-SNAPSHOT:remapped-mojang'
-
-    // Shaded
-    implementation 'com.dfsek:Paralithic:0.4.0'
-    implementation 'io.papermc:paperlib:1.0.5'
-    implementation "net.kyori:adventure-text-minimessage:4.2.0-SNAPSHOT"
-    implementation 'net.kyori:adventure-platform-bukkit:4.0.1' // Dont upgrade yet
-    implementation 'net.kyori:adventure-api:4.9.3' // Dont upgrade yet
-
-    // Dynamically Loaded
-    implementation 'io.timeandspace:smoothie-map:2.0.2'
-    implementation 'it.unimi.dsi:fastutil:8.5.8'
-    implementation 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
-    implementation 'org.zeroturnaround:zt-zip:1.14'
-    implementation 'com.google.code.gson:gson:2.9.0'
-    implementation 'org.ow2.asm:asm:9.2'
-    implementation 'com.google.guava:guava:31.1-jre'
-    implementation 'bsf:bsf:2.4.0'
-    implementation 'rhino:js:1.7R2'
-    implementation 'com.github.ben-manes.caffeine:caffeine:3.0.6'
-    implementation 'org.apache.commons:commons-lang3:3.12.0'
-}
-
-if (JavaVersion.current().toString() != "17") {
-    System.err.println()
-    System.err.println("=========================================================================================================")
-    System.err.println("You must run gradle on Java 17. You are using " + JavaVersion.current())
-    System.err.println()
-    System.err.println("=== For IDEs ===")
-    System.err.println("1. Configure the project for Java 17")
-    System.err.println("2. Configure the bundled gradle to use Java 17 in settings")
-    System.err.println()
-    System.err.println("=== For Command Line (gradlew) ===")
-    System.err.println("1. Install JDK 17 from https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html")
-    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-17.0.1")
-    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
-    System.err.println("=========================================================================================================")
-    System.err.println()
-    System.exit(69);
-}
-
-def buildToolsJar = new File(buildDir, "buildtools/BuildTools.jar");
-def specialSourceJar = new File(buildDir, "specialsource/SpecialSource.jar");
-def buildToolsFolder = new File(buildDir, "buildtools");
-def specialSourceFolder = new File(buildDir, "specialsource");
-def buildToolsHint = new File(buildDir, "buildtools/craftbukkit-" + nmsVersion + ".jar");
-def outputShadeJar = new File(buildDir, "libs/Iris-" + version + "-all.jar");
-def ssiJar = new File(buildDir, "specialsource/Iris-" + version + "-all.jar");
-def ssobfJar = new File(buildDir, "specialsource/Iris-" + version + "-rmo.jar");
-def ssJar = new File(buildDir, "specialsource/Iris-" + version + "-rma.jar");
-def homePath = System.properties['user.home']
-def m2 = new File(homePath + "/.m2/repository")
-def m2s = m2.getAbsolutePath();
-
-// ======================== Building Mapped Jars =============================
-task downloadBuildtools(type: Download) {
-    group "remapping"
-    src 'https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar'
-    dest buildToolsJar
-    onlyIf {
-        !buildToolsJar.exists()
-    }
-}
-
-task downloadSpecialSource(type: Download) {
-    group "remapping"
-    src 'https://repo.maven.apache.org/maven2/net/md-5/SpecialSource/1.10.0/SpecialSource-1.10.0-shaded.jar'
-    dest specialSourceJar
-    onlyIf {
-        !specialSourceJar.exists()
-    }
-}
-
-task executeBuildTools(dependsOn: downloadBuildtools, type: JavaExec)
-{
-    group "remapping"
-    classpath = files(buildToolsJar)
-    workingDir = buildToolsFolder
-    args = [
-            "--rev",
-            nmsVersion,
-            "--compile",
-            "craftbukkit",
-            "--remap"
-    ]
-    onlyIf {
-        !buildToolsHint.exists()
-    }
-}
-
-task copyBuildToSpecialSource(type: Copy)
-{
-    group "remapping"
-    from outputShadeJar
-    into specialSourceFolder
-    dependsOn(downloadSpecialSource, shadowJar)
-}
-
-task specialSourceRemapObfuscate(type: JavaExec)
-{
-    group "remapping"
-    dependsOn(copyBuildToSpecialSource, downloadSpecialSource, shadowJar)
-    workingDir = specialSourceFolder
-    classpath = files(specialSourceJar,
-            new File(m2s + "/org/spigotmc/spigot/" + spigotJarVersion + "/spigot-" + spigotJarVersion + "-remapped-mojang.jar"))
-    mainClass = "net.md_5.specialsource.SpecialSource"
-    args = [
-            "--live",
-            "-i",
-            ssiJar.getName(),
-            "-o",
-            ssobfJar.getName(),
-            "-m",
-            m2s + "/org/spigotmc/minecraft-server/" + spigotJarVersion + "/minecraft-server-" + spigotJarVersion + "-maps-mojang.txt",
-            "--reverse",
-    ]
-}
-
-task specialSourceRemap(type: JavaExec)
-{
-    group "remapping"
-    dependsOn(specialSourceRemapObfuscate)
-    workingDir = specialSourceFolder
-    classpath = files(specialSourceJar,
-            new File(m2s + "/org/spigotmc/spigot/" + spigotJarVersion + "/spigot-" + spigotJarVersion + "-remapped-obf.jar"))
-    mainClass = "net.md_5.specialsource.SpecialSource"
-    args = [
-            "--live",
-            "-i",
-            ssobfJar.getName(),
-            "-o",
-            ssJar.getName(),
-            "-m",
-            m2s + "/org/spigotmc/minecraft-server/" + spigotJarVersion + "/minecraft-server-" + spigotJarVersion + "-maps-spigot.csrg"
-    ]
-}
-
-tasks.compileJava.dependsOn(executeBuildTools)
-
-task setup()
-{
-    group("iris")
-    dependsOn(clean, executeBuildTools)
-}
-
-task iris(type: Copy)
-{
-    group "iris"
-    from ssJar
-    into buildDir
-    rename { String fileName ->
-        fileName.replace('Iris-' + version + '-rma.jar', "Iris-" + version + ".jar")
-    }
-    dependsOn(specialSourceRemap)
-}
-
-def registerCustomOutputTask(name, path) {
-    if (!System.properties['os.name'].toLowerCase().contains('windows')) {
-        return;
-    }
-
-    tasks.register('build' + name, Copy) {
-        group('development')
-        outputs.upToDateWhen { false }
-        dependsOn(iris)
-        from(new File(buildDir, "Iris-" + version + ".jar"))
-        into(file(path))
-        rename { String fileName ->
-            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
-        }
-    }
-}
-
-def registerCustomOutputTaskUnix(name, path) {
-    if (System.properties['os.name'].toLowerCase().contains('windows')) {
-        return;
-    }
-
-    tasks.register('build' + name, Copy) {
-        group('development')
-        outputs.upToDateWhen { false }
-        dependsOn(iris)
-        from(new File(buildDir, "Iris-" + version + ".jar"))
-        into(file(path))
-        rename { String fileName ->
-            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
-        }
-    }
-}
+import java.util.function.Consumer
+
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2021 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/>.
+ */
+
+plugins {
+    id 'java'
+    id 'java-library'
+    id "com.github.johnrengelman.shadow" version "7.1.2"
+    id "de.undercouch.download" version "5.0.1"
+}
+
+version '3.2.2-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
+// ======================== WINDOWS =============================
+registerCustomOutputTask('Cyberpwn', 'C://Users/cyberpwn/Documents/development/server/plugins')
+registerCustomOutputTask('Psycho', 'C://Dan/MinecraftDevelopment/Server/plugins')
+registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
+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.4 - Iris Development/plugins')
+// ========================== UNIX ==============================
+registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
+registerCustomOutputTaskUnix('PsychoLT', '/Volumes/PRO-G40/Minecraft/MinecraftDevelopment/Server/plugins')
+// ==============================================================
+
+def NMS_BINDINGS = Map.of(
+        "v1_20_R3", "1.20.4-R0.1-SNAPSHOT",
+        "v1_20_R2", "1.20.2-R0.1-SNAPSHOT",
+        "v1_20_R1", "1.20.1-R0.1-SNAPSHOT",
+        "v1_19_R3", "1.19.4-R0.1-SNAPSHOT",
+        "v1_19_R2", "1.19.3-R0.1-SNAPSHOT",
+        "v1_19_R1", "1.19.2-R0.1-SNAPSHOT"
+)
+NMS_BINDINGS.each {
+    def key = it.key
+    def value = it.value
+    def nms =  value.split("-")[0];
+    project(":nms:${key}") {
+        apply plugin: 'java-library'
+        apply plugin: 'de.undercouch.download'
+
+        dependencies {
+            implementation project(":core")
+            compileOnly "org.spigotmc:spigot-api:${value}"
+            compileOnly "org.bukkit:craftbukkit:${value}:remapped-mojang" //[NMS]
+        }
+        def buildToolsJar = new File(rootProject.buildDir, "tools/BuildTools.jar")
+        def specialSourceJar = new File(rootProject.buildDir, "tools/SpecialSource.jar")
+
+        def buildToolsFolder = new File(buildDir, "buildtools")
+        def specialSourceFolder = new File(buildDir, "specialsource")
+        def buildToolsHint = new File(buildDir, "buildtools/craftbukkit-" + nms + ".jar")
+
+        def outputJar = new File(buildDir, "libs/${key}.jar")
+        def ssiJar = new File(buildDir, "specialsource/${key}.jar")
+        def ssobfJar = new File(buildDir, "specialsource/${key}-rmo.jar")
+        def ssJar = new File(buildDir, "specialsource/${key}-rma.jar")
+
+        def homePath = System.properties['user.home']
+        def m2 = new File(homePath + "/.m2/repository")
+        def m2s = m2.getAbsolutePath();
+
+        // ======================== Building Mapped Jars =============================
+
+        ext {
+            executeBuildTools = new Runnable() {
+                @Override
+                void run() {
+                    //Download
+                    if (!buildToolsJar.exists()) {
+                        download.run {
+                            src 'https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar'
+                            dest buildToolsJar
+                        }
+                    }
+
+                    //Execute
+                    if (!buildToolsHint.exists()) {
+                        buildToolsFolder.mkdirs()
+                        project.javaexec {
+                            classpath = files(buildToolsJar)
+                            workingDir = buildToolsFolder
+                            args = [
+                                    "--rev",
+                                    nms,
+                                    "--compile",
+                                    "craftbukkit",
+                                    "--remap"
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+        tasks.register("executeBuildTools") {
+            doLast {
+                property("executeBuildTools").run();
+            }
+        }
+
+        tasks.build.doLast {
+            //Download
+            if (!specialSourceJar.exists()) {
+                download.run {
+                    src 'https://repo.maven.apache.org/maven2/net/md-5/SpecialSource/' + specialSourceVersion + '/SpecialSource-'+specialSourceVersion+'-shaded.jar'
+                    dest specialSourceJar
+                }
+            }
+            specialSourceFolder.mkdirs();
+
+            //Copy
+            copy {
+                from outputJar
+                into specialSourceFolder
+            }
+
+            //obfuscate
+            javaexec {
+                workingDir = specialSourceFolder
+                classpath = files(specialSourceJar,
+                        new File(m2s + "/org/spigotmc/spigot/" + value + "/spigot-" + value + "-remapped-mojang.jar"))
+                mainClass = "net.md_5.specialsource.SpecialSource"
+                args = [
+                        "--live",
+                        "-i",
+                        ssiJar.getName(),
+                        "-o",
+                        ssobfJar.getName(),
+                        "-m",
+                        m2s + "/org/spigotmc/minecraft-server/" + value + "/minecraft-server-" + value + "-maps-mojang.txt",
+                        "--reverse",
+                ]
+            }
+
+            //remap
+            javaexec {
+                workingDir = specialSourceFolder
+                classpath = files(specialSourceJar,
+                        new File(m2s + "/org/spigotmc/spigot/" + value + "/spigot-" + value + "-remapped-obf.jar"))
+                mainClass = "net.md_5.specialsource.SpecialSource"
+                args = [
+                        "--live",
+                        "-i",
+                        ssobfJar.getName(),
+                        "-o",
+                        ssJar.getName(),
+                        "-m",
+                        m2s + "/org/spigotmc/minecraft-server/" + value + "/minecraft-server-" + value + "-maps-spigot.csrg"
+                ]
+            }
+            //copy
+            copy {
+                from ssJar
+                into outputJar.getParentFile()
+                rename {
+                    outputJar.getName()
+                }
+            }
+        }
+    }
+}
+
+shadowJar {
+    NMS_BINDINGS.each {dependsOn(":nms:${it.key}:build")}
+
+    //minimize()
+    append("plugin.yml")
+    relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
+    relocate 'io.papermc.lib', 'com.volmit.iris.util.paper'
+    relocate 'net.kyori', 'com.volmit.iris.util.kyori'
+    archiveFileName.set("Iris-${project.version}.jar")
+}
+
+dependencies {
+    implementation project(':core')
+    NMS_BINDINGS.each {
+        implementation project(":nms:${it.key}")
+    }
+}
+
+configurations.configureEach {
+    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
+    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
+}
+
+allprojects {
+    apply plugin: 'java'
+
+    repositories {
+        mavenLocal {
+            content {
+                includeGroup("org.bukkit")
+                includeGroup("org.spigotmc")
+            }
+        }
+        mavenCentral()
+        maven { url "https://repo.papermc.io/repository/maven-public/"}
+        maven { url "https://repo.codemc.org/repository/maven-public" }
+        maven { url "https://mvn.lumine.io/repository/maven-public/" }
+        maven { url "https://jitpack.io"}
+
+        maven { url "https://s01.oss.sonatype.org/content/repositories/snapshots" }
+        maven { url "https://mvn.lumine.io/repository/maven/" }
+        maven { url "https://repo.triumphteam.dev/snapshots" }
+        maven { url "https://repo.mineinabyss.com/releases" }
+        maven { url 'https://hub.jeff-media.com/nexus/repository/jeff-media-public/' }
+    }
+
+    dependencies {
+        // Provided or Classpath
+        compileOnly 'org.projectlombok:lombok:1.18.24'
+        annotationProcessor 'org.projectlombok:lombok:1.18.24'
+
+        // Shaded
+        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.2'
+        implementation 'net.kyori:adventure-api:4.13.1'
+        compileOnly 'io.lumine:Mythic-Dist:5.2.1'
+
+        // Dynamically Loaded
+        compileOnly 'io.timeandspace:smoothie-map:2.0.2'
+        compileOnly 'it.unimi.dsi:fastutil:8.5.8'
+        compileOnly 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
+        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: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'
+        compileOnly 'org.apache.commons:commons-lang3:3.12.0'
+    }
+
+    /**
+     * We need parameter meta for the decree command system
+     */
+    compileJava {
+        options.compilerArgs << '-parameters'
+        options.encoding = "UTF-8"
+    }
+}
+
+if (JavaVersion.current().toString() != "17") {
+    System.err.println()
+    System.err.println("=========================================================================================================")
+    System.err.println("You must run gradle on Java 17. You are using " + JavaVersion.current())
+    System.err.println()
+    System.err.println("=== For IDEs ===")
+    System.err.println("1. Configure the project for Java 17")
+    System.err.println("2. Configure the bundled gradle to use Java 17 in settings")
+    System.err.println()
+    System.err.println("=== For Command Line (gradlew) ===")
+    System.err.println("1. Install JDK 17 from https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html")
+    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-17.0.1")
+    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
+    System.err.println("=========================================================================================================")
+    System.err.println()
+    System.exit(69);
+}
+
+task iris(type: Copy) {
+    group "iris"
+    from new File(buildDir, "libs/Iris-${version}.jar")
+    into buildDir
+    dependsOn(build)
+}
+
+task setup() {
+    group "iris"
+    dependsOn(clean)
+    NMS_BINDINGS.each {
+        dependsOn(":nms:${it.key}:clean");
+    }
+
+    doLast {
+        NMS_BINDINGS.each {
+            project(":nms:${it.key}").property("executeBuildTools").run();
+        }
+    }
+}
+
+NMS_BINDINGS.keySet().forEach {
+    def nms = it
+    tasks.register("setup-${nms}") {
+        group "iris"
+        dependsOn(":nms:${nms}:clean")
+        dependsOn(":nms:${nms}:executeBuildTools")
+    }
+}
+
+def registerCustomOutputTask(name, path) {
+    if (!System.properties['os.name'].toLowerCase().contains('windows')) {
+        return;
+    }
+
+    tasks.register('build' + name, Copy) {
+        group('development')
+        outputs.upToDateWhen { false }
+        dependsOn(iris)
+        from(new File(buildDir, "Iris-" + version + ".jar"))
+        into(file(path))
+        rename { String fileName ->
+            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
+        }
+    }
+}
+
+def registerCustomOutputTaskUnix(name, path) {
+    if (System.properties['os.name'].toLowerCase().contains('windows')) {
+        return;
+    }
+
+    tasks.register('build' + name, Copy) {
+        group('development')
+        outputs.upToDateWhen { false }
+        dependsOn(iris)
+        from(new File(buildDir, "Iris-" + version + ".jar"))
+        into(file(path))
+        rename { String fileName ->
+            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
+        }
+    }
+}
+
+tasks.build.dependsOn(shadowJar)

core/build.gradle

@@ -0,0 +1,90 @@
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2021 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/>.
+ */
+
+plugins {
+    id 'java'
+    id 'java-library'
+    id "io.freefair.lombok" version "6.3.0"
+}
+
+def apiVersion = '1.19'
+def main = 'com.volmit.iris.Iris'
+
+/**
+ * We need parameter meta for the decree command system
+ */
+compileJava {
+    options.compilerArgs << '-parameters'
+    options.encoding = "UTF-8"
+}
+
+repositories {
+    maven { url 'https://nexus.phoenixdevt.fr/repository/maven-public/'}
+}
+
+/**
+ * Dependencies.
+ *
+ * Provided or classpath dependencies are not shaded and are available on the runtime classpath
+ *
+ * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
+ * need to be shaded into the jar (increasing binary size)
+ *
+ * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
+ * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
+ * these dependencies if they are available on mvn central.
+ */
+dependencies {
+    // Provided or Classpath
+    compileOnly 'org.spigotmc:spigot-api:1.20.1-R0.1-SNAPSHOT'
+    compileOnly 'org.apache.logging.log4j:log4j-api:2.19.0'
+    compileOnly 'org.apache.logging.log4j:log4j-core:2.19.0'
+    compileOnly 'commons-io:commons-io:2.13.0'
+    compileOnly 'commons-lang:commons-lang:2.6'
+    compileOnly 'com.github.oshi:oshi-core:5.8.5'
+    compileOnly 'org.lz4:lz4-java:1.8.0'
+
+    // Third Party Integrations
+    compileOnly 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
+    compileOnly 'com.github.oraxen:oraxen:1.158.0'
+    compileOnly 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
+    compileOnly 'com.github.PlaceholderAPI:placeholderapi:2.11.3'
+    compileOnly 'com.github.Ssomar-Developement:SCore:4.23.10.8'
+    compileOnly 'net.Indyuce:MMOItems-API:6.9.5-SNAPSHOT'
+    //implementation files('libs/CustomItems.jar')
+}
+
+
+/**
+ * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.
+ */
+file(jar.archiveFile.get().getAsFile().getParentFile().getParentFile().getParentFile().getAbsolutePath() + '/build/resources/main/plugin.yml').delete()
+
+/**
+ * Expand properties into plugin yml
+ */
+processResources {
+    filesMatching('**/plugin.yml') {
+        expand(
+                'name': rootProject.name.toString(),
+                'version': rootProject.version.toString(),
+                'main': main.toString(),
+                'apiversion': apiVersion.toString()
+        )
+    }
+}

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

@@ -0,0 +1,916 @@
+/*
+ * 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;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParseException;
+import com.google.gson.JsonParser;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.ServerConfigurator;
+import com.volmit.iris.core.link.IrisPapiExpansion;
+import com.volmit.iris.core.link.MultiverseCoreLink;
+import com.volmit.iris.core.link.MythicMobsLink;
+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.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.EnginePanic;
+import com.volmit.iris.engine.object.IrisCompat;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.core.safeguard.IrisSafeguard;
+import com.volmit.iris.core.safeguard.UtilsSFG;
+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.function.NastyRunnable;
+import com.volmit.iris.util.io.FileWatcher;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.io.InstanceState;
+import com.volmit.iris.util.io.JarScanner;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.misc.getHardware;
+import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.plugin.IrisService;
+import com.volmit.iris.util.plugin.Metrics;
+import com.volmit.iris.util.plugin.VolmitPlugin;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.reflect.ShadeFix;
+import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.Queue;
+import com.volmit.iris.util.scheduling.ShurikenQueue;
+import io.papermc.lib.PaperLib;
+import lombok.Getter;
+import net.kyori.adventure.platform.bukkit.BukkitAudiences;
+import net.kyori.adventure.text.serializer.ComponentSerializer;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.WorldCreator;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.IllegalPluginAccessException;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.*;
+import java.lang.annotation.Annotation;
+import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
+import java.net.URL;
+import java.util.Date;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
+import static com.volmit.iris.core.safeguard.ServerBootSFG.passedserversoftware;
+import static com.volmit.iris.util.misc.getHardware.getCPUModel;
+
+@SuppressWarnings("CanBeFinal")
+public class Iris extends VolmitPlugin implements Listener {
+    public static final String OVERWORLD_TAG = "3800";
+
+    private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
+
+    public static Iris instance;
+    public static BukkitAudiences audiences;
+    public static MultiverseCoreLink linkMultiverseCore;
+    public static MythicMobsLink linkMythicMobs;
+    public static IrisCompat compat;
+    public static FileWatcher configWatcher;
+    private static VolmitSender sender;
+
+    static {
+        try {
+            fixShading();
+            InstanceState.updateInstanceId();
+        } catch (Throwable ignored) {
+
+        }
+    }
+
+    private final KList<Runnable> postShutdown = new KList<>();
+    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;
+    }
+
+    @SuppressWarnings("unchecked")
+    public static <T> T service(Class<T> c) {
+        return (T) instance.services.get(c);
+    }
+
+    public static void callEvent(Event e) {
+        if (!e.isAsynchronous()) {
+            J.s(() -> Bukkit.getPluginManager().callEvent(e));
+        } else {
+            Bukkit.getPluginManager().callEvent(e);
+        }
+    }
+
+    public static KList<Object> initialize(String s, Class<? extends Annotation> slicedClass) {
+        JarScanner js = new JarScanner(instance.getJarFile(), s);
+        KList<Object> v = new KList<>();
+        J.attempt(js::scan);
+        for (Class<?> i : js.getClasses()) {
+            if (slicedClass == null || i.isAnnotationPresent(slicedClass)) {
+                try {
+                    v.add(i.getDeclaredConstructor().newInstance());
+                } catch (Throwable ignored) {
+
+                }
+            }
+        }
+
+        return v;
+    }
+
+    public static KList<Class<?>> getClasses(String s, Class<? extends Annotation> slicedClass) {
+        JarScanner js = new JarScanner(instance.getJarFile(), s);
+        KList<Class<?>> v = new KList<>();
+        J.attempt(js::scan);
+        for (Class<?> i : js.getClasses()) {
+            if (slicedClass == null || i.isAnnotationPresent(slicedClass)) {
+                try {
+                    v.add(i);
+                } catch (Throwable ignored) {
+
+                }
+            }
+        }
+
+        return v;
+    }
+
+    public static KList<Object> initialize(String s) {
+        return initialize(s, null);
+    }
+
+    public static void sq(Runnable r) {
+        synchronized (syncJobs) {
+            syncJobs.queue(r);
+        }
+    }
+
+    public static File getTemp() {
+        return instance.getDataFolder("cache", "temp");
+    }
+
+    public static void msg(String string) {
+        try {
+            getSender().sendMessage(string);
+        } catch (Throwable e) {
+            try {
+                instance.getLogger().info(instance.getTag() + string.replaceAll("(<([^>]+)>)", ""));
+            } catch (Throwable ignored1) {
+
+            }
+        }
+    }
+
+    public static File getCached(String name, String url) {
+        String h = IO.hash(name + "@" + url);
+        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
+
+        if (!f.exists()) {
+            try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
+                byte[] dataBuffer = new byte[1024];
+                int bytesRead;
+                while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                    fileOutputStream.write(dataBuffer, 0, bytesRead);
+                    Iris.verbose("Aquiring " + name);
+                }
+            } catch (IOException e) {
+                Iris.reportError(e);
+            }
+        }
+
+        return f.exists() ? f : null;
+    }
+
+    public static String getNonCached(String name, String url) {
+        String h = IO.hash(name + "*" + url);
+        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
+
+        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
+            byte[] dataBuffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                fileOutputStream.write(dataBuffer, 0, bytesRead);
+            }
+        } catch (IOException e) {
+            Iris.reportError(e);
+        }
+
+        try {
+            return IO.readAll(f);
+        } catch (IOException e) {
+            Iris.reportError(e);
+        }
+
+        return "";
+    }
+
+    public static File getNonCachedFile(String name, String url) {
+        String h = IO.hash(name + "*" + url);
+        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
+        Iris.verbose("Download " + name + " -> " + url);
+        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
+            byte[] dataBuffer = new byte[1024];
+            int bytesRead;
+            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
+                fileOutputStream.write(dataBuffer, 0, bytesRead);
+            }
+
+            fileOutputStream.flush();
+        } catch (IOException e) {
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+
+        return f;
+    }
+
+    public static void warn(String format, Object... objs) {
+        msg(C.YELLOW + String.format(format, objs));
+    }
+
+    public static void error(String format, Object... objs) {
+        msg(C.RED + String.format(format, objs));
+    }
+
+    public static void debug(String string) {
+        if (!IrisSettings.get().getGeneral().isDebug()) {
+            return;
+        }
+
+        try {
+            throw new RuntimeException();
+        } catch (Throwable e) {
+            try {
+                String[] cc = e.getStackTrace()[1].getClassName().split("\\Q.\\E");
+
+                if (cc.length > 5) {
+                    debug(cc[3] + "/" + cc[4] + "/" + cc[cc.length - 1], e.getStackTrace()[1].getLineNumber(), string);
+                } else {
+                    debug(cc[3] + "/" + cc[4], e.getStackTrace()[1].getLineNumber(), string);
+                }
+            } catch (Throwable ex) {
+                debug("Origin", -1, string);
+            }
+        }
+    }
+
+    public static void debug(String category, int line, String string) {
+        if (!IrisSettings.get().getGeneral().isDebug()) {
+            return;
+        }
+        if (IrisSettings.get().getGeneral().isUseConsoleCustomColors()) {
+            msg("<gradient:#095fe0:#a848db>" + category + " <#bf3b76>" + line + "<reset> " + C.LIGHT_PURPLE + string.replaceAll("\\Q<\\E", "[").replaceAll("\\Q>\\E", "]"));
+        } else {
+            msg(C.BLUE + category + ":" + C.AQUA + line + C.RESET + C.LIGHT_PURPLE + " " + string.replaceAll("\\Q<\\E", "[").replaceAll("\\Q>\\E", "]"));
+
+        }
+    }
+
+    public static void verbose(String string) {
+        debug(string);
+    }
+
+    public static void success(String string) {
+        msg(C.IRIS + string);
+    }
+
+    public static void info(String format, Object... args) {
+        msg(C.WHITE + String.format(format, args));
+    }
+    public static void safeguard(String format, Object... args) {
+        msg(C.RESET + String.format(format, args));
+    }
+
+    @SuppressWarnings("deprecation")
+    public static void later(NastyRunnable object) {
+        try {
+            Bukkit.getScheduler().scheduleAsyncDelayedTask(instance, () ->
+            {
+                try {
+                    object.run();
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    Iris.reportError(e);
+                }
+            }, RNG.r.i(100, 1200));
+        } catch (IllegalPluginAccessException ignored) {
+
+        }
+    }
+
+    public static int jobCount() {
+        return syncJobs.size();
+    }
+
+    public static void clearQueues() {
+        synchronized (syncJobs) {
+            syncJobs.clear();
+        }
+    }
+
+    public static int getJavaVersion() {
+        String version = System.getProperty("java.version");
+        if (version.startsWith("1.")) {
+            version = version.substring(2, 3);
+        } else {
+            int dot = version.indexOf(".");
+            if (dot != -1) {
+                version = version.substring(0, dot);
+            }
+        }
+        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");
+
+            if (!f.exists()) {
+                J.attempt(() -> {
+                    PrintWriter pw = new PrintWriter(f);
+                    pw.println("Thread: " + Thread.currentThread().getName());
+                    pw.println("First: " + new Date(M.ms()));
+                    e.printStackTrace(pw);
+                    pw.close();
+                });
+            }
+
+            Iris.debug("Chunk " + x + "," + z + " Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
+        }
+    }
+
+    public static void reportError(Throwable e) {
+        if (IrisSettings.get().getGeneral().isDebug()) {
+            String n = e.getClass().getCanonicalName() + "-" + e.getStackTrace()[0].getClassName() + "-" + e.getStackTrace()[0].getLineNumber();
+
+            if (e.getCause() != null) {
+                n += "-" + e.getCause().getStackTrace()[0].getClassName() + "-" + e.getCause().getStackTrace()[0].getLineNumber();
+            }
+
+            File f = instance.getDataFile("debug", "caught-exceptions", n + ".txt");
+
+            if (!f.exists()) {
+                J.attempt(() -> {
+                    PrintWriter pw = new PrintWriter(f);
+                    pw.println("Thread: " + Thread.currentThread().getName());
+                    pw.println("First: " + new Date(M.ms()));
+                    e.printStackTrace(pw);
+                    pw.close();
+                });
+            }
+
+            Iris.debug("Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
+        }
+    }
+
+    public static void dump() {
+        try {
+            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
+            FileOutputStream fos = new FileOutputStream(fi);
+            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
+            PrintWriter pw = new PrintWriter(fos);
+            for (Thread i : f.keySet()) {
+                pw.println("========================================");
+                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
+
+                for (StackTraceElement j : f.get(i)) {
+                    pw.println("    @ " + j.toString());
+                }
+
+                pw.println("========================================");
+                pw.println();
+                pw.println();
+            }
+
+            pw.close();
+            Iris.info("DUMPED! See " + fi.getAbsolutePath());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void panic() {
+        EnginePanic.panic();
+    }
+
+    public static void addPanic(String s, String v) {
+        EnginePanic.add(s, v);
+    }
+
+    private static void fixShading() {
+        ShadeFix.fix(ComponentSerializer.class);
+    }
+    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"));
+        IrisSafeguard.IrisSafeguardSystem();
+        getSender().setTag(getTag());
+        compat = IrisCompat.configured(getDataFile("compat.json"));
+        linkMultiverseCore = new MultiverseCoreLink();
+        linkMythicMobs = new MythicMobsLink();
+        configWatcher = new FileWatcher(getDataFile("settings.json"));
+        services.values().forEach(IrisService::onEnable);
+        services.values().forEach(this::registerListener);
+        J.s(() -> {
+            J.a(() -> PaperLib.suggestPaper(this));
+            J.a(() -> IO.delete(getTemp()));
+            J.a(LazyPregenerator::loadLazyGenerators, 100);
+            J.a(this::bstats);
+            J.ar(this::checkConfigHotload, 60);
+            J.sr(this::tickQueue, 0);
+            J.s(this::setupPapi);
+            J.a(ServerConfigurator::configure, 20);
+            splash();
+            UtilsSFG.splash();
+
+            autoStartStudio();
+            checkForBukkitWorlds();
+            IrisToolbelt.retainMantleDataForSlice(String.class.getCanonicalName());
+            IrisToolbelt.retainMantleDataForSlice(BlockData.class.getCanonicalName());
+        });
+    }
+
+    private void checkForBukkitWorlds() {
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            for (String s : section.getKeys(false)) {
+                ConfigurationSection entry = section.getConfigurationSection(s);
+                if (!entry.contains("generator", true)) {
+                    continue;
+                }
+
+                String generator = entry.getString("generator");
+                if (generator.startsWith("Iris:")) {
+                    generator = generator.split("\\Q:\\E")[1];
+                } else if (generator.equalsIgnoreCase("Iris")) {
+                    generator = IrisSettings.get().getGenerator().getDefaultWorldType();
+                } else {
+                    continue;
+                }
+
+                Iris.info("2 World: %s | Generator: %s", s, generator);
+
+                if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                    continue;
+                }
+
+                Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                new WorldCreator(s)
+                        .generator(getDefaultWorldGenerator(s, generator))
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
+                Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private void autoStartStudio() {
+        if (IrisSettings.get().getStudio().isAutoStartDefaultStudio()) {
+            Iris.info("Starting up auto Studio!");
+            try {
+                Player r = new KList<>(getServer().getOnlinePlayers()).getRandom();
+                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);
+                            i.teleport(new Location(w, 0, 200, 0));
+                        }
+                    });
+                });
+            } catch (IrisException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void setupAudience() {
+        try {
+            audiences = BukkitAudiences.create(this);
+        } catch (Throwable e) {
+            e.printStackTrace();
+            IrisSettings.get().getGeneral().setUseConsoleCustomColors(false);
+            IrisSettings.get().getGeneral().setUseCustomColorsIngame(false);
+            Iris.error("Failed to setup Adventure API... No custom colors :(");
+        }
+    }
+
+    public void postShutdown(Runnable r) {
+        postShutdown.add(r);
+    }
+
+    public void onEnable() {
+        enable();
+        super.onEnable();
+        Bukkit.getPluginManager().registerEvents(this, this);
+        setupChecks();
+    }
+
+    public void onDisable() {
+        services.values().forEach(IrisService::onDisable);
+        Bukkit.getScheduler().cancelTasks(this);
+        HandlerList.unregisterAll((Plugin) this);
+        postShutdown.forEach(Runnable::run);
+        services.clear();
+        MultiBurst.burst.close();
+        super.onDisable();
+    }
+
+    private void setupPapi() {
+        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
+            new IrisPapiExpansion().register();
+        }
+    }
+
+    @Override
+    public void start() {
+
+    }
+
+    @Override
+    public void stop() {
+
+    }
+
+    @Override
+    public String getTag(String subTag) {
+        if (unstablemode) {
+            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.RED + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+        }
+        if (warningmode) {
+            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.GOLD + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+        }
+        return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.IRIS + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+
+    }
+
+    private boolean setupChecks() {
+        boolean passed = true;
+        Iris.info("Version Information: " + instance.getServer().getVersion() + " | " + instance.getServer().getBukkitVersion());
+        if (INMS.get() instanceof NMSBinding1X) {
+            passed = false;
+            Iris.warn("============================================");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("Iris is not compatible with this version of Minecraft.");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("=");
+            Iris.warn("============================================");
+        }
+        if (!instance.getServer().getVersion().contains("Purpur")) {
+            passed = false;
+            Iris.info("We recommend using Purpur for the best experience with Iris.");
+            Iris.info("Purpur is a fork of Paper that is optimized for performance and stability.");
+            Iris.info("Plugins that work on Spigot / Paper work on Purpur.");
+            Iris.info("You can download it here: https://purpurmc.org");
+        }
+        return passed;
+    }
+
+    private void checkConfigHotload() {
+        if (configWatcher.checkModified()) {
+            IrisSettings.invalidate();
+            IrisSettings.get();
+            configWatcher.checkModified();
+            Iris.info("Hotloaded settings.json ");
+        }
+    }
+
+    private void tickQueue() {
+        synchronized (Iris.syncJobs) {
+            if (!Iris.syncJobs.hasNext()) {
+                return;
+            }
+
+            long ms = M.ms();
+
+            while (Iris.syncJobs.hasNext() && M.ms() - ms < 25) {
+                try {
+                    Iris.syncJobs.next().run();
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                    Iris.reportError(e);
+                }
+            }
+        }
+    }
+
+    private void bstats() {
+        if (IrisSettings.get().getGeneral().isPluginMetrics()) {
+            J.s(() -> new Metrics(Iris.instance, 8757));
+        }
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
+        return super.onCommand(sender, command, label, args);
+    }
+
+    public void imsg(CommandSender s, String msg) {
+        s.sendMessage(C.IRIS + "[" + C.DARK_GRAY + "Iris" + C.IRIS + "]" + C.GRAY + ": " + msg);
+    }
+
+    @Nullable
+    @Override
+    public BiomeProvider getDefaultBiomeProvider(@NotNull String worldName, @Nullable String id) {
+        Iris.debug("Biome Provider Called for " + worldName + " using ID: " + id);
+        return super.getDefaultBiomeProvider(worldName, id);
+    }
+
+    @Override
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
+        if (worldName.equals("test")) {
+            try {
+                throw new RuntimeException();
+            } catch (Throwable e) {
+                Iris.info(e.getStackTrace()[1].getClassName());
+                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
+                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
+                    return new DummyChunkGenerator();
+                }
+            }
+        }
+
+        IrisDimension dim;
+        if (id == null || id.isEmpty()) {
+            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+        } else {
+            dim = IrisData.loadAnyDimension(id);
+        }
+        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
+
+        if (dim == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+
+            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
+            dim = IrisData.loadAnyDimension(id);
+
+            if (dim == null) {
+                throw new RuntimeException("Can't find dimension " + id + "!");
+            } else {
+                Iris.info("Resolved missing dimension, proceeding with generation.");
+            }
+        }
+
+        Iris.debug("Assuming IrisDimension: " + dim.getName());
+
+        IrisWorld w = IrisWorld.builder()
+                .name(worldName)
+                .seed(1337)
+                .environment(dim.getEnvironment())
+                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
+                .minHeight(dim.getMinHeight())
+                .maxHeight(dim.getMaxHeight())
+                .build();
+
+        Iris.debug("Generator Config: " + w.toString());
+
+        File ff = new File(w.worldFolder(), "iris/pack");
+        if (!ff.exists() || ff.listFiles().length == 0) {
+            ff.mkdirs();
+            service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
+        }
+
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+    }
+
+    public void splash() {
+        if (!IrisSettings.get().getGeneral().isSplashLogoStartup()) {
+            return;
+        }
+
+        String padd = Form.repeat(" ", 8);
+        String padd2 = Form.repeat(" ", 4);
+        String[] info = {"", "", "", "", "", padd2 + C.IRIS + " Iris", padd2 + C.GRAY + " by " + "<rainbow>Volmit Software", padd2 + C.GRAY + " v" + C.IRIS + getDescription().getVersion()};
+        if (unstablemode) {
+             info = new String[]{"", "", "", "", "", padd2 + C.RED + " Iris", padd2 + C.GRAY + " by " + C.DARK_RED + "Volmit Software", padd2 + C.GRAY + " v" + C.RED + getDescription().getVersion()};
+        }
+        if (warningmode) {
+            info = new String[]{"", "", "", "", "", padd2 + C.GOLD + " Iris", padd2 + C.GRAY + " by " + C.GOLD + "Volmit Software", padd2 + C.GRAY + " v" + C.GOLD + getDescription().getVersion()};
+        }
+
+        String[] splashstable = {
+                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
+                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.IRIS + "   .(((()))).                     ",
+                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.IRIS + "  .((((((())))))).                  ",
+                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.IRIS + "  ((((((((()))))))))               " + C.GRAY + " @",
+                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.IRIS + "    ((((((((-)))))))))              " + C.GRAY + " @@",
+                padd + C.GRAY + "@@@&&" + C.IRIS + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
+                padd + C.GRAY + "@@" + C.IRIS + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
+                padd + C.GRAY + "@" + C.IRIS + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
+                padd + C.GRAY + "" + C.IRIS + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
+                padd + C.GRAY + "" + C.IRIS + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
+                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
+        };
+
+        String[] splashunstable = {
+                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
+                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.RED + "   .(((()))).                     ",
+                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.RED + "  .((((((())))))).                  ",
+                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.RED + "  ((((((((()))))))))               " + C.GRAY + " @",
+                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.RED + "    ((((((((-)))))))))              " + C.GRAY + " @@",
+                padd + C.GRAY + "@@@&&" + C.RED + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
+                padd + C.GRAY + "@@" + C.RED + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
+                padd + C.GRAY + "@" + C.RED + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
+                padd + C.GRAY + "" + C.RED + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
+                padd + C.GRAY + "" + C.RED + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
+                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
+        };
+        String[] splashwarning = {
+                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
+                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.GOLD + "   .(((()))).                     ",
+                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.GOLD + "  .((((((())))))).                  ",
+                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.GOLD + "  ((((((((()))))))))               " + C.GRAY + " @",
+                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.GOLD + "    ((((((((-)))))))))              " + C.GRAY + " @@",
+                padd + C.GRAY + "@@@&&" + C.GOLD + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
+                padd + C.GRAY + "@@" + C.GOLD + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
+                padd + C.GRAY + "@" + C.GOLD + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
+                padd + C.GRAY + "" + C.GOLD + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
+                padd + C.GRAY + "" + C.GOLD + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
+                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
+        };
+        String[] splash;
+        File freeSpace = new File(Bukkit.getWorldContainer() + ".");
+        if (unstablemode) {
+            splash = splashunstable;
+        } else if (warningmode) {
+            splash = splashwarning;
+        } else {
+            splash = splashstable;
+        }
+        OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
+        String osArch = osBean.getArch();
+        String osName = osBean.getName();
+
+        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..");
+            } else {
+                Iris.info(C.YELLOW + "Purpur is recommended to use with iris.");
+            }
+        }
+        Iris.info("Server OS: " + osName + " (" + osArch + ")");
+
+        try {
+            if (warningmode){
+                Iris.info("Server Cpu: " + C.GOLD + getCPUModel());
+            } else {
+            if(unstablemode){
+                Iris.info("Server Cpu: " + C.DARK_RED + getCPUModel());
+            } else {
+                if (getCPUModel().contains("Intel")) {
+                    Iris.info("Server Cpu: " + C.BLUE + getCPUModel());
+                }
+                if (getCPUModel().contains("Ryzen")) {
+                    Iris.info("Server Cpu: " + C.RED + getCPUModel());
+                }
+                if (!getCPUModel().contains("Ryzen") && !getCPUModel().contains("Intel")) {
+                    Iris.info("Server Cpu: " + C.GRAY + getCPUModel());
+                }
+            }
+            }
+        } catch (Exception e){
+            Iris.info("Server Cpu: " + C.DARK_RED + "Failed");
+        }
+
+        Iris.info("Process Threads: " +  Runtime.getRuntime().availableProcessors());
+        Iris.info("Process Memory: " + getHardware.getProcessMemory() + " MB");
+        Iris.info("Free DiskSpace: " + Form.ofSize(freeSpace.getFreeSpace(), 1024));
+        if (getHardware.getProcessMemory() < 5999) {
+            Iris.warn("6GB+ Ram is recommended");
+        }
+        Iris.info("Bukkit version: " + Bukkit.getBukkitVersion());
+        Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
+        setupChecks();
+        printPacks();
+
+        for (int i = 0; i < info.length; i++) {
+            splash[i] += info[i];
+        }
+
+        Iris.info("\n\n " + new KList<>(splash).toString("\n") + "\n");
+    }
+
+    private void printPacks() {
+        File packFolder = Iris.service(StudioSVC.class).getWorkspaceFolder();
+        File[] packs = packFolder.listFiles(File::isDirectory);
+        if (packs == null || packs.length == 0)
+            return;
+        Iris.info("Custom Dimensions: " + packs.length);
+        for (File f : packs)
+            printPack(f);
+    }
+
+    private void printPack(File pack) {
+        String dimName = pack.getName();
+        String version = "???";
+        try (FileReader r = new FileReader(new File(pack, "dimensions/" + dimName + ".json"))) {
+            JsonObject json = JsonParser.parseReader(r).getAsJsonObject();
+            if (json.has("version"))
+                version = json.get("version").getAsString();
+        } catch (IOException | JsonParseException ignored) {
+        }
+        Iris.info("  " + dimName + " v" + version);
+    }
+
+    public int getIrisVersion() {
+        String input = Iris.instance.getDescription().getVersion();
+        int hyphenIndex = input.indexOf('-');
+        if (hyphenIndex != -1) {
+            String result = input.substring(0, hyphenIndex);
+            result = result.replaceAll("\\.", "");
+            return Integer.parseInt(result);
+        }
+        return -1;
+    }
+
+    public int getMCVersion() {
+        try {
+            String version = Bukkit.getVersion();
+            Matcher matcher = Pattern.compile("\\(MC: ([\\d.]+)\\)").matcher(version);
+            if (matcher.find()) {
+                version = matcher.group(1).replaceAll("\\.", "");
+                long versionNumber = Long.parseLong(version);
+                if (versionNumber > Integer.MAX_VALUE) {
+                    return -1;
+                }
+                return (int) versionNumber;
+            }
+            return -1;
+        } catch (Exception e) {
+            return -1;
+        }
+    }
+}

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;
@@ -32,7 +33,7 @@ import java.io.IOException;
 @SuppressWarnings("SynchronizeOnNonFinalField")
 @Data
 public class IrisSettings {
-    public static transient IrisSettings settings;
+    public static IrisSettings settings;
     private IrisSettingsGeneral general = new IrisSettingsGeneral();
     private IrisSettingsWorld world = new IrisSettingsWorld();
     private IrisSettingsGUI gui = new IrisSettingsGUI();
@@ -43,13 +44,64 @@ public class IrisSettings {
     private IrisSettingsPerformance performance = new IrisSettingsPerformance();
 
     public static int getThreadCount(int c) {
-        return switch(c) {
+        return switch (c) {
             case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
             case 0, 1, 2 -> 1;
             default -> Math.max(c, 2);
         };
     }
 
+    public static IrisSettings get() {
+        if (settings != null) {
+            return settings;
+        }
+
+        settings = new IrisSettings();
+
+        File s = Iris.instance.getDataFile("settings.json");
+
+        if (!s.exists()) {
+            try {
+                IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+            } catch (JSONException | IOException e) {
+                e.printStackTrace();
+                Iris.reportError(e);
+            }
+        } else {
+            try {
+                String ss = IO.readAll(s);
+                settings = new Gson().fromJson(ss, IrisSettings.class);
+                try {
+                    IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+            } catch (Throwable ee) {
+                // Iris.reportError(ee); causes a self-reference & stackoverflow
+                Iris.error("Configuration Error in settings.json! " + ee.getClass().getSimpleName() + ": " + ee.getMessage());
+            }
+        }
+
+        return settings;
+    }
+
+    public static void invalidate() {
+        synchronized (settings) {
+            settings = null;
+        }
+    }
+
+    public void forceSave() {
+        File s = Iris.instance.getDataFile("settings.json");
+
+        try {
+            IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
+        } catch (JSONException | IOException e) {
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+    }
+
     @Data
     public static class IrisSettingsAutoconfiguration {
         public boolean configureSpigotTimeoutTime = true;
@@ -74,6 +126,7 @@ public class IrisSettings {
         public double targetSpawnEntitiesPerChunk = 0.95;
         public boolean markerEntitySpawningSystem = true;
         public boolean effectSystem = true;
+        public boolean worldEditWandCUI = true;
     }
 
     @Data
@@ -83,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;
@@ -93,6 +146,7 @@ public class IrisSettings {
 
     @Data
     public static class IrisSettingsGeneral {
+        public boolean ignoreBootMode = false;
         public boolean commandSounds = true;
         public boolean debug = false;
         public boolean disableNMS = false;
@@ -104,6 +158,8 @@ public class IrisSettings {
         public int spinh = -20;
         public int spins = 7;
         public int spinb = 8;
+        public String cartographerMessage = "Iris does not allow cartographers in its world due to crashes.";
+
 
         @SuppressWarnings("BooleanMethodIsAlwaysInverted")
         public boolean canUseCustomColors(VolmitSender volmitSender) {
@@ -121,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;
     }
 
@@ -131,55 +188,4 @@ public class IrisSettings {
         public boolean disableTimeAndWeather = true;
         public boolean autoStartDefaultStudio = false;
     }
-
-    public static IrisSettings get() {
-        if(settings != null) {
-            return settings;
-        }
-
-        settings = new IrisSettings();
-
-        File s = Iris.instance.getDataFile("settings.json");
-
-        if(!s.exists()) {
-            try {
-                IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-            } catch(JSONException | IOException e) {
-                e.printStackTrace();
-                Iris.reportError(e);
-            }
-        } else {
-            try {
-                String ss = IO.readAll(s);
-                settings = new Gson().fromJson(ss, IrisSettings.class);
-                try {
-                    IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-                } catch(IOException e) {
-                    e.printStackTrace();
-                }
-            } catch(Throwable ee) {
-                // Iris.reportError(ee); causes a self-reference & stackoverflow
-                Iris.error("Configuration Error in settings.json! " + ee.getClass().getSimpleName() + ": " + ee.getMessage());
-            }
-        }
-
-        return settings;
-    }
-
-    public static void invalidate() {
-        synchronized(settings) {
-            settings = null;
-        }
-    }
-
-    public void forceSave() {
-        File s = Iris.instance.getDataFile("settings.json");
-
-        try {
-            IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-        } catch(JSONException | IOException e) {
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-    }
 }

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

@@ -24,10 +24,10 @@ 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;
-import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
 import org.bukkit.Bukkit;
@@ -38,16 +38,17 @@ import org.bukkit.entity.Player;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 import java.util.concurrent.TimeUnit;
 
 public class ServerConfigurator {
     public static void configure() {
         IrisSettings.IrisSettingsAutoconfiguration s = IrisSettings.get().getAutoConfiguration();
-        if(s.isConfigureSpigotTimeoutTime()) {
+        if (s.isConfigureSpigotTimeoutTime()) {
             J.attempt(ServerConfigurator::increaseKeepAliveSpigot);
         }
 
-        if(s.isConfigurePaperWatchdogDelay()) {
+        if (s.isConfigurePaperWatchdogDelay()) {
             J.attempt(ServerConfigurator::increasePaperWatchdog);
         }
 
@@ -55,88 +56,88 @@ public class ServerConfigurator {
     }
 
     private static void increaseKeepAliveSpigot() throws IOException, InvalidConfigurationException {
-        File spigotConfig = new File("spigot.yml");
+        File spigotConfig = new File("config/spigot.yml");
         FileConfiguration f = new YamlConfiguration();
         f.load(spigotConfig);
         long tt = f.getLong("settings.timeout-time");
 
-        if(tt < TimeUnit.MINUTES.toSeconds(5)) {
-            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(5) + " (5 minutes)");
+        if (tt < TimeUnit.MINUTES.toSeconds(5)) {
+            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(20) + " (5 minutes)");
             Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
             f.set("settings.timeout-time", TimeUnit.MINUTES.toSeconds(5));
             f.save(spigotConfig);
         }
     }
-
     private static void increasePaperWatchdog() throws IOException, InvalidConfigurationException {
-        File spigotConfig = new File("paper.yml");
+        File spigotConfig = new File("config/paper-global.yml");
         FileConfiguration f = new YamlConfiguration();
         f.load(spigotConfig);
-        long tt = f.getLong("settings.watchdog.early-warning-delay");
+        long tt = f.getLong("watchdog.early-warning-delay");
 
-        if(tt < TimeUnit.MINUTES.toMillis(3)) {
-            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(3) + " (3 minutes)");
+        if (tt < TimeUnit.MINUTES.toMillis(3)) {
+            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(15) + " (3 minutes)");
             Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("settings.watchdog.early-warning-delay", TimeUnit.MINUTES.toMillis(3));
+            f.set("watchdog.early-warning-delay", TimeUnit.MINUTES.toMillis(3));
             f.save(spigotConfig);
         }
     }
 
-    private static File getDatapacksFolder() {
-        if(!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
-            return new File(IrisSettings.get().getGeneral().forceMainWorld + "/datapacks");
+    private static List<File> getDatapacksFolder() {
+        if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
+            return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
         }
-
-        File props = new File("server.properties");
-
-        if(props.exists()) {
-            try {
-                KList<String> m = new KList<>(IO.readAll(props).split("\\Q\n\\E"));
-
-                for(String i : m) {
-                    if(i.trim().startsWith("level-name=")) {
-                        return new File(i.trim().split("\\Q=\\E")[1] + "/datapacks");
-                    }
-                }
-            } catch(IOException e) {
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-        }
-
-        return null;
+        KList<File> worlds = new KList<>();
+        Bukkit.getServer().getWorlds().forEach(w -> worlds.add(new File(w.getWorldFolder(), "datapacks")));
+        return worlds;
     }
 
+
     public static void installDataPacks(boolean fullInstall) {
         Iris.info("Checking Data Packs...");
-        boolean reboot = false;
         File packs = new File("plugins/Iris/packs");
-        File dpacks = getDatapacksFolder();
-
-        if(dpacks == null) {
-            Iris.error("Cannot find the datapacks folder! Please try generating a default world first maybe? Is this a new server?");
-            return;
+        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()) {
-                if(i.isDirectory()) {
+        if (packs.exists()) {
+            for (File i : packs.listFiles()) {
+                if (i.isDirectory()) {
                     Iris.verbose("Checking Pack: " + i.getPath());
                     IrisData data = IrisData.get(i);
                     File dims = new File(i, "dimensions");
 
-                    if(dims.exists()) {
-                        for(File j : dims.listFiles()) {
-                            if(j.getName().endsWith(".json")) {
+                    if (dims.exists()) {
+                        for (File j : dims.listFiles()) {
+                            if (j.getName().endsWith(".json")) {
                                 IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
 
-                                if(dim == null) {
+                                if (dim == null) {
                                     continue;
                                 }
 
                                 Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
-                                if(dim.installDataPack(() -> data, dpacks)) {
-                                    reboot = true;
+                                for (File dpack : getDatapacksFolder()) {
+                                    dim.installDataPack(() -> data, dpack, ultimateMaxHeight, ultimateMinHeight);
                                 }
                             }
                         }
@@ -147,39 +148,32 @@ public class ServerConfigurator {
 
         Iris.info("Data Packs Setup!");
 
-        if(fullInstall) {
+        if (fullInstall)
             verifyDataPacksPost(IrisSettings.get().getAutoConfiguration().isAutoRestartOnCustomBiomeInstall());
-        }
     }
 
     private static void verifyDataPacksPost(boolean allowRestarting) {
         File packs = new File("plugins/Iris/packs");
-        File dpacks = getDatapacksFolder();
-
-        if(dpacks == null) {
-            Iris.error("Cannot find the datapacks folder! Please try generating a default world first maybe? Is this a new server?");
-            return;
-        }
 
         boolean bad = false;
-        if(packs.exists()) {
-            for(File i : packs.listFiles()) {
-                if(i.isDirectory()) {
+        if (packs.exists()) {
+            for (File i : packs.listFiles()) {
+                if (i.isDirectory()) {
                     Iris.verbose("Checking Pack: " + i.getPath());
                     IrisData data = IrisData.get(i);
                     File dims = new File(i, "dimensions");
 
-                    if(dims.exists()) {
-                        for(File j : dims.listFiles()) {
-                            if(j.getName().endsWith(".json")) {
+                    if (dims.exists()) {
+                        for (File j : dims.listFiles()) {
+                            if (j.getName().endsWith(".json")) {
                                 IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
 
-                                if(dim == null) {
+                                if (dim == null) {
                                     Iris.error("Failed to load " + j.getPath() + " ");
                                     continue;
                                 }
 
-                                if(!verifyDataPackInstalled(dim)) {
+                                if (!verifyDataPackInstalled(dim)) {
                                     bad = true;
                                 }
                             }
@@ -189,10 +183,10 @@ public class ServerConfigurator {
             }
         }
 
-        if(bad) {
-            if(allowRestarting) {
+        if (bad) {
+            if (allowRestarting) {
                 restart();
-            } else if(INMS.get().supportsDataPacks()) {
+            } else if (INMS.get().supportsDataPacks()) {
                 Iris.error("============================================================================");
                 Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
                 Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
@@ -200,8 +194,8 @@ public class ServerConfigurator {
                 Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
                 Iris.error("============================================================================");
 
-                for(Player i : Bukkit.getOnlinePlayers()) {
-                    if(i.isOp() || i.hasPermission("iris.all")) {
+                for (Player i : Bukkit.getOnlinePlayers()) {
+                    if (i.isOp() || i.hasPermission("iris.all")) {
                         VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
                         sender.sendMessage("There are some Iris Packs that have custom biomes in them");
                         sender.sendMessage("You need to restart your server to use these packs.");
@@ -231,16 +225,16 @@ public class ServerConfigurator {
         KSet<String> keys = new KSet<>();
         boolean warn = false;
 
-        for(IrisBiome i : dimension.getAllBiomes(() -> idm)) {
-            if(i.isCustom()) {
-                for(IrisBiomeCustom j : i.getCustomDerivitives()) {
+        for (IrisBiome i : dimension.getAllBiomes(() -> idm)) {
+            if (i.isCustom()) {
+                for (IrisBiomeCustom j : i.getCustomDerivitives()) {
                     keys.add(dimension.getLoadKey() + ":" + j.getId());
                 }
             }
         }
 
-        if(!INMS.get().supportsDataPacks()) {
-            if(!keys.isEmpty()) {
+        if (!INMS.get().supportsDataPacks()) {
+            if (!keys.isEmpty()) {
                 Iris.warn("===================================================================================");
                 Iris.warn("Pack " + dimension.getLoadKey() + " has " + keys.size() + " custom biome(s). ");
                 Iris.warn("Your server version does not yet support datapacks for iris.");
@@ -251,16 +245,16 @@ public class ServerConfigurator {
             return true;
         }
 
-        for(String i : keys) {
+        for (String i : keys) {
             Object o = INMS.get().getCustomBiomeBaseFor(i);
 
-            if(o == null) {
+            if (o == null) {
                 Iris.warn("The Biome " + i + " is not registered on the server.");
                 warn = true;
             }
         }
 
-        if(warn) {
+        if (warn) {
             Iris.error("The Pack " + dimension.getLoadKey() + " is INCAPABLE of generating custom biomes");
             Iris.error("If not done automatically, restart your server before generating with this pack!");
         }

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

@@ -0,0 +1,134 @@
+/*
+ * 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.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.DeepSearchPregenerator;
+import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.core.pregenerator.TurboPregenerator;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.util.data.Dimension;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.Position2;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+
+@Decree(name = "DeepSearch", aliases = "search", description = "Pregenerate your Iris worlds!")
+public class CommandDeepSearch implements DecreeExecutor {
+    public String worldName;
+    @Decree(description = "DeepSearch a world")
+    public void start(
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            int radius,
+            @Param(description = "The world to pregen", contextual = true)
+            World world,
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
+            Vector center
+            ) {
+
+        worldName = world.getName();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File TurboFile = new File(worldDirectory, "DeepSearch.json");
+        if (TurboFile.exists()) {
+            if (DeepSearchPregenerator.getInstance() != null) {
+                sender().sendMessage(C.BLUE + "DeepSearch is already in progress");
+                Iris.info(C.YELLOW + "DeepSearch is already in progress");
+                return;
+            } else {
+                try {
+                    TurboFile.delete();
+                } catch (Exception e){
+                   Iris.error("Failed to delete the old instance file of DeepSearch!");
+                   return;
+                }
+            }
+        }
+
+        try {
+            if (sender().isPlayer() && access() == null) {
+                sender().sendMessage(C.RED + "The engine access for this world is null!");
+                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
+            }
+
+            DeepSearchPregenerator.DeepSearchJob DeepSearchJob = DeepSearchPregenerator.DeepSearchJob.builder()
+                    .world(world)
+                    .radiusBlocks(radius)
+                    .position(0)
+                    .build();
+
+            File SearchGenFile = new File(worldDirectory, "DeepSearch.json");
+            DeepSearchPregenerator pregenerator = new DeepSearchPregenerator(DeepSearchJob, SearchGenFile);
+            pregenerator.start();
+
+            String msg = C.GREEN + "DeepSearch started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
+            sender().sendMessage(msg);
+            Iris.info(msg);
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Epic fail. See console.");
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Stop the active DeepSearch task", aliases = "x")
+    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
+        DeepSearchPregenerator DeepSearchInstance = DeepSearchPregenerator.getInstance();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File turboFile = new File(worldDirectory, "DeepSearch.json");
+
+        if (DeepSearchInstance != null) {
+            DeepSearchInstance.shutdownInstance(world);
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
+        } else if (turboFile.exists() && turboFile.delete()) {
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
+        } else if (turboFile.exists()) {
+            Iris.error("Failed to delete the old instance file of Turbo Pregen!");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
+        }
+    }
+
+    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
+    public void pause(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) {
+        if (TurboPregenerator.getInstance() != null) {
+            TurboPregenerator.setPausedTurbo(world);
+            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
+        } else {
+            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+            File TurboFile = new File(worldDirectory, "DeepSearch.json");
+            if (TurboFile.exists()){
+                TurboPregenerator.loadTurboGenerator(world.getName());
+                sender().sendMessage(C.YELLOW + "Started DeepSearch back up!");
+            } else {
+                sender().sendMessage(C.YELLOW + "No active DeepSearch tasks to pause/unpause.");
+            }
+
+        }
+    }
+}

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

@@ -0,0 +1,284 @@
+/*
+ * 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.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;
+import com.volmit.iris.util.decree.annotations.Param;
+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;
+import java.util.zip.GZIPOutputStream;
+
+@Decree(name = "Developer", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"dev"})
+public class CommandDeveloper implements DecreeExecutor {
+    private CommandTurboPregen turboPregen;
+
+    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
+    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
+            }
+        }
+
+        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")
+    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")
+    public void compression(
+            @Param(description = "base IrisWorld") World world,
+            @Param(description = "raw TectonicPlate File") String path,
+            @Param(description = "Algorithm to Test") String algorithm,
+            @Param(description = "Amount of Tests") int amount) {
+        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;
+        }
+
+        File file = new File(path);
+        if (!file.exists()) return;
+
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        if(engine != null) {
+            int height = engine.getTarget().getHeight();
+            ExecutorService service = Executors.newFixedThreadPool(1);
+            VolmitSender sender = sender();
+            service.submit(() -> {
+                try {
+                    DataInputStream raw = new DataInputStream(new FileInputStream(file));
+                    TectonicPlate plate = new TectonicPlate(height, raw);
+                    raw.close();
+
+                    double d1 = 0;
+                    double d2 = 0;
+                    long size = 0;
+                    File folder = new File("tmp");
+                    folder.mkdirs();
+                    for (int i = 0; i < amount; i++) {
+                        File tmp = new File(folder, RandomStringUtils.randomAlphanumeric(10) + "." + algorithm + ".bin");
+                        DataOutputStream dos = createOutput(tmp, algorithm);
+                        long start = System.currentTimeMillis();
+                        plate.write(dos);
+                        dos.close();
+                        d1 += System.currentTimeMillis() - start;
+                        if (size == 0)
+                            size = tmp.length();
+                        start = System.currentTimeMillis();
+                        DataInputStream din = createInput(tmp, algorithm);
+                        new TectonicPlate(height, din);
+                        din.close();
+                        d2 += System.currentTimeMillis() - start;
+                        tmp.delete();
+                    }
+                    IO.delete(folder);
+                    sender.sendMessage(algorithm + " is " + Form.fileSize(size) + " big after compression");
+                    sender.sendMessage(algorithm + " Took " + d2/amount + "ms to read");
+                    sender.sendMessage(algorithm + " Took " + d1/amount + "ms to write");
+                } catch (Throwable e) {
+                    e.printStackTrace();
+                }
+            });
+            service.shutdown();
+		} else {
+            Iris.info(C.RED + "Engine is null!");
+        }
+    }
+
+    private DataInputStream createInput(File file, String algorithm) throws Throwable {
+        FileInputStream in = new FileInputStream(file);
+
+        return new DataInputStream(switch (algorithm) {
+            case "gzip" -> new GZIPInputStream(in);
+            case "lz4f" -> new LZ4FrameInputStream(in);
+            case "lz4b" -> new LZ4BlockInputStream(in);
+            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
+        });
+    }
+
+    private DataOutputStream createOutput(File file, String algorithm) throws Throwable {
+        FileOutputStream out = new FileOutputStream(file);
+
+        return new DataOutputStream(switch (algorithm) {
+            case "gzip" -> new GZIPOutputStream(out);
+            case "lz4f" -> new LZ4FrameOutputStream(out);
+            case "lz4b" -> new LZ4BlockOutputStream(out);
+            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
+        });
+    }
+}
+
+

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

@@ -20,35 +20,29 @@ package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.service.StudioSVC;
-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.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPool;
-import com.volmit.iris.engine.object.IrisJigsawStructure;
-import com.volmit.iris.engine.object.IrisRegion;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 
-import java.awt.Desktop;
+import java.awt.*;
 
 
 @Decree(name = "edit", origin = DecreeOrigin.PLAYER, studio = true, description = "Edit something")
 public class CommandEdit implements DecreeExecutor {
 
     private boolean noStudio() {
-        if(!sender().isPlayer()) {
+        if (!sender().isPlayer()) {
             sender().sendMessage(C.RED + "Players only!");
             return true;
         }
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world is open!");
             return true;
         }
-        if(!engine().isStudio()) {
+        if (!engine().isStudio()) {
             sender().sendMessage(C.RED + "You must be in a studio world!");
             return true;
         }
@@ -58,17 +52,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the biome you specified", aliases = {"b"}, origin = DecreeOrigin.PLAYER)
     public void biome(@Param(contextual = false, description = "The biome to edit") IrisBiome biome) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(biome == null || biome.getLoadFile() == null) {
+            if (biome == null || biome.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(biome.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + biome.getTypeName() + " " + biome.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -76,17 +70,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the region you specified", aliases = {"r"}, origin = DecreeOrigin.PLAYER)
     public void region(@Param(contextual = false, description = "The region to edit") IrisRegion region) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(region == null || region.getLoadFile() == null) {
+            if (region == null || region.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(region.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + region.getTypeName() + " " + region.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -94,17 +88,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the dimension you specified", aliases = {"d"}, origin = DecreeOrigin.PLAYER)
     public void dimension(@Param(contextual = false, description = "The dimension to edit") IrisDimension dimension) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(dimension == null || dimension.getLoadFile() == null) {
+            if (dimension == null || dimension.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(dimension.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + dimension.getTypeName() + " " + dimension.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -112,17 +106,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the cave file you specified", aliases = {"c"}, origin = DecreeOrigin.PLAYER)
     public void cave(@Param(contextual = false, description = "The cave to edit") IrisCave cave) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(cave == null || cave.getLoadFile() == null) {
+            if (cave == null || cave.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(cave.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + cave.getTypeName() + " " + cave.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -130,17 +124,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the structure file you specified", aliases = {"jigsawstructure", "structure"}, origin = DecreeOrigin.PLAYER)
     public void jigsaw(@Param(contextual = false, description = "The jigsaw structure to edit") IrisJigsawStructure jigsaw) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(jigsaw == null || jigsaw.getLoadFile() == null) {
+            if (jigsaw == null || jigsaw.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(jigsaw.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + jigsaw.getTypeName() + " " + jigsaw.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -148,17 +142,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the pool file you specified", aliases = {"jigsawpool", "pool"}, origin = DecreeOrigin.PLAYER)
     public void jigsawPool(@Param(contextual = false, description = "The jigsaw pool to edit") IrisJigsawPool pool) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(pool == null || pool.getLoadFile() == null) {
+            if (pool == null || pool.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(pool.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + pool.getTypeName() + " " + pool.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }
@@ -166,17 +160,17 @@ public class CommandEdit implements DecreeExecutor {
 
     @Decree(description = "Edit the jigsaw piece file you specified", aliases = {"jigsawpiece", "piece"}, origin = DecreeOrigin.PLAYER)
     public void jigsawPiece(@Param(contextual = false, description = "The jigsaw piece to edit") IrisJigsawPiece piece) {
-        if(noStudio()) {
+        if (noStudio()) {
             return;
         }
         try {
-            if(piece == null || piece.getLoadFile() == null) {
+            if (piece == null || piece.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
             Desktop.getDesktop().open(piece.getLoadFile());
             sender().sendMessage(C.GREEN + "Opening " + piece.getTypeName() + " " + piece.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
         }

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

@@ -33,61 +33,85 @@ import com.volmit.iris.util.format.C;
 public class CommandFind implements DecreeExecutor {
     @Decree(description = "Find a biome")
     public void biome(
-        @Param(description = "The biome to look for")
-            IrisBiome biome
+            @Param(description = "The biome to look for")
+            IrisBiome biome,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoBiome(biome, player());
+        e.gotoBiome(biome, player(), teleport);
     }
 
     @Decree(description = "Find a region")
     public void region(
-        @Param(description = "The region to look for")
-            IrisRegion region
+            @Param(description = "The region to look for")
+            IrisRegion region,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoRegion(region, player());
+        e.gotoRegion(region, player(), teleport);
     }
 
     @Decree(description = "Find a structure")
     public void structure(
-        @Param(description = "The structure to look for")
-            IrisJigsawStructure structure
+            @Param(description = "The structure to look for")
+            IrisJigsawStructure structure,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoJigsaw(structure, player());
+        e.gotoJigsaw(structure, player(), teleport);
+    }
+
+    @Decree(description = "Find a point of interest.")
+    public void poi(
+            @Param(description = "The type of PoI to look for.")
+            String type,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
+    ) {
+        Engine e = engine();
+        if (e == null) {
+            sender().sendMessage(C.GOLD + "Not in an Iris World!");
+            return;
+        }
+
+        e.gotoPOI(type, player(), teleport);
     }
 
     @Decree(description = "Find an object")
     public void object(
-        @Param(description = "The object to look for", customHandler = ObjectHandler.class)
-            String object
+            @Param(description = "The object to look for", customHandler = ObjectHandler.class)
+            String object,
+            @Param(description = "Should you be teleported", defaultValue = "true")
+            boolean teleport
     ) {
         Engine e = engine();
 
-        if(e == null) {
+        if (e == null) {
             sender().sendMessage(C.GOLD + "Not in an Iris World!");
             return;
         }
 
-        e.gotoObject(object, player());
+        e.gotoObject(object, player(), teleport);
     }
 }

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

@@ -0,0 +1,627 @@
+/*
+ * 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.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+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;
+import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.NullablePlayerHandler;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.J;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.Difficulty;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+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;
+
+import static com.volmit.iris.Iris.service;
+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 {
+    private CommandStudio studio;
+    private CommandPregen pregen;
+    private CommandLazyPregen lazyPregen;
+    private CommandSettings settings;
+    private CommandObject object;
+    private CommandJigsaw jigsaw;
+    private CommandWhat what;
+    private CommandEdit edit;
+    private CommandFind find;
+    private CommandDeveloper developer;
+    public static boolean worldCreation = false;
+    String WorldToLoad;
+    String WorldEngine;
+    String worldNameToCheck = "YourWorldName";
+    VolmitSender sender = Iris.getSender();
+
+    @Decree(description = "Create a new world", aliases = {"+", "c"})
+    public void create(
+            @Param(aliases = "world-name", description = "The name of the world to create")
+            String name,
+            @Param(aliases = "dimension", description = "The dimension type to create the world with", defaultValue = "default")
+            IrisDimension type,
+            @Param(description = "The seed to generate the world with", defaultValue = "1337")
+            long seed
+    ) {
+        if(sender() instanceof Player) {
+            if (incompatibilities.get("Multiverse-Core")) {
+                sender().sendMessage(C.RED + "Your server has an incompatibility that may corrupt all worlds on the server if not handled properly.");
+                sender().sendMessage(C.RED + "it is strongly advised for you to take action. see log for full detail");
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+                sender().sendMessage(C.RED + "Command ran: /iris create");
+                sender().sendMessage(C.RED + UtilsSFG.MSGIncompatibleWarnings());
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+            }
+            if (unstablemode && !incompatibilities.get("Multiverse-Core")) {
+                sender().sendMessage(C.RED + "Your server is experiencing an incompatibility with the Iris plugin.");
+                sender().sendMessage(C.RED + "Please rectify this problem to avoid further complications.");
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+                sender().sendMessage(C.RED + "Command ran: /iris create");
+                sender().sendMessage(C.RED + UtilsSFG.MSGIncompatibleWarnings());
+                sender().sendMessage(C.RED + "----------------------------------------------------------------");
+            }
+        }
+            if (name.equals("iris")) {
+                sender().sendMessage(C.RED + "You cannot use the world name \"iris\" for creating worlds as Iris uses this directory for studio worlds.");
+                sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
+                return;
+            }
+            if (name.equals("Benchmark")) {
+                sender().sendMessage(C.RED + "You cannot use the world name \"Benchmark\" for creating worlds as Iris uses this directory for Benchmarking Packs.");
+                sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
+                return;
+            }
+
+        if (new File(Bukkit.getWorldContainer(), name).exists()) {
+            sender().sendMessage(C.RED + "That folder already exists!");
+            return;
+        }
+
+        try {
+            worldCreation = true;
+            IrisToolbelt.createWorld()
+                    .dimension(type.getLoadKey())
+                    .name(name)
+                    .seed(seed)
+                    .sender(sender())
+                    .studio(false)
+                    .create();
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Exception raised during creation. See the console for more details.");
+            Iris.error("Exception raised during world creation: " + e.getMessage());
+            Iris.reportError(e);
+            worldCreation = false;
+            return;
+        }
+        worldCreation = false;
+        sender().sendMessage(C.GREEN + "Successfully created your world!");
+    }
+
+    @Decree(description = "Teleport to another world", aliases = {"tp"}, sync = true)
+    public void teleport(
+            @Param(description = "World to teleport to")
+            World world,
+            @Param(description = "Player to teleport", defaultValue = "---", customHandler = NullablePlayerHandler.class)
+            Player player
+    ) {
+        if (player == null && sender().isPlayer())
+            player = sender().player();
+
+        final Player target = player;
+        if (target == null) {
+            sender().sendMessage(C.RED + "The specified player does not exist.");
+            return;
+        }
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                target.teleport(world.getSpawnLocation());
+                new VolmitSender(target).sendMessage(C.GREEN + "You have been teleported to " + world.getName() + ".");
+            }
+        }.runTask(Iris.instance);
+    }
+
+    @Decree(description = "Print version information")
+    public void version() {
+        sender().sendMessage(C.GREEN + "Iris v" + Iris.instance.getDescription().getVersion() + " by Volmit Software");
+    }
+
+    //todo Move to React
+    @Decree(description = "Benchmark your server", origin = DecreeOrigin.CONSOLE)
+    public void serverbenchmark() throws InterruptedException {
+        if(!inProgress) {
+            IrisBenchmarking.runBenchmark();
+        } else {
+            Iris.info(C.RED + "Benchmark already is in progress.");
+        }
+    }
+
+    /*
+    /todo
+    @Decree(description = "Benchmark a pack", origin = DecreeOrigin.CONSOLE)
+    public void packbenchmark(
+            @Param(description = "Dimension to benchmark")
+            IrisDimension type
+    ) throws InterruptedException {
+
+         BenchDimension = type.getLoadKey();
+
+        IrisPackBenchmarking.runBenchmark();
+    } */
+
+    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
+    public void height() {
+        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)
+    public void so() {
+        sender().sendMessage(C.GREEN + "Opening studio for the \"Overworld\" pack (seed: 1337)");
+        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")
+            World world,
+            @Param(description = "Whether to also remove the folder (if set to false, just does not load the world)", defaultValue = "true")
+            boolean delete
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            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());
+        try {
+            if (IrisToolbelt.removeWorld(world)) {
+                sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
+            } else {
+                sender().sendMessage(C.YELLOW + "Looks like the world was already removed from bukkit.yml");
+            }
+        } catch (IOException e) {
+            sender().sendMessage(C.RED + "Failed to save bukkit.yml because of " + e.getMessage());
+            e.printStackTrace();
+        }
+        IrisToolbelt.evacuate(world, "Deleting world");
+        deletingWorld = true;
+        Bukkit.unloadWorld(world, false);
+        int retries = 12;
+        if (delete) {
+            if (deleteDirectory(world.getWorldFolder())) {
+                sender().sendMessage(C.GREEN + "Successfully removed world folder");
+            } else {
+                while(true){
+                    if (deleteDirectory(world.getWorldFolder())){
+                        sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                        break;
+                    }
+                    retries--;
+                    if (retries == 0){
+                        sender().sendMessage(C.RED + "Failed to remove world folder");
+                        break;
+                    }
+                    J.sleep(3000);
+                }
+            }
+        }
+        deletingWorld = false;
+    }
+
+    public static boolean deleteDirectory(File dir) {
+        if (dir.isDirectory()) {
+            File[] children = dir.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                boolean success = deleteDirectory(children[i]);
+                if (!success) {
+                    return false;
+                }
+            }
+        }
+        return dir.delete();
+    }
+
+    @Decree(description = "Set aura spins")
+    public void aura(
+            @Param(description = "The h color value", defaultValue = "-20")
+            int h,
+            @Param(description = "The s color value", defaultValue = "7")
+            int s,
+            @Param(description = "The b color value", defaultValue = "8")
+            int b
+    ) {
+        IrisSettings.get().getGeneral().setSpinh(h);
+        IrisSettings.get().getGeneral().setSpins(s);
+        IrisSettings.get().getGeneral().setSpinb(b);
+        IrisSettings.get().forceSave();
+        sender().sendMessage("<rainbow>Aura Spins updated to " + h + " " + s + " " + b);
+    }
+
+    @Decree(description = "Bitwise calculations")
+    public void bitwise(
+            @Param(description = "The first value to run calculations on")
+            int value1,
+            @Param(description = "The operator: | & ^ ≺≺ ≻≻ ％")
+            String operator,
+            @Param(description = "The second value to run calculations on")
+            int value2
+    ) {
+        Integer v = null;
+        switch (operator) {
+            case "|" -> v = value1 | value2;
+            case "&" -> v = value1 & value2;
+            case "^" -> v = value1 ^ value2;
+            case "%" -> v = value1 % value2;
+            case ">>" -> v = value1 >> value2;
+            case "<<" -> v = value1 << value2;
+        }
+        if (v == null) {
+            sender().sendMessage(C.RED + "The operator you entered: (" + operator + ") is invalid!");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "" + value1 + " " + C.GREEN + operator.replaceAll("<", "≺").replaceAll(">", "≻").replaceAll("%", "％") + " " + C.GREEN + value2 + C.GREEN + " returns " + C.GREEN + v);
+    }
+
+    @Decree(description = "Toggle debug")
+    public void debug(
+            @Param(name = "on", description = "Whether or not debug should be on", defaultValue = "other")
+            Boolean on
+    ) {
+        boolean to = on == null ? !IrisSettings.get().getGeneral().isDebug() : on;
+        IrisSettings.get().getGeneral().setDebug(to);
+        IrisSettings.get().forceSave();
+        sender().sendMessage(C.GREEN + "Set debug to: " + to);
+    }
+
+    @Decree(description = "Download a project.", aliases = "dl")
+    public void download(
+            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
+            String pack,
+            @Param(name = "branch", description = "The branch to download from", defaultValue = "main")
+            String branch,
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            boolean trim,
+            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
+            boolean overwrite
+    ) {
+        sender().sendMessage(C.GREEN + "Downloading pack: " + pack + "/" + branch + (trim ? " trimmed" : "") + (overwrite ? " overwriting" : ""));
+        if (pack.equals("overworld")) {
+            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + Iris.OVERWORLD_TAG + "/overworld.zip";
+            Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
+        } else {
+            Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
+        }
+    }
+
+    @Decree(description = "Get metrics for your world", aliases = "measure", origin = DecreeOrigin.PLAYER)
+    public void metrics() {
+        if (!IrisToolbelt.isIrisWorld(world())) {
+            sender().sendMessage(C.RED + "You must be in an Iris world");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Sending metrics...");
+        engine().printMetrics(sender());
+    }
+
+    @Decree(description = "Reload configuration file (this is also done automatically)")
+    public void reload() {
+        IrisSettings.invalidate();
+        IrisSettings.get();
+        sender().sendMessage(C.GREEN + "Hotloaded settings");
+    }
+
+    @Decree(description = "Update the pack of a world (UNSAFE!)", name = "^world", aliases = "update-world")
+    public void updateWorld(
+            @Param(description = "The world to update", contextual = true)
+            World world,
+            @Param(description = "The pack to install into the world", contextual = true, aliases = "dimension")
+            IrisDimension pack,
+            @Param(description = "Make sure to make a backup & read the warnings first!", defaultValue = "false", aliases = "c")
+            boolean confirm,
+            @Param(description = "Should Iris download the pack again for you", defaultValue = "false", name = "fresh-download", aliases = {"fresh", "new"})
+            boolean freshDownload
+    ) {
+        if (!confirm) {
+            sender().sendMessage(new String[]{
+                    C.RED + "You should always make a backup before using this",
+                    C.YELLOW + "Issues caused by this can be, but are not limited to:",
+                    C.YELLOW + " - Broken chunks (cut-offs) between old and new chunks (before & after the update)",
+                    C.YELLOW + " - Regenerated chunks that do not fit in with the old chunks",
+                    C.YELLOW + " - Structures not spawning again when regenerating",
+                    C.YELLOW + " - Caves not lining up",
+                    C.YELLOW + " - Terrain layers not lining up",
+                    C.RED + "Now that you are aware of the risks, and have made a back-up:",
+                    C.RED + "/iris ^world " + world.getName() + " " + pack.getLoadKey() + " confirm=true"
+            });
+            return;
+        }
+
+        File folder = world.getWorldFolder();
+        folder.mkdirs();
+
+        if (freshDownload) {
+            Iris.service(StudioSVC.class).downloadSearch(sender(), pack.getLoadKey(), false, true);
+        }
+
+        Iris.service(StudioSVC.class).installIntoWorld(sender(), pack.getLoadKey(), folder);
+    }
+
+    @Decree(description = "Unload an Iris World", origin = DecreeOrigin.PLAYER, sync = true)
+    public void unloadWorld(
+            @Param(description = "The world to unload")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            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());
+        try {
+            IrisToolbelt.evacuate(world);
+            Bukkit.unloadWorld(world, false);
+            sender().sendMessage(C.GREEN + "World unloaded successfully.");
+        } catch (Exception e) {
+            sender().sendMessage(C.RED + "Failed to unload the world: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Load an Iris World", origin = DecreeOrigin.PLAYER, sync = true, aliases = {"import"})
+    public void loadWorld(
+            @Param(description = "The name of the world to load")
+            String world
+    ) {
+        World worldloaded = Bukkit.getWorld(world);
+        worldNameToCheck = world;
+        boolean worldExists = doesWorldExist(worldNameToCheck);
+        WorldEngine = world;
+
+        if (!worldExists) {
+            sender().sendMessage(C.YELLOW + world + " Doesnt exist on the server.");
+            return;
+        }
+        WorldToLoad = world;
+        File BUKKIT_YML = new File("bukkit.yml");
+        String pathtodim = world + File.separator +"iris"+File.separator +"pack"+File.separator +"dimensions"+File.separator;
+        File directory = new File(Bukkit.getWorldContainer(), pathtodim);
+
+        String dimension = null;
+        if (directory.exists() && directory.isDirectory()) {
+            File[] files = directory.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isFile()) {
+                        String fileName = file.getName();
+                        if (fileName.endsWith(".json")) {
+                            dimension = fileName.substring(0, fileName.length() - 5);
+                            sender().sendMessage(C.BLUE + "Generator: " + dimension);
+                        }
+                    }
+                }
+            }
+        } else {
+            sender().sendMessage(C.GOLD + world + " is not an iris world.");
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Loading world: " + world);
+
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
+        String gen = "Iris:" + dimension;
+        ConfigurationSection section = yml.contains("worlds") ? yml.getConfigurationSection("worlds") : yml.createSection("worlds");
+        if (!section.contains(world)) {
+            section.createSection(world).set("generator", gen);
+            try {
+                yml.save(BUKKIT_YML);
+                Iris.info("Registered \"" + world + "\" in bukkit.yml");
+            } catch (IOException e) {
+                Iris.error("Failed to update bukkit.yml!");
+                e.printStackTrace();
+            }
+        }
+        checkForBukkitWorlds();
+        sender().sendMessage(C.GREEN + world + " loaded successfully.");
+    }
+    @Decree(description = "Evacuate an iris world", origin = DecreeOrigin.PLAYER, sync = true)
+    public void evacuate(
+            @Param(description = "Evacuate the world")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            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());
+        IrisToolbelt.evacuate(world);
+    }
+
+    boolean doesWorldExist(String worldName) {
+        File worldContainer = Bukkit.getWorldContainer();
+        File worldDirectory = new File(worldContainer, worldName);
+        return worldDirectory.exists() && worldDirectory.isDirectory();
+    }
+    private void checkForBukkitWorlds() {
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            List<String> worldsToLoad = Collections.singletonList(WorldToLoad);
+
+            for (String s : section.getKeys(false)) {
+                if (!worldsToLoad.contains(s)) {
+                    continue;
+                }
+                ConfigurationSection entry = section.getConfigurationSection(s);
+                if (!entry.contains("generator", true)) {
+                    continue;
+                }
+                String generator = entry.getString("generator");
+                if (generator.startsWith("Iris:")) {
+                    generator = generator.split("\\Q:\\E")[1];
+                } else if (generator.equalsIgnoreCase("Iris")) {
+                    generator = IrisSettings.get().getGenerator().getDefaultWorldType();
+                } else {
+                    continue;
+                }
+                Iris.info("2 World: %s | Generator: %s", s, generator);
+                if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                    continue;
+                }
+                Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                new WorldCreator(s)
+                        .generator(getDefaultWorldGenerator(s, generator))
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
+                Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
+        if (worldName.equals("test")) {
+            try {
+                throw new RuntimeException();
+            } catch (Throwable e) {
+                Iris.info(e.getStackTrace()[1].getClassName());
+                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
+                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
+                    return new DummyChunkGenerator();
+                }
+            }
+        }
+        IrisDimension dim;
+        if (id == null || id.isEmpty()) {
+            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+        } else {
+            dim = IrisData.loadAnyDimension(id);
+        }
+        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
+
+        if (dim == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+
+            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
+            dim = IrisData.loadAnyDimension(id);
+
+            if (dim == null) {
+                throw new RuntimeException("Can't find dimension " + id + "!");
+            } else {
+                Iris.info("Resolved missing dimension, proceeding with generation.");
+            }
+        }
+        Iris.debug("Assuming IrisDimension: " + dim.getName());
+        IrisWorld w = IrisWorld.builder()
+                .name(worldName)
+                .seed(1337)
+                .environment(dim.getEnvironment())
+                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
+                .minHeight(dim.getMinHeight())
+                .maxHeight(dim.getMaxHeight())
+                .build();
+        Iris.debug("Generator Config: " + w.toString());
+        File ff = new File(w.worldFolder(), "iris/pack");
+        if (!ff.exists() || ff.listFiles().length == 0) {
+            ff.mkdirs();
+            service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
+        }
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+    }
+}

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

@@ -42,7 +42,7 @@ import java.io.File;
 public class CommandJigsaw implements DecreeExecutor {
     @Decree(description = "Edit a jigsaw piece")
     public void edit(
-        @Param(description = "The jigsaw piece to edit")
+            @Param(description = "The jigsaw piece to edit")
             IrisJigsawPiece piece
     ) {
         File dest = piece.getLoadFile();
@@ -51,7 +51,7 @@ public class CommandJigsaw implements DecreeExecutor {
 
     @Decree(description = "Place a jigsaw structure")
     public void place(
-        @Param(description = "The jigsaw structure to place")
+            @Param(description = "The jigsaw structure to place")
             IrisJigsawStructure structure
     ) {
         PrecisionStopwatch p = PrecisionStopwatch.start();
@@ -62,16 +62,16 @@ public class CommandJigsaw implements DecreeExecutor {
 
     @Decree(description = "Create a jigsaw piece")
     public void create(
-        @Param(description = "The name of the jigsaw piece")
+            @Param(description = "The name of the jigsaw piece")
             String piece,
-        @Param(description = "The project to add the jigsaw piece to")
+            @Param(description = "The project to add the jigsaw piece to")
             String project,
-        @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
+            @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
             String object
     ) {
         IrisObject o = IrisData.loadAnyObject(object);
 
-        if(object == null) {
+        if (object == null) {
             sender().sendMessage(C.RED + "Failed to find existing object");
             return;
         }
@@ -88,7 +88,7 @@ public class CommandJigsaw implements DecreeExecutor {
     public void exit() {
         JigsawEditor editor = JigsawEditor.editors.get(player());
 
-        if(editor == null) {
+        if (editor == null) {
             sender().sendMessage(C.GOLD + "You don't have any pieces open to exit!");
             return;
         }
@@ -101,7 +101,7 @@ public class CommandJigsaw implements DecreeExecutor {
     public void save() {
         JigsawEditor editor = JigsawEditor.editors.get(player());
 
-        if(editor == null) {
+        if (editor == null) {
             sender().sendMessage(C.GOLD + "You don't have any pieces open to save!");
             return;
         }

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

@@ -0,0 +1,121 @@
+/*
+ * 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.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.gui.PregeneratorJob;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.Position2;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+
+@Decree(name = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
+public class CommandLazyPregen implements DecreeExecutor {
+    public String worldName;
+    @Decree(description = "Pregenerate a world")
+    public void start(
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            int radius,
+            @Param(description = "The world to pregen", contextual = true)
+            World world,
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
+            Vector center,
+            @Param(aliases = "maxcpm", description = "Limit the chunks per minute the pregen will generate", defaultValue = "999999999")
+            int cpm,
+            @Param(aliases = "silent", description = "Silent generation", defaultValue = "false")
+            boolean silent
+            ) {
+
+        worldName = world.getName();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File lazyFile = new File(worldDirectory, "lazygen.json");
+        if (lazyFile.exists()) {
+            sender().sendMessage(C.BLUE + "Lazy pregen is already in progress");
+            Iris.info(C.YELLOW + "Lazy pregen is already in progress");
+            return;
+        }
+
+        try {
+            if (sender().isPlayer() && access() == null) {
+                sender().sendMessage(C.RED + "The engine access for this world is null!");
+                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
+            }
+
+            LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
+                    .world(worldName)
+                    .healingPosition(0)
+                    .healing(false)
+                    .chunksPerMinute(cpm)
+                    .radiusBlocks(radius)
+                    .position(0)
+                    .silent(silent)
+                    .build();
+
+            File lazyGenFile = new File(worldDirectory, "lazygen.json");
+            LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, lazyGenFile);
+            pregenerator.start();
+
+            String msg = C.GREEN + "LazyPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
+            sender().sendMessage(msg);
+            Iris.info(msg);
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Epic fail. See console.");
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Stop the active pregeneration task", aliases = "x")
+    public void stop(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) throws IOException {
+        if (LazyPregenerator.getInstance() != null) {
+            LazyPregenerator.getInstance().shutdownInstance(world);
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed lazygen instance for " + world.getName());
+        } else {
+            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
+        }
+    }
+
+    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
+    public void pause(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) {
+        if (LazyPregenerator.getInstance() != null) {
+            LazyPregenerator.getInstance().setPausedLazy(world);
+            sender().sendMessage(C.GREEN + "Paused/unpaused Lazy Pregen, now: " + (LazyPregenerator.getInstance().isPausedLazy(world) ? "Paused" : "Running") + ".");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active Lazy Pregen tasks to pause/unpause.");
+
+        }
+    }
+}

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

@@ -19,18 +19,13 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.WorldEditLink;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.service.ObjectSVC;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.service.WandSVC;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IObjectPlacer;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisObjectPlacementScaleInterpolator;
-import com.volmit.iris.engine.object.IrisObjectRotation;
-import com.volmit.iris.engine.object.TileData;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.data.Cuboid;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
@@ -41,12 +36,7 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Direction;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.scheduling.Queue;
-import org.bukkit.ChatColor;
-import org.bukkit.HeightMap;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Sound;
-import org.bukkit.World;
+import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.TileState;
@@ -57,21 +47,13 @@ import org.bukkit.util.Vector;
 import java.io.File;
 import java.io.IOException;
 import java.text.NumberFormat;
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.TreeSet;
-import java.util.stream.Collectors;
+import java.util.*;
 
 @Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
 public class CommandObject implements DecreeExecutor {
 
     private static final Set<Material> skipBlocks = Set.of(Material.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
-        Material.POPPY, Material.DANDELION);
+            Material.POPPY, Material.DANDELION);
 
     public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
 
@@ -91,7 +73,7 @@ public class CommandObject implements DecreeExecutor {
                 Block block = world.getBlockAt(x, y, z);
 
                 //Prevent blocks being set in or bellow bedrock
-                if(y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
+                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
 
                 futureBlockChanges.put(block, block.getBlockData());
 
@@ -149,7 +131,7 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Check the composition of an object")
     public void analyze(
-        @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
+            @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
             String object
     ) {
         IrisObject o = IrisData.loadAnyObject(object);
@@ -160,19 +142,19 @@ public class CommandObject implements DecreeExecutor {
         Map<Material, Set<BlockData>> unsorted = new HashMap<>();
         Map<BlockData, Integer> amounts = new HashMap<>();
         Map<Material, Integer> materials = new HashMap<>();
-        while(queue.hasNext()) {
+        while (queue.hasNext()) {
             BlockData block = queue.next();
 
             //unsorted.put(block.getMaterial(), block);
 
-            if(!amounts.containsKey(block)) {
+            if (!amounts.containsKey(block)) {
                 amounts.put(block, 1);
 
 
             } else
                 amounts.put(block, amounts.get(block) + 1);
 
-            if(!materials.containsKey(block.getMaterial())) {
+            if (!materials.containsKey(block.getMaterial())) {
                 materials.put(block.getMaterial(), 1);
                 unsorted.put(block.getMaterial(), new HashSet<>());
                 unsorted.get(block.getMaterial()).add(block);
@@ -184,13 +166,13 @@ public class CommandObject implements DecreeExecutor {
         }
 
         List<Material> sortedMatsList = amounts.keySet().stream().map(BlockData::getMaterial)
-            .sorted().collect(Collectors.toList());
+                .sorted().toList();
         Set<Material> sortedMats = new TreeSet<>(Comparator.comparingInt(materials::get).reversed());
         sortedMats.addAll(sortedMatsList);
         sender().sendMessage("== Blocks in object ==");
 
         int n = 0;
-        for(Material mat : sortedMats) {
+        for (Material mat : sortedMats) {
             int amount = materials.get(mat);
             List<BlockData> set = new ArrayList<>(unsorted.get(mat));
             set.sort(Comparator.comparingInt(amounts::get).reversed());
@@ -198,17 +180,17 @@ public class CommandObject implements DecreeExecutor {
             int dataAmount = amounts.get(data);
 
             String string = " - " + mat.toString() + "*" + amount;
-            if(data.getAsString(true).contains("[")) {
+            if (data.getAsString(true).contains("[")) {
                 string = string + " --> [" + data.getAsString(true).split("\\[")[1]
-                    .replaceAll("true", ChatColor.GREEN + "true" + ChatColor.GRAY)
-                    .replaceAll("false", ChatColor.RED + "false" + ChatColor.GRAY) + "*" + dataAmount;
+                        .replaceAll("true", ChatColor.GREEN + "true" + ChatColor.GRAY)
+                        .replaceAll("false", ChatColor.RED + "false" + ChatColor.GRAY) + "*" + dataAmount;
             }
 
             sender().sendMessage(string);
 
             n++;
 
-            if(n >= 10) {
+            if (n >= 10) {
                 sender().sendMessage("  + " + (sortedMats.size() - n) + " other block types");
                 return;
             }
@@ -223,16 +205,19 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Contract a selection based on your looking direction", aliases = "-")
     public void contract(
-        @Param(description = "The amount to inset by", defaultValue = "1")
+            @Param(description = "The amount to inset by", defaultValue = "1")
             int amount
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Hold your wand.");
             return;
         }
 
 
-        Location[] b = WandSVC.getCuboid(player().getInventory().getItemInMainHand());
+        Location[] b = WandSVC.getCuboid(player());
+        if (b == null) {
+            return;
+        }
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Cuboid cursor = new Cuboid(a1, a2);
@@ -248,20 +233,21 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Set point 1 to look", aliases = "p1")
     public void position1(
-        @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
+            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
             boolean here
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Ready your Wand.");
             return;
         }
 
-        ItemStack wand = player().getInventory().getItemInMainHand();
+        if (WandSVC.isHoldingWand(player())) {
+            Location[] g = WandSVC.getCuboid(player());
 
-        if(WandSVC.isWand(wand)) {
-            Location[] g = WandSVC.getCuboid(wand);
-
-            if(!here) {
+            if (g == null) {
+                return;
+            }
+            if (!here) {
                 // TODO: WARNING HEIGHT
                 g[1] = player().getTargetBlock(null, 256).getLocation().clone();
             } else {
@@ -273,20 +259,22 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Set point 2 to look", aliases = "p2")
     public void position2(
-        @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
+            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
             boolean here
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Ready your Wand.");
             return;
         }
 
-        ItemStack wand = player().getInventory().getItemInMainHand();
+        if (WandSVC.isHoldingIrisWand(player())) {
+            Location[] g = WandSVC.getCuboid(player());
 
-        if(WandSVC.isWand(wand)) {
-            Location[] g = WandSVC.getCuboid(wand);
+            if (g == null) {
+                return;
+            }
 
-            if(!here) {
+            if (!here) {
                 // TODO: WARNING HEIGHT
                 g[0] = player().getTargetBlock(null, 256).getLocation().clone();
             } else {
@@ -298,13 +286,13 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Paste an object", sync = true)
     public void paste(
-        @Param(description = "The object to paste", customHandler = ObjectHandler.class)
+            @Param(description = "The object to paste", customHandler = ObjectHandler.class)
             String object,
-        @Param(description = "Whether or not to edit the object (need to hold wand)", defaultValue = "false")
+            @Param(description = "Whether or not to edit the object (need to hold wand)", defaultValue = "false")
             boolean edit,
-        @Param(description = "The amount of degrees to rotate by", defaultValue = "0")
+            @Param(description = "The amount of degrees to rotate by", defaultValue = "0")
             int rotate,
-        @Param(description = "The factor by which to scale the object placement", defaultValue = "1")
+            @Param(description = "The factor by which to scale the object placement", defaultValue = "1")
             double scale
 //            ,
 //            @Param(description = "The scale interpolator to use", defaultValue = "none")
@@ -312,7 +300,7 @@ public class CommandObject implements DecreeExecutor {
     ) {
         IrisObject o = IrisData.loadAnyObject(object);
         double maxScale = Double.max(10 - o.getBlocks().size() / 10000d, 1);
-        if(scale > maxScale) {
+        if (scale > maxScale) {
             sender().sendMessage(C.YELLOW + "Indicated scale exceeds maximum. Downscaled to maximum: " + maxScale);
             scale = maxScale;
         }
@@ -327,8 +315,7 @@ public class CommandObject implements DecreeExecutor {
 
         Map<Block, BlockData> futureChanges = new HashMap<>();
 
-        if(scale != 1)
-        {
+        if (scale != 1) {
             o = o.scaled(scale, IrisObjectPlacementScaleInterpolator.TRICUBIC);
         }
 
@@ -336,16 +323,16 @@ public class CommandObject implements DecreeExecutor {
 
         Iris.service(ObjectSVC.class).addChanges(futureChanges);
 
-        if(edit) {
+        if (edit) {
             ItemStack newWand = WandSVC.createWand(block.clone().subtract(o.getCenter()).add(o.getW() - 1,
-                o.getH() + o.getCenter().clone().getY() - 1, o.getD() - 1), block.clone().subtract(o.getCenter().clone().setY(0)));
-            if(WandSVC.isWand(wand)) {
+                    o.getH() + o.getCenter().clone().getY() - 1, o.getD() - 1), block.clone().subtract(o.getCenter().clone().setY(0)));
+            if (WandSVC.isWand(wand)) {
                 wand = newWand;
                 player().getInventory().setItemInMainHand(wand);
                 sender().sendMessage("Updated wand for " + "objects/" + o.getLoadKey() + ".iob ");
             } else {
                 int slot = WandSVC.findWand(player().getInventory());
-                if(slot == -1) {
+                if (slot == -1) {
                     player().getInventory().addItem(newWand);
                     sender().sendMessage("Given new wand for " + "objects/" + o.getLoadKey() + ".iob ");
                 } else {
@@ -354,35 +341,35 @@ public class CommandObject implements DecreeExecutor {
                 }
             }
         } else {
-            sender().sendMessage("Placed " + object);
+            sender().sendMessage(C.IRIS + "Placed " + object);
         }
     }
 
     @Decree(description = "Save an object")
     public void save(
-        @Param(description = "The dimension to store the object in", contextual = true)
+            @Param(description = "The dimension to store the object in", contextual = true)
             IrisDimension dimension,
-        @Param(description = "The file to store it in, can use / for subfolders")
+            @Param(description = "The file to store it in, can use / for subfolders")
             String name,
-        @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
+            @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
             boolean overwrite
     ) {
-        IrisObject o = WandSVC.createSchematic(player().getInventory().getItemInMainHand());
+        IrisObject o = WandSVC.createSchematic(player());
 
-        if(o == null) {
+        if (o == null) {
             sender().sendMessage(C.YELLOW + "You need to hold your wand!");
             return;
         }
 
         File file = Iris.service(StudioSVC.class).getWorkspaceFile(dimension.getLoadKey(), "objects", name + ".iob");
 
-        if(file.exists() && !overwrite) {
+        if (file.exists() && !overwrite) {
             sender().sendMessage(C.RED + "File already exists. Set overwrite=true to overwrite it.");
             return;
         }
         try {
             o.write(file);
-        } catch(IOException e) {
+        } catch (IOException e) {
             sender().sendMessage(C.RED + "Failed to save object because of an IOException: " + e.getMessage());
             Iris.reportError(e);
         }
@@ -393,18 +380,21 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Shift a selection in your looking direction", aliases = "-")
     public void shift(
-        @Param(description = "The amount to shift by", defaultValue = "1")
+            @Param(description = "The amount to shift by", defaultValue = "1")
             int amount
     ) {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage("Hold your wand.");
             return;
         }
 
-        Location[] b = WandSVC.getCuboid(player().getInventory().getItemInMainHand());
+        Location[] b = WandSVC.getCuboid(player());
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
+        if (d == null) {
+            return; // HOW DID THIS HAPPEN
+        }
         a1.add(d.toVector().multiply(amount));
         a2.add(d.toVector().multiply(amount));
         Cuboid cursor = new Cuboid(a1, a2);
@@ -417,13 +407,31 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Undo a number of pastes", aliases = "-")
     public void undo(
-        @Param(description = "The amount of pastes to undo", defaultValue = "1")
+            @Param(description = "The amount of pastes to undo", defaultValue = "1")
             int amount
     ) {
         ObjectSVC service = Iris.service(ObjectSVC.class);
         int actualReverts = Math.min(service.getUndos().size(), amount);
         service.revertChanges(actualReverts);
-        sender().sendMessage("Reverted " + actualReverts + " pastes!");
+        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE +" pastes!");
+    }
+
+    @Decree(description = "Gets an object wand and grabs the current WorldEdit selection.", aliases = "we", origin = DecreeOrigin.PLAYER, studio = true)
+    public void we() {
+        if (!Bukkit.getPluginManager().isPluginEnabled("WorldEdit")) {
+            sender().sendMessage(C.RED + "You can't get a WorldEdit selection without WorldEdit, you know.");
+            return;
+        }
+
+        Cuboid locs = WorldEditLink.getSelection(sender().player());
+
+        if (locs == null) {
+            sender().sendMessage(C.RED + "You don't have a WorldEdit selection in this world.");
+            return;
+        }
+
+        sender().player().getInventory().addItem(WandSVC.createWand(locs.getLowerNE(), locs.getUpperSW()));
+        sender().sendMessage(C.GREEN + "A fresh wand with your current WorldEdit selection on it!");
     }
 
     @Decree(description = "Get an object wand", sync = true)
@@ -435,12 +443,12 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(name = "x&y", description = "Autoselect up, down & out", sync = true)
     public void xay() {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage(C.YELLOW + "Hold your wand!");
             return;
         }
 
-        Location[] b = WandSVC.getCuboid(player().getInventory().getItemInMainHand());
+        Location[] b = WandSVC.getCuboid(player());
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Location a1x = b[0].clone();
@@ -448,7 +456,7 @@ public class CommandObject implements DecreeExecutor {
         Cuboid cursor = new Cuboid(a1, a2);
         Cuboid cursorx = new Cuboid(a1, a2);
 
-        while(!cursor.containsOnly(Material.AIR)) {
+        while (!cursor.containsOnly(Material.AIR)) {
             a1.add(new org.bukkit.util.Vector(0, 1, 0));
             a2.add(new org.bukkit.util.Vector(0, 1, 0));
             cursor = new Cuboid(a1, a2);
@@ -457,7 +465,7 @@ public class CommandObject implements DecreeExecutor {
         a1.add(new org.bukkit.util.Vector(0, -1, 0));
         a2.add(new org.bukkit.util.Vector(0, -1, 0));
 
-        while(!cursorx.containsOnly(Material.AIR)) {
+        while (!cursorx.containsOnly(Material.AIR)) {
             a1x.add(new org.bukkit.util.Vector(0, -1, 0));
             a2x.add(new org.bukkit.util.Vector(0, -1, 0));
             cursorx = new Cuboid(a1x, a2x);
@@ -482,19 +490,19 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(name = "x+y", description = "Autoselect up & out", sync = true)
     public void xpy() {
-        if(!WandSVC.isHoldingWand(player())) {
+        if (!WandSVC.isHoldingWand(player())) {
             sender().sendMessage(C.YELLOW + "Hold your wand!");
             return;
         }
 
-        Location[] b = WandSVC.getCuboid(player().getInventory().getItemInMainHand());
+        Location[] b = WandSVC.getCuboid(player());
         b[0].add(new Vector(0, 1, 0));
         b[1].add(new Vector(0, 1, 0));
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Cuboid cursor = new Cuboid(a1, a2);
 
-        while(!cursor.containsOnly(Material.AIR)) {
+        while (!cursor.containsOnly(Material.AIR)) {
             a1.add(new Vector(0, 1, 0));
             a2.add(new Vector(0, 1, 0));
             cursor = new Cuboid(a1, a2);

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

@@ -19,7 +19,9 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.PregeneratorJob;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.decree.DecreeExecutor;
@@ -27,37 +29,41 @@ import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Position2;
+import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.util.Vector;
 
+import java.io.File;
+
 @Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
 public class CommandPregen implements DecreeExecutor {
     @Decree(description = "Pregenerate a world")
     public void start(
-        @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
             int radius,
-        @Param(description = "The world to pregen", contextual = true)
+            @Param(description = "The world to pregen", contextual = true)
             World world,
-        @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
             Vector center
-    ) {
+            ) {
         try {
-            if(sender().isPlayer() && access() == null) {
+            if (sender().isPlayer() && access() == null) {
                 sender().sendMessage(C.RED + "The engine access for this world is null!");
                 sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
             }
             radius = Math.max(radius, 1024);
             int w = (radius >> 9 + 1) * 2;
             IrisToolbelt.pregenerate(PregenTask
-                .builder()
-                .center(new Position2(center))
-                .width(w)
-                .height(w)
-                .build(), world);
+                    .builder()
+                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                    .gui(true)
+                    .width(w)
+                    .height(w)
+                    .build(), world);
             String msg = C.GREEN + "Pregen started in " + C.GOLD + world.getName() + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
             sender().sendMessage(msg);
             Iris.info(msg);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             sender().sendMessage(C.RED + "Epic fail. See console.");
             Iris.reportError(e);
             e.printStackTrace();
@@ -66,8 +72,8 @@ public class CommandPregen implements DecreeExecutor {
 
     @Decree(description = "Stop the active pregeneration task", aliases = "x")
     public void stop() {
-        if(PregeneratorJob.shutdownInstance()) {
-            sender().sendMessage(C.GREEN + "Stopped pregeneration task");
+        if (PregeneratorJob.shutdownInstance()) {
+            Iris.info( C.BLUE + "Finishing up mca region...");
         } else {
             sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
         }
@@ -75,7 +81,7 @@ public class CommandPregen implements DecreeExecutor {
 
     @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
     public void pause() {
-        if(PregeneratorJob.pauseResume()) {
+        if (PregeneratorJob.pauseResume()) {
             sender().sendMessage(C.GREEN + "Paused/unpaused pregeneration task, now: " + (PregeneratorJob.isPaused() ? "Paused" : "Running") + ".");
         } else {
             sender().sendMessage(C.YELLOW + "No active pregeneration tasks to pause/unpause.");

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

@@ -26,25 +26,15 @@ 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.InventorySlotType;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomePaletteLayer;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisEntity;
-import com.volmit.iris.engine.object.IrisGenerator;
-import com.volmit.iris.engine.object.IrisInterpolator;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.engine.object.IrisNoiseGenerator;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.engine.object.NoiseStyle;
+import com.volmit.iris.engine.object.*;
+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.collection.KSet;
+import com.volmit.iris.util.decree.DecreeContext;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -58,31 +48,24 @@ import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.math.Spiraler;
 import com.volmit.iris.util.noise.CNG;
+import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import com.volmit.iris.util.scheduling.jobs.Job;
-import com.volmit.iris.util.scheduling.jobs.JobCollection;
 import com.volmit.iris.util.scheduling.jobs.QueueJob;
-import com.volmit.iris.util.scheduling.jobs.SingleJob;
 import io.papermc.lib.PaperLib;
-
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.FluidCollisionMode;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.World;
+import org.bukkit.*;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.util.BlockVector;
 import org.bukkit.util.Vector;
 
-import java.awt.*;
 import java.io.File;
 import java.io.FileNotFoundException;
 import java.io.IOException;
@@ -95,28 +78,28 @@ import java.util.Date;
 import java.util.Objects;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
-import java.util.function.Consumer;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 
 @Decree(name = "studio", aliases = {"std", "s"}, description = "Studio Commands", studio = true)
 public class CommandStudio implements DecreeExecutor {
+    private CommandFind find;
+    private CommandEdit edit;
+    private CommandDeepSearch deepSearch;
+
     public static String hrf(Duration duration) {
         return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
     }
 
-    private CommandFind find;
-    private CommandEdit edit;
-
-
     @Decree(description = "Download a project.", aliases = "dl")
     public void download(
-        @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
+            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
             String pack,
-        @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
+            @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
             String branch,
-        @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
             boolean trim,
-        @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
+            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
             boolean overwrite
     ) {
         new CommandIris().download(pack, branch, trim, overwrite);
@@ -124,9 +107,9 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Open a new studio world", aliases = "o", sync = true)
     public void open(
-        @Param(defaultValue = "default", description = "The dimension to open a studio for", aliases = "dim")
+            @Param(defaultValue = "default", description = "The dimension to open a studio for", aliases = "dim")
             IrisDimension dimension,
-        @Param(defaultValue = "1337", description = "The seed to generate the studio with", aliases = "s")
+            @Param(defaultValue = "1337", description = "The seed to generate the studio with", aliases = "s")
             long seed) {
         sender().sendMessage(C.GREEN + "Opening studio for the \"" + dimension.getName() + "\" pack (seed: " + seed + ")");
         Iris.service(StudioSVC.class).open(sender(), seed, dimension.getLoadKey());
@@ -134,7 +117,7 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Open VSCode for a dimension", aliases = {"vsc", "edit"})
     public void vscode(
-        @Param(defaultValue = "default", description = "The dimension to open VSCode for", aliases = "dim")
+            @Param(defaultValue = "default", description = "The dimension to open VSCode for", aliases = "dim")
             IrisDimension dimension
     ) {
         sender().sendMessage(C.GREEN + "Opening VSCode for the \"" + dimension.getName() + "\" pack");
@@ -143,7 +126,7 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Close an open studio project", aliases = {"x", "c"}, sync = true)
     public void close() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No open studio projects.");
             return;
         }
@@ -154,158 +137,105 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Create a new studio project", aliases = "+", sync = true)
     public void create(
-        @Param(description = "The name of this new Iris Project.")
+            @Param(description = "The name of this new Iris Project.")
             String name,
-        @Param(description = "Copy the contents of an existing project in your packs folder and use it as a template in this new project.", contextual = true)
+            @Param(description = "Copy the contents of an existing project in your packs folder and use it as a template in this new project.", contextual = true)
             IrisDimension template) {
-        if(template != null) {
+        if (template != null) {
             Iris.service(StudioSVC.class).create(sender(), name, template.getLoadKey());
         } else {
             Iris.service(StudioSVC.class).create(sender(), name);
         }
     }
 
-    @Decree(description = "Clean an Iris Project, optionally beautifying JSON & fixing block ids with missing keys. Also rebuilds the vscode schemas. ")
-    public void clean(
-        @Param(description = "The project to update", contextual = true)
-            IrisDimension project,
-
-        @Param(defaultValue = "true", description = "Filters all valid JSON files with a beautifier (indentation: 4)")
-            boolean beautify,
-
-        @Param(name = "fix-ids", defaultValue = "true", description = "Fixes any block ids used such as \"dirt\" will be converted to \"minecraft:dirt\"")
-            boolean fixIds,
-
-        @Param(name = "rewrite-objects", defaultValue = "false", description = "Imports all objects and re-writes them cleaning up positions & block data in the process.")
-            boolean rewriteObjects
-    ) {
-        KList<Job> jobs = new KList<>();
-        KList<File> files = new KList<File>();
-        files(Iris.instance.getDataFolder("packs", project.getLoadKey()), files);
-        MultiBurst burst = MultiBurst.burst;
-
-        jobs.add(new SingleJob("Updating Workspace", () -> {
-            if(!new IrisProject(Iris.service(StudioSVC.class).getWorkspaceFolder(project.getLoadKey())).updateWorkspace()) {
-                sender().sendMessage(C.GOLD + "Invalid project: " + project.getLoadKey() + ". Try deleting the code-workspace file and try again.");
-            }
-            J.sleep(250);
-        }));
-
-        sender().sendMessage("Files: " + files.size());
-
-        if(fixIds) {
-            QueueJob<File> r = new QueueJob<>() {
-                @Override
-                public void execute(File f) {
-                    try {
-                        JSONObject p = new JSONObject(IO.readAll(f));
-                        fixBlocks(p);
-                        J.sleep(1);
-                        IO.writeAll(f, p.toString(4));
-
-                    } catch(IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-
-                @Override
-                public String getName() {
-                    return "Fixing IDs";
-                }
-            };
-
-            r.queue(files);
-            jobs.add(r);
-        }
-
-        if(beautify) {
-            QueueJob<File> r = new QueueJob<>() {
-                @Override
-                public void execute(File f) {
-                    try {
-                        JSONObject p = new JSONObject(IO.readAll(f));
-                        IO.writeAll(f, p.toString(4));
-                        J.sleep(1);
-                    } catch(IOException e) {
-                        e.printStackTrace();
-                    }
-                }
-
-                @Override
-                public String getName() {
-                    return "Beautify";
-                }
-            };
-
-            r.queue(files);
-            jobs.add(r);
-        }
-
-        if(rewriteObjects) {
-            QueueJob<Runnable> q = new QueueJob<>() {
-                @Override
-                public void execute(Runnable runnable) {
-                    runnable.run();
-                    J.sleep(50);
-                }
-
-                @Override
-                public String getName() {
-                    return "Rewriting Objects";
-                }
-            };
-
-            IrisData data = IrisData.get(Iris.service(StudioSVC.class).getWorkspaceFolder(project.getLoadKey()));
-            for(String f : data.getObjectLoader().getPossibleKeys()) {
-                Future<?> gg = burst.complete(() -> {
-                    File ff = data.getObjectLoader().findFile(f);
-                    IrisObject oo = new IrisObject(0, 0, 0);
-                    try {
-                        oo.read(ff);
-                    } catch(Throwable e) {
-                        Iris.error("FAILER TO READ: " + f);
-                        return;
-                    }
-
-                    try {
-                        oo.write(ff);
-                    } catch(IOException e) {
-                        Iris.error("FAILURE TO WRITE: " + oo.getLoadFile());
-                    }
-                });
-
-                q.queue(() -> {
-                    try {
-                        gg.get();
-                    } catch(InterruptedException | ExecutionException e) {
-                        e.printStackTrace();
-                    }
-                });
-            }
-
-            jobs.add(q);
-        }
-
-        new JobCollection("Cleaning", jobs).execute(sender());
-    }
-
     @Decree(description = "Get the version of a pack")
     public void version(
-        @Param(defaultValue = "default", description = "The dimension get the version of", aliases = "dim", contextual = true)
+            @Param(defaultValue = "default", description = "The dimension get the version of", aliases = "dim", contextual = true)
             IrisDimension dimension
     ) {
         sender().sendMessage(C.GREEN + "The \"" + dimension.getName() + "\" pack has version: " + dimension.getVersion());
     }
 
+    @Decree(name = "regen", description = "Regenerate nearby chunks.", aliases = "rg", sync = true, origin = DecreeOrigin.PLAYER)
+    public void regen(
+            @Param(name = "radius", description = "The radius of nearby cunks", defaultValue = "5")
+            int radius
+    ) {
+        if (IrisToolbelt.isIrisWorld(player().getWorld())) {
+            VolmitSender sender = sender();
+            J.a(() -> {
+                DecreeContext.touch(sender);
+                PlatformChunkGenerator plat = IrisToolbelt.access(player().getWorld());
+                Engine engine = plat.getEngine();
+                try {
+                    Chunk cx = player().getLocation().getChunk();
+                    KList<Runnable> js = new KList<>();
+                    BurstExecutor b = MultiBurst.burst.burst();
+                    b.setMulticore(false);
+                    int rad = engine.getMantle().getRealRadius();
+                    for (int i = -(radius + rad); i <= radius + rad; i++) {
+                        for (int j = -(radius + rad); j <= radius + rad; j++) {
+                            engine.getMantle().getMantle().deleteChunk(i + cx.getX(), j + cx.getZ());
+                        }
+                    }
+
+                    for (int i = -radius; i <= radius; i++) {
+                        for (int j = -radius; j <= radius; j++) {
+                            int finalJ = j;
+                            int finalI = i;
+                            b.queue(() -> plat.injectChunkReplacement(player().getWorld(), finalI + cx.getX(), finalJ + cx.getZ(), (f) -> {
+                                synchronized (js) {
+                                    js.add(f);
+                                }
+                            }));
+                        }
+                    }
+
+                    b.complete();
+                    sender().sendMessage(C.GREEN + "Regenerating " + Form.f(js.size()) + " Sections");
+                    QueueJob<Runnable> r = new QueueJob<>() {
+                        final KList<Future<?>> futures = new KList<>();
+
+                        @Override
+                        public void execute(Runnable runnable) {
+                            futures.add(J.sfut(runnable));
+
+                            if (futures.size() > 64) {
+                                while (futures.isNotEmpty()) {
+                                    try {
+                                        futures.remove(0).get();
+                                    } catch (InterruptedException | ExecutionException e) {
+                                        e.printStackTrace();
+                                    }
+                                }
+                            }
+                        }
+
+                        @Override
+                        public String getName() {
+                            return "Regenerating";
+                        }
+                    };
+                    r.queue(js);
+                    r.execute(sender());
+                } catch (Throwable e) {
+                    sender().sendMessage("Unable to parse view-distance");
+                }
+            });
+        } else {
+            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
+        }
+    }
+
     @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")
+            @Param(description = "The script to run")
             IrisScript script
     ) {
         engine().getExecution().execute(script.getLoadKey());
@@ -313,14 +243,14 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Open the noise explorer (External GUI)", aliases = {"nmap", "n"})
     public void noise() {
-        if(noGUI()) return;
+        if (noGUI()) return;
         sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
         NoiseExplorerGUI.launch();
     }
 
     @Decree(description = "Charges all spawners in the area", aliases = "zzt", origin = DecreeOrigin.PLAYER)
     public void charge() {
-        if(!IrisToolbelt.isIrisWorld(world())) {
+        if (!IrisToolbelt.isIrisWorld(world())) {
             sender().sendMessage(C.RED + "You must be in an Iris world to charge spawners!");
             return;
         }
@@ -330,17 +260,17 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Preview noise gens (External GUI)", aliases = {"generator", "gen"})
     public void explore(
-        @Param(description = "The generator to explore", contextual = true)
+            @Param(description = "The generator to explore", contextual = true)
             IrisGenerator generator,
-        @Param(description = "The seed to generate with", defaultValue = "12345")
+            @Param(description = "The seed to generate with", defaultValue = "12345")
             long seed
     ) {
-        if(noGUI()) return;
+        if (noGUI()) return;
         sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
 
         Supplier<Function2<Double, Double, Double>> l = () -> {
 
-            if(generator == null) {
+            if (generator == null) {
                 return (x, z) -> 0D;
             }
 
@@ -351,7 +281,7 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Hotload a studio", aliases = {"reload", "h"})
     public void hotload() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world open!");
             return;
         }
@@ -361,19 +291,19 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Show loot if a chest were right here", origin = DecreeOrigin.PLAYER, sync = true)
     public void loot(
-        @Param(description = "Fast insertion of items in virtual inventory (may cause performance drop)", defaultValue = "false")
+            @Param(description = "Fast insertion of items in virtual inventory (may cause performance drop)", defaultValue = "false")
             boolean fast,
-        @Param(description = "Whether or not to append to the inventory currently open (if false, clears opened inventory)", defaultValue = "true")
+            @Param(description = "Whether or not to append to the inventory currently open (if false, clears opened inventory)", defaultValue = "true")
             boolean add
     ) {
-        if(noStudio()) return;
+        if (noStudio()) return;
 
         KList<IrisLootTable> tables = engine().getLootTables(RNG.r, player().getLocation().getBlock());
         Inventory inv = Bukkit.createInventory(null, 27 * 2);
 
         try {
             engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cannot add items to virtual inventory because of: " + e.getMessage());
             return;
@@ -385,13 +315,13 @@ public class CommandStudio implements DecreeExecutor {
 
         ta.set(Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, () ->
         {
-            if(!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
+            if (!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
                 Bukkit.getScheduler().cancelTask(ta.get());
                 sender().sendMessage(C.GREEN + "Opened inventory!");
                 return;
             }
 
-            if(!add) {
+            if (!add) {
                 inv.clear();
             }
 
@@ -404,12 +334,12 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Render a world map (External GUI)", aliases = "render")
     public void map(
-        @Param(name = "world", description = "The world to open the generator for", contextual = true)
+            @Param(name = "world", description = "The world to open the generator for", contextual = true)
             World world
     ) {
-        if(noGUI()) return;
+        if (noGUI()) return;
 
-        if(!IrisToolbelt.isIrisWorld(world)) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
             sender().sendMessage(C.RED + "You need to be in or specify an Iris-generated world!");
             return;
         }
@@ -420,11 +350,11 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Package a dimension into a compressed format", aliases = "package")
     public void pkg(
-        @Param(name = "dimension", description = "The dimension pack to compress", contextual = true, defaultValue = "default")
+            @Param(name = "dimension", description = "The dimension pack to compress", contextual = true, defaultValue = "default")
             IrisDimension dimension,
-        @Param(name = "obfuscate", description = "Whether or not to obfuscate the pack", defaultValue = "false")
+            @Param(name = "obfuscate", description = "Whether or not to obfuscate the pack", defaultValue = "false")
             boolean obfuscate,
-        @Param(name = "minify", description = "Whether or not to minify the pack", defaultValue = "true")
+            @Param(name = "minify", description = "Whether or not to minify the pack", defaultValue = "true")
             boolean minify
     ) {
         Iris.service(StudioSVC.class).compilePackage(sender(), dimension.getLoadKey(), obfuscate, minify);
@@ -432,9 +362,10 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Profiles the performance of a dimension", origin = DecreeOrigin.PLAYER)
     public void profile(
-        @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
+            @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
             IrisDimension dimension
     ) {
+        // Todo: Make this more accurate
         File pack = dimension.getLoadFile().getParentFile().getParentFile();
         File report = Iris.instance.getDataFile("profile.txt");
         IrisProject project = new IrisProject(pack);
@@ -450,17 +381,17 @@ public class CommandStudio implements DecreeExecutor {
 
         sender().sendMessage("Calculating Performance Metrics for Noise generators");
 
-        for(NoiseStyle i : NoiseStyle.values()) {
+        for (NoiseStyle i : NoiseStyle.values()) {
             CNG c = i.create(new RNG(i.hashCode()));
 
-            for(int j = 0; j < 3000; j++) {
+            for (int j = 0; j < 3000; j++) {
                 c.noise(j, j + 1000, j * j);
                 c.noise(j, -j);
             }
 
             PrecisionStopwatch px = PrecisionStopwatch.start();
 
-            for(int j = 0; j < 100000; j++) {
+            for (int j = 0; j < 100000; j++) {
                 c.noise(j, j + 1000, j * j);
                 c.noise(j, -j);
             }
@@ -470,7 +401,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Noise Style Performance Impacts: ");
 
-        for(NoiseStyle i : styleTimings.sortKNumber()) {
+        for (NoiseStyle i : styleTimings.sortKNumber()) {
             fileText.add(i.name() + ": " + styleTimings.get(i));
         }
 
@@ -478,20 +409,20 @@ public class CommandStudio implements DecreeExecutor {
 
         sender().sendMessage("Calculating Interpolator Timings...");
 
-        for(InterpolationMethod i : InterpolationMethod.values()) {
+        for (InterpolationMethod i : InterpolationMethod.values()) {
             IrisInterpolator in = new IrisInterpolator();
             in.setFunction(i);
             in.setHorizontalScale(8);
 
             NoiseProvider np = (x, z) -> Math.random();
 
-            for(int j = 0; j < 3000; j++) {
+            for (int j = 0; j < 3000; j++) {
                 in.interpolate(j, -j, np);
             }
 
             PrecisionStopwatch px = PrecisionStopwatch.start();
 
-            for(int j = 0; j < 100000; j++) {
+            for (int j = 0; j < 100000; j++) {
                 in.interpolate(j + 10000, -j - 100000, np);
             }
 
@@ -500,7 +431,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Noise Interpolator Performance Impacts: ");
 
-        for(InterpolationMethod i : interpolatorTimings.sortKNumber()) {
+        for (InterpolationMethod i : interpolatorTimings.sortKNumber()) {
             fileText.add(i.name() + ": " + interpolatorTimings.get(i));
         }
 
@@ -510,13 +441,13 @@ public class CommandStudio implements DecreeExecutor {
 
         KMap<String, KList<String>> btx = new KMap<>();
 
-        for(String i : data.getGeneratorLoader().getPossibleKeys()) {
+        for (String i : data.getGeneratorLoader().getPossibleKeys()) {
             KList<String> vv = new KList<>();
             IrisGenerator g = data.getGeneratorLoader().load(i);
             KList<IrisNoiseGenerator> composites = g.getAllComposites();
             double score = 0;
             int m = 0;
-            for(IrisNoiseGenerator j : composites) {
+            for (IrisNoiseGenerator j : composites) {
                 m++;
                 score += styleTimings.get(j.getStyle().getStyle());
                 vv.add("Composite Noise Style " + m + " " + j.getStyle().getStyle().name() + ": " + styleTimings.get(j.getStyle().getStyle()));
@@ -530,7 +461,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Project Generator Performance Impacts: ");
 
-        for(String i : generatorTimings.sortKNumber()) {
+        for (String i : generatorTimings.sortKNumber()) {
             fileText.add(i + ": " + generatorTimings.get(i));
 
             btx.get(i).forEach((ii) -> fileText.add("  " + ii));
@@ -540,13 +471,13 @@ public class CommandStudio implements DecreeExecutor {
 
         KMap<String, KList<String>> bt = new KMap<>();
 
-        for(String i : data.getBiomeLoader().getPossibleKeys()) {
+        for (String i : data.getBiomeLoader().getPossibleKeys()) {
             KList<String> vv = new KList<>();
             IrisBiome b = data.getBiomeLoader().load(i);
             double score = 0;
 
             int m = 0;
-            for(IrisBiomePaletteLayer j : b.getLayers()) {
+            for (IrisBiomePaletteLayer j : b.getLayers()) {
                 m++;
                 score += styleTimings.get(j.getStyle().getStyle());
                 vv.add("Palette Layer " + m + ": " + styleTimings.get(j.getStyle().getStyle()));
@@ -562,7 +493,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Project Biome Performance Impacts: ");
 
-        for(String i : biomeTimings.sortKNumber()) {
+        for (String i : biomeTimings.sortKNumber()) {
             fileText.add(i + ": " + biomeTimings.get(i));
 
             bt.get(i).forEach((ff) -> fileText.add("  " + ff));
@@ -570,7 +501,7 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("");
 
-        for(String i : data.getRegionLoader().getPossibleKeys()) {
+        for (String i : data.getRegionLoader().getPossibleKeys()) {
             IrisRegion b = data.getRegionLoader().load(i);
             double score = 0;
 
@@ -581,25 +512,25 @@ public class CommandStudio implements DecreeExecutor {
 
         fileText.add("Project Region Performance Impacts: ");
 
-        for(String i : regionTimings.sortKNumber()) {
+        for (String i : regionTimings.sortKNumber()) {
             fileText.add(i + ": " + regionTimings.get(i));
         }
 
         fileText.add("");
 
         double m = 0;
-        for(double i : biomeTimings.v()) {
+        for (double i : biomeTimings.v()) {
             m += i;
         }
         m /= biomeTimings.size();
         double mm = 0;
-        for(double i : generatorTimings.v()) {
+        for (double i : generatorTimings.v()) {
             mm += i;
         }
         mm /= generatorTimings.size();
         m += mm;
         double mmm = 0;
-        for(double i : regionTimings.v()) {
+        for (double i : regionTimings.v()) {
             mmm += i;
         }
         mmm /= regionTimings.size();
@@ -610,7 +541,7 @@ public class CommandStudio implements DecreeExecutor {
 
         try {
             IO.writeAll(report, fileText.toString("\n"));
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -618,30 +549,27 @@ public class CommandStudio implements DecreeExecutor {
         sender().sendMessage(C.GREEN + "Done! " + report.getPath());
     }
 
-    @Decree(description = "Summon an Iris Entity", origin = DecreeOrigin.PLAYER)
-    public void summon(
-        @Param(description = "The Iris Entity to spawn")
+    @Decree(description = "Spawn an Iris entity", aliases = "summon", origin = DecreeOrigin.PLAYER)
+    public void spawn(
+            @Param(description = "The entity to spawn")
             IrisEntity entity,
-        @Param(description = "The location at which to spawn the entity", defaultValue = "self")
+            @Param(description = "The location to spawn the entity at", contextual = true)
             Vector location
     ) {
-        if(!sender().isPlayer()) {
-            sender().sendMessage(C.RED + "Players only (this is a config error. Ask support to add DecreeOrigin.PLAYER to the command you tried to run)");
-            return;
+        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
+            sender().sendMessage(C.RED + "You have to be in an Iris world to spawn entities properly. Trying to spawn the best we can do.");
         }
-
-        sender().sendMessage(C.GREEN + "Spawning entity");
         entity.spawn(engine(), new Location(world(), location.getX(), location.getY(), location.getZ()));
     }
 
     @Decree(description = "Teleport to the active studio world", aliases = "stp", origin = DecreeOrigin.PLAYER, sync = true)
     public void tpstudio() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world is open!");
             return;
         }
 
-        if(IrisToolbelt.isIrisWorld(world()) && engine().isStudio()) {
+        if (IrisToolbelt.isIrisWorld(world()) && engine().isStudio()) {
             sender().sendMessage(C.RED + "You are already in a studio world!");
             return;
         }
@@ -653,11 +581,11 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(description = "Update your dimension projects VSCode workspace")
     public void update(
-        @Param(description = "The dimension to update the workspace of", contextual = true, defaultValue = "default")
+            @Param(description = "The dimension to update the workspace of", contextual = true, defaultValue = "default")
             IrisDimension dimension
     ) {
         sender().sendMessage(C.GOLD + "Updating Code Workspace for " + dimension.getName() + "...");
-        if(new IrisProject(dimension.getLoader().getDataFolder()).updateWorkspace()) {
+        if (new IrisProject(dimension.getLoader().getDataFolder()).updateWorkspace()) {
             sender().sendMessage(C.GREEN + "Updated Code Workspace for " + dimension.getName());
         } else {
             sender().sendMessage(C.RED + "Invalid project: " + dimension.getName() + ". Try deleting the code-workspace file and try again.");
@@ -666,14 +594,14 @@ public class CommandStudio implements DecreeExecutor {
 
     @Decree(aliases = "find-objects", description = "Get information about nearby structures")
     public void objects() {
-        if(!IrisToolbelt.isIrisWorld(player().getWorld())) {
+        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
             sender().sendMessage(C.RED + "You must be in an Iris world");
             return;
         }
 
         World world = player().getWorld();
 
-        if(!IrisToolbelt.isIrisWorld(world)) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
             sender().sendMessage("You must be in an iris world.");
             return;
         }
@@ -687,7 +615,7 @@ public class CommandStudio implements DecreeExecutor {
             int cx = l.getChunk().getX();
             int cz = l.getChunk().getZ();
             new Spiraler(3, 3, (x, z) -> chunks.addIfMissing(world.getChunkAt(x + cx, z + cz))).drain();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
         }
 
@@ -705,7 +633,7 @@ public class CommandStudio implements DecreeExecutor {
             pw.println("Report Captured At: " + new Date());
             pw.println("Chunks: (" + chunks.size() + "): ");
 
-            for(Chunk i : chunks) {
+            for (Chunk i : chunks) {
                 pw.println("- [" + i.getX() + ", " + i.getZ() + "]");
             }
 
@@ -714,19 +642,19 @@ public class CommandStudio implements DecreeExecutor {
             String age = "No idea...";
 
             try {
-                for(File i : Objects.requireNonNull(new File(world.getWorldFolder(), "region").listFiles())) {
-                    if(i.isFile()) {
+                for (File i : Objects.requireNonNull(new File(world.getWorldFolder(), "region").listFiles())) {
+                    if (i.isFile()) {
                         size += i.length();
                     }
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
 
             try {
                 FileTime creationTime = (FileTime) Files.getAttribute(world.getWorldFolder().toPath(), "creationTime");
                 age = hrf(Duration.of(M.ms() - creationTime.toMillis(), ChronoUnit.MILLIS));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
 
@@ -734,10 +662,10 @@ public class CommandStudio implements DecreeExecutor {
             KList<String> caveBiomes = new KList<>();
             KMap<String, KMap<String, KList<String>>> objects = new KMap<>();
 
-            for(Chunk i : chunks) {
-                for(int j = 0; j < 16; j += 3) {
+            for (Chunk i : chunks) {
+                for (int j = 0; j < 16; j += 3) {
 
-                    for(int k = 0; k < 16; k += 3) {
+                    for (int k = 0; k < 16; k += 3) {
 
                         assert engine() != null;
                         IrisBiome bb = engine().getSurfaceBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
@@ -764,20 +692,20 @@ public class CommandStudio implements DecreeExecutor {
             pw.println("== Biome Info ==");
             pw.println("Found " + biomes.size() + " Biome(s): ");
 
-            for(String i : biomes) {
+            for (String i : biomes) {
                 pw.println("- " + i);
             }
             pw.println();
 
             pw.println("== Object Info ==");
 
-            for(String i : objects.k()) {
+            for (String i : objects.k()) {
                 pw.println("- " + i);
 
-                for(String j : objects.get(i).k()) {
+                for (String j : objects.get(i).k()) {
                     pw.println("  @ " + j);
 
-                    for(String k : objects.get(i).get(j)) {
+                    for (String k : objects.get(i).get(j)) {
                         pw.println("    * " + k);
                     }
                 }
@@ -787,7 +715,7 @@ public class CommandStudio implements DecreeExecutor {
             pw.close();
 
             sender().sendMessage("Reported to: " + ff.getPath());
-        } catch(FileNotFoundException e) {
+        } catch (FileNotFoundException e) {
             e.printStackTrace();
             Iris.reportError(e);
         }
@@ -797,15 +725,15 @@ public class CommandStudio implements DecreeExecutor {
         String n1 = bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")";
         int m = 0;
         KSet<String> stop = new KSet<>();
-        for(IrisObjectPlacement f : bb.getObjects()) {
+        for (IrisObjectPlacement f : bb.getObjects()) {
             m++;
             String n2 = "Placement #" + m + " (" + f.getPlace().size() + " possible objects)";
 
-            for(String i : f.getPlace()) {
+            for (String i : f.getPlace()) {
                 String nn3 = i + ": [ERROR] Failed to find object!";
 
                 try {
-                    if(stop.contains(i)) {
+                    if (stop.contains(i)) {
                         continue;
                     }
 
@@ -813,13 +741,13 @@ public class CommandStudio implements DecreeExecutor {
                     BlockVector sz = IrisObject.sampleSize(ff);
                     nn3 = i + ": size=[" + sz.getBlockX() + "," + sz.getBlockY() + "," + sz.getBlockZ() + "] location=[" + ff.getPath() + "]";
                     stop.add(i);
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
                 }
 
                 String n3 = nn3;
                 objects.computeIfAbsent(n1, (k1) -> new KMap<>())
-                    .computeIfAbsent(n2, (k) -> new KList<>()).addIfMissing(n3);
+                        .computeIfAbsent(n2, (k) -> new KList<>()).addIfMissing(n3);
             }
         }
     }
@@ -828,7 +756,7 @@ public class CommandStudio implements DecreeExecutor {
      * @return true if server GUIs are not enabled
      */
     private boolean noGUI() {
-        if(!IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
+        if (!IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
             sender().sendMessage(C.RED + "You must have server launched GUIs enabled in the settings!");
             return true;
         }
@@ -839,15 +767,15 @@ public class CommandStudio implements DecreeExecutor {
      * @return true if no studio is open or the player is not in one
      */
     private boolean noStudio() {
-        if(!sender().isPlayer()) {
+        if (!sender().isPlayer()) {
             sender().sendMessage(C.RED + "Players only!");
             return true;
         }
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             sender().sendMessage(C.RED + "No studio world is open!");
             return true;
         }
-        if(!engine().isStudio()) {
+        if (!engine().isStudio()) {
             sender().sendMessage(C.RED + "You must be in a studio world!");
             return true;
         }
@@ -856,14 +784,14 @@ public class CommandStudio implements DecreeExecutor {
 
 
     public void files(File clean, KList<File> files) {
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 files(i, files);
             }
-        } else if(clean.getName().endsWith(".json")) {
+        } else if (clean.getName().endsWith(".json")) {
             try {
                 files.add(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 Iris.error("Failed to beautify " + clean.getAbsolutePath() + " You may have errors in your json!");
             }
@@ -871,28 +799,28 @@ public class CommandStudio implements DecreeExecutor {
     }
 
     private void fixBlocks(JSONObject obj) {
-        for(String i : obj.keySet()) {
+        for (String i : obj.keySet()) {
             Object o = obj.get(i);
 
-            if(i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
                 obj.put(i, "minecraft:" + o);
             }
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }
     }
 
     private void fixBlocks(JSONArray obj) {
-        for(int i = 0; i < obj.length(); i++) {
+        for (int i = 0; i < obj.length(); i++) {
             Object o = obj.get(i);
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }

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

@@ -0,0 +1,131 @@
+/*
+ * 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.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.pregenerator.TurboPregenerator;
+import com.volmit.iris.core.pregenerator.TurboPregenerator;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.util.Vector;
+
+import java.io.File;
+import java.io.IOException;
+
+@Decree(name = "turbopregen", aliases = "turbo", description = "Pregenerate your Iris worlds!")
+public class CommandTurboPregen implements DecreeExecutor {
+    public String worldName;
+    @Decree(description = "Pregenerate a world")
+    public void start(
+            @Param(description = "The radius of the pregen in blocks", aliases = "size")
+            int radius,
+            @Param(description = "The world to pregen", contextual = true)
+            World world,
+            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
+            Vector center
+            ) {
+
+        worldName = world.getName();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File TurboFile = new File(worldDirectory, "turbogen.json");
+        if (TurboFile.exists()) {
+            if (TurboPregenerator.getInstance() != null) {
+                sender().sendMessage(C.BLUE + "Turbo pregen is already in progress");
+                Iris.info(C.YELLOW + "Turbo pregen is already in progress");
+                return;
+            } else {
+                try {
+                    TurboFile.delete();
+                } catch (Exception e){
+                   Iris.error("Failed to delete the old instance file of Turbo Pregen!");
+                   return;
+                }
+            }
+        }
+
+        try {
+            if (sender().isPlayer() && access() == null) {
+                sender().sendMessage(C.RED + "The engine access for this world is null!");
+                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
+            }
+
+            TurboPregenerator.TurboPregenJob pregenJob = TurboPregenerator.TurboPregenJob.builder()
+                    .world(worldName)
+                    .radiusBlocks(radius)
+                    .position(0)
+                    .build();
+
+            File TurboGenFile = new File(worldDirectory, "turbogen.json");
+            TurboPregenerator pregenerator = new TurboPregenerator(pregenJob, TurboGenFile);
+            pregenerator.start();
+
+            String msg = C.GREEN + "TurboPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
+            sender().sendMessage(msg);
+            Iris.info(msg);
+        } catch (Throwable e) {
+            sender().sendMessage(C.RED + "Epic fail. See console.");
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Stop the active pregeneration task", aliases = "x")
+    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
+        TurboPregenerator turboPregenInstance = TurboPregenerator.getInstance();
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File turboFile = new File(worldDirectory, "turbogen.json");
+
+        if (turboPregenInstance != null) {
+            turboPregenInstance.shutdownInstance(world);
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
+        } else if (turboFile.exists() && turboFile.delete()) {
+            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
+        } else if (turboFile.exists()) {
+            Iris.error("Failed to delete the old instance file of Turbo Pregen!");
+        } else {
+            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
+        }
+    }
+
+    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
+    public void pause(
+            @Param(aliases = "world", description = "The world to pause")
+            World world
+    ) {
+        if (TurboPregenerator.getInstance() != null) {
+            TurboPregenerator.setPausedTurbo(world);
+            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
+        } else {
+            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+            File TurboFile = new File(worldDirectory, "turbogen.json");
+            if (TurboFile.exists()){
+                TurboPregenerator.loadTurboGenerator(world.getName());
+                sender().sendMessage(C.YELLOW + "Started Turbo Pregen back up!");
+            } else {
+                sender().sendMessage(C.YELLOW + "No active Turbo Pregen tasks to pause/unpause.");
+            }
+
+        }
+    }
+}

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?")
@@ -45,16 +48,16 @@ public class CommandWhat implements DecreeExecutor {
     public void hand() {
         try {
             BlockData bd = player().getInventory().getItemInMainHand().getType().createBlockData();
-            if(!bd.getMaterial().equals(Material.AIR)) {
+            if (!bd.getMaterial().equals(Material.AIR)) {
                 sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
                 sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
             } else {
                 sender().sendMessage("Please hold a block/item");
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Material bd = player().getInventory().getItemInMainHand().getType();
-            if(!bd.equals(Material.AIR)) {
+            if (!bd.equals(Material.AIR)) {
                 sender().sendMessage("Material: " + C.GREEN + bd.name());
             } else {
                 sender().sendMessage("Please hold a block/item");
@@ -65,63 +68,76 @@ public class CommandWhat implements DecreeExecutor {
     @Decree(description = "What biome am i in?", origin = DecreeOrigin.PLAYER)
     public void biome() {
         try {
-            IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ());
+            IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
             sender().sendMessage("IBiome: " + b.getLoadKey() + " (" + b.getDerivative().name() + ")");
 
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
 
-            if(player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
+            if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
                 try {
                     sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
-                } catch(Throwable ee) {
+                } catch (Throwable ee) {
                     Iris.reportError(ee);
                 }
             }
         }
     }
 
+    @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;
         try {
             bd = player().getTargetBlockExact(128, FluidCollisionMode.NEVER).getBlockData();
-        } catch(NullPointerException e) {
+        } catch (NullPointerException e) {
             Iris.reportError(e);
             sender().sendMessage("Please look at any block, not at the sky");
             bd = null;
         }
 
-        if(bd != null) {
+        if (bd != null) {
             sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
             sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
 
-            if(B.isStorage(bd)) {
+            if (B.isStorage(bd)) {
                 sender().sendMessage(C.YELLOW + "* Storage Block (Loot Capable)");
             }
 
-            if(B.isLit(bd)) {
+            if (B.isLit(bd)) {
                 sender().sendMessage(C.YELLOW + "* Lit Block (Light Capable)");
             }
 
-            if(B.isFoliage(bd)) {
+            if (B.isFoliage(bd)) {
                 sender().sendMessage(C.YELLOW + "* Foliage Block");
             }
 
-            if(B.isDecorant(bd)) {
+            if (B.isDecorant(bd)) {
                 sender().sendMessage(C.YELLOW + "* Decorant Block");
             }
 
-            if(B.isFluid(bd)) {
+            if (B.isFluid(bd)) {
                 sender().sendMessage(C.YELLOW + "* Fluid Block");
             }
 
-            if(B.isFoliagePlantable(bd)) {
+            if (B.isFoliagePlantable(bd)) {
                 sender().sendMessage(C.YELLOW + "* Plantable Foliage Block");
             }
 
-            if(B.isSolid(bd)) {
+            if (B.isSolid(bd)) {
                 sender().sendMessage(C.YELLOW + "* Solid Block");
             }
         }
@@ -131,23 +147,23 @@ public class CommandWhat implements DecreeExecutor {
     public void markers(@Param(description = "Marker name such as cave_floor or cave_ceiling") String marker) {
         Chunk c = player().getLocation().getChunk();
 
-        if(IrisToolbelt.isIrisWorld(c.getWorld())) {
+        if (IrisToolbelt.isIrisWorld(c.getWorld())) {
             int m = 1;
             AtomicInteger v = new AtomicInteger(0);
 
-            for(int xxx = c.getX() - 4; xxx <= c.getX() + 4; xxx++) {
-                for(int zzz = c.getZ() - 4; zzz <= c.getZ() + 4; zzz++) {
+            for (int xxx = c.getX() - 4; xxx <= c.getX() + 4; xxx++) {
+                for (int zzz = c.getZ() - 4; zzz <= c.getZ() + 4; zzz++) {
                     IrisToolbelt.access(c.getWorld()).getEngine().getMantle().findMarkers(xxx, zzz, new MatterMarker(marker))
-                        .convert((i) -> i.toLocation(c.getWorld())).forEach((i) -> {
-                            J.s(() -> BlockSignal.of(i.getBlock(), 100));
-                            v.incrementAndGet();
-                        });
+                            .convert((i) -> i.toLocation(c.getWorld())).forEach((i) -> {
+                                J.s(() -> BlockSignal.of(i.getBlock(), 100));
+                                v.incrementAndGet();
+                            });
                 }
             }
 
             sender().sendMessage("Found " + v.get() + " Nearby Markers (" + marker + ")");
         } else {
-            sender().sendMessage("Iris worlds only.");
+            sender().sendMessage(C.IRIS + "Iris worlds only.");
         }
     }
 }

core/src/main/java/com/volmit/iris/core/edit/BlockSignal.java

@@ -36,12 +36,11 @@ public class BlockSignal {
 
     public BlockSignal(Block block, int ticks) {
         active.incrementAndGet();
-        Location tg = block.getLocation().clone().add(0.5, 0, 0.5).clone();
-        FallingBlock e = block.getWorld().spawnFallingBlock(tg.clone(), block.getBlockData());
+        Location tg = block.getLocation().clone().add(0.5, 0, 0.5);
+        FallingBlock e = block.getWorld().spawnFallingBlock(tg, block.getBlockData());
         e.setGravity(false);
         e.setInvulnerable(true);
         e.setGlowing(true);
-        e.teleport(tg.clone());
         e.setDropItem(false);
         e.setHurtEntities(false);
         e.setSilent(true);
@@ -52,7 +51,7 @@ public class BlockSignal {
             active.decrementAndGet();
             BlockData type = block.getBlockData();
             MultiBurst.burst.lazy(() -> {
-                for(Player i : block.getWorld().getPlayers()) {
+                for (Player i : block.getWorld().getPlayers()) {
                     i.sendBlockChange(block.getLocation(), block.getBlockData());
                 }
             });
@@ -83,7 +82,7 @@ public class BlockSignal {
         new SR(20) {
             @Override
             public void run() {
-                if(e.isDead()) {
+                if (e.isDead()) {
                     cancel();
                     return;
                 }
@@ -99,7 +98,7 @@ public class BlockSignal {
             BlockData type = block.getBlockData();
 
             MultiBurst.burst.lazy(() -> {
-                for(Player i : block.getWorld().getPlayers()) {
+                for (Player i : block.getWorld().getPlayers()) {
                     i.sendBlockChange(block.getLocation(), block.getBlockData());
                 }
             });

core/src/main/java/com/volmit/iris/core/edit/DustRevealer.java

@@ -49,12 +49,12 @@ public class DustRevealer {
         this.hits = hits;
 
         J.s(() -> {
-            new BlockSignal(world.getBlockAt(block.getX(), block.getY(), block.getZ()), 7);
-            if(M.r(0.25)) {
+            new BlockSignal(world.getBlockAt(block.getX(), block.getY(), block.getZ()), 10);
+            if (M.r(0.25)) {
                 world.playSound(block.toBlock(world).getLocation(), Sound.BLOCK_AMETHYST_BLOCK_CHIME, 1f, RNG.r.f(0.2f, 2f));
             }
             J.a(() -> {
-                while(BlockSignal.active.get() > 128) {
+                while (BlockSignal.active.get() > 128) {
                     J.sleep(5);
                 }
 
@@ -85,7 +85,7 @@ public class DustRevealer {
                     is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ() + 1));
                     is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() - 1));
                     is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() + 1));
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
                     e.printStackTrace();
                 }
@@ -97,10 +97,9 @@ public class DustRevealer {
         World world = block.getWorld();
         Engine access = IrisToolbelt.access(world).getEngine();
 
-        if(access != null) {
-            String a = access.getObjectPlacementKey(block.getX(), block.getY(), block.getZ());
-
-            if(a != null) {
+        if (access != null) {
+            String a = access.getObjectPlacementKey(block.getX(), block.getY() - block.getWorld().getMinHeight(), block.getZ());
+            if (a != null) {
                 world.playSound(block.getLocation(), Sound.ITEM_LODESTONE_COMPASS_LOCK, 1f, 0.1f);
 
                 sender.sendMessage("Found object " + a);
@@ -112,7 +111,8 @@ public class DustRevealer {
     }
 
     private boolean is(BlockPosition a) {
-        if(isValidTry(a) && engine.getObjectPlacementKey(a.getX(), a.getY(), a.getZ()) != null && engine.getObjectPlacementKey(a.getX(), a.getY(), a.getZ()).equals(key)) {
+        int betterY = a.getY() - world.getMinHeight();
+        if (isValidTry(a) && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()) != null && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()).equals(key)) {
             hits.add(a);
             new DustRevealer(engine, world, a, key, hits);
             return true;

core/src/main/java/com/volmit/iris/core/edit/JigsawEditor.java

@@ -21,11 +21,8 @@ package com.volmit.iris.core.edit;
 import com.google.gson.Gson;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.service.WandSVC;
-import com.volmit.iris.engine.object.IrisDirection;
-import com.volmit.iris.engine.object.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPieceConnector;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisPosition;
+import com.volmit.iris.engine.object.*;
+import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.Cuboid;
 import com.volmit.iris.util.io.IO;
@@ -47,6 +44,7 @@ import org.bukkit.util.Vector;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.List;
 import java.util.concurrent.ExecutionException;
 
 public class JigsawEditor implements Listener {
@@ -63,11 +61,14 @@ public class JigsawEditor implements Listener {
     private Location target;
 
     public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
-        if(editors.containsKey(player)) {
+        if (editors.containsKey(player)) {
             editors.get(player).close();
         }
 
         editors.put(player, this);
+        if (object == null) {
+            throw new RuntimeException("Object is null! " + piece.getObject());
+        }
         this.object = object;
         this.player = player;
         origin = player.getLocation().clone().add(0, 7, 0);
@@ -77,26 +78,26 @@ public class JigsawEditor implements Listener {
         this.piece.setObject(object.getLoadKey());
         cuboid = new Cuboid(origin.clone(), origin.clone().add(object.getW() - 1, object.getH() - 1, object.getD() - 1));
         ticker = J.sr(this::onTick, 0);
-        object.placeCenterY(origin);
+        J.s(() -> object.placeCenterY(origin));
         Iris.instance.registerListener(this);
     }
 
     @EventHandler
     public void on(PlayerMoveEvent e) {
-        if(e.getPlayer().equals(player)) {
+        if (e.getPlayer().equals(player)) {
             try {
                 target = player.getTargetBlockExact(7).getLocation();
-            } catch(Throwable ex) {
+            } catch (Throwable ex) {
                 Iris.reportError(ex);
                 target = player.getLocation();
                 return;
             }
 
-            if(cuboid.contains(target)) {
-                for(IrisPosition i : falling.k()) {
+            if (cuboid.contains(target)) {
+                for (IrisPosition i : falling.k()) {
                     Location at = toLocation(i);
 
-                    if(at.equals(target)) {
+                    if (at.equals(target)) {
                         falling.remove(i).run();
                     }
                 }
@@ -106,43 +107,43 @@ public class JigsawEditor implements Listener {
 
     public Location toLocation(IrisPosition i) {
         return origin.clone()
-            .add(new Vector(i.getX(), i.getY(), i.getZ()))
-            .add(object.getCenter())
-            .getBlock()
-            .getLocation();
+                .add(new Vector(i.getX(), i.getY(), i.getZ()))
+                .add(object.getCenter())
+                .getBlock()
+                .getLocation();
     }
 
     public IrisPosition toPosition(Location l) {
         return new IrisPosition(l.clone().getBlock().getLocation()
-            .subtract(origin.clone())
-            .subtract(object.getCenter())
-            .add(1, 1, 1)
-            .toVector());
+                .subtract(origin.clone())
+                .subtract(object.getCenter())
+                .add(1, 1, 1)
+                .toVector());
     }
 
     @EventHandler
     public void on(PlayerInteractEvent e) {
-        if(e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
-            if(e.getClickedBlock() != null && cuboid.contains(e.getClickedBlock().getLocation()) && e.getPlayer().equals(player)) {
+        if (e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
+            if (e.getClickedBlock() != null && cuboid.contains(e.getClickedBlock().getLocation()) && e.getPlayer().equals(player)) {
                 IrisPosition pos = toPosition(e.getClickedBlock().getLocation());
                 IrisJigsawPieceConnector connector = null;
-                for(IrisJigsawPieceConnector i : piece.getConnectors()) {
-                    if(i.getPosition().equals(pos)) {
+                for (IrisJigsawPieceConnector i : piece.getConnectors()) {
+                    if (i.getPosition().equals(pos)) {
                         connector = i;
                         break;
                     }
                 }
 
-                if(!player.isSneaking() && connector == null) {
+                if (!player.isSneaking() && connector == null) {
                     connector = new IrisJigsawPieceConnector();
                     connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
                     connector.setPosition(pos);
                     piece.getConnectors().add(connector);
                     player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ADD_ITEM, 1f, 1f);
-                } else if(player.isSneaking() && connector != null) {
+                } else if (player.isSneaking() && connector != null) {
                     piece.getConnectors().remove(connector);
                     player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_REMOVE_ITEM, 1f, 1f);
-                } else if(connector != null && !player.isSneaking()) {
+                } else if (connector != null && !player.isSneaking()) {
                     connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
                     player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 1f);
                 }
@@ -150,11 +151,46 @@ public class JigsawEditor implements Listener {
         }
     }
 
+    private void removeKey(JSONObject o, String... path) {
+        if (path.length == 1) {
+            o.remove(path[0]);
+            return;
+        }
+
+        List<String> s = new java.util.ArrayList<>(List.of(path));
+        s.remove(0);
+        removeKey(o.getJSONObject(path[0]), s.toArray(new String[0]));
+    }
+
+    private List<JSONObject> getObjectsInArray(JSONObject a) { // This gets all the objects in an array that are connectors
+        KList<JSONObject> o = new KList<>();
+
+        for (int i = 0; i < a.getJSONArray("connectors").length(); i++) {
+            o.add(a.getJSONArray("connectors").getJSONObject(i));
+        }
+
+        return o;
+    }
+
     public void close() {
         exit();
         try {
-            IO.writeAll(targetSaveLocation, new JSONObject(new Gson().toJson(piece)).toString(4));
-        } catch(IOException e) {
+            JSONObject j = new JSONObject(new Gson().toJson(piece));
+            // Remove sub-key
+            removeKey(j, "placementOptions", "translateCenter"); // should work
+            J.attempt(() -> j.getJSONObject("placementOptions").remove("translateCenter")); // otherwise
+
+            // remove root key
+            removeKey(j, "placementOptions"); // should work
+            j.remove("placementOptions"); // otherwise
+
+            // Remove key in all objects in array
+            for (JSONObject i : getObjectsInArray(j)) {
+                removeKey(i, "rotateConnector");
+            }
+
+            IO.writeAll(targetSaveLocation, j.toString(4));
+        } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -168,20 +204,20 @@ public class JigsawEditor implements Listener {
                 object.unplaceCenterY(origin);
                 falling.v().forEach(Runnable::run);
             }).get();
-        } catch(InterruptedException | ExecutionException e) {
+        } catch (InterruptedException | ExecutionException e) {
             e.printStackTrace();
         }
         editors.remove(player);
     }
 
     public void onTick() {
-        if(cl.flip()) {
+        if (cl.flip()) {
             Iris.service(WandSVC.class).draw(cuboid, player);
 
             f:
-            for(IrisPosition i : falling.k()) {
-                for(IrisJigsawPieceConnector j : piece.getConnectors()) {
-                    if(j.getPosition().equals(i)) {
+            for (IrisPosition i : falling.k()) {
+                for (IrisJigsawPieceConnector j : piece.getConnectors()) {
+                    if (j.getPosition().equals(i)) {
                         continue f;
                     }
                 }
@@ -189,23 +225,23 @@ public class JigsawEditor implements Listener {
                 falling.remove(i).run();
             }
 
-            for(IrisJigsawPieceConnector i : piece.getConnectors()) {
+            for (IrisJigsawPieceConnector i : piece.getConnectors()) {
                 IrisPosition pos = i.getPosition();
                 Location at = toLocation(pos);
 
                 Vector dir = i.getDirection().toVector().clone();
 
 
-                for(int ix = 0; ix < RNG.r.i(1, 3); ix++) {
+                for (int ix = 0; ix < RNG.r.i(1, 3); ix++) {
                     at.getWorld().spawnParticle(Particle.SOUL_FIRE_FLAME, at.clone().getBlock().getLocation().add(0.25, 0.25, 0.25).add(RNG.r.d(0.5), RNG.r.d(0.5), RNG.r.d(0.5)), 0, dir.getX(), dir.getY(), dir.getZ(), 0.092 + RNG.r.d(-0.03, 0.08));
                 }
 
-                if(at.getBlock().getLocation().equals(target)) {
+                if (at.getBlock().getLocation().equals(target)) {
                     continue;
                 }
 
-                if(!falling.containsKey(pos)) {
-                    if(at.getBlock().getType().isAir()) {
+                if (!falling.containsKey(pos)) {
+                    if (at.getBlock().getType().isAir()) {
                         at.getBlock().setType(Material.STONE);
                     }
 

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

@@ -35,24 +35,9 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 
 import javax.imageio.ImageIO;
-import javax.swing.JComboBox;
-import javax.swing.JComponent;
-import javax.swing.JFrame;
-import javax.swing.JLayeredPane;
-import javax.swing.JPanel;
-import javax.swing.JViewport;
-import java.awt.Color;
-import java.awt.Dimension;
-import java.awt.EventQueue;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
-import java.awt.Point;
-import java.awt.Rectangle;
-import java.awt.event.MouseAdapter;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseMotionListener;
-import java.awt.event.MouseWheelEvent;
-import java.awt.event.MouseWheelListener;
+import javax.swing.*;
+import java.awt.*;
+import java.awt.event.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
@@ -133,10 +118,10 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         frame.add(pane);
         File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
 
-        if(file != null) {
+        if (file != null) {
             try {
                 frame.setIconImage(ImageIO.read(file));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
         }
@@ -148,7 +133,7 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         JFrame frame = new JFrame("Noise Explorer");
         NoiseExplorerGUI nv = new NoiseExplorerGUI();
         frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-        KList<String> li = new KList<>(NoiseStyle.values()).toStringList();
+        KList<String> li = new KList<>(NoiseStyle.values()).toStringList().sort();
         combo = new JComboBox<>(li.toArray(new String[0]));
         combo.setSelectedItem("STATIC");
         combo.setFocusable(false);
@@ -167,10 +152,10 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         frame.add(pane);
         File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
 
-        if(file != null) {
+        if (file != null) {
             try {
                 frame.setIconImage(ImageIO.read(file));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
         }
@@ -194,14 +179,14 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
 
     @EventHandler
     public void on(IrisEngineHotloadEvent e) {
-        if(generator != null)
+        if (generator != null)
             generator = loader.get();
     }
 
     public void mouseWheelMoved(MouseWheelEvent e) {
 
         int notches = e.getWheelRotation();
-        if(e.isControlDown()) {
+        if (e.isControlDown()) {
             t = t + ((0.0025 * t) * notches);
             return;
         }
@@ -212,51 +197,51 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
 
     @Override
     public void paint(Graphics g) {
-        if(scale < ascale) {
+        if (scale < ascale) {
             ascale -= Math.abs(scale - ascale) * 0.16;
         }
 
-        if(scale > ascale) {
+        if (scale > ascale) {
             ascale += Math.abs(ascale - scale) * 0.16;
         }
 
-        if(t < tz) {
+        if (t < tz) {
             tz -= Math.abs(t - tz) * 0.29;
         }
 
-        if(t > tz) {
+        if (t > tz) {
             tz += Math.abs(tz - t) * 0.29;
         }
 
-        if(ox < oxp) {
+        if (ox < oxp) {
             oxp -= Math.abs(ox - oxp) * 0.16;
         }
 
-        if(ox > oxp) {
+        if (ox > oxp) {
             oxp += Math.abs(oxp - ox) * 0.16;
         }
 
-        if(oz < ozp) {
+        if (oz < ozp) {
             ozp -= Math.abs(oz - ozp) * 0.16;
         }
 
-        if(oz > ozp) {
+        if (oz > ozp) {
             ozp += Math.abs(ozp - oz) * 0.16;
         }
 
-        if(mx < mxx) {
+        if (mx < mxx) {
             mxx -= Math.abs(mx - mxx) * 0.16;
         }
 
-        if(mx > mxx) {
+        if (mx > mxx) {
             mxx += Math.abs(mxx - mx) * 0.16;
         }
 
-        if(mz < mzz) {
+        if (mz < mzz) {
             mzz -= Math.abs(mz - mzz) * 0.16;
         }
 
-        if(mz > mzz) {
+        if (mz > mzz) {
             mzz += Math.abs(mzz - mz) * 0.16;
         }
 
@@ -265,26 +250,26 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         accuracy = down ? accuracy * 4 : accuracy;
         int v = 1000;
 
-        if(g instanceof Graphics2D gg) {
+        if (g instanceof Graphics2D gg) {
 
-            if(getParent().getWidth() != w || getParent().getHeight() != h) {
+            if (getParent().getWidth() != w || getParent().getHeight() != h) {
                 w = getParent().getWidth();
                 h = getParent().getHeight();
                 img = null;
             }
 
-            if(img == null) {
+            if (img == null) {
                 img = new BufferedImage(w / accuracy, h / accuracy, BufferedImage.TYPE_INT_RGB);
             }
 
             BurstExecutor e = gx.burst(w);
 
-            for(int x = 0; x < w / accuracy; x++) {
+            for (int x = 0; x < w / accuracy; x++) {
                 int xx = x;
 
                 int finalAccuracy = accuracy;
                 e.queue(() -> {
-                    for(int z = 0; z < h / finalAccuracy; z++) {
+                    for (int z = 0; z < h / finalAccuracy; z++) {
                         double n = generator != null ? generator.apply(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp) : cng.noise(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp);
                         n = n > 1 ? 1 : n < 0 ? 0 : n;
 
@@ -292,8 +277,7 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
                             Color color = colorMode ? Color.getHSBColor((float) (n), 1f - (float) (n * n * n * n * n * n), 1f - (float) n) : Color.getHSBColor(0f, 0f, (float) n);
                             int rgb = color.getRGB();
                             img.setRGB(xx, z, rgb);
-                        } catch(Throwable xxx) {
-
+                        } catch (Throwable ignored) {
                         }
                     }
                 });
@@ -308,15 +292,15 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
         t += 1D;
         r.put(p.getMilliseconds());
 
-        if(!isVisible()) {
+        if (!isVisible()) {
             return;
         }
 
-        if(!getParent().isVisible()) {
+        if (!getParent().isVisible()) {
             return;
         }
 
-        if(!getParent().getParent().isVisible()) {
+        if (!getParent().getParent().isVisible()) {
             return;
         }
 

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;
@@ -35,12 +36,8 @@ import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 
-import javax.swing.JFrame;
-import javax.swing.JPanel;
-import java.awt.Color;
-import java.awt.Font;
-import java.awt.Graphics;
-import java.awt.Graphics2D;
+import javax.swing.*;
+import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.awt.image.BufferedImage;
@@ -48,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");
@@ -66,24 +65,23 @@ public class PregeneratorJob implements PregenListener {
     private final IrisPregenerator pregenerator;
     private final Position2 min;
     private final Position2 max;
+    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
+    private final Engine engine;
     private JFrame frame;
     private PregenRenderer renderer;
     private int rgc = 0;
-    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
     private String[] info;
-    private final Engine engine;
 
     public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
         this.engine = engine;
         instance = this;
         monitor = new MemoryMonitor(50);
         saving = false;
-        info = new String[] {"Initializing..."};
+        info = new String[]{"Initializing..."};
         this.task = task;
         this.pregenerator = new IrisPregenerator(task, method, this);
         max = new Position2(0, 0);
         min = new Position2(0, 0);
-        KList<Runnable> draw = new KList<>();
         task.iterateRegions((xx, zz) -> {
             min.setX(Math.min(xx << 5, min.getX()));
             min.setZ(Math.min(zz << 5, min.getZ()));
@@ -91,19 +89,15 @@ 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();
         }
 
         J.a(this.pregenerator::start, 20);
     }
 
-    public Mantle getMantle() {
-        return pregenerator.getMantle();
-    }
-
     public static boolean shutdownInstance() {
-        if(instance == null) {
+        if (instance == null) {
             return false;
         }
 
@@ -116,11 +110,11 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public static boolean pauseResume() {
-        if(instance == null) {
+        if (instance == null) {
             return false;
         }
 
-        if(isPaused()) {
+        if (isPaused()) {
             instance.pregenerator.resume();
         } else {
             instance.pregenerator.pause();
@@ -129,7 +123,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public static boolean isPaused() {
-        if(instance == null) {
+        if (instance == null) {
             return true;
         }
 
@@ -140,7 +134,7 @@ public class PregeneratorJob implements PregenListener {
         String v = (c.startsWith("#") ? c : "#" + c).trim();
         try {
             return Color.decode(v);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.error("Error Parsing 'color', (" + c + ")");
         }
@@ -148,6 +142,10 @@ public class PregeneratorJob implements PregenListener {
         return Color.RED;
     }
 
+    public Mantle getMantle() {
+        return pregenerator.getMantle();
+    }
+
     public PregeneratorJob onProgress(Consumer<Double> c) {
         onProgress.add(c);
         return this;
@@ -159,21 +157,19 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public void drawRegion(int x, int z, Color color) {
-        J.a(() -> {
-            PregenTask.iterateRegion(x, z, (xx, zz) -> {
-                draw(xx, zz, color);
-                J.sleep(3);
-            });
-        });
+        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
+            draw(xx, zz, color);
+            J.sleep(3);
+        }));
     }
 
     public void draw(int x, int z, Color color) {
         try {
-            if(renderer != null && frame != null && frame.isVisible()) {
+            if (renderer != null && frame != null && frame.isVisible()) {
                 renderer.func.accept(new Position2(x, z), color);
             }
-        } catch(Throwable ignored) {
-
+        } catch (Throwable ignored) {
+            Iris.error("Failed to draw pregen");
         }
     }
 
@@ -191,8 +187,8 @@ public class PregeneratorJob implements PregenListener {
                 monitor.close();
                 J.sleep(3000);
                 frame.setVisible(false);
-            } catch(Throwable e) {
-
+            } catch (Throwable ignored) {
+                Iris.error("Error closing pregen gui");
             }
         });
     }
@@ -206,8 +202,7 @@ public class PregeneratorJob implements PregenListener {
                 renderer.l = new ReentrantLock();
                 renderer.frame = frame;
                 renderer.job = this;
-                renderer.func = (c, b) ->
-                {
+                renderer.func = (c, b) -> {
                     renderer.l.lock();
                     renderer.order.add(() -> renderer.draw(c, b, renderer.bg));
                     renderer.l.unlock();
@@ -215,40 +210,36 @@ public class PregeneratorJob implements PregenListener {
                 frame.add(renderer);
                 frame.setSize(1000, 1000);
                 frame.setVisible(true);
-            } catch(Throwable e) {
-
+            } catch (Throwable ignored) {
+                Iris.error("Error opening pregen gui");
             }
         });
     }
 
     @Override
     public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
-        info = new String[] {
-            (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
-            "Speed: " + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
-            Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
-            "Generation Method: " + method,
-            "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
+        info = new String[]{
+                (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
+                "Speed: " + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
+                Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
+                "Generation Method: " + method,
+                "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
 
         };
 
-        for(Consumer<Double> i : onProgress) {
+        for (Consumer<Double> i : onProgress) {
             i.accept(percent);
         }
     }
 
     @Override
     public void onChunkGenerating(int x, int z) {
-        if(engine != null) {
-            return;
-        }
-
         draw(x, z, COLOR_GENERATING);
     }
 
     @Override
     public void onChunkGenerated(int x, int z) {
-        if(engine != null) {
+        if (engine != null) {
             draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
             return;
         }
@@ -263,7 +254,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     private void shouldGc() {
-        if(cl.flip() && rgc > 16) {
+        if (cl.flip() && rgc > 16) {
             System.gc();
         }
     }
@@ -322,7 +313,7 @@ public class PregeneratorJob implements PregenListener {
 
     @Override
     public void onChunkExistsInRegionGen(int x, int z) {
-        if(engine != null) {
+        if (engine != null) {
             draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
             return;
         }
@@ -371,10 +362,10 @@ public class PregeneratorJob implements PregenListener {
             bg = (Graphics2D) image.getGraphics();
             l.lock();
 
-            while(order.isNotEmpty()) {
+            while (order.isNotEmpty()) {
                 try {
                     order.pop().run();
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
 
                 }
@@ -388,12 +379,12 @@ public class PregeneratorJob implements PregenListener {
             int h = g.getFontMetrics().getHeight() + 5;
             int hh = 20;
 
-            if(job.paused()) {
+            if (job.paused()) {
                 g.drawString("PAUSED", 20, hh += h);
 
                 g.drawString("Press P to Resume", 20, hh += h);
             } else {
-                for(String i : prog) {
+                for (String i : prog) {
                     g.drawString(i, 20, hh += h);
                 }
 
@@ -429,7 +420,7 @@ public class PregeneratorJob implements PregenListener {
 
         @Override
         public void keyReleased(KeyEvent e) {
-            if(e.getKeyCode() == KeyEvent.VK_P) {
+            if (e.getKeyCode() == KeyEvent.VK_P) {
                 PregeneratorJob.pauseResume();
             }
         }

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

@@ -44,16 +44,10 @@ import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
 import javax.imageio.ImageIO;
-import javax.swing.JFrame;
-import javax.swing.JPanel;
+import javax.swing.*;
 import javax.swing.event.MouseInputListener;
 import java.awt.*;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-import java.awt.event.MouseEvent;
-import java.awt.event.MouseMotionListener;
-import java.awt.event.MouseWheelEvent;
-import java.awt.event.MouseWheelListener;
+import java.awt.event.*;
 import java.awt.image.BufferedImage;
 import java.io.File;
 import java.io.IOException;
@@ -143,7 +137,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         J.a(() -> {
             J.sleep(10000);
 
-            if(!helpIgnored && help) {
+            if (!helpIgnored && help) {
                 help = false;
             }
         });
@@ -167,11 +161,11 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         frame.setVisible(true);
         File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
 
-        if(file != null) {
+        if (file != null) {
             try {
                 nv.texture = ImageIO.read(file);
                 frame.setIconImage(ImageIO.read(file));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
 
             }
@@ -180,16 +174,16 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     public static void launch(Engine g, int i) {
         J.a(() ->
-            createAndShowGUI(g, i, g.getWorld()));
+                createAndShowGUI(g, i, g.getWorld()));
     }
 
     public boolean updateEngine() {
-        if(engine.isClosed()) {
-            if(world.hasRealWorld()) {
+        if (engine.isClosed()) {
+            if (world.hasRealWorld()) {
                 try {
                     engine = IrisToolbelt.access(world.realWorld()).getEngine();
                     return !engine.isClosed();
-                } catch(Throwable e) {
+                } catch (Throwable e) {
 
                 }
             }
@@ -217,13 +211,19 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     public int getColor(double wx, double wz) {
         BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
 
-        switch(currentType) {
-            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD -> colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case BIOME_LAND -> colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case BIOME_SEA -> colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case REGION -> colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
-            case CAVE_LAND -> colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case HEIGHT -> colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
         }
 
         return colorFunction.apply(wx, wz);
@@ -240,51 +240,51 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     @Override
     public void keyPressed(KeyEvent e) {
-        if(e.getKeyCode() == KeyEvent.VK_SHIFT) {
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
             shift = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_CONTROL) {
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
             control = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
             debug = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SLASH) {
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
             help = true;
             helpIgnored = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_ALT) {
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
             alt = true;
         }
     }
 
     @Override
     public void keyReleased(KeyEvent e) {
-        if(e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
+        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
             debug = false;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SHIFT) {
+        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
             shift = false;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_CONTROL) {
+        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
             control = false;
         }
-        if(e.getKeyCode() == KeyEvent.VK_SLASH) {
+        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
             help = false;
             helpIgnored = true;
         }
-        if(e.getKeyCode() == KeyEvent.VK_ALT) {
+        if (e.getKeyCode() == KeyEvent.VK_ALT) {
             alt = false;
         }
 
         // Pushes
-        if(e.getKeyCode() == KeyEvent.VK_F) {
+        if (e.getKeyCode() == KeyEvent.VK_F) {
             follow = !follow;
 
-            if(player != null && follow) {
+            if (player != null && follow) {
                 notify("Following " + player.getName() + ". Press F to disable");
-            } else if(follow) {
+            } else if (follow) {
                 notify("Can't follow, no one is in the world");
                 follow = false;
             } else {
@@ -294,38 +294,38 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_R) {
+        if (e.getKeyCode() == KeyEvent.VK_R) {
             dump();
             notify("Refreshing Chunks");
             return;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_P) {
+        if (e.getKeyCode() == KeyEvent.VK_P) {
             lowtile = !lowtile;
             dump();
             notify("Rendering " + (lowtile ? "Low" : "High") + " Quality Tiles");
             return;
         }
-        if(e.getKeyCode() == KeyEvent.VK_E) {
+        if (e.getKeyCode() == KeyEvent.VK_E) {
             eco = !eco;
             dump();
             notify("Using " + (eco ? "60" : "Uncapped") + " FPS Limit");
             return;
         }
-        if(e.getKeyCode() == KeyEvent.VK_EQUALS) {
+        if (e.getKeyCode() == KeyEvent.VK_EQUALS) {
             mscale = mscale + ((0.044 * mscale) * -3);
             mscale = Math.max(mscale, 0.00001);
             dump();
             return;
         }
-        if(e.getKeyCode() == KeyEvent.VK_MINUS) {
+        if (e.getKeyCode() == KeyEvent.VK_MINUS) {
             mscale = mscale + ((0.044 * mscale) * 3);
             mscale = Math.max(mscale, 0.00001);
             dump();
             return;
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
+        if (e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
             mscale = 1D;
             dump();
             notify("Zoom Reset");
@@ -334,9 +334,9 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
         int currentMode = currentType.ordinal();
 
-        for(RenderType i : RenderType.values()) {
-            if(e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
-                if(i.ordinal() != currentMode) {
+        for (RenderType i : RenderType.values()) {
+            if (e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
+                if (i.ordinal() != currentMode) {
                     currentType = i;
                     dump();
                     notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
@@ -345,7 +345,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             }
         }
 
-        if(e.getKeyCode() == KeyEvent.VK_M) {
+        if (e.getKeyCode() == KeyEvent.VK_M) {
             currentType = RenderType.values()[(currentMode + 1) % RenderType.values().length];
             notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
             dump();
@@ -361,15 +361,15 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         BlockPosition key = new BlockPosition((int) mscale, Math.floorDiv(x, div), Math.floorDiv(z, div));
         fg.add(key);
 
-        if(positions.containsKey(key)) {
+        if (positions.containsKey(key)) {
             return positions.get(key);
         }
 
-        if(fastpositions.containsKey(key)) {
-            if(!working.contains(key) && working.size() < 9) {
+        if (fastpositions.containsKey(key)) {
+            if (!working.contains(key) && working.size() < 9) {
                 m.set(m.get() - 1);
 
-                if(m.get() >= 0 && velocity < 50) {
+                if (m.get() >= 0 && velocity < 50) {
                     working.add(key);
                     double mk = mscale;
                     double mkd = scale;
@@ -380,7 +380,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
                         rs.put(ps.getMilliseconds());
                         working.remove(key);
 
-                        if(mk == mscale && mkd == scale) {
+                        if (mk == mscale && mkd == scale) {
                             positions.put(key, b);
                         }
                     });
@@ -390,7 +390,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return fastpositions.get(key);
         }
 
-        if(workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
+        if (workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
             return null;
         }
 
@@ -404,7 +404,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             rs.put(ps.getMilliseconds());
             workingfast.remove(key);
 
-            if(mk == mscale && mkd == scale) {
+            if (mk == mscale && mkd == scale) {
                 fastpositions.put(key, b);
             }
         });
@@ -431,15 +431,11 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     @Override
     public void paint(Graphics gx) {
 
-        if(engine.isClosed()) {
+        if (engine.isClosed()) {
             EventQueue.invokeLater(() -> {
-                try
-                {
+                try {
                     setVisible(false);
-                }
-
-                catch(Throwable e)
-                {
+                } catch (Throwable e) {
 
                 }
             });
@@ -447,49 +443,49 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return;
         }
 
-        if(updateEngine()) {
+        if (updateEngine()) {
             dump();
         }
 
-        if(ox < oxp) {
+        if (ox < oxp) {
             velocity = Math.abs(ox - oxp) * 0.36;
             oxp -= velocity;
         }
 
-        if(ox > oxp) {
+        if (ox > oxp) {
             velocity = Math.abs(oxp - ox) * 0.36;
             oxp += velocity;
         }
 
-        if(oz < ozp) {
+        if (oz < ozp) {
             velocity = Math.abs(oz - ozp) * 0.36;
             ozp -= velocity;
         }
 
-        if(oz > ozp) {
+        if (oz > ozp) {
             velocity = Math.abs(ozp - oz) * 0.36;
             ozp += velocity;
         }
 
-        if(lx < hx) {
+        if (lx < hx) {
             hx -= Math.abs(lx - hx) * 0.36;
         }
 
-        if(lx > hx) {
+        if (lx > hx) {
             hx += Math.abs(hx - lx) * 0.36;
         }
 
-        if(lz < hz) {
+        if (lz < hz) {
             hz -= Math.abs(lz - hz) * 0.36;
         }
 
-        if(lz > hz) {
+        if (lz > hz) {
             hz += Math.abs(hz - lz) * 0.36;
         }
 
-        if(centities.flip()) {
+        if (centities.flip()) {
             J.s(() -> {
-                synchronized(lastEntities) {
+                synchronized (lastEntities) {
                     lastEntities.clear();
                     lastEntities.addAll(world.getEntitiesByClass(LivingEntity.class));
                 }
@@ -503,7 +499,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         double vscale = scale;
         scale = w / 12D;
 
-        if(scale != vscale) {
+        if (scale != vscale) {
             positions.clear();
         }
 
@@ -515,15 +511,15 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         int posZ = (int) ozp;
         m.set(3);
 
-        for(int r = 0; r < Math.max(w, h); r += iscale) {
-            for(int i = -iscale; i < w + iscale; i += iscale) {
-                for(int j = -iscale; j < h + iscale; j += iscale) {
+        for (int r = 0; r < Math.max(w, h); r += iscale) {
+            for (int i = -iscale; i < w + iscale; i += iscale) {
+                for (int j = -iscale; j < h + iscale; j += iscale) {
                     int a = i - (w / 2);
                     int b = j - (h / 2);
-                    if(a * a + b * b <= r * r) {
+                    if (a * a + b * b <= r * r) {
                         BufferedImage t = getTile(gg, iscale, Math.floorDiv((posX / iscale) + i, iscale) * iscale, Math.floorDiv((posZ / iscale) + j, iscale) * iscale, m);
 
-                        if(t != null) {
+                        if (t != null) {
                             g.drawImage(t, i - ((posX / iscale) % (iscale)), j - ((posZ / iscale) % (iscale)), iscale, iscale, (img, infoflags, x, y, width, height) -> true);
                         }
                     }
@@ -533,8 +529,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
         p.end();
 
-        for(BlockPosition i : positions.k()) {
-            if(!gg.contains(i)) {
+        for (BlockPosition i : positions.k()) {
+            if (!gg.contains(i)) {
                 positions.remove(i);
             }
         }
@@ -542,15 +538,15 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         hanleFollow();
         renderOverlays(g);
 
-        if(!isVisible()) {
+        if (!isVisible()) {
             return;
         }
 
-        if(!getParent().isVisible()) {
+        if (!getParent().isVisible()) {
             return;
         }
 
-        if(!getParent().getParent().isVisible()) {
+        if (!getParent().getParent().isVisible()) {
             return;
         }
 
@@ -562,7 +558,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     }
 
     private void hanleFollow() {
-        if(follow && player != null) {
+        if (follow && player != null) {
             animateTo(player.getLocation().getX(), player.getLocation().getZ());
         }
     }
@@ -570,16 +566,16 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void renderOverlays(Graphics2D g) {
         renderPlayer(g);
 
-        if(help) {
+        if (help) {
             renderOverlayHelp(g);
-        } else if(debug) {
+        } else if (debug) {
             renderOverlayDebug(g);
         }
 
         renderOverlayLegend(g);
 
         renderHoverOverlay(g, shift);
-        if(!notifications.isEmpty()) {
+        if (!notifications.isEmpty()) {
             renderNotification(g);
         }
     }
@@ -597,8 +593,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void renderNotification(Graphics2D g) {
         drawCardCB(g, notifications.k());
 
-        for(String i : notifications.k()) {
-            if(M.ms() > notifications.get(i)) {
+        for (String i : notifications.k()) {
+            if (M.ms() > notifications.get(i)) {
                 notifications.remove(i);
             }
         }
@@ -607,32 +603,32 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void renderPlayer(Graphics2D g) {
         Player b = null;
 
-        for(Player i : world.getPlayers()) {
+        for (Player i : world.getPlayers()) {
             b = i;
             renderPosition(g, i.getLocation().getX(), i.getLocation().getZ());
         }
 
-        synchronized(lastEntities) {
+        synchronized (lastEntities) {
             double dist = Double.MAX_VALUE;
             LivingEntity h = null;
 
-            for(LivingEntity i : lastEntities) {
-                if(i instanceof Player) {
+            for (LivingEntity i : lastEntities) {
+                if (i instanceof Player) {
                     continue;
                 }
 
                 renderMobPosition(g, i, i.getLocation().getX(), i.getLocation().getZ());
-                if(shift) {
+                if (shift) {
                     double d = i.getLocation().distanceSquared(new Location(i.getWorld(), getWorldX(hx), i.getLocation().getY(), getWorldZ(hz)));
 
-                    if(d < dist) {
+                    if (d < dist) {
                         dist = d;
                         h = i;
                     }
                 }
             }
 
-            if(h != null && shift) {
+            if (h != null && shift) {
                 g.setColor(Color.red);
                 g.fillRoundRect((int) getScreenX(h.getLocation().getX()) - 10, (int) getScreenZ(h.getLocation().getZ()) - 10, 20, 20, 20, 20);
                 KList<String> k = new KList<>();
@@ -657,7 +653,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     }
 
     private void renderPosition(Graphics2D g, double x, double z) {
-        if(texture != null) {
+        if (texture != null) {
             g.drawImage(texture, (int) getScreenX(x), (int) getScreenZ(z), 66, 66, (img, infoflags, xx, xy, width, height) -> true);
         } else {
             g.setColor(Color.darkGray);
@@ -679,7 +675,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         l.add("Biome: " + biome.getName());
         l.add("Region: " + region.getName() + "(" + region.getLoadKey() + ")");
         l.add("Block " + (int) getWorldX(hx) + ", " + (int) getWorldZ(hz));
-        if(detailed) {
+        if (detailed) {
             l.add("Chunk " + ((int) getWorldX(hx) >> 4) + ", " + ((int) getWorldZ(hz) >> 4));
             l.add("Region " + (((int) getWorldX(hx) >> 4) >> 5) + ", " + (((int) getWorldZ(hz) >> 4) >> 5));
             l.add("Key: " + biome.getLoadKey());
@@ -708,7 +704,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         l.add("E to toggle Eco FPS Mode");
 
         int ff = 0;
-        for(RenderType i : RenderType.values()) {
+        for (RenderType i : RenderType.values()) {
             ff++;
             l.add(ff + " to view " + Form.capitalizeWords(i.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
         }
@@ -738,8 +734,9 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void open() {
         IrisComplex complex = engine.getComplex();
         File r = null;
-        switch(currentType) {
-            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT -> r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
+        switch (currentType) {
+            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT ->
+                    r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
             case BIOME_LAND -> r = complex.getLandBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
             case BIOME_SEA -> r = complex.getSeaBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
             case REGION -> r = complex.getRegionStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
@@ -751,7 +748,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     private void teleport() {
         J.s(() -> {
-            if(player != null) {
+            if (player != null) {
                 int xx = (int) getWorldX(hx);
                 int zz = (int) getWorldZ(hz);
                 int h = engine.getComplex().getRoundedHeighteightStream().get(xx, zz);
@@ -776,7 +773,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         int h = 0;
         int w = 0;
 
-        for(String i : text) {
+        for (String i : text) {
             h += g.getFontMetrics().getHeight();
             w = Math.max(w, g.getFontMetrics().stringWidth(i));
         }
@@ -796,14 +793,14 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
         g.setColor(Color.black);
         int m = 0;
-        for(String i : text) {
+        for (String i : text) {
             g.drawString(i, x + 14 - cw, y + 14 - ch + (++m * g.getFontMetrics().getHeight()));
         }
     }
 
     public void mouseWheelMoved(MouseWheelEvent e) {
         int notches = e.getWheelRotation();
-        if(e.isControlDown()) {
+        if (e.isControlDown()) {
             return;
         }
 
@@ -816,9 +813,9 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     @Override
     public void mouseClicked(MouseEvent e) {
-        if(control) {
+        if (control) {
             teleport();
-        } else if(alt) {
+        } else if (alt) {
             open();
         }
     }

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

@@ -0,0 +1,85 @@
+/*
+ * 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.gui.components;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisBiomeGeneratorLink;
+import com.volmit.iris.util.interpolation.IrisInterpolation;
+
+import java.awt.*;
+import java.awt.image.BufferedImage;
+import java.util.function.BiFunction;
+
+public class IrisRenderer {
+    private final Engine renderer;
+
+    public IrisRenderer(Engine renderer) {
+        this.renderer = renderer;
+    }
+
+    public BufferedImage render(double sx, double sz, double size, int resolution, RenderType currentType) {
+        BufferedImage image = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_RGB);
+        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
+
+        switch (currentType) {
+            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
+                    colorFunction = (x, z) -> renderer.getComplex().getTrueBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getLandBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case BIOME_SEA ->
+                    colorFunction = (x, z) -> renderer.getComplex().getSeaBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case REGION ->
+                    colorFunction = (x, z) -> renderer.getComplex().getRegionStream().get(x, z).getColor(renderer.getComplex(), currentType).getRGB();
+            case CAVE_LAND ->
+                    colorFunction = (x, z) -> renderer.getComplex().getCaveBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
+            case HEIGHT ->
+                    colorFunction = (x, z) -> Color.getHSBColor(renderer.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
+            case CONTINENT -> colorFunction = (x, z) -> {
+                IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
+                IrisBiomeGeneratorLink g = b.getGenerators().get(0);
+                Color c;
+                if (g.getMax() <= 0) {
+                    // Max is below water level, so it is most likely an ocean biome
+                    c = Color.BLUE;
+                } else if (g.getMin() < 0) {
+                    // Min is below water level, but max is not, so it is most likely a shore biome
+                    c = Color.YELLOW;
+                } else {
+                    // Both min and max are above water level, so it is most likely a land biome
+                    c = Color.GREEN;
+                }
+                return c.getRGB();
+            };
+        }
+
+        double x, z;
+        int i, j;
+        for (i = 0; i < resolution; i++) {
+            x = IrisInterpolation.lerp(sx, sx + size, (double) i / (double) (resolution));
+
+            for (j = 0; j < resolution; j++) {
+                z = IrisInterpolation.lerp(sz, sz + size, (double) j / (double) (resolution));
+                image.setRGB(i, j, colorFunction.apply(x, z));
+            }
+        }
+
+        return image;
+    }
+}

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

@@ -19,5 +19,5 @@
 package com.volmit.iris.core.gui.components;
 
 public enum RenderType {
-    BIOME, BIOME_LAND, BIOME_SEA, REGION, CAVE_LAND, HEIGHT, OBJECT_LOAD, DECORATOR_LOAD, LAYER_LOAD
+    BIOME, BIOME_LAND, BIOME_SEA, REGION, CAVE_LAND, HEIGHT, OBJECT_LOAD, DECORATOR_LOAD, CONTINENT, LAYER_LOAD
 }

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

@@ -18,7 +18,7 @@
 
 package com.volmit.iris.core.gui.components;
 
-import java.awt.Color;
+import java.awt.*;
 
 @FunctionalInterface
 public interface Renderer {

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

@@ -0,0 +1,102 @@
+//package com.volmit.iris.core.link;
+//
+//import com.jojodmo.customitems.api.CustomItemsAPI;
+//import com.jojodmo.customitems.item.custom.CustomItem;
+//import com.jojodmo.customitems.item.custom.block.CustomMushroomBlock;
+//import com.jojodmo.customitems.version.SafeMaterial;
+//import com.volmit.iris.util.collection.KList;
+//import com.volmit.iris.util.reflect.WrappedField;
+//import com.volmit.iris.util.reflect.WrappedReturningMethod;
+//import org.bukkit.block.BlockFace;
+//import org.bukkit.block.data.BlockData;
+//import org.bukkit.block.data.MultipleFacing;
+//import org.bukkit.inventory.ItemStack;
+//
+//import java.util.Map;
+//import java.util.MissingResourceException;
+//
+//public class CustomItemsDataProvider extends ExternalDataProvider {
+//
+//    private static final String FIELD_FACES = "faces";
+//    private static final String METHOD_GET_MATERIAL = "getMaterial";
+//
+//    private WrappedField<CustomMushroomBlock, Map<Integer, boolean[]>> mushroomFaces;
+//    private WrappedReturningMethod<CustomMushroomBlock, SafeMaterial> mushroomMaterial;
+//
+//    public CustomItemsDataProvider() {
+//        super("CustomItems");
+//    }
+//
+//    @Override
+//    public void init() {
+//        this.mushroomFaces = new WrappedField<>(CustomMushroomBlock.class, FIELD_FACES);
+//        this.mushroomMaterial = new WrappedReturningMethod<>(CustomMushroomBlock.class, METHOD_GET_MATERIAL);
+//    }
+//
+//    @Override
+//    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+//        CustomItem item = CustomItem.get(blockId.key());
+//        if(item == null) {
+//            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+//        } else if(item.getBlockTexture().isSpawner()) {
+//            throw new MissingResourceException("Iris does not yet support SpawnerBlocks from CustomItems.", blockId.namespace(), blockId.key());
+//        } else if(item.getBlockTexture() != null && item.getBlockTexture().isValid()) {
+//            throw new MissingResourceException("Tried to fetch BlockData for a CustomItem that is not placeable!", blockId.namespace(), blockId.key());
+//        }
+//        return getMushroomData(item);
+//    }
+//
+//    @Override
+//    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+//        ItemStack stack = CustomItemsAPI.getCustomItem(itemId.key());
+//        if(stack == null) {
+//            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+//        }
+//        return stack;
+//    }
+//
+//    @Override
+//    public Identifier[] getBlockTypes() {
+//        KList<Identifier> names = new KList<>();
+//        for (String name : CustomItemsAPI.listBlockCustomItemIDs()) {
+//            try {
+//                Identifier key = new Identifier("cui", name);
+//                if (getItemStack(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 : CustomItemsAPI.listCustomItemIDs()) {
+//            try {
+//                Identifier key = new Identifier("cui", name);
+//                if (getItemStack(key) != null)
+//                    names.add(key);
+//            } catch (MissingResourceException ignored) { }
+//        }
+//
+//        return names.toArray(new Identifier[0]);
+//    }
+//
+//    @Override
+//    public boolean isValidProvider(Identifier key, boolean isItem) {
+//        return key.namespace().equalsIgnoreCase("cui");
+//    }
+//
+//    private BlockData getMushroomData(CustomItem item) {
+//        MultipleFacing data = (MultipleFacing)mushroomMaterial.invoke(item.getBlockTexture().getMushroomId()).parseMaterial().createBlockData();
+//        boolean[] values = mushroomFaces.get().get(item.getBlockTexture().getMushroomId());
+//        data.setFace(BlockFace.DOWN, values[0]);
+//        data.setFace(BlockFace.EAST, values[1]);
+//        data.setFace(BlockFace.NORTH, values[2]);
+//        data.setFace(BlockFace.SOUTH, values[3]);
+//        data.setFace(BlockFace.UP, values[4]);
+//        data.setFace(BlockFace.WEST, values[5]);
+//        return data;
+//    }
+//}

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

@@ -0,0 +1,58 @@
+package com.volmit.iris.core.link;
+
+import com.ssomar.score.api.executableitems.ExecutableItemsAPI;
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+import java.util.Optional;
+
+public class ExecutableItemsDataProvider extends ExternalDataProvider {
+    public ExecutableItemsDataProvider() {
+        super("ExecutableItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up ExecutableItems Link...");
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+        return ExecutableItemsAPI.getExecutableItemsManager().getExecutableItem(itemId.key())
+                .map(item -> item.buildItem(1, Optional.empty()))
+                .orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()));
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        return new Identifier[0];
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> names = new KList<>();
+        for (String name : ExecutableItemsAPI.getExecutableItemsManager().getExecutableItemIdsList()) {
+            try {
+                Identifier key = new Identifier("executable_items", name);
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier key, boolean isItem) {
+        return key.namespace().equalsIgnoreCase("executable_items") && isItem;
+    }
+}

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

@@ -0,0 +1,40 @@
+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;
+
+import java.util.MissingResourceException;
+
+@RequiredArgsConstructor
+public abstract class ExternalDataProvider {
+
+    @Getter
+    private final String pluginId;
+
+    public Plugin getPlugin() {
+        return Bukkit.getPluginManager().getPlugin(pluginId);
+    }
+
+    public boolean isReady() {
+        return getPlugin() != null && getPlugin().isEnabled();
+    }
+
+    public abstract void init();
+
+    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();
+
+    public abstract Identifier[] getItemTypes();
+
+    public abstract boolean isValidProvider(Identifier id, boolean isItem);
+}

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

@@ -0,0 +1,129 @@
+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.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 (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(), true});
+		if (result == null || !result)
+			Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
+	}
+
+	@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());
+	}
+}

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

@@ -0,0 +1,33 @@
+package com.volmit.iris.core.link;
+
+import org.bukkit.NamespacedKey;
+
+public record Identifier(String namespace, String key) {
+
+    private static final String DEFAULT_NAMESPACE = "minecraft";
+
+    public static Identifier fromString(String id) {
+        String[] strings = id.split(":", 2);
+        if (strings.length == 1) {
+            return new Identifier(DEFAULT_NAMESPACE, strings[0]);
+        } else {
+            return new Identifier(strings[0], strings[1]);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return namespace + ":" + key;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj instanceof Identifier i) {
+            return i.namespace().equals(this.namespace) && i.key().equals(this.key);
+        } else if (obj instanceof NamespacedKey i) {
+            return i.getNamespace().equals(this.namespace) && i.getKey().equals(this.key);
+        } else {
+            return false;
+        }
+    }
+}

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

@@ -20,31 +20,33 @@ package com.volmit.iris.core.link;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
 import org.bukkit.Location;
 import org.bukkit.OfflinePlayer;
+import org.jetbrains.annotations.NotNull;
 
 // See/update https://app.gitbook.com/@volmitsoftware/s/iris/compatability/papi/
 public class IrisPapiExpansion extends PlaceholderExpansion {
     @Override
-    public String getIdentifier() {
+    public @NotNull String getIdentifier() {
         return "iris";
     }
 
     @Override
-    public String getAuthor() {
+    public @NotNull String getAuthor() {
         return "Volmit Software";
     }
 
     @Override
-    public String getVersion() {
+    public @NotNull String getVersion() {
         return Iris.instance.getDescription().getVersion();
     }
 
     @Override
     public boolean persist() {
-        return false;
+        return true;
     }
 
     @Override
@@ -52,59 +54,63 @@ public class IrisPapiExpansion extends PlaceholderExpansion {
         Location l = null;
         PlatformChunkGenerator a = null;
 
-        if(player.isOnline()) {
-            l = player.getPlayer().getLocation();
+        if (player.isOnline() && player.getPlayer() != null) {
+            l = player.getPlayer().getLocation().add(0, 2, 0);
             a = IrisToolbelt.access(l.getWorld());
         }
 
-        if(p.equalsIgnoreCase("biome_name")) {
-            if(a != null) {
-                return a.getEngine().getBiome(l).getName();
+        if (p.equalsIgnoreCase("biome_name")) {
+            if (a != null) {
+                return getBiome(a, l).getName();
             }
-        } else if(p.equalsIgnoreCase("biome_id")) {
-            if(a != null) {
-                return a.getEngine().getBiome(l).getLoadKey();
+        } else if (p.equalsIgnoreCase("biome_id")) {
+            if (a != null) {
+                return getBiome(a, l).getLoadKey();
             }
-        } else if(p.equalsIgnoreCase("biome_file")) {
-            if(a != null) {
-                return a.getEngine().getBiome(l).getLoadFile().getPath();
+        } else if (p.equalsIgnoreCase("biome_file")) {
+            if (a != null) {
+                return getBiome(a, l).getLoadFile().getPath();
             }
-        } else if(p.equalsIgnoreCase("region_name")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("region_name")) {
+            if (a != null) {
                 return a.getEngine().getRegion(l).getName();
             }
-        } else if(p.equalsIgnoreCase("region_id")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("region_id")) {
+            if (a != null) {
                 return a.getEngine().getRegion(l).getLoadKey();
             }
-        } else if(p.equalsIgnoreCase("region_file")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("region_file")) {
+            if (a != null) {
                 return a.getEngine().getRegion(l).getLoadFile().getPath();
             }
-        } else if(p.equalsIgnoreCase("terrain_slope")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("terrain_slope")) {
+            if (a != null) {
                 return (a.getEngine())
-                    .getComplex().getSlopeStream()
-                    .get(l.getX(), l.getZ()) + "";
+                        .getComplex().getSlopeStream()
+                        .get(l.getX(), l.getZ()) + "";
             }
-        } else if(p.equalsIgnoreCase("terrain_height")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("terrain_height")) {
+            if (a != null) {
                 return Math.round(a.getEngine().getHeight(l.getBlockX(), l.getBlockZ())) + "";
             }
-        } else if(p.equalsIgnoreCase("world_mode")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("world_mode")) {
+            if (a != null) {
                 return a.isStudio() ? "Studio" : "Production";
             }
-        } else if(p.equalsIgnoreCase("world_seed")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("world_seed")) {
+            if (a != null) {
                 return a.getEngine().getSeedManager().getSeed() + "";
             }
-        } else if(p.equalsIgnoreCase("world_speed")) {
-            if(a != null) {
+        } else if (p.equalsIgnoreCase("world_speed")) {
+            if (a != null) {
                 return a.getEngine().getGeneratedPerSecond() + "/s";
             }
         }
 
         return null;
     }
+
+    private IrisBiome getBiome(PlatformChunkGenerator a, Location l) {
+        return a.getEngine().getBiome(l.getBlockX(), l.getBlockY() - l.getWorld().getMinHeight(), l.getBlockZ());
+    }
 }

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

@@ -0,0 +1,70 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.collection.KList;
+import dev.lone.itemsadder.api.CustomBlock;
+import dev.lone.itemsadder.api.CustomStack;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.MissingResourceException;
+
+public class ItemAdderDataProvider extends ExternalDataProvider {
+
+    private KList<String> itemNamespaces, blockNamespaces;
+
+    public ItemAdderDataProvider() {
+        super("ItemsAdder");
+    }
+
+    @Override
+    public void init() {
+        this.itemNamespaces = new KList<>();
+        this.blockNamespaces = new KList<>();
+
+        for (Identifier i : getItemTypes()) {
+            itemNamespaces.addIfMissing(i.namespace());
+        }
+        for (Identifier i : getBlockTypes()) {
+            blockNamespaces.addIfMissing(i.namespace());
+            Iris.info("Found ItemAdder Block: " + i);
+        }
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+        return CustomBlock.getBaseBlockData(blockId.toString());
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+        CustomStack stack = CustomStack.getInstance(itemId.toString());
+        if (stack == null) {
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        }
+        return stack.getItemStack();
+    }
+
+    @Override
+    public Identifier[] getBlockTypes() {
+        KList<Identifier> keys = new KList<>();
+        for (String s : CustomBlock.getNamespacedIdsInRegistry()) {
+            keys.add(Identifier.fromString(s));
+        }
+        return keys.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public Identifier[] getItemTypes() {
+        KList<Identifier> keys = new KList<>();
+        for (String s : CustomStack.getNamespacedIdsInRegistry()) {
+            keys.add(Identifier.fromString(s));
+        }
+        return keys.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier id, boolean isItem) {
+        return isItem ? this.itemNamespaces.contains(id.namespace()) : this.blockNamespaces.contains(id.namespace());
+    }
+}

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;
+    }
+}

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

@@ -38,7 +38,7 @@ public class MultiverseCoreLink {
     }
 
     public boolean addWorld(String worldName, IrisDimension dim, String seed) {
-        if(!isSupported()) {
+        if (!isSupported()) {
             return false;
         }
 
@@ -47,11 +47,11 @@ public class MultiverseCoreLink {
             Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
             Method m = mvWorldManager.getClass().getDeclaredMethod("addWorld",
 
-                String.class, World.Environment.class, String.class, WorldType.class, Boolean.class, String.class, boolean.class);
+                    String.class, World.Environment.class, String.class, WorldType.class, Boolean.class, String.class, boolean.class);
             boolean b = (boolean) m.invoke(mvWorldManager, worldName, dim.getEnvironment(), seed, WorldType.NORMAL, false, "Iris", false);
             saveConfig();
             return b;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -67,7 +67,7 @@ public class MultiverseCoreLink {
             Field f = mvWorldManager.getClass().getDeclaredField("worldsFromTheConfig");
             f.setAccessible(true);
             return (Map<String, ?>) f.get(mvWorldManager);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -76,7 +76,7 @@ public class MultiverseCoreLink {
     }
 
     public void removeFromConfig(World world) {
-        if(!isSupported()) {
+        if (!isSupported()) {
             return;
         }
 
@@ -85,7 +85,7 @@ public class MultiverseCoreLink {
     }
 
     public void removeFromConfig(String world) {
-        if(!isSupported()) {
+        if (!isSupported()) {
             return;
         }
 
@@ -98,7 +98,7 @@ public class MultiverseCoreLink {
             Plugin p = getMultiverse();
             Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
             mvWorldManager.getClass().getDeclaredMethod("saveWorldsConfig").invoke(mvWorldManager);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -112,7 +112,7 @@ public class MultiverseCoreLink {
         try {
             String t = worldNameTypes.get(worldName);
             return t == null ? defaultType : t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             return defaultType;
         }
@@ -128,11 +128,11 @@ public class MultiverseCoreLink {
     }
 
     public String envName(World.Environment environment) {
-        if(environment == null) {
+        if (environment == null) {
             return "normal";
         }
 
-        return switch(environment) {
+        return switch (environment) {
             case NORMAL -> "normal";
             case NETHER -> "nether";
             case THE_END -> "end";

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

@@ -0,0 +1,59 @@
+/*
+ * 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.link;
+
+import io.lumine.mythic.bukkit.MythicBukkit;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.plugin.Plugin;
+
+import javax.annotation.Nullable;
+import java.util.Collection;
+
+public class MythicMobsLink {
+
+    public MythicMobsLink() {
+
+    }
+
+    public boolean isEnabled() {
+        return getPlugin() != null;
+    }
+
+    public Plugin getPlugin() {
+        return Bukkit.getPluginManager().getPlugin("MythicMobs");
+    }
+
+    /**
+     * Spawn a mythic mob at this location
+     *
+     * @param mob      The mob
+     * @param location The location
+     * @return The mob, or null if it can't be spawned
+     */
+    public @Nullable
+    Entity spawnMob(String mob, Location location) {
+        return isEnabled() ? MythicBukkit.inst().getMobManager().spawnMob(mob, location).getEntity().getBukkitEntity() : null;
+    }
+
+    public Collection<String> getMythicMobTypes() {
+        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : null;
+    }
+}

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

@@ -0,0 +1,151 @@
+/*
+ * 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.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;
+
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.Optional;
+
+public class OraxenDataProvider extends ExternalDataProvider {
+
+    private static final String FIELD_FACTORIES_MAP = "FACTORIES_BY_MECHANIC_ID";
+
+    private WrappedField<MechanicsManager, Map<String, MechanicFactory>> factories;
+
+    public OraxenDataProvider() {
+        super("Oraxen");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up Oraxen Link...");
+        this.factories = new WrappedField<>(MechanicsManager.class, FIELD_FACTORIES_MAP);
+        if (this.factories.hasFailed()) {
+            Iris.error("Failed to set up Oraxen Link: Unable to fetch MechanicFactoriesMap!");
+        }
+    }
+
+    @Override
+    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+        MechanicFactory factory = getFactory(blockId);
+        if (factory instanceof NoteBlockMechanicFactory f)
+            return f.createNoteBlockData(blockId.key());
+        else if (factory instanceof BlockMechanicFactory f) {
+            MultipleFacing newBlockData = (MultipleFacing) Bukkit.createBlockData(Material.MUSHROOM_STEM);
+            BlockMechanic.setBlockFacing(newBlockData, ((BlockMechanic) f.getMechanic(blockId.key())).getCustomVariation());
+            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());
+    }
+
+    @Override
+    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+        Optional<ItemBuilder> opt = OraxenItems.getOptionalItemById(itemId.key());
+        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<>();
+        for (String name : OraxenItems.getItemNames()) {
+            try {
+                Identifier key = new Identifier("oraxen", 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 : OraxenItems.getItemNames()) {
+            try {
+                Identifier key = new Identifier("oraxen", name);
+                if (getItemStack(key) != null)
+                    names.add(key);
+            } catch (MissingResourceException ignored) {
+            }
+        }
+
+        return names.toArray(new Identifier[0]);
+    }
+
+    @Override
+    public boolean isReady() {
+        if (super.isReady()) {
+            if (factories == null) {
+                this.factories = new WrappedField<>(MechanicsManager.class, FIELD_FACTORIES_MAP);
+            }
+            return super.isReady() && !factories.hasFailed();
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isValidProvider(Identifier key, boolean isItem) {
+        return key.namespace().equalsIgnoreCase("oraxen");
+    }
+
+    private MechanicFactory getFactory(Identifier key) throws MissingResourceException {
+        return factories.get().values().stream()
+                .filter(i -> i.getItems().contains(key.key()))
+                .findFirst()
+                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", key.namespace(), key.key()));
+    }
+}

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

@@ -0,0 +1,43 @@
+package com.volmit.iris.core.link;
+
+import com.volmit.iris.util.data.Cuboid;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+
+public class WorldEditLink {
+    private static Boolean enabled = null;
+
+    public static Cuboid getSelection(Player p) {
+        if (!hasWorldEdit())
+            return null;
+
+        try {
+            Object instance = Class.forName("com.sk89q.worldedit.WorldEdit").getDeclaredMethod("getInstance").invoke(null);
+            Object sessionManager = instance.getClass().getDeclaredMethod("getSessionManager").invoke(instance);
+            Object player = Class.forName("com.sk89q.worldedit.bukkit.BukkitAdapter").getDeclaredMethod("adapt", Player.class).invoke(null, p);
+            Object localSession = sessionManager.getClass().getDeclaredMethod("getIfPresent", Class.forName("com.sk89q.worldedit.session.SessionOwner")).invoke(sessionManager, player);
+            Object world = Class.forName("com.sk89q.worldedit.bukkit.BukkitAdapter").getDeclaredMethod("adapt", World.class).invoke(null, p.getWorld());
+            Object region = localSession.getClass().getDeclaredMethod("getSelection", world.getClass()).invoke(localSession, world);
+            Object min = region.getClass().getDeclaredMethod("getMinimumPoint").invoke(region);
+            Object max = region.getClass().getDeclaredMethod("getMaximumPoint").invoke(region);
+            return new Cuboid(p.getWorld(),
+                    (int) min.getClass().getDeclaredMethod("getX").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("getY").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("getZ").invoke(min),
+                    (int) min.getClass().getDeclaredMethod("getX").invoke(max),
+                    (int) min.getClass().getDeclaredMethod("getY").invoke(max),
+                    (int) min.getClass().getDeclaredMethod("getZ").invoke(max)
+            );
+        } catch (Throwable ignored) {
+
+        }
+        return null;
+    }
+
+    public static boolean hasWorldEdit() {
+        if (enabled == null)
+            enabled = Bukkit.getPluginManager().isPluginEnabled("WorldEdit");
+        return enabled;
+    }
+}

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

@@ -29,6 +29,7 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import javax.imageio.ImageIO;
 import java.awt.image.BufferedImage;
 import java.io.File;
+import java.util.Set;
 
 public class ImageResourceLoader extends ResourceLoader<IrisImage> {
     public ImageResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
@@ -59,57 +60,73 @@ public class ImageResourceLoader extends ResourceLoader<IrisImage> {
             logLoad(j, img);
             tlt.addAndGet(p.getMilliseconds());
             return img;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
         }
     }
 
+    void getPNGFiles(File directory, Set<String> m) {
+        for (File file : directory.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".png")) {
+                m.add(file.getName().replaceAll("\\Q.png\\E", ""));
+            } else if (file.isDirectory()) {
+                getPNGFiles(file, m);
+            }
+        }
+    }
+
+
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
         KSet<String> m = new KSet<>();
 
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".png")) {
-                    m.add(j.getName().replaceAll("\\Q.png\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".png")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.png\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".png")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.png\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+
+        for (File i : getFolders()) {
+            getPNGFiles(i, m);
         }
 
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".png")) {
+//                    m.add(j.getName().replaceAll("\\Q.png\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".png")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.png\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".png")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.png\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+
         KList<String> v = new KList<>(m);
         possibleKeys = v.toArray(new String[0]);
         return possibleKeys;
     }
 
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".png");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -124,16 +141,16 @@ public class ImageResourceLoader extends ResourceLoader<IrisImage> {
     }
 
     private IrisImage loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".png");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -18,12 +18,7 @@
 
 package com.volmit.iris.core.loader;
 
-import com.google.gson.ExclusionStrategy;
-import com.google.gson.FieldAttributes;
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.TypeAdapter;
-import com.google.gson.TypeAdapterFactory;
+import com.google.gson.*;
 import com.google.gson.reflect.TypeToken;
 import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonToken;
@@ -31,31 +26,16 @@ import com.google.gson.stream.JsonWriter;
 import com.volmit.iris.Iris;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBlockData;
-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.engine.object.IrisExpression;
-import com.volmit.iris.engine.object.IrisGenerator;
-import com.volmit.iris.engine.object.IrisImage;
-import com.volmit.iris.engine.object.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPool;
-import com.volmit.iris.engine.object.IrisJigsawStructure;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.engine.object.IrisMarker;
-import com.volmit.iris.engine.object.IrisMod;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisRavine;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.engine.object.IrisSpawner;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.engine.object.annotations.Snippet;
+import com.volmit.iris.engine.object.matter.IrisMatterObject;
 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.format.C;
 import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Data;
@@ -87,10 +67,12 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     private ResourceLoader<IrisBlockData> blockLoader;
     private ResourceLoader<IrisExpression> expressionLoader;
     private ResourceLoader<IrisObject> objectLoader;
+    private ResourceLoader<IrisMatterObject> matterLoader;
     private ResourceLoader<IrisImage> imageLoader;
     private ResourceLoader<IrisScript> scriptLoader;
     private ResourceLoader<IrisCave> caveLoader;
     private ResourceLoader<IrisRavine> ravineLoader;
+    private ResourceLoader<IrisMatterObject> matterObjectLoader;
     private KMap<String, KList<String>> possibleSnippets;
     private Gson gson;
     private Gson snippetLoader;
@@ -115,8 +97,8 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     public static int cacheSize() {
         int m = 0;
-        for(IrisData i : dataLoaders.values()) {
-            for(ResourceLoader<?> j : i.getLoaders().values()) {
+        for (IrisData i : dataLoaders.values()) {
+            for (ResourceLoader<?> j : i.getLoaders().values()) {
                 m += j.getLoadCache().getSize();
             }
         }
@@ -132,6 +114,10 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         return loadAny(key, (dm) -> dm.getObjectLoader().load(key, false));
     }
 
+    public static IrisMatterObject loadAnyMatter(String key) {
+        return loadAny(key, (dm) -> dm.getMatterLoader().load(key, false));
+    }
+
     public static IrisBiome loadAnyBiome(String key) {
         return loadAny(key, (dm) -> dm.getBiomeLoader().load(key, false));
     }
@@ -206,17 +192,17 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     public static <T extends IrisRegistrant> T loadAny(String key, Function<IrisData, T> v) {
         try {
-            for(File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
-                if(i.isDirectory()) {
+            for (File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
+                if (i.isDirectory()) {
                     IrisData dm = get(i);
                     T t = v.apply(dm);
 
-                    if(t != null) {
+                    if (t != null) {
                         return t;
                     }
                 }
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -227,9 +213,9 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public ResourceLoader<?> getTypedLoaderFor(File f) {
         String[] k = f.getPath().split("\\Q" + File.separator + "\\E");
 
-        for(String i : k) {
-            for(ResourceLoader<?> j : loaders.values()) {
-                if(j.getFolderName().equals(i)) {
+        for (String i : k) {
+            for (ResourceLoader<?> j : loaders.values()) {
+                if (j.getFolderName().equals(i)) {
                     return j;
                 }
             }
@@ -239,7 +225,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     }
 
     public void cleanupEngine() {
-        if(engine != null && engine.isClosed()) {
+        if (engine != null && engine.isClosed()) {
             engine = null;
             Iris.debug("Dereferenced Data<Engine> " + getId() + " " + getDataFolder());
         }
@@ -250,30 +236,30 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             IrisContext ctx = IrisContext.get();
             Engine engine = this.engine;
 
-            if(engine == null && ctx != null && ctx.getEngine() != null) {
+            if (engine == null && ctx != null && ctx.getEngine() != null) {
                 engine = ctx.getEngine();
             }
 
-            if(engine == null && t.getPreprocessors().isNotEmpty()) {
+            if (engine == null && t.getPreprocessors().isNotEmpty()) {
                 Iris.error("Failed to preprocess object " + t.getLoadKey() + " because there is no engine context here. (See stack below)");
                 try {
                     throw new RuntimeException();
-                } catch(Throwable ex) {
+                } catch (Throwable ex) {
                     ex.printStackTrace();
                 }
             }
 
-            if(engine != null && t.getPreprocessors().isNotEmpty()) {
-                synchronized(this) {
+            if (engine != null && t.getPreprocessors().isNotEmpty()) {
+                synchronized (this) {
                     engine.getExecution().getAPI().setPreprocessorObject(t);
 
-                    for(String i : t.getPreprocessors()) {
+                    for (String i : t.getPreprocessors()) {
                         engine.getExecution().execute(i);
                         Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
                     }
                 }
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.error("Failed to preprocess object!");
             e.printStackTrace();
         }
@@ -292,15 +278,18 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         try {
             IrisRegistrant rr = registrant.getConstructor().newInstance();
             ResourceLoader<T> r = null;
-            if(registrant.equals(IrisObject.class)) {
+            if (registrant.equals(IrisObject.class)) {
                 r = (ResourceLoader<T>) new ObjectResourceLoader(dataFolder, this, rr.getFolderName(),
-                    rr.getTypeName());
-            } else if(registrant.equals(IrisScript.class)) {
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisMatterObject.class)) {
+                r = (ResourceLoader<T>) new MatterObjectResourceLoader(dataFolder, this, rr.getFolderName(),
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisScript.class)) {
                 r = (ResourceLoader<T>) new ScriptResourceLoader(dataFolder, this, rr.getFolderName(),
-                    rr.getTypeName());
-            } else if(registrant.equals(IrisImage.class)) {
+                        rr.getTypeName());
+            } else if (registrant.equals(IrisImage.class)) {
                 r = (ResourceLoader<T>) new ImageResourceLoader(dataFolder, this, rr.getFolderName(),
-                    rr.getTypeName());
+                        rr.getTypeName());
             } else {
                 J.attempt(() -> registrant.getConstructor().newInstance().registerTypeAdapters(builder));
                 r = new ResourceLoader<>(dataFolder, this, rr.getFolderName(), rr.getTypeName(), registrant);
@@ -309,7 +298,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             loaders.put(registrant, r);
 
             return r;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
             Iris.error("Failed to create loader! " + registrant.getCanonicalName());
         }
@@ -320,11 +309,11 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public synchronized void hotloaded() {
         possibleSnippets = new KMap<>();
         builder = new GsonBuilder()
-            .addDeserializationExclusionStrategy(this)
-            .addSerializationExclusionStrategy(this)
-            .setLenient()
-            .registerTypeAdapterFactory(this)
-            .setPrettyPrinting();
+                .addDeserializationExclusionStrategy(this)
+                .addSerializationExclusionStrategy(this)
+                .setLenient()
+                .registerTypeAdapterFactory(this)
+                .setPrettyPrinting();
         loaders.clear();
         File packs = dataFolder;
         packs.mkdirs();
@@ -347,30 +336,31 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         this.objectLoader = registerLoader(IrisObject.class);
         this.imageLoader = registerLoader(IrisImage.class);
         this.scriptLoader = registerLoader(IrisScript.class);
+        this.matterObjectLoader = registerLoader(IrisMatterObject.class);
         gson = builder.create();
     }
 
     public void dump() {
-        for(ResourceLoader<?> i : loaders.values()) {
+        for (ResourceLoader<?> i : loaders.values()) {
             i.clearCache();
         }
     }
 
     public void clearLists() {
-        for(ResourceLoader<?> i : loaders.values()) {
+        for (ResourceLoader<?> i : loaders.values()) {
             i.clearList();
         }
     }
 
     public String toLoadKey(File f) {
-        if(f.getPath().startsWith(getDataFolder().getPath())) {
+        if (f.getPath().startsWith(getDataFolder().getPath())) {
             String[] full = f.getPath().split("\\Q" + File.separator + "\\E");
             String[] df = getDataFolder().getPath().split("\\Q" + File.separator + "\\E");
             StringBuilder g = new StringBuilder();
             boolean m = true;
-            for(int i = 0; i < full.length; i++) {
-                if(i >= df.length) {
-                    if(m) {
+            for (int i = 0; i < full.length; i++) {
+                if (i >= df.length) {
+                    if (m) {
                         m = false;
                         continue;
                     }
@@ -379,8 +369,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                 }
             }
 
-            String ff = g.substring(1).split("\\Q.\\E")[0];
-            return ff;
+            return g.substring(1).split("\\Q.\\E")[0];
         } else {
             Iris.error("Forign file from loader " + f.getPath() + " (loader realm: " + getDataFolder().getPath() + ")");
         }
@@ -397,14 +386,14 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
     @Override
     public boolean shouldSkipClass(Class<?> c) {
-        if(c.equals(AtomicCache.class)) {
+        if (c.equals(AtomicCache.class)) {
             return true;
         } else return c.equals(ChronoLatch.class);
     }
 
     @Override
     public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
-        if(!typeToken.getRawType().isAnnotationPresent(Snippet.class)) {
+        if (!typeToken.getRawType().isAnnotationPresent(Snippet.class)) {
             return null;
         }
 
@@ -420,17 +409,17 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             public T read(JsonReader reader) throws IOException {
                 TypeAdapter<T> adapter = gson.getDelegateAdapter(IrisData.this, typeToken);
 
-                if(reader.peek().equals(JsonToken.STRING)) {
+                if (reader.peek().equals(JsonToken.STRING)) {
                     String r = reader.nextString();
 
-                    if(r.startsWith("snippet/" + snippetType + "/")) {
+                    if (r.startsWith("snippet/" + snippetType + "/")) {
                         File f = new File(getDataFolder(), r + ".json");
 
-                        if(f.exists()) {
+                        if (f.exists()) {
                             try {
                                 JsonReader snippetReader = new JsonReader(new FileReader(f));
                                 return adapter.read(snippetReader);
-                            } catch(Throwable e) {
+                            } catch (Throwable e) {
                                 Iris.error("Couldn't read snippet " + r + " in " + reader.getPath() + " (" + e.getMessage() + ")");
                             }
                         } else {
@@ -443,11 +432,11 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
                 try {
                     return adapter.read(reader);
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.error("Failed to read " + typeToken.getRawType().getCanonicalName() + "... faking objects a little to load the file at least.");
                     try {
                         return (T) typeToken.getRawType().getConstructor().newInstance();
-                    } catch(Throwable ignored) {
+                    } catch (Throwable ignored) {
 
                     }
                 }
@@ -462,8 +451,8 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
             File snippetFolder = new File(getDataFolder(), "snippet/" + f);
 
-            if(snippetFolder.exists() && snippetFolder.isDirectory()) {
-                for(File i : snippetFolder.listFiles()) {
+            if (snippetFolder.exists() && snippetFolder.isDirectory()) {
+                for (File i : snippetFolder.listFiles()) {
                     l.add("snippet/" + f + "/" + i.getName().split("\\Q.\\E")[0]);
                 }
             }
@@ -475,4 +464,38 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public boolean isClosed() {
         return closed;
     }
+
+    public void savePrefetch(Engine engine) {
+        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+
+        for (ResourceLoader<?> i : loaders.values()) {
+            b.queue(() -> {
+                try {
+                    i.saveFirstAccess(engine);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        b.complete();
+        Iris.info("Saved Prefetch Cache to speed up future world startups");
+    }
+
+    public void loadPrefetch(Engine engine) {
+        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+
+        for (ResourceLoader<?> i : loaders.values()) {
+            b.queue(() -> {
+                try {
+                    i.loadFirstAccess(engine);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            });
+        }
+
+        b.complete();
+        Iris.info("Loaded Prefetch Cache to reduce generation disk use.");
+    }
 }

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

@@ -29,7 +29,7 @@ import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.plugin.VolmitSender;
 import lombok.Data;
 
-import java.awt.Desktop;
+import java.awt.*;
 import java.io.File;
 
 @Data
@@ -56,7 +56,7 @@ public abstract class IrisRegistrant {
     public File openInVSCode() {
         try {
             Desktop.getDesktop().open(getLoadFile());
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
         }
 

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

@@ -0,0 +1,176 @@
+/*
+ * 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.loader;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.engine.object.matter.IrisMatterObject;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.KCache;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+
+import java.io.File;
+
+public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject> {
+    private String[] possibleKeys;
+
+    public MatterObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
+        super(root, idm, folderName, resourceTypeName, IrisMatterObject.class);
+        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
+    }
+
+    public boolean supportsSchemas() {
+        return false;
+    }
+
+    public long getSize() {
+        return loadCache.getSize();
+    }
+
+    public long getTotalStorage() {
+        return getSize();
+    }
+
+    protected IrisMatterObject loadFile(File j, String name) {
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            IrisMatterObject t = IrisMatterObject.from(j);
+            t.setLoadKey(name);
+            t.setLoader(manager);
+            t.setLoadFile(j);
+            logLoad(j, t);
+            tlt.addAndGet(p.getMilliseconds());
+            return t;
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
+            return null;
+        }
+    }
+
+    private void findMatFiles(File dir, KSet<String> m) {
+        for (File file : dir.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".mat")) {
+                m.add(file.getName().replaceAll("\\Q.mat\\E", ""));
+            } else if (file.isDirectory()) {
+                findMatFiles(file, m);
+            }
+        }
+    }
+
+    public String[] getPossibleKeys() {
+        if (possibleKeys != null) {
+            return possibleKeys;
+        }
+
+        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+        KSet<String> m = new KSet<>();
+
+        for (File folder : getFolders()) {
+            findMatFiles(folder, m);
+        }
+
+        KList<String> v = new KList<>(m);
+        possibleKeys = v.toArray(new String[0]);
+        return possibleKeys;
+    }
+
+
+//    public String[] getPossibleKeys() {
+//        if (possibleKeys != null) {
+//            return possibleKeys;
+//        }
+//
+//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+//        KSet<String> m = new KSet<>();
+//
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".mat")) {
+//                    m.add(j.getName().replaceAll("\\Q.mat\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".mat")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.mat\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".mat")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.mat\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        KList<String> v = new KList<>(m);
+//        possibleKeys = v.toArray(new String[0]);
+//        return possibleKeys;
+//    }
+
+    public File findFile(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return j;
+                }
+            }
+
+            File file = new File(i, name + ".mat");
+
+            if (file.exists()) {
+                return file;
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisMatterObject load(String name) {
+        return load(name, true);
+    }
+
+    private IrisMatterObject loadRaw(String name) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                    return loadFile(j, name);
+                }
+            }
+
+            File file = new File(i, name + ".mat");
+
+            if (file.exists()) {
+                return loadFile(file, name);
+            }
+        }
+
+        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
+
+        return null;
+    }
+
+    public IrisMatterObject load(String name, boolean warn) {
+        return loadCache.get(name);
+    }
+}

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

@@ -57,7 +57,7 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
@@ -65,49 +65,42 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
     }
 
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
-
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
         KSet<String> m = new KSet<>();
-
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".iob")) {
-                    m.add(j.getName().replaceAll("\\Q.iob\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".iob")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.iob\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".iob")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.iob\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
+        for (File i : getFolders()) {
+            m.addAll(getFiles(i, ".iob", true));
         }
-
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
+        possibleKeys = m.toArray(new String[0]);
         return possibleKeys;
     }
 
+    private KList<String> getFiles(File dir, String ext, boolean skipDirName) {
+        KList<String> paths = new KList<>();
+        String name = skipDirName ? "" : dir.getName() + "/";
+        for (File f : dir.listFiles()) {
+            if (f.isFile() && f.getName().endsWith(ext)) {
+                paths.add(name + f.getName().replaceAll("\\Q" + ext + "\\E", ""));
+            } else if (f.isDirectory()) {
+                getFiles(f, ext, false).forEach(e -> paths.add(name + e));
+            }
+        }
+        return paths;
+    }
+
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".iob");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -122,16 +115,16 @@ public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
     }
 
     private IrisObject loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".iob");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -23,37 +23,48 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.project.SchemaBuilder;
 import com.volmit.iris.core.service.PreservationSVC;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.MeteredCache;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.data.KCache;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.CustomOutputStream;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
 
-import java.io.File;
+import java.io.*;
 import java.util.Locale;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
+import java.util.zip.GZIPInputStream;
+import java.util.zip.GZIPOutputStream;
 
 @Data
+@EqualsAndHashCode(exclude = "manager")
+@ToString(exclude = "manager")
 public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public static final AtomicDouble tlt = new AtomicDouble(0);
     private static final int CACHE_SIZE = 100000;
+    protected final AtomicReference<KList<File>> folderCache;
+    protected KSet<String> firstAccess;
     protected File root;
     protected String folderName;
     protected String resourceTypeName;
     protected KCache<String, T> loadCache;
-    protected final AtomicReference<KList<File>> folderCache;
     protected Class<? extends T> objectClass;
     protected String cname;
     protected String[] possibleKeys = null;
@@ -63,6 +74,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
 
     public ResourceLoader(File root, IrisData manager, String folderName, String resourceTypeName, Class<? extends T> objectClass) {
         this.manager = manager;
+        firstAccess = new KSet<>();
         folderCache = new AtomicReference<>();
         sec = new ChronoLatch(5000);
         loads = new AtomicInteger();
@@ -81,7 +93,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         JSONObject o = new JSONObject();
         KList<String> fm = new KList<>();
 
-        for(int g = 1; g < 8; g++) {
+        for (int g = 1; g < 8; g++) {
             fm.add("/" + folderName + Form.repeat("/*", g) + ".json");
         }
 
@@ -94,16 +106,16 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".json");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -116,11 +128,11 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public void logLoad(File path, T t) {
         loads.getAndIncrement();
 
-        if(loads.get() == 1) {
+        if (loads.get() == 1) {
             sec.flip();
         }
 
-        if(sec.flip()) {
+        if (sec.flip()) {
             J.a(() -> {
                 Iris.verbose("Loaded " + C.WHITE + loads.get() + " " + resourceTypeName + (loads.get() == 1 ? "" : "s") + C.GRAY + " (" + Form.f(getLoadCache().getSize()) + " " + resourceTypeName + (loadCache.getSize() == 1 ? "" : "s") + " Loaded)");
                 loads.set(0);
@@ -141,32 +153,32 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     private void matchFiles(File at, KList<File> files, Predicate<File> f) {
-        if(at.isDirectory()) {
-            for(File i : at.listFiles()) {
+        if (at.isDirectory()) {
+            for (File i : at.listFiles()) {
                 matchFiles(i, files, f);
             }
         } else {
-            if(f.test(at)) {
+            if (f.test(at)) {
                 files.add(at);
             }
         }
     }
 
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         KSet<String> m = new KSet<>();
         KList<File> files = getFolders();
 
-        if(files == null) {
+        if (files == null) {
             possibleKeys = new String[0];
             return possibleKeys;
         }
 
-        for(File i : files) {
-            for(File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
+        for (File i : files) {
+            for (File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
                 m.add(i.toURI().relativize(j.toURI()).getPath().replaceAll("\\Q.json\\E", ""));
             }
         }
@@ -184,7 +196,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         try {
             PrecisionStopwatch p = PrecisionStopwatch.start();
             T t = getManager().getGson()
-                .fromJson(preprocess(new JSONObject(IO.readAll(j))).toString(0), objectClass);
+                    .fromJson(preprocess(new JSONObject(IO.readAll(j))).toString(0), objectClass);
             t.setLoadKey(name);
             t.setLoadFile(j);
             t.setLoader(manager);
@@ -192,7 +204,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             failLoad(j, e);
             return null;
@@ -210,10 +222,10 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<T> loadAll(KList<String> s) {
         KList<T> m = new KList<>();
 
-        for(String i : s) {
+        for (String i : s) {
             T t = load(i);
 
-            if(t != null) {
+            if (t != null) {
                 m.add(t);
             }
         }
@@ -221,13 +233,31 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         return m;
     }
 
+    public KList<T> loadAllParallel(KList<String> s) {
+        KList<T> m = new KList<>();
+        BurstExecutor burst = MultiBurst.burst.burst(s.size());
+
+        for (String i : s) {
+            burst.queue(() -> {
+                T t = load(i);
+
+                if (t != null) {
+                    m.add(t);
+                }
+            });
+        }
+
+        burst.complete();
+        return m;
+    }
+
     public KList<T> loadAll(KList<String> s, Consumer<T> postLoad) {
         KList<T> m = new KList<>();
 
-        for(String i : s) {
+        for (String i : s) {
             T t = load(i);
 
-            if(t != null) {
+            if (t != null) {
                 m.add(t);
                 postLoad.accept(t);
             }
@@ -239,10 +269,10 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<T> loadAll(String[] s) {
         KList<T> m = new KList<>();
 
-        for(String i : s) {
+        for (String i : s) {
             T t = load(i);
 
-            if(t != null) {
+            if (t != null) {
                 m.add(t);
             }
         }
@@ -255,17 +285,17 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     private T loadRaw(String name) {
-        for(File i : getFolders(name)) {
+        for (File i : getFolders(name)) {
             //noinspection ConstantConditions
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".json");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }
@@ -274,27 +304,67 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public T load(String name, boolean warn) {
-        if(name == null) {
+        if (name == null) {
             return null;
         }
 
-        if(name.trim().isEmpty()) {
+        if (name.trim().isEmpty()) {
             return null;
         }
 
+        firstAccess.add(name);
         return loadCache.get(name);
     }
 
+    public void loadFirstAccess(Engine engine) throws IOException {
+        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
+        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
+
+        if (!file.exists()) {
+            return;
+        }
+
+        FileInputStream fin = new FileInputStream(file);
+        GZIPInputStream gzi = new GZIPInputStream(fin);
+        DataInputStream din = new DataInputStream(gzi);
+        int m = din.readInt();
+        KList<String> s = new KList<>();
+
+        for (int i = 0; i < m; i++) {
+            s.add(din.readUTF());
+        }
+
+        din.close();
+        file.deleteOnExit();
+        Iris.info("Loading " + s.size() + " prefetch " + getFolderName());
+        loadAllParallel(s);
+    }
+
+    public void saveFirstAccess(Engine engine) throws IOException {
+        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
+        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
+        file.getParentFile().mkdirs();
+        FileOutputStream fos = new FileOutputStream(file);
+        GZIPOutputStream gzo = new CustomOutputStream(fos, 9);
+        DataOutputStream dos = new DataOutputStream(gzo);
+        dos.writeInt(firstAccess.size());
+
+        for (String i : firstAccess) {
+            dos.writeUTF(i);
+        }
+
+        dos.flush();
+        dos.close();
+    }
+
     public KList<File> getFolders() {
-
-
-        synchronized(folderCache) {
-            if(folderCache.get() == null) {
+        synchronized (folderCache) {
+            if (folderCache.get() == null) {
                 KList<File> fc = new KList<>();
 
-                for(File i : root.listFiles()) {
-                    if(i.isDirectory()) {
-                        if(i.getName().equals(folderName)) {
+                for (File i : root.listFiles()) {
+                    if (i.isDirectory()) {
+                        if (i.getName().equals(folderName)) {
                             fc.add(i);
                             break;
                         }
@@ -311,9 +381,9 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<File> getFolders(String rc) {
         KList<File> folders = getFolders().copy();
 
-        if(rc.contains(":")) {
-            for(File i : folders.copy()) {
-                if(!rc.startsWith(i.getName() + ":")) {
+        if (rc.contains(":")) {
+            for (File i : folders.copy()) {
+                if (!rc.startsWith(i.getName() + ":")) {
                     folders.remove(i);
                 }
             }
@@ -329,16 +399,16 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public File fileFor(T b) {
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(b.getLoadKey())) {
+        for (File i : getFolders()) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(b.getLoadKey())) {
                     return j;
                 }
             }
 
             File file = new File(i, b.getLoadKey() + ".json");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -358,8 +428,8 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public KList<String> getPossibleKeys(String arg) {
         KList<String> f = new KList<>();
 
-        for(String i : getPossibleKeys()) {
-            if(i.equalsIgnoreCase(arg) || i.toLowerCase(Locale.ROOT).startsWith(arg.toLowerCase(Locale.ROOT)) || i.toLowerCase(Locale.ROOT).contains(arg.toLowerCase(Locale.ROOT)) || arg.toLowerCase(Locale.ROOT).contains(i.toLowerCase(Locale.ROOT))) {
+        for (String i : getPossibleKeys()) {
+            if (i.equalsIgnoreCase(arg) || i.toLowerCase(Locale.ROOT).startsWith(arg.toLowerCase(Locale.ROOT)) || i.toLowerCase(Locale.ROOT).contains(arg.toLowerCase(Locale.ROOT)) || arg.toLowerCase(Locale.ROOT).contains(i.toLowerCase(Locale.ROOT))) {
                 f.add(i);
             }
         }

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

@@ -21,13 +21,13 @@ package com.volmit.iris.core.loader;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.data.KCache;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 
 import java.io.File;
+import java.util.HashSet;
+import java.util.Set;
 
 public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     public ScriptResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
@@ -53,57 +53,88 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
             logLoad(j, t);
             tlt.addAndGet(p.getMilliseconds());
             return t;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
             return null;
         }
     }
 
+
     public String[] getPossibleKeys() {
-        if(possibleKeys != null) {
+        if (possibleKeys != null) {
             return possibleKeys;
         }
 
         Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-        KSet<String> m = new KSet<>();
+        Set<String> keys = new HashSet<>();
 
-        for(File i : getFolders()) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".js")) {
-                    m.add(j.getName().replaceAll("\\Q.js\\E", ""));
-                } else if(j.isDirectory()) {
-                    for(File k : j.listFiles()) {
-                        if(k.isFile() && k.getName().endsWith(".js")) {
-                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.js\\E", ""));
-                        } else if(k.isDirectory()) {
-                            for(File l : k.listFiles()) {
-                                if(l.isFile() && l.getName().endsWith(".js")) {
-                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.js\\E", ""));
-                                }
-                            }
-                        }
-                    }
-                }
+        for (File i : getFolders()) {
+            if (i.isDirectory()) {
+                keys.addAll(getKeysInDirectory(i));
             }
         }
 
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
+        possibleKeys = keys.toArray(new String[0]);
         return possibleKeys;
     }
 
+    private Set<String> getKeysInDirectory(File directory) {
+        Set<String> keys = new HashSet<>();
+        for (File file : directory.listFiles()) {
+            if (file.isFile() && file.getName().endsWith(".js")) {
+                keys.add(file.getName().replaceAll("\\Q.js\\E", ""));
+            } else if (file.isDirectory()) {
+                keys.addAll(getKeysInDirectory(file));
+            }
+        }
+        return keys;
+    }
+
+//    public String[] getPossibleKeys() {
+//        if (possibleKeys != null) {
+//            return possibleKeys;
+//        }
+//
+//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
+//        KSet<String> m = new KSet<>();
+//
+//        for (File i : getFolders()) {
+//            for (File j : i.listFiles()) {
+//                if (j.isFile() && j.getName().endsWith(".js")) {
+//                    m.add(j.getName().replaceAll("\\Q.js\\E", ""));
+//                } else if (j.isDirectory()) {
+//                    for (File k : j.listFiles()) {
+//                        if (k.isFile() && k.getName().endsWith(".js")) {
+//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.js\\E", ""));
+//                        } else if (k.isDirectory()) {
+//                            for (File l : k.listFiles()) {
+//                                if (l.isFile() && l.getName().endsWith(".js")) {
+//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.js\\E", ""));
+//                                }
+//                            }
+//                        }
+//                    }
+//                }
+//            }
+//        }
+//
+//        KList<String> v = new KList<>(m);
+//        possibleKeys = v.toArray(new String[0]);
+//        return possibleKeys;
+//    }
+
     public File findFile(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
             File file = new File(i, name + ".js");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return file;
             }
         }
@@ -114,16 +145,16 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     }
 
     private IrisScript loadRaw(String name) {
-        for(File i : getFolders(name)) {
-            for(File j : i.listFiles()) {
-                if(j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+        for (File i : getFolders(name)) {
+            for (File j : i.listFiles()) {
+                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
             File file = new File(i, name + ".js");
 
-            if(file.exists()) {
+            if (file.exists()) {
                 return loadFile(file, name);
             }
         }

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

@@ -20,15 +20,10 @@ package com.volmit.iris.core.nms;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.nms.v18_2.NMSBinding18_2;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import com.volmit.iris.util.collection.KMap;
 import org.bukkit.Bukkit;
 
 public class INMS {
-    //@builder
-    private static final KMap<String, Class<? extends INMSBinding>> bindings = new KMap<String, Class<? extends INMSBinding>>()
-        .qput("v1_18_R2", NMSBinding18_2.class);
     //@done
     private static final INMSBinding binding = bind();
 
@@ -37,13 +32,13 @@ public class INMS {
     }
 
     public static String getNMSTag() {
-        if(IrisSettings.get().getGeneral().isDisableNMS()) {
+        if (IrisSettings.get().getGeneral().isDisableNMS()) {
             return "BUKKIT";
         }
 
         try {
             return Bukkit.getServer().getClass().getCanonicalName().split("\\Q.\\E")[3];
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.error("Failed to determine server nms version!");
             e.printStackTrace();
@@ -56,17 +51,19 @@ public class INMS {
         String code = getNMSTag();
         Iris.info("Locating NMS Binding for " + code);
 
-        if(bindings.containsKey(code)) {
+        try {
+            Class<?> clazz = Class.forName("com.volmit.iris.core.nms."+code+".NMSBinding");
             try {
-                INMSBinding b = bindings.get(code).getConstructor().newInstance();
-                Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
-
-                return b;
-            } catch(Throwable e) {
+                Object b = clazz.getConstructor().newInstance();
+                if (b instanceof INMSBinding binding) {
+                    Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
+                    return binding;
+                }
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 e.printStackTrace();
             }
-        }
+        } catch (ClassNotFoundException|NoClassDefFoundError classNotFoundException) {}
 
         Iris.info("Craftbukkit " + code + " <-> " + NMSBinding1X.class.getSimpleName() + " Successfully Bound");
         Iris.warn("Note: Some features of Iris may not work the same since you are on an unsupported version of Minecraft.");

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

@@ -18,15 +18,27 @@
 
 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;
+import org.bukkit.Chunk;
 import org.bukkit.Location;
 import org.bukkit.World;
 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;
 
 public interface INMSBinding {
     boolean hasTile(Location l);
@@ -54,14 +66,19 @@ public interface INMSBinding {
     String getTrueBiomeBaseKey(Location location);
 
     Object getCustomBiomeBaseFor(String mckey);
+
     Object getCustomBiomeBaseHolderFor(String mckey);
 
+    int getBiomeBaseIdForKey(String key);
+
     String getKeyForBiomeBase(Object biomeBase);
 
     Object getBiomeBase(World world, Biome biome);
 
     Object getBiomeBase(Object registry, Biome biome);
 
+    KList<Biome> getBiomes();
+
     boolean isBukkit();
 
     int getBiomeId(Biome biome);
@@ -83,4 +100,16 @@ public interface INMSBinding {
     }
 
     MCAPaletteAccess createPalette();
+
+    void injectBiomesFromMantle(Chunk e, Mantle mantle);
+
+    ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException;
+
+    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);
 }

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

@@ -0,0 +1,14 @@
+package com.volmit.iris.core.nms.container;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class BlockPos {
+    private int x;
+    private int y;
+    private int z;
+}

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

@@ -0,0 +1,13 @@
+package com.volmit.iris.core.nms.container;
+
+import lombok.AllArgsConstructor;
+import lombok.Data;
+import lombok.NoArgsConstructor;
+
+@Data
+@AllArgsConstructor
+@NoArgsConstructor
+public class Pair<A, B> {
+    private A a;
+    private B b;
+}

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

@@ -20,14 +20,25 @@ package com.volmit.iris.core.nms.v1X;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMSBinding;
+import com.volmit.iris.core.nms.container.BlockPos;
+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;
+import org.bukkit.Chunk;
 import org.bukkit.Location;
 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;
 
 public class NMSBinding1X implements INMSBinding {
     private static final boolean supportsCustomHeight = testCustomHeight();
@@ -35,12 +46,12 @@ public class NMSBinding1X implements INMSBinding {
     @SuppressWarnings("ConstantConditions")
     private static boolean testCustomHeight() {
         try {
-            if(World.class.getDeclaredMethod("getMaxHeight") != null && World.class.getDeclaredMethod("getMinHeight") != null)
+            if (World.class.getDeclaredMethod("getMaxHeight") != null && World.class.getDeclaredMethod("getMinHeight") != null)
                 ;
             {
                 return true;
             }
-        } catch(Throwable ignored) {
+        } catch (Throwable ignored) {
 
         }
 
@@ -57,6 +68,35 @@ public class NMSBinding1X implements INMSBinding {
         return null;
     }
 
+    @Override
+    public void injectBiomesFromMantle(Chunk e, Mantle mantle) {
+
+    }
+
+    @Override
+    public ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException {
+        return itemStack;
+    }
+
+    @Override
+    public void setTreasurePos(Dolphin dolphin, BlockPos pos) {
+
+    }
+
+    @Override
+    public void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException {
+
+    }
+
+    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) {
 
@@ -117,6 +157,11 @@ public class NMSBinding1X implements INMSBinding {
         return null;
     }
 
+    @Override
+    public int getBiomeBaseIdForKey(String key) {
+        return 0;
+    }
+
     @Override
     public String getKeyForBiomeBase(Object biomeBase) {
         return null;
@@ -131,6 +176,11 @@ public class NMSBinding1X implements INMSBinding {
         return null;
     }
 
+    @Override
+    public KList<Biome> getBiomes() {
+        return new KList<>(Biome.values()).qdel(Biome.CUSTOM);
+    }
+
     @Override
     public boolean isBukkit() {
         return true;
@@ -165,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!");

core/src/main/java/com/volmit/iris/core/pack/IrisPack.java

@@ -54,8 +54,7 @@ public class IrisPack {
      * Create an iris pack backed by a data folder
      * the data folder is assumed to be in the Iris/packs/NAME folder
      *
-     * @param name
-     *     the name
+     * @param name the name
      */
     public IrisPack(String name) {
         this(packsPack(name));
@@ -64,17 +63,16 @@ public class IrisPack {
     /**
      * Create an iris pack backed by a data folder
      *
-     * @param folder
-     *     the folder of the pack. Must be a directory
+     * @param folder the folder of the pack. Must be a directory
      */
     public IrisPack(File folder) {
         this.folder = folder;
 
-        if(!folder.exists()) {
+        if (!folder.exists()) {
             throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (directory doesnt exist)");
         }
 
-        if(!folder.isDirectory()) {
+        if (!folder.isDirectory()) {
             throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (not a directory)");
         }
 
@@ -84,23 +82,20 @@ public class IrisPack {
     /**
      * Create a new pack from the input url
      *
-     * @param sender
-     *     the sender
-     * @param url
-     *     the url, or name, or really anything see IrisPackRepository.from(String)
+     * @param sender the sender
+     * @param url    the url, or name, or really anything see IrisPackRepository.from(String)
      * @return the iris pack
-     * @throws IrisException
-     *     fails
+     * @throws IrisException fails
      */
     public static Future<IrisPack> from(VolmitSender sender, String url) throws IrisException {
         IrisPackRepository repo = IrisPackRepository.from(url);
-        if(repo == null) {
+        if (repo == null) {
             throw new IrisException("Null Repo");
         }
 
         try {
             return from(sender, repo);
-        } catch(MalformedURLException e) {
+        } catch (MalformedURLException e) {
             throw new IrisException("Malformed URL " + e.getMessage());
         }
     }
@@ -108,13 +103,10 @@ public class IrisPack {
     /**
      * Create a pack from a repo
      *
-     * @param sender
-     *     the sender
-     * @param repo
-     *     the repo
+     * @param sender the sender
+     * @param repo   the repo
      * @return the pack
-     * @throws MalformedURLException
-     *     shit happens
+     * @throws MalformedURLException shit happens
      */
     public static Future<IrisPack> from(VolmitSender sender, IrisPackRepository repo) throws MalformedURLException {
         CompletableFuture<IrisPack> pack = new CompletableFuture<>();
@@ -127,16 +119,14 @@ public class IrisPack {
     /**
      * Create a blank pack with a given name
      *
-     * @param name
-     *     the name of the pack
+     * @param name the name of the pack
      * @return the pack
-     * @throws IrisException
-     *     if the pack already exists or another error
+     * @throws IrisException if the pack already exists or another error
      */
     public static IrisPack blank(String name) throws IrisException {
         File f = packsPack(name);
 
-        if(f.exists()) {
+        if (f.exists()) {
             throw new IrisException("Already exists");
         }
 
@@ -144,10 +134,10 @@ public class IrisPack {
         fd.getParentFile().mkdirs();
         try {
             IO.writeAll(fd, "{\n" +
-                "    \"name\": \"" + Form.capitalize(name) + "\",\n" +
-                "    \"version\": 1\n" +
-                "}\n");
-        } catch(IOException e) {
+                    "    \"name\": \"" + Form.capitalize(name) + "\",\n" +
+                    "    \"version\": 1\n" +
+                    "}\n");
+        } catch (IOException e) {
             throw new IrisException(e.getMessage(), e);
         }
 
@@ -159,8 +149,7 @@ public class IrisPack {
     /**
      * Get a packs pack folder for a name. Such that overworld would resolve as Iris/packs/overworld
      *
-     * @param name
-     *     the name
+     * @param name the name
      * @return the file path
      */
     public static File packsPack(String name) {
@@ -170,11 +159,11 @@ public class IrisPack {
     private static KList<File> collectFiles(File f, String fileExtension) {
         KList<File> l = new KList<>();
 
-        if(f.isDirectory()) {
-            for(File i : f.listFiles()) {
+        if (f.isDirectory()) {
+            for (File i : f.listFiles()) {
                 l.addAll(collectFiles(i, fileExtension));
             }
-        } else if(f.getName().endsWith("." + fileExtension)) {
+        } else if (f.getName().endsWith("." + fileExtension)) {
             l.add(f);
         }
 
@@ -225,13 +214,13 @@ public class IrisPack {
             p.end();
             Iris.debug("Building Workspace: " + ws.getPath() + " took " + Form.duration(p.getMilliseconds(), 2));
             return true;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Pack invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
             ws.delete();
             try {
                 IO.writeAll(ws, generateWorkspaceConfig());
-            } catch(IOException e1) {
+            } catch (IOException e1) {
                 Iris.reportError(e1);
                 e1.printStackTrace();
             }
@@ -243,8 +232,7 @@ public class IrisPack {
     /**
      * Install this pack into a world
      *
-     * @param world
-     *     the world to install into (world/iris/pack)
+     * @param world the world to install into (world/iris/pack)
      * @return the installed pack
      */
     public IrisPack install(World world) throws IrisException {
@@ -254,8 +242,7 @@ public class IrisPack {
     /**
      * Install this pack into a world
      *
-     * @param world
-     *     the world to install into (world/iris/pack)
+     * @param world the world to install into (world/iris/pack)
      * @return the installed pack
      */
     public IrisPack install(IrisWorld world) throws IrisException {
@@ -265,12 +252,11 @@ public class IrisPack {
     /**
      * Install this pack into a world
      *
-     * @param folder
-     *     the folder to install this pack into
+     * @param folder the folder to install this pack into
      * @return the installed pack
      */
     public IrisPack install(File folder) throws IrisException {
-        if(folder.exists()) {
+        if (folder.exists()) {
             throw new IrisException("Cannot install new pack because the folder " + folder.getName() + " already exists!");
         }
 
@@ -278,7 +264,7 @@ public class IrisPack {
 
         try {
             FileUtils.copyDirectory(getFolder(), folder);
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
         }
 
@@ -289,20 +275,19 @@ public class IrisPack {
      * Create a new pack using this pack as a template. The new pack will be renamed & have a renamed dimension
      * to match it.
      *
-     * @param newName
-     *     the new pack name
+     * @param newName the new pack name
      * @return the new IrisPack
      */
     public IrisPack install(String newName) throws IrisException {
         File newPack = packsPack(newName);
 
-        if(newPack.exists()) {
+        if (newPack.exists()) {
             throw new IrisException("Cannot install new pack because the folder " + newName + " already exists!");
         }
 
         try {
             FileUtils.copyDirectory(getFolder(), newPack);
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
         }
 
@@ -314,7 +299,7 @@ public class IrisPack {
         try {
             FileUtils.moveFile(from, to);
             new File(newPack, getWorkspaceFile().getName()).delete();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             throw new IrisException(e);
         }
 
@@ -345,8 +330,7 @@ public class IrisPack {
     /**
      * Find all files in this pack with the given extension
      *
-     * @param fileExtension
-     *     the extension
+     * @param fileExtension the extension
      * @return the list of files
      */
     public KList<File> collectFiles(String fileExtension) {
@@ -386,8 +370,8 @@ public class IrisPack {
         JSONArray schemas = new JSONArray();
         IrisData dm = IrisData.get(getFolder());
 
-        for(ResourceLoader<?> r : dm.getLoaders().v()) {
-            if(r.supportsSchemas()) {
+        for (ResourceLoader<?> r : dm.getLoaders().v()) {
+            if (r.supportsSchemas()) {
                 schemas.put(r.buildSchema());
             }
         }

core/src/main/java/com/volmit/iris/core/pack/IrisPackRepository.java

@@ -55,34 +55,34 @@ public class IrisPackRepository {
      */
     public static IrisPackRepository from(String g) {
         // https://github.com/IrisDimensions/overworld
-        if(g.startsWith("https://github.com/")) {
+        if (g.startsWith("https://github.com/")) {
             String sub = g.split("\\Qgithub.com/\\E")[1];
             IrisPackRepository r = IrisPackRepository.builder()
-                .user(sub.split("\\Q/\\E")[0])
-                .repo(sub.split("\\Q/\\E")[1]).build();
+                    .user(sub.split("\\Q/\\E")[0])
+                    .repo(sub.split("\\Q/\\E")[1]).build();
 
-            if(g.contains("/tree/")) {
+            if (g.contains("/tree/")) {
                 r.setBranch(g.split("/tree/")[1]);
             }
 
             return r;
-        } else if(g.contains("/")) {
+        } else if (g.contains("/")) {
             String[] f = g.split("\\Q/\\E");
 
-            if(f.length == 1) {
+            if (f.length == 1) {
                 return from(g);
-            } else if(f.length == 2) {
+            } else if (f.length == 2) {
                 return IrisPackRepository.builder()
-                    .user(f[0])
-                    .repo(f[1])
-                    .build();
-            } else if(f.length >= 3) {
+                        .user(f[0])
+                        .repo(f[1])
+                        .build();
+            } else if (f.length >= 3) {
                 IrisPackRepository r = IrisPackRepository.builder()
-                    .user(f[0])
-                    .repo(f[1])
-                    .build();
+                        .user(f[0])
+                        .repo(f[1])
+                        .build();
 
-                if(f[2].startsWith("#")) {
+                if (f[2].startsWith("#")) {
                     r.setTag(f[2].substring(1));
                 } else {
                     r.setBranch(f[2]);
@@ -92,17 +92,17 @@ public class IrisPackRepository {
             }
         } else {
             return IrisPackRepository.builder()
-                .user("IrisDimensions")
-                .repo(g)
-                .branch(g.equals("overworld") ? "stable" : "master")
-                .build();
+                    .user("IrisDimensions")
+                    .repo(g)
+                    .branch(g.equals("overworld") ? "stable" : "master")
+                    .build();
         }
 
         return null;
     }
 
     public String toURL() {
-        if(!tag.trim().isEmpty()) {
+        if (!tag.trim().isEmpty()) {
             return "https://codeload.github.com/" + user + "/" + repo + "/zip/refs/tags/" + tag;
         }
 
@@ -112,19 +112,19 @@ public class IrisPackRepository {
     public void install(VolmitSender sender, Runnable whenComplete) throws MalformedURLException {
         File pack = Iris.instance.getDataFolderNoCreate(StudioSVC.WORKSPACE_NAME, getRepo());
 
-        if(!pack.exists()) {
+        if (!pack.exists()) {
             File dl = new File(Iris.getTemp(), "dltk-" + UUID.randomUUID() + ".zip");
             File work = new File(Iris.getTemp(), "extk-" + UUID.randomUUID());
             new JobCollection(Form.capitalize(getRepo()),
-                new DownloadJob(toURL(), pack),
-                new SingleJob("Extracting", () -> ZipUtil.unpack(dl, work)),
-                new SingleJob("Installing", () -> {
-                    try {
-                        FileUtils.copyDirectory(work.listFiles()[0], pack);
-                    } catch(IOException e) {
-                        e.printStackTrace();
-                    }
-                })).execute(sender, whenComplete);
+                    new DownloadJob(toURL(), pack),
+                    new SingleJob("Extracting", () -> ZipUtil.unpack(dl, work)),
+                    new SingleJob("Installing", () -> {
+                        try {
+                            FileUtils.copyDirectory(work.listFiles()[0], pack);
+                        } catch (IOException e) {
+                            e.printStackTrace();
+                        }
+                    })).execute(sender, whenComplete);
         } else {
             sender.sendMessage("Pack already exists!");
         }

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

@@ -0,0 +1,275 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+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.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 lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.FileWriter;
+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;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class DeepSearchPregenerator extends Thread implements Listener {
+    @Getter
+    private static DeepSearchPregenerator instance;
+    private final DeepSearchJob job;
+    private final File destination;
+    private final int maxPosition;
+    private World world;
+    private final ChronoLatch latch;
+    private static AtomicInteger foundChunks;
+    private final AtomicInteger foundLast;
+    private final AtomicInteger foundTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    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 KList<Position2> chunkQueue;
+    private final ReentrantLock cacheLock;
+
+    private static final Map<String, DeepSearchJob> jobs = new HashMap<>();
+
+    public DeepSearchPregenerator(DeepSearchJob job, File destination) {
+        this.job = job;
+        this.chunkCacheSize = new AtomicInteger(); // todo
+        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.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        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);
+        this.chunksPerMinute = new RollingSequence(10);
+        foundChunks = new AtomicInteger(0);
+        this.foundLast = new AtomicInteger(0);
+        this.foundTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+
+        this.pos = 0;
+        jobs.put(job.getWorld().getName(), job);
+        DeepSearchPregenerator.instance = this;
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            tick();
+        }
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        DeepSearchJob job = jobs.get(world.getName());
+       // 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));
+            }
+
+        }
+        if (foundChunks.get() >= foundTotalChunks.get()) {
+            Iris.info("Completed DeepSearch!");
+            interrupt();
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((foundTotalChunks.get() - foundChunks.get()) / chunksPerSecond.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    private void queueSystem(Position2 chunk) {
+        if (chunkQueue.isEmpty()) {
+            for (int limit = 512; limit != 0; limit--) {
+                pos = job.getPosition() + 1;
+                chunkQueue.add(getChunk(pos));
+            }
+        } else {
+            //MCAUtil.read();
+
+        }
+
+
+    }
+
+    private void findInChunk(World world, int x, int z) throws IOException {
+        int xx = x * 16;
+        int zz = z * 16;
+        Engine engine = IrisToolbelt.access(world).getEngine();
+        for (int i = 0; i < 16; i++) {
+            for (int j = 0; j < 16; j++) {
+                int height = engine.getHeight(xx + i, zz + j);
+                if (height > 300) {
+                    File found = new File("plugins" + "iris" + "found.txt");
+                    FileWriter writer = new FileWriter(found);
+                    if (!found.exists()) {
+                        found.createNewFile();
+                    }
+                    IrisBiome biome = engine.getBiome(xx, engine.getHeight(), zz);
+                    Iris.info("Found at! " + xx + ", " + zz + "Biome ID: " + biome.getName() + ", ");
+                    writer.write("Biome at: X: " + xx + " Z: " + zz + "Biome ID: " + biome.getName() +  ", ");
+                    return;
+               }
+            }
+        }
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public static void setPausedDeep(World world) {
+        DeepSearchJob job = jobs.get(world.getName());
+        if (isPausedDeep(world)){
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if ( job.paused) {
+            Iris.info(C.BLUE + "DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedDeep(World world) {
+        DeepSearchJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        DeepSearchJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File deepFile = new File(worldDirectory, "DeepSearch.json");
+
+        if (job == null) {
+            Iris.error("No DeepSearch job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (deepFile.exists()){
+                        deepFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown DeepSearch for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @Builder
+    public static class DeepSearchJob {
+        private World world;
+        @Builder.Default
+        private int radiusBlocks = 5000;
+        @Builder.Default
+        private int position = 0;
+        @Builder.Default
+        boolean paused = false;
+    }
+}
+

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

@@ -19,7 +19,11 @@
 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;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.M;
@@ -34,6 +38,7 @@ import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
+
 public class IrisPregenerator {
     private final PregenTask task;
     private final PregeneratorMethod generator;
@@ -44,10 +49,11 @@ public class IrisPregenerator {
     private final RollingSequence chunksPerSecond;
     private final RollingSequence chunksPerMinute;
     private final RollingSequence regionsPerMinute;
-    private final AtomicInteger generated;
+    private final KList<Integer> chunksPerSecondHistory;
+    private static AtomicInteger generated;
     private final AtomicInteger generatedLast;
     private final AtomicInteger generatedLastMinute;
-    private final AtomicInteger totalChunks;
+    private static AtomicInteger totalChunks;
     private final AtomicLong startTime;
     private final ChronoLatch minuteLatch;
     private final AtomicReference<String> currentGeneratorMethod;
@@ -55,6 +61,7 @@ public class IrisPregenerator {
     private final KSet<Position2> retry;
     private final KSet<Position2> net;
     private final ChronoLatch cl;
+    private final ChronoLatch saveLatch = new ChronoLatch(30000);
 
     public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
         this.listener = listenify(listener);
@@ -71,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);
@@ -84,8 +92,9 @@ public class IrisPregenerator {
                 int secondGenerated = generated.get() - generatedLast.get();
                 generatedLast.set(generated.get());
                 chunksPerSecond.put(secondGenerated);
+                chunksPerSecondHistory.add(secondGenerated);
 
-                if(minuteLatch.flip()) {
+                if (minuteLatch.flip()) {
                     int minuteGenerated = generated.get() - generatedLastMinute.get();
                     generatedLastMinute.set(generated.get());
                     chunksPerMinute.put(minuteGenerated);
@@ -93,26 +102,35 @@ public class IrisPregenerator {
                 }
 
                 listener.onTick(chunksPerSecond.getAverage(), chunksPerMinute.getAverage(),
-                    regionsPerMinute.getAverage(),
-                    (double) generated.get() / (double) totalChunks.get(),
-                    generated.get(), totalChunks.get(),
-                    totalChunks.get() - generated.get(),
-                    eta, M.ms() - startTime.get(), currentGeneratorMethod.get());
+                        regionsPerMinute.getAverage(),
+                        (double) generated.get() / (double) totalChunks.get(),
+                        generated.get(), totalChunks.get(),
+                        totalChunks.get() - generated.get(),
+                        eta, M.ms() - startTime.get(), currentGeneratorMethod.get());
 
-                if(cl.flip()) {
-                    Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (" + Form.pc((double) generated.get() / (double) totalChunks.get(), 0) + ") " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+                if (cl.flip()) {
+                    double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
+                    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("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;
             }
         };
     }
 
     private long computeETA() {
-        return (long) ((totalChunks.get() - generated.get()) *
-            ((double) (M.ms() - startTime.get()) / (double) generated.get()));
+        return (long) (totalChunks.get() > 1024 ? // Generated chunks exceed 1/8th of total?
+                // 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
+        );
     }
 
+
     public void close() {
         shutdown.set(true);
     }
@@ -124,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() {
@@ -140,47 +163,61 @@ public class IrisPregenerator {
         generator.close();
         ticker.interrupt();
         listener.onClose();
+        Mantle mantle = getMantle();
+        if (mantle != null) {
+            mantle.trim(0, 0);
+        }
     }
 
     private void visitRegion(int x, int z, boolean regions) {
-        while(paused.get() && !shutdown.get()) {
+        while (paused.get() && !shutdown.get()) {
             J.sleep(50);
         }
 
-        if(shutdown.get()) {
+        if (shutdown.get()) {
             listener.onRegionSkipped(x, z);
             return;
         }
 
         Position2 pos = new Position2(x, z);
 
-        if(generatedRegions.contains(pos)) {
+        if (generatedRegions.contains(pos)) {
             return;
         }
 
         currentGeneratorMethod.set(generator.getMethod(x, z));
         boolean hit = false;
-        if(generator.supportsRegions(x, z, listener) && regions) {
+        if (generator.supportsRegions(x, z, listener) && regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
             generator.generateRegion(x, z, listener);
-        } else if(!regions) {
+        } else if (!regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
-            PregenTask.iterateRegion(x, z, (xx, zz) -> generator.generateChunk(xx, zz, listener));
+            PregenTask.iterateRegion(x, z, (xx, zz) -> {
+                while (paused.get() && !shutdown.get()) {
+                    J.sleep(50);
+                }
+
+                generator.generateChunk(xx, zz, listener);
+            });
         }
 
-        if(hit) {
+        if (hit) {
             listener.onRegionGenerated(x, z);
-            listener.onSaving();
-            generator.save();
+
+            if (saveLatch.flip()) {
+                listener.onSaving();
+                generator.save();
+            }
+
             generatedRegions.add(pos);
             checkRegions();
         }
     }
 
     private void checkRegion(int x, int z) {
-        if(generatedRegions.contains(new Position2(x, z))) {
+        if (generatedRegions.contains(new Position2(x, z))) {
             return;
         }
 

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

@@ -0,0 +1,286 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+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.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 io.papermc.lib.PaperLib;
+import lombok.Builder;
+import lombok.Data;
+import lombok.Getter;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+import java.util.HashMap;
+import java.util.Map;
+
+public class LazyPregenerator extends Thread implements Listener {
+    @Getter
+    private static LazyPregenerator instance;
+    private final LazyPregenJob job;
+    private final File destination;
+    private final int maxPosition;
+    private World world;
+    private final long rate;
+    private final ChronoLatch latch;
+    private static AtomicInteger lazyGeneratedChunks;
+    private final AtomicInteger generatedLast;
+    private final AtomicInteger lazyTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+
+    private static final Map<String, LazyPregenJob> jobs = new HashMap<>();
+
+    public LazyPregenerator(LazyPregenJob job, File destination) {
+        this.job = job;
+        this.destination = destination;
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld());
+        this.rate = Math.round((1D / (job.getChunksPerMinute() / 60D)) * 1000D);
+        this.latch = new ChronoLatch(15000);
+        this.startTime = new AtomicLong(M.ms());
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        lazyGeneratedChunks = new AtomicInteger(0);
+        this.generatedLast = new AtomicInteger(0);
+        this.lazyTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+        jobs.put(job.getWorld(), job);
+        LazyPregenerator.instance = this;
+    }
+
+    public LazyPregenerator(File file) throws IOException {
+        this(new Gson().fromJson(IO.readAll(file), LazyPregenJob.class), file);
+    }
+
+    public static void loadLazyGenerators() {
+        for (World i : Bukkit.getWorlds()) {
+            File lazygen = new File(i.getWorldFolder(), "lazygen.json");
+            if (lazygen.exists()) {
+                try {
+                    LazyPregenerator p = new LazyPregenerator(lazygen);
+                    p.start();
+                    Iris.info("Started Lazy Pregenerator: " + p.job);
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+        }
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            J.sleep(rate);
+            tick();
+        }
+
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (latch.flip() && !job.paused) {
+            long eta = computeETA();
+            save();
+            int secondGenerated = lazyGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(lazyGeneratedChunks.get());
+            secondGenerated = secondGenerated / 15;
+            chunksPerSecond.put(secondGenerated);
+            chunksPerMinute.put(secondGenerated * 60);
+            if (!job.isSilent()) {
+                Iris.info("LazyGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(lazyGeneratedChunks.get()) + " of " + Form.f(lazyTotalChunks.get()) + " " + Form.f((int) chunksPerMinute.getAverage()) + "/m ETA: " + Form.duration((double) eta, 2));
+            }
+        }
+
+        if (lazyGeneratedChunks.get() >= lazyTotalChunks.get()) {
+            if (job.isHealing()) {
+                int pos = (job.getHealingPosition() + 1) % maxPosition;
+                job.setHealingPosition(pos);
+                tickRegenerate(getChunk(pos));
+            } else {
+                Iris.info("Completed Lazy Gen!");
+                interrupt();
+            }
+        } else {
+            int pos = job.getPosition() + 1;
+            job.setPosition(pos);
+            if (!job.paused) {
+                tickGenerate(getChunk(pos));
+            }
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((lazyTotalChunks.get() - lazyGeneratedChunks.get()) / chunksPerMinute.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
+    private void tickGenerate(Position2 chunk) {
+        executorService.submit(() -> {
+            CountDownLatch latch = new CountDownLatch(1);
+            if (PaperLib.isPaper()) {
+                PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true)
+                        .thenAccept((i) -> {
+                            Iris.verbose("Generated Async " + chunk);
+                            latch.countDown();
+                        });
+            } else {
+                J.s(() -> {
+                    world.getChunkAt(chunk.getX(), chunk.getZ());
+                    Iris.verbose("Generated " + chunk);
+                    latch.countDown();
+                });
+            }
+            try {
+                latch.await();
+            } catch (InterruptedException ignored) {}
+            lazyGeneratedChunks.addAndGet(1);
+        });
+    }
+
+    private void tickRegenerate(Position2 chunk) {
+        J.s(() -> world.regenerateChunk(chunk.getX(), chunk.getZ()));
+        Iris.verbose("Regenerated " + chunk);
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public static void setPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (isPausedLazy(world)){
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if ( job.paused) {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        LazyPregenJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File lazyFile = new File(worldDirectory, "lazygen.json");
+
+        if (job == null) {
+            Iris.error("No Lazygen job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (lazyFile.exists()){
+                        lazyFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown Lazygen for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @Builder
+    public static class LazyPregenJob {
+        private String world;
+        @Builder.Default
+        private int healingPosition = 0;
+        @Builder.Default
+        private boolean healing = false;
+        @Builder.Default
+        private int chunksPerMinute = 32;
+        @Builder.Default
+        private int radiusBlocks = 5000;
+        @Builder.Default
+        private int position = 0;
+        @Builder.Default
+        boolean silent = false;
+        @Builder.Default
+        boolean paused = false;
+    }
+}
+

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
@@ -43,13 +45,13 @@ public class PregenTask {
     private int height = 1;
 
     public static void iterateRegion(int xr, int zr, Spiraled s, Position2 pull) {
-        for(Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
+        for (Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
             s.on(i.getX() + (xr << 5), i.getZ() + (zr << 5));
         }
     }
 
     public static void iterateRegion(int xr, int zr, Spiraled s) {
-        iterateRegion(xr, zr, s, new Position2(0, 0));
+        iterateRegion(xr, zr, s, new Position2(-(xr << 5), -(zr << 5)));
     }
 
     private static KList<Position2> computeOrder(Position2 pull) {
@@ -57,7 +59,7 @@ public class PregenTask {
         new Spiraler(33, 33, (x, z) -> {
             int xx = (x + 15);
             int zz = (z + 15);
-            if(xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
                 return;
             }
 
@@ -74,7 +76,7 @@ public class PregenTask {
         new Spiraler(33, 33, (x, z) -> {
             int xx = x + 15;
             int zz = z + 15;
-            if(xx < 0 || xx > 31 || zz < 0 || zz > 31) {
+            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
                 return;
             }
 
@@ -86,11 +88,11 @@ public class PregenTask {
 
     public void iterateRegions(Spiraled s) {
         new Spiraler(getWidth() * 2, getHeight() * 2, s)
-            .setOffset(center.getX(), center.getZ()).drain();
+                .setOffset(center.getX(), center.getZ()).drain();
     }
 
     public void iterateAllChunks(Spiraled s) {
         new Spiraler(getWidth() * 2, getHeight() * 2, (x, z) -> iterateRegion(x, z, s))
-            .setOffset(center.getX(), center.getZ()).drain();
+                .setOffset(center.getX(), center.getZ()).drain();
     }
 }

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

@@ -43,10 +43,8 @@ public interface PregeneratorMethod {
     /**
      * Return true if regions can be generated
      *
-     * @param x
-     *     the x region
-     * @param z
-     *     the z region
+     * @param x the x region
+     * @param z the z region
      * @return true if they can be
      */
     boolean supportsRegions(int x, int z, PregenListener listener);
@@ -54,10 +52,8 @@ public interface PregeneratorMethod {
     /**
      * Return the name of the method being used
      *
-     * @param x
-     *     the x region
-     * @param z
-     *     the z region
+     * @param x the x region
+     * @param z the z region
      * @return the name
      */
     String getMethod(int x, int z);
@@ -66,22 +62,17 @@ public interface PregeneratorMethod {
      * Called to generate a region. Execute sync, if multicore internally, wait
      * for the task to complete
      *
-     * @param x
-     *     the x
-     * @param z
-     *     the z
-     * @param listener
-     *     signal chunks generating & generated. Parallel capable.
+     * @param x        the x
+     * @param z        the z
+     * @param listener signal chunks generating & generated. Parallel capable.
      */
     void generateRegion(int x, int z, PregenListener listener);
 
     /**
      * Called to generate a chunk. You can go async so long as save will wait on the threads to finish
      *
-     * @param x
-     *     the x
-     * @param z
-     *     the z
+     * @param x the x
+     * @param z the z
      */
     void generateChunk(int x, int z, PregenListener listener);
 

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

@@ -0,0 +1,342 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.google.gson.Gson;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+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.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.parallel.BurstExecutor;
+import com.volmit.iris.util.parallel.HyperLock;
+import com.volmit.iris.util.parallel.MultiBurst;
+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;
+import org.apache.logging.log4j.core.util.ExecutorServices;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.checkerframework.checker.units.qual.N;
+
+import java.io.File;
+import java.io.IOException;
+import java.lang.reflect.Array;
+import java.util.*;
+import java.util.concurrent.*;
+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.stream.IntStream;
+
+public class TurboPregenerator extends Thread implements Listener {
+    @Getter
+    private static TurboPregenerator instance;
+    private final TurboPregenJob job;
+    private final File destination;
+    private final int maxPosition;
+    private World world;
+    private final ChronoLatch latch;
+    private static AtomicInteger turboGeneratedChunks;
+    private final AtomicInteger generatedLast;
+    private final AtomicLong cachedLast;
+    private final RollingSequence cachePerSecond;
+    private final AtomicInteger turboTotalChunks;
+    private final AtomicLong startTime;
+    private final RollingSequence chunksPerSecond;
+    private final RollingSequence chunksPerMinute;
+    private KList<Position2> queue;
+    private ConcurrentHashMap<Integer, Position2> cache;
+    private AtomicInteger maxWaiting;
+    private ReentrantLock cachinglock;
+    private AtomicBoolean caching;
+    private final HyperLock hyperLock;
+    private MultiBurst burst;
+    private static final Map<String, TurboPregenJob> jobs = new HashMap<>();
+
+    public TurboPregenerator(TurboPregenJob job, File destination) {
+        this.job = job;
+        queue = new KList<>(512);
+        this.maxWaiting = new AtomicInteger(128);
+        this.destination = destination;
+        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+        }).count();
+        this.world = Bukkit.getWorld(job.getWorld());
+        this.latch = new ChronoLatch(3000);
+        this.burst = MultiBurst.burst;
+        this.hyperLock = new HyperLock();
+        this.startTime = new AtomicLong(M.ms());
+        this.cachePerSecond = new RollingSequence(10);
+        this.chunksPerSecond = new RollingSequence(10);
+        this.chunksPerMinute = new RollingSequence(10);
+        turboGeneratedChunks = new AtomicInteger(0);
+        this.generatedLast = new AtomicInteger(0);
+        this.cachedLast = new AtomicLong(0);
+        this.caching = new AtomicBoolean(false);
+        this.turboTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
+        cache = new ConcurrentHashMap<>(turboTotalChunks.get());
+        this.cachinglock = new ReentrantLock();
+        jobs.put(job.getWorld(), job);
+        TurboPregenerator.instance = this;
+    }
+
+    public TurboPregenerator(File file) throws IOException {
+        this(new Gson().fromJson(IO.readAll(file), TurboPregenerator.TurboPregenJob.class), file);
+    }
+
+    public static void loadTurboGenerator(String i) {
+        World x = Bukkit.getWorld(i);
+        File turbogen = new File(x.getWorldFolder(), "turbogen.json");
+        if (turbogen.exists()) {
+            try {
+                TurboPregenerator p = new TurboPregenerator(turbogen);
+                p.start();
+                Iris.info("Started Turbo Pregenerator: " + p.job);
+            } catch (IOException e) {
+                throw new RuntimeException(e);
+            }
+        }
+
+    }
+
+    @EventHandler
+    public void on(WorldUnloadEvent e) {
+        if (e.getWorld().equals(world)) {
+            interrupt();
+        }
+    }
+
+    public void run() {
+        while (!interrupted()) {
+            tick();
+        }
+
+        try {
+            saveNow();
+        } catch (IOException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public void tick() {
+        TurboPregenJob job = jobs.get(world.getName());
+        if (!cachinglock.isLocked() && cache.isEmpty() && !caching.get()) {
+            ExecutorService cache = Executors.newFixedThreadPool(1);
+            cache.submit(this::cache);
+        }
+
+        if (latch.flip() && caching.get()) {
+            long secondCached = cache.mappingCount() - cachedLast.get();
+            cachedLast.set(cache.mappingCount());
+            secondCached = secondCached / 3;
+            cachePerSecond.put(secondCached);
+            Iris.info("TurboGen: " + C.IRIS + world.getName() + C.RESET + C.BLUE + " Caching: " + Form.f(cache.mappingCount()) + " of " + Form.f(turboTotalChunks.get()) + " " + Form.f((int) cachePerSecond.getAverage()) + "/s");
+        }
+
+        if (latch.flip() && !job.paused && !cachinglock.isLocked()) {
+            long eta = computeETA();
+            save();
+            int secondGenerated = turboGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(turboGeneratedChunks.get());
+            secondGenerated = secondGenerated / 3;
+            chunksPerSecond.put(secondGenerated);
+            chunksPerMinute.put(secondGenerated * 60);
+            Iris.info("TurboGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(turboGeneratedChunks.get()) + " of " + Form.f(turboTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+
+        }
+        if (turboGeneratedChunks.get() >= turboTotalChunks.get()) {
+            Iris.info("Completed Turbo Gen!");
+            interrupt();
+        } else {
+            if (!cachinglock.isLocked()) {
+                int pos = job.getPosition() + 1;
+                job.setPosition(pos);
+                if (!job.paused) {
+                    if (queue.size() < maxWaiting.get()) {
+                        Position2 chunk = cache.get(pos);
+                        queue.add(chunk);
+                    }
+                    waitForChunksPartial();
+                }
+            }
+        }
+    }
+
+    private void cache() {
+        if (!cachinglock.isLocked()) {
+            cachinglock.lock();
+            caching.set(true);
+            PrecisionStopwatch p = PrecisionStopwatch.start();
+            BurstExecutor b = MultiBurst.burst.burst(turboTotalChunks.get());
+            b.setMulticore(true);
+            int[] list = IntStream.rangeClosed(0, turboTotalChunks.get()).toArray();
+            AtomicInteger order = new AtomicInteger(turboTotalChunks.get());
+
+            int threads = Runtime.getRuntime().availableProcessors();
+            if (threads > 1) threads--;
+            ExecutorService process = Executors.newFixedThreadPool(threads);
+
+            for (int id : list) {
+                b.queue(() -> {
+                    cache.put(id, getChunk(id));
+                    order.addAndGet(-1);
+                });
+            }
+            b.complete();
+
+            if (order.get() < 0) {
+                cachinglock.unlock();
+                caching.set(false);
+                Iris.info("Completed Caching in: " + Form.duration(p.getMilliseconds(), 2));
+            }
+        } else {
+            Iris.error("TurboCache is locked!");
+        }
+    }
+
+    private void waitForChunksPartial() {
+        while (!queue.isEmpty() && maxWaiting.get() > queue.size()) {
+            try {
+                for (Position2 c : new KList<>(queue)) {
+                    tickGenerate(c);
+                    queue.remove(c);
+                }
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private long computeETA() {
+        return (long) ((turboTotalChunks.get() - turboGeneratedChunks.get()) / chunksPerMinute.getAverage()) * 1000;
+        // todo broken
+    }
+
+    private final ExecutorService executorService = Executors.newFixedThreadPool(10);
+    private void tickGenerate(Position2 chunk) {
+        executorService.submit(() -> {
+            CountDownLatch latch = new CountDownLatch(1);
+            PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true)
+                    .thenAccept((i) -> {
+                        latch.countDown();
+                    });
+            try {
+                latch.await();
+            } catch (InterruptedException ignored) {
+            }
+            turboGeneratedChunks.addAndGet(1);
+        });
+    }
+
+    public Position2 getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+
+        return new Position2(xx.get(), zz.get());
+    }
+
+    public void save() {
+        J.a(() -> {
+            try {
+                saveNow();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        });
+    }
+
+    public static void setPausedTurbo(World world) {
+        TurboPregenJob job = jobs.get(world.getName());
+        if (isPausedTurbo(world)) {
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if (job.paused) {
+            Iris.info(C.BLUE + "TurboGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "TurboGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedTurbo(World world) {
+        TurboPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
+    public void shutdownInstance(World world) throws IOException {
+        Iris.info("turboGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
+        TurboPregenJob job = jobs.get(world.getName());
+        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
+        File turboFile = new File(worldDirectory, "turbogen.json");
+
+        if (job == null) {
+            Iris.error("No turbogen job found for world: " + world.getName());
+            return;
+        }
+
+        try {
+            if (!job.isPaused()) {
+                job.setPaused(true);
+            }
+            save();
+            jobs.remove(world.getName());
+            new BukkitRunnable() {
+                @Override
+                public void run() {
+                    while (turboFile.exists()) {
+                        turboFile.delete();
+                        J.sleep(1000);
+                    }
+                    Iris.info("turboGen: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
+                }
+            }.runTaskLater(Iris.instance, 20L);
+        } catch (Exception e) {
+            Iris.error("Failed to shutdown turbogen for " + world.getName());
+            e.printStackTrace();
+        } finally {
+            saveNow();
+            interrupt();
+        }
+    }
+
+
+    public void saveNow() throws IOException {
+        IO.writeAll(this.destination, new Gson().toJson(job));
+    }
+
+    @Data
+    @Builder
+    public static class TurboPregenJob {
+        private String world;
+        @Builder.Default
+        private int radiusBlocks = 5000;
+        @Builder.Default
+        private int position = 0;
+        @Builder.Default
+        boolean paused = false;
+    }
+}
+

core/src/main/java/com/volmit/iris/core/pregenerator/methods/AsyncPregenMethod.java

@@ -19,74 +19,116 @@
 package com.volmit.iris.core.pregenerator.methods;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
 import com.volmit.iris.core.tools.IrisToolbelt;
 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.M;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.scheduling.J;
 import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.Future;
 
 public class AsyncPregenMethod implements PregeneratorMethod {
     private final World world;
     private final MultiBurst burst;
     private final KList<Future<?>> future;
+    private final Map<Chunk, Long> lastUse;
 
     public AsyncPregenMethod(World world, int threads) {
-        if(!PaperLib.isPaper()) {
+        if (!PaperLib.isPaper()) {
             throw new UnsupportedOperationException("Cannot use PaperAsync on non paper!");
         }
 
         this.world = world;
         burst = MultiBurst.burst;
         future = new KList<>(1024);
+        this.lastUse = new KMap<>();
     }
 
     private void unloadAndSaveAllChunks() {
         try {
             J.sfut(() -> {
-                if(world == null) {
+                if (world == null) {
                     Iris.warn("World was null somehow...");
                     return;
                 }
 
-                for(Chunk i : world.getLoadedChunks()) {
-                    i.unload(true);
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 10000) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
                 }
                 world.save();
             }).get();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
     }
 
     private void completeChunk(int x, int z, PregenListener listener) {
         try {
-            PaperLib.getChunkAtAsync(world, x, z, true).get();
-            listener.onChunkGenerated(x, z);
-            listener.onChunkCleaned(x, z);
-        } catch(Throwable e) {
+            future.add(PaperLib.getChunkAtAsync(world, x, z, true).thenApply((i) -> {
+                if (i == null) {
+
+                }
+                Chunk c = Bukkit.getWorld(world.getUID()).getChunkAt(x, z);
+                lastUse.put(c, M.ms());
+                listener.onChunkGenerated(x, z);
+                listener.onChunkCleaned(x, z);
+                return 0;
+            }));
+        } catch (Throwable e) {
             e.printStackTrace();
-            J.sleep(5);
-            future.add(burst.complete(() -> completeChunk(x, z, listener)));
+        }
+    }
+
+    private void waitForChunksPartial(int maxWaiting) {
+        future.removeWhere(Objects::isNull);
+
+        while (future.size() > maxWaiting) {
+            try {
+                Future<?> i = future.remove(0);
+
+                if (i == null) {
+                    continue;
+                }
+
+                i.get();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
         }
     }
 
     private void waitForChunks() {
-        for(Future<?> i : future.copy()) {
+        for (Future<?> i : future.copy()) {
+            if (i == null) {
+                continue;
+            }
+
             try {
                 i.get();
                 future.remove(i);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
             }
         }
+
+        future.removeWhere(Objects::isNull);
     }
 
     @Override
@@ -107,7 +149,7 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void save() {
-        waitForChunks();
+        waitForChunksPartial(256);
         unloadAndSaveAllChunks();
     }
 
@@ -123,17 +165,16 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
-        if(future.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) { // TODO: FIX
-            waitForChunks();
-        }
-
         listener.onChunkGenerating(x, z);
+        if (future.size() > 256) {
+            waitForChunksPartial(256);
+        }
         future.add(burst.complete(() -> completeChunk(x, z, listener)));
     }
 
     @Override
     public Mantle getMantle() {
-        if(IrisToolbelt.isIrisWorld(world)) {
+        if (IrisToolbelt.isIrisWorld(world)) {
             return IrisToolbelt.access(world).getEngine().getMantle().getMantle();
         }
 

core/src/main/java/com/volmit/iris/core/pregenerator/methods/HybridPregenMethod.java

@@ -18,17 +18,11 @@
 
 package com.volmit.iris.core.pregenerator.methods;
 
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
-import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.math.Position2;
 import org.bukkit.World;
 
-import java.io.File;
-
 public class HybridPregenMethod implements PregeneratorMethod {
     private final PregeneratorMethod inWorld;
     private final World world;
@@ -60,7 +54,7 @@ public class HybridPregenMethod implements PregeneratorMethod {
 
     @Override
     public boolean supportsRegions(int x, int z, PregenListener listener) {
-       return inWorld.supportsRegions(x, z, listener);
+        return inWorld.supportsRegions(x, z, listener);
     }
 
     @Override

core/src/main/java/com/volmit/iris/core/pregenerator/methods/MedievalPregenMethod.java

@@ -18,32 +18,40 @@
 
 package com.volmit.iris.core.pregenerator.methods;
 
+import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
 import com.volmit.iris.core.tools.IrisToolbelt;
 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.M;
 import com.volmit.iris.util.scheduling.J;
+import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
+import java.util.ArrayList;
+import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 public class MedievalPregenMethod implements PregeneratorMethod {
     private final World world;
     private final KList<CompletableFuture<?>> futures;
+    private final Map<Chunk, Long> lastUse;
 
     public MedievalPregenMethod(World world) {
         this.world = world;
         futures = new KList<>();
+        this.lastUse = new KMap<>();
     }
 
     private void waitForChunks() {
-        for(CompletableFuture<?> i : futures) {
+        for (CompletableFuture<?> i : futures) {
             try {
                 i.get();
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
             }
         }
@@ -52,15 +60,23 @@ public class MedievalPregenMethod implements PregeneratorMethod {
     }
 
     private void unloadAndSaveAllChunks() {
-        waitForChunks();
         try {
             J.sfut(() -> {
-                for(Chunk i : world.getLoadedChunks()) {
-                    i.unload(true);
+                if (world == null) {
+                    Iris.warn("World was null somehow...");
+                    return;
+                }
+
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 10) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
                 }
                 world.save();
             }).get();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
     }
@@ -97,13 +113,15 @@ public class MedievalPregenMethod implements PregeneratorMethod {
 
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
-        if(futures.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) {
+        if (futures.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) {
             waitForChunks();
         }
 
         listener.onChunkGenerating(x, z);
         futures.add(J.sfut(() -> {
             world.getChunkAt(x, z);
+            Chunk c = Bukkit.getWorld(world.getUID()).getChunkAt(x, z);
+            lastUse.put(c, M.ms());
             listener.onChunkGenerated(x, z);
             listener.onChunkCleaned(x, z);
         }));
@@ -111,7 +129,7 @@ public class MedievalPregenMethod implements PregeneratorMethod {
 
     @Override
     public Mantle getMantle() {
-        if(IrisToolbelt.isIrisWorld(world)) {
+        if (IrisToolbelt.isIrisWorld(world)) {
             return IrisToolbelt.access(world).getEngine().getMantle().getMantle();
         }
 

core/src/main/java/com/volmit/iris/core/project/IrisProject.java

@@ -25,16 +25,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.loader.ResourceLoader;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBlockData;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisEntity;
-import com.volmit.iris.engine.object.IrisGenerator;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisSpawner;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.engine.object.annotations.Snippet;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import com.volmit.iris.util.collection.KList;
@@ -60,8 +51,7 @@ import org.bukkit.GameMode;
 import org.bukkit.World;
 import org.zeroturnaround.zip.ZipUtil;
 
-import java.awt.Desktop;
-import java.awt.GraphicsEnvironment;
+import java.awt.*;
 import java.io.File;
 import java.io.IOException;
 import java.util.Objects;
@@ -82,14 +72,14 @@ public class IrisProject {
 
     public static int clean(VolmitSender s, File clean) {
         int c = 0;
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 c += clean(s, i);
             }
-        } else if(clean.getName().endsWith(".json")) {
+        } else if (clean.getName().endsWith(".json")) {
             try {
                 clean(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 Iris.error("Failed to beautify " + clean.getAbsolutePath() + " You may have errors in your json!");
             }
@@ -108,29 +98,29 @@ public class IrisProject {
     }
 
     public static void fixBlocks(JSONObject obj, File f) {
-        for(String i : obj.keySet()) {
+        for (String i : obj.keySet()) {
             Object o = obj.get(i);
 
-            if(i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
                 obj.put(i, "minecraft:" + o);
                 Iris.debug("Updated Block Key: " + o + " to " + obj.getString(i) + " in " + f.getPath());
             }
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o, f);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o, f);
             }
         }
     }
 
     public static void fixBlocks(JSONArray obj, File f) {
-        for(int i = 0; i < obj.length(); i++) {
+        for (int i = 0; i < obj.length(); i++) {
             Object o = obj.get(i);
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o, f);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o, f);
             }
         }
@@ -143,11 +133,11 @@ public class IrisProject {
     public KList<File> collectFiles(File f, String fileExtension) {
         KList<File> l = new KList<>();
 
-        if(f.isDirectory()) {
-            for(File i : f.listFiles()) {
+        if (f.isDirectory()) {
+            for (File i : f.listFiles()) {
                 l.addAll(collectFiles(i, fileExtension));
             }
-        } else if(f.getName().endsWith("." + fileExtension)) {
+        } else if (f.getName().endsWith("." + fileExtension)) {
             l.add(f);
         }
 
@@ -170,28 +160,28 @@ public class IrisProject {
         J.attemptAsync(() ->
         {
             try {
-                if(d.getLoader() == null) {
+                if (d.getLoader() == null) {
                     sender.sendMessage("Could not get dimension loader");
                     return;
                 }
                 File f = d.getLoader().getDataFolder();
 
-                if(!doOpenVSCode(f)) {
+                if (!doOpenVSCode(f)) {
                     File ff = new File(d.getLoader().getDataFolder(), d.getLoadKey() + ".code-workspace");
                     Iris.warn("Project missing code-workspace: " + ff.getAbsolutePath() + " Re-creating code workspace.");
 
                     try {
                         IO.writeAll(ff, createCodeWorkspaceConfig());
-                    } catch(IOException e1) {
+                    } catch (IOException e1) {
                         Iris.reportError(e1);
                         e1.printStackTrace();
                     }
                     updateWorkspace();
-                    if(!doOpenVSCode(f)) {
+                    if (!doOpenVSCode(f)) {
                         Iris.warn("Tried creating code workspace but failed a second time. Your project is likely corrupt.");
                     }
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
                 e.printStackTrace();
             }
@@ -200,16 +190,16 @@ public class IrisProject {
 
     private boolean doOpenVSCode(File f) throws IOException {
         boolean foundWork = false;
-        for(File i : Objects.requireNonNull(f.listFiles())) {
-            if(i.getName().endsWith(".code-workspace")) {
+        for (File i : Objects.requireNonNull(f.listFiles())) {
+            if (i.getName().endsWith(".code-workspace")) {
                 foundWork = true;
                 J.a(() ->
                 {
                     updateWorkspace();
                 });
 
-                if(IrisSettings.get().getStudio().isOpenVSCode()) {
-                    if(!GraphicsEnvironment.isHeadless()) {
+                if (IrisSettings.get().getStudio().isOpenVSCode()) {
+                    if (!GraphicsEnvironment.isHeadless()) {
                         Iris.msg("Opening VSCode. You may see the output from VSCode.");
                         Iris.msg("VSCode output always starts with: '(node:#####) electron'");
                         Desktop.getDesktop().open(i);
@@ -223,21 +213,21 @@ public class IrisProject {
     }
 
     public void open(VolmitSender sender, long seed, Consumer<World> onDone) throws IrisException {
-        if(isOpen()) {
+        if (isOpen()) {
             close();
         }
 
         boolean hasError = false;
 
-        if(hasError) {
+        if (hasError) {
             return;
         }
 
         IrisDimension d = IrisData.loadAnyDimension(getName());
-        if(d == null) {
+        if (d == null) {
             sender.sendMessage("Can't find dimension: " + getName());
             return;
-        } else if(sender.isPlayer()) {
+        } else if (sender.isPlayer()) {
             sender.player().setGameMode(GameMode.SPECTATOR);
         }
 
@@ -247,14 +237,14 @@ public class IrisProject {
         J.a(() -> {
             try {
                 activeProvider = (PlatformChunkGenerator) IrisToolbelt.createWorld()
-                    .seed(seed)
-                    .sender(sender)
-                    .studio(true)
-                    .name("iris/" + UUID.randomUUID())
-                    .dimension(d.getLoadKey())
-                    .create().getGenerator();
+                        .seed(seed)
+                        .sender(sender)
+                        .studio(true)
+                        .name("iris/" + UUID.randomUUID())
+                        .dimension(d.getLoadKey())
+                        .create().getGenerator();
                 onDone.accept(activeProvider.getTarget().getWorld().realWorld());
-            } catch(IrisException e) {
+            } catch (IrisException e) {
                 e.printStackTrace();
             }
         });
@@ -286,13 +276,13 @@ public class IrisProject {
             IO.writeAll(ws, j.toString(4));
             p.end();
             return true;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             Iris.warn("Project invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
             ws.delete();
             try {
                 IO.writeAll(ws, createCodeWorkspaceConfig());
-            } catch(IOException e1) {
+            } catch (IOException e1) {
                 Iris.reportError(e1);
                 e1.printStackTrace();
             }
@@ -334,19 +324,19 @@ public class IrisProject {
         JSONArray schemas = new JSONArray();
         IrisData dm = IrisData.get(getPath());
 
-        for(ResourceLoader<?> r : dm.getLoaders().v()) {
-            if(r.supportsSchemas()) {
+        for (ResourceLoader<?> r : dm.getLoaders().v()) {
+            if (r.supportsSchemas()) {
                 schemas.put(r.buildSchema());
             }
         }
 
-        for(Class<?> i : Iris.getClasses("com.volmit.iris.engine.object.", Snippet.class)) {
+        for (Class<?> i : Iris.getClasses("com.volmit.iris.engine.object.", Snippet.class)) {
             try {
                 String snipType = i.getDeclaredAnnotation(Snippet.class).value();
                 JSONObject o = new JSONObject();
                 KList<String> fm = new KList<>();
 
-                for(int g = 1; g < 8; g++) {
+                for (int g = 1; g < 8; g++) {
                     fm.add("/snippet/" + snipType + Form.repeat("/*", g) + ".json");
                 }
 
@@ -357,11 +347,11 @@ public class IrisProject {
                 J.attemptAsync(() -> {
                     try {
                         IO.writeAll(a, new SchemaBuilder(i, dm).construct().toString(4));
-                    } catch(Throwable e) {
+                    } catch (Throwable e) {
                         e.printStackTrace();
                     }
                 });
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
             }
         }
@@ -387,7 +377,7 @@ public class IrisProject {
         KSet<IrisLootTable> loot = new KSet<>();
         KSet<IrisBlockData> blocks = new KSet<>();
 
-        for(String i : dm.getDimensionLoader().getPossibleKeys()) {
+        for (String i : dm.getDimensionLoader().getPossibleKeys()) {
             blocks.add(dm.getBlockLoader().load(i));
         }
 
@@ -407,13 +397,13 @@ public class IrisProject {
         StringBuilder c = new StringBuilder();
         sender.sendMessage("Serializing Objects");
 
-        for(IrisBiome i : biomes) {
-            for(IrisObjectPlacement j : i.getObjects()) {
+        for (IrisBiome i : biomes) {
+            for (IrisObjectPlacement j : i.getObjects()) {
                 b.append(j.hashCode());
                 KList<String> newNames = new KList<>();
 
-                for(String k : j.getPlace()) {
-                    if(renameObjects.containsKey(k)) {
+                for (String k : j.getPlace()) {
+                    if (renameObjects.containsKey(k)) {
                         newNames.add(renameObjects.get(k));
                         continue;
                     }
@@ -441,12 +431,12 @@ public class IrisProject {
                 gb.append(IO.hash(f));
                 ggg.set(ggg.get() + 1);
 
-                if(cl.flip()) {
+                if (cl.flip()) {
                     int g = ggg.get();
                     ggg.set(0);
                     sender.sendMessage("Wrote another " + g + " Objects");
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
         })));
@@ -462,7 +452,7 @@ public class IrisProject {
             IO.writeAll(new File(folder, "dimensions/" + dimension.getLoadKey() + ".json"), a);
             b.append(IO.hash(a));
 
-            for(IrisGenerator i : generators) {
+            for (IrisGenerator i : generators) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "generators/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
@@ -471,31 +461,31 @@ public class IrisProject {
             c.append(IO.hash(b.toString()));
             b = new StringBuilder();
 
-            for(IrisRegion i : regions) {
+            for (IrisRegion i : regions) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "regions/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisBlockData i : blocks) {
+            for (IrisBlockData i : blocks) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "blocks/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisBiome i : biomes) {
+            for (IrisBiome i : biomes) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "biomes/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisEntity i : entities) {
+            for (IrisEntity i : entities) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "entities/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
             }
 
-            for(IrisLootTable i : loot) {
+            for (IrisLootTable i : loot) {
                 a = new JSONObject(new Gson().toJson(i)).toString(minify ? 0 : 4);
                 IO.writeAll(new File(folder, "loot/" + i.getLoadKey() + ".json"), a);
                 b.append(IO.hash(a));
@@ -515,7 +505,7 @@ public class IrisProject {
 
             sender.sendMessage("Package Compiled!");
             return p;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -538,18 +528,18 @@ public class IrisProject {
                     IrisObject o = new IrisObject(0, 0, 0);
                     o.read(f);
 
-                    if(o.getBlocks().isEmpty()) {
+                    if (o.getBlocks().isEmpty()) {
                         sender.sendMessageRaw("<hover:show_text:'Error:\n" +
-                            "<yellow>" + f.getPath() +
-                            "'><red>- IOB " + f.getName() + " has 0 blocks!");
+                                "<yellow>" + f.getPath() +
+                                "'><red>- IOB " + f.getName() + " has 0 blocks!");
                     }
 
-                    if(o.getW() == 0 || o.getH() == 0 || o.getD() == 0) {
+                    if (o.getW() == 0 || o.getH() == 0 || o.getD() == 0) {
                         sender.sendMessageRaw("<hover:show_text:'Error:\n" +
-                            "<yellow>" + f.getPath() + "\n<red>The width height or depth has a zero in it (bad format)" +
-                            "'><red>- IOB " + f.getName() + " is not 3D!");
+                                "<yellow>" + f.getPath() + "\n<red>The width height or depth has a zero in it (bad format)" +
+                                "'><red>- IOB " + f.getName() + " is not 3D!");
                     }
-                } catch(IOException e) {
+                } catch (IOException e) {
                     e.printStackTrace();
                 }
             }
@@ -569,11 +559,11 @@ public class IrisProject {
                     scanForErrors(data, f, p, sender);
                     IO.writeAll(f, p.toString(4));
 
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     sender.sendMessageRaw("<hover:show_text:'Error:\n" +
-                        "<yellow>" + f.getPath() +
-                        "\n<red>" + e.getMessage() +
-                        "'><red>- JSON Error " + f.getName());
+                            "<yellow>" + f.getPath() +
+                            "\n<red>" + e.getMessage() +
+                            "'><red>- JSON Error " + f.getName());
                 }
             }
 
@@ -590,7 +580,7 @@ public class IrisProject {
         String key = data.toLoadKey(f);
         ResourceLoader<?> loader = data.getTypedLoaderFor(f);
 
-        if(loader == null) {
+        if (loader == null) {
             sender.sendMessageBasic("Can't find loader for " + f.getPath());
             return;
         }
@@ -603,62 +593,62 @@ public class IrisProject {
     public void compare(Class<?> c, JSONObject j, VolmitSender sender, KList<String> path) {
         try {
             Object o = c.getClass().getConstructor().newInstance();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
 
         }
     }
 
     public void files(File clean, KList<File> files) {
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 files(i, files);
             }
-        } else if(clean.getName().endsWith(".json")) {
+        } else if (clean.getName().endsWith(".json")) {
             try {
                 files.add(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
         }
     }
 
     public void filesObjects(File clean, KList<File> files) {
-        if(clean.isDirectory()) {
-            for(File i : clean.listFiles()) {
+        if (clean.isDirectory()) {
+            for (File i : clean.listFiles()) {
                 filesObjects(i, files);
             }
-        } else if(clean.getName().endsWith(".iob")) {
+        } else if (clean.getName().endsWith(".iob")) {
             try {
                 files.add(clean);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
         }
     }
 
     private void fixBlocks(JSONObject obj) {
-        for(String i : obj.keySet()) {
+        for (String i : obj.keySet()) {
             Object o = obj.get(i);
 
-            if(i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
+            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
                 obj.put(i, "minecraft:" + o);
             }
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }
     }
 
     private void fixBlocks(JSONArray obj) {
-        for(int i = 0; i < obj.length(); i++) {
+        for (int i = 0; i < obj.length(); i++) {
             Object o = obj.get(i);
 
-            if(o instanceof JSONObject) {
+            if (o instanceof JSONObject) {
                 fixBlocks((JSONObject) o);
-            } else if(o instanceof JSONArray) {
+            } else if (o instanceof JSONArray) {
                 fixBlocks((JSONArray) o);
             }
         }

core/src/main/java/com/volmit/iris/core/project/SchemaBuilder.java

@@ -22,17 +22,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.loader.ResourceLoader;
-import com.volmit.iris.engine.object.annotations.ArrayType;
-import com.volmit.iris.engine.object.annotations.Desc;
-import com.volmit.iris.engine.object.annotations.MaxNumber;
-import com.volmit.iris.engine.object.annotations.MinNumber;
-import com.volmit.iris.engine.object.annotations.RegistryListBlockType;
-import com.volmit.iris.engine.object.annotations.RegistryListFont;
-import com.volmit.iris.engine.object.annotations.RegistryListItemType;
-import com.volmit.iris.engine.object.annotations.RegistryListResource;
-import com.volmit.iris.engine.object.annotations.RegistryListSpecialEntity;
-import com.volmit.iris.engine.object.annotations.Required;
-import com.volmit.iris.engine.object.annotations.Snippet;
+import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.B;
@@ -41,7 +31,7 @@ import com.volmit.iris.util.json.JSONObject;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.potion.PotionEffectType;
 
-import java.awt.GraphicsEnvironment;
+import java.awt.*;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.List;
@@ -52,7 +42,7 @@ public class SchemaBuilder {
     private static final String SYMBOL_LIMIT__N = "*";
     private static final String SYMBOL_TYPE__N = "";
     private static final JSONArray POTION_TYPES = getPotionTypes();
-    private static final JSONArray ENCHANT_TYPES = getEnchantmentTypes();
+    private static final JSONArray ENCHANT_TYPES = getEnchantTypes();
     private static final JSONArray ITEM_TYPES = new JSONArray(B.getItemTypes());
     private static final JSONArray FONT_TYPES = new JSONArray(GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames());
     private final KMap<String, JSONObject> definitions;
@@ -67,24 +57,22 @@ public class SchemaBuilder {
         this.root = root;
     }
 
-    private static JSONArray getEnchantmentTypes() {
+    private static JSONArray getPotionTypes() {
         JSONArray a = new JSONArray();
 
-        for(Field gg : Enchantment.class.getDeclaredFields()) {
-            a.put(gg.getName());
+        for (PotionEffectType gg : PotionEffectType.values()) {
+            a.put(gg.getName().toUpperCase().replaceAll("\\Q \\E", "_"));
         }
 
         return a;
     }
 
-    private static JSONArray getPotionTypes() {
-        JSONArray a = new JSONArray();
-
-        for(PotionEffectType gg : PotionEffectType.values()) {
-            a.put(gg.getName().toUpperCase().replaceAll("\\Q \\E", "_"));
+    private static JSONArray getEnchantTypes() {
+        JSONArray array = new JSONArray();
+        for (Enchantment e : Enchantment.values()) {
+            array.put(e.getKey().getKey());
         }
-
-        return a;
+        return array;
     }
 
     public JSONObject construct() {
@@ -94,21 +82,21 @@ public class SchemaBuilder {
 
         JSONObject props = buildProperties(root);
 
-        for(String i : props.keySet()) {
-            if(!schema.has(i)) {
+        for (String i : props.keySet()) {
+            if (!schema.has(i)) {
                 schema.put(i, props.get(i));
             }
         }
 
         JSONObject defs = new JSONObject();
 
-        for(Map.Entry<String, JSONObject> entry : definitions.entrySet()) {
+        for (Map.Entry<String, JSONObject> entry : definitions.entrySet()) {
             defs.put(entry.getKey(), entry.getValue());
         }
 
         schema.put("definitions", defs);
 
-        for(String i : warnings) {
+        for (String i : warnings) {
             Iris.warn(root.getSimpleName() + ": " + i);
         }
 
@@ -122,17 +110,17 @@ public class SchemaBuilder {
         o.put("type", getType(c));
         JSONArray required = new JSONArray();
 
-        if(c.isAssignableFrom(IrisRegistrant.class) || IrisRegistrant.class.isAssignableFrom(c)) {
-            for(Field k : IrisRegistrant.class.getDeclaredFields()) {
+        if (c.isAssignableFrom(IrisRegistrant.class) || IrisRegistrant.class.isAssignableFrom(c)) {
+            for (Field k : IrisRegistrant.class.getDeclaredFields()) {
                 k.setAccessible(true);
 
-                if(Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
+                if (Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
                     continue;
                 }
 
                 JSONObject property = buildProperty(k, c);
 
-                if(property.getBoolean("!required")) {
+                if (property.getBoolean("!required")) {
                     required.put(k.getName());
                 }
 
@@ -141,10 +129,10 @@ public class SchemaBuilder {
             }
         }
 
-        for(Field k : c.getDeclaredFields()) {
+        for (Field k : c.getDeclaredFields()) {
             k.setAccessible(true);
 
-            if(Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
+            if (Modifier.isStatic(k.getModifiers()) || Modifier.isFinal(k.getModifiers()) || Modifier.isTransient(k.getModifiers())) {
                 continue;
             }
 
@@ -154,14 +142,14 @@ public class SchemaBuilder {
             properties.put(k.getName(), property);
         }
 
-        if(required.length() > 0) {
+        if (required.length() > 0) {
             o.put("required", required);
         }
 
         o.put("properties", properties);
 
 
-        if(c.isAnnotationPresent(Snippet.class)) {
+        if (c.isAnnotationPresent(Snippet.class)) {
             JSONObject anyOf = new JSONObject();
             JSONArray arr = new JSONArray();
             JSONObject str = new JSONObject();
@@ -184,16 +172,16 @@ public class SchemaBuilder {
         prop.put("type", type);
         String fancyType = "Unknown Type";
 
-        switch(type) {
+        switch (type) {
             case "boolean" -> fancyType = "Boolean";
             case "integer" -> {
                 fancyType = "Integer";
-                if(k.isAnnotationPresent(MinNumber.class)) {
+                if (k.isAnnotationPresent(MinNumber.class)) {
                     int min = (int) k.getDeclaredAnnotation(MinNumber.class).value();
                     prop.put("minimum", min);
                     description.add(SYMBOL_LIMIT__N + " Minimum allowed is " + min);
                 }
-                if(k.isAnnotationPresent(MaxNumber.class)) {
+                if (k.isAnnotationPresent(MaxNumber.class)) {
                     int max = (int) k.getDeclaredAnnotation(MaxNumber.class).value();
                     prop.put("maximum", max);
                     description.add(SYMBOL_LIMIT__N + " Maximum allowed is " + max);
@@ -201,12 +189,12 @@ public class SchemaBuilder {
             }
             case "number" -> {
                 fancyType = "Number";
-                if(k.isAnnotationPresent(MinNumber.class)) {
+                if (k.isAnnotationPresent(MinNumber.class)) {
                     double min = k.getDeclaredAnnotation(MinNumber.class).value();
                     prop.put("minimum", min);
                     description.add(SYMBOL_LIMIT__N + " Minimum allowed is " + min);
                 }
-                if(k.isAnnotationPresent(MaxNumber.class)) {
+                if (k.isAnnotationPresent(MaxNumber.class)) {
                     double max = k.getDeclaredAnnotation(MaxNumber.class).value();
                     prop.put("maximum", max);
                     description.add(SYMBOL_LIMIT__N + " Maximum allowed is " + max);
@@ -214,26 +202,26 @@ public class SchemaBuilder {
             }
             case "string" -> {
                 fancyType = "Text";
-                if(k.isAnnotationPresent(MinNumber.class)) {
+                if (k.isAnnotationPresent(MinNumber.class)) {
                     int min = (int) k.getDeclaredAnnotation(MinNumber.class).value();
                     prop.put("minLength", min);
                     description.add(SYMBOL_LIMIT__N + " Minimum Length allowed is " + min);
                 }
-                if(k.isAnnotationPresent(MaxNumber.class)) {
+                if (k.isAnnotationPresent(MaxNumber.class)) {
                     int max = (int) k.getDeclaredAnnotation(MaxNumber.class).value();
                     prop.put("maxLength", max);
                     description.add(SYMBOL_LIMIT__N + " Maximum Length allowed is " + max);
                 }
 
 
-                if(k.isAnnotationPresent(RegistryListResource.class)) {
+                if (k.isAnnotationPresent(RegistryListResource.class)) {
                     RegistryListResource rr = k.getDeclaredAnnotation(RegistryListResource.class);
                     ResourceLoader<?> loader = data.getLoaders().get(rr.value());
 
-                    if(loader != null) {
+                    if (loader != null) {
                         String key = "erz" + loader.getFolderName();
 
-                        if(!definitions.containsKey(key)) {
+                        if (!definitions.containsKey(key)) {
                             JSONObject j = new JSONObject();
                             j.put("enum", new JSONArray(loader.getPossibleKeys()));
                             definitions.put(key, j);
@@ -245,18 +233,18 @@ public class SchemaBuilder {
                     } else {
                         Iris.error("Cannot find Registry Loader for type " + rr.value() + " used in " + k.getDeclaringClass().getCanonicalName() + " in field " + k.getName());
                     }
-                } else if(k.isAnnotationPresent(RegistryListBlockType.class)) {
+                } else if (k.isAnnotationPresent(RegistryListBlockType.class)) {
                     String key = "enum-block-type";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         JSONArray ja = new JSONArray();
 
-                        for(String i : data.getBlockLoader().getPossibleKeys()) {
+                        for (String i : data.getBlockLoader().getPossibleKeys()) {
                             ja.put(i);
                         }
 
-                        for(String i : B.getBlockTypes()) {
+                        for (String i : B.getBlockTypes()) {
                             ja.put(i);
                         }
 
@@ -268,10 +256,10 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Block Type (use ctrl+space for auto complete!)");
 
-                } else if(k.isAnnotationPresent(RegistryListItemType.class)) {
+                } else if (k.isAnnotationPresent(RegistryListItemType.class)) {
                     String key = "enum-item-type";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", ITEM_TYPES);
                         definitions.put(key, j);
@@ -281,10 +269,10 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Item Type (use ctrl+space for auto complete!)");
 
-                } else if(k.isAnnotationPresent(RegistryListSpecialEntity.class)) {
+                } else if (k.isAnnotationPresent(RegistryListSpecialEntity.class)) {
                     String key = "enum-reg-specialentity";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         KList<String> list = new KList<>();
                         list.addAll(Iris.linkMythicMobs.getMythicMobTypes().stream().map(s -> "MythicMobs:" + s).collect(Collectors.toList()));
@@ -296,10 +284,10 @@ public class SchemaBuilder {
                     fancyType = "Mythic Mob Type";
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Mythic Mob Type (use ctrl+space for auto complete!) Define mythic mobs with the mythic mobs plugin configuration files.");
-                } else if(k.isAnnotationPresent(RegistryListFont.class)) {
+                } else if (k.isAnnotationPresent(RegistryListFont.class)) {
                     String key = "enum-font";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", FONT_TYPES);
                         definitions.put(key, j);
@@ -309,10 +297,10 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Font Family (use ctrl+space for auto complete!)");
 
-                } else if(k.getType().equals(Enchantment.class)) {
+                } else if (k.isAnnotationPresent(RegistryListEnchantment.class)) {
                     String key = "enum-enchantment";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", ENCHANT_TYPES);
                         definitions.put(key, j);
@@ -321,10 +309,10 @@ public class SchemaBuilder {
                     fancyType = "Enchantment Type";
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Enchantment Type (use ctrl+space for auto complete!)");
-                } else if(k.getType().equals(PotionEffectType.class)) {
+                } else if (k.getType().equals(PotionEffectType.class)) {
                     String key = "enum-potion-effect-type";
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put("enum", POTION_TYPES);
                         definitions.put(key, j);
@@ -334,12 +322,12 @@ public class SchemaBuilder {
                     prop.put("$ref", "#/definitions/" + key);
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Potion Effect Type (use ctrl+space for auto complete!)");
 
-                } else if(k.getType().isEnum()) {
+                } else if (k.getType().isEnum()) {
                     fancyType = k.getType().getSimpleName().replaceAll("\\QIris\\E", "");
                     JSONArray a = new JSONArray();
                     boolean advanced = k.getType().isAnnotationPresent(Desc.class);
-                    for(Object gg : k.getType().getEnumConstants()) {
-                        if(advanced) {
+                    for (Object gg : k.getType().getEnumConstants()) {
+                        if (advanced) {
                             try {
                                 JSONObject j = new JSONObject();
                                 String name = ((Enum<?>) gg).name();
@@ -347,7 +335,7 @@ public class SchemaBuilder {
                                 Desc dd = k.getType().getField(name).getAnnotation(Desc.class);
                                 j.put("description", dd == null ? ("No Description for " + name) : dd.value());
                                 a.put(j);
-                            } catch(Throwable e) {
+                            } catch (Throwable e) {
                                 Iris.reportError(e);
                                 e.printStackTrace();
                             }
@@ -358,7 +346,7 @@ public class SchemaBuilder {
 
                     String key = (advanced ? "oneof-" : "") + "enum-" + k.getType().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
 
-                    if(!definitions.containsKey(key)) {
+                    if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
                         j.put(advanced ? "oneOf" : "enum", a);
                         definitions.put(key, j);
@@ -372,7 +360,7 @@ public class SchemaBuilder {
             case "object" -> {
                 fancyType = k.getType().getSimpleName().replaceAll("\\QIris\\E", "") + " (Object)";
                 String key = "obj-" + k.getType().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-                if(!definitions.containsKey(key)) {
+                if (!definitions.containsKey(key)) {
                     definitions.put(key, new JSONObject());
                     definitions.put(key, buildProperties(k.getType()));
                 }
@@ -381,10 +369,10 @@ public class SchemaBuilder {
             case "array" -> {
                 fancyType = "List of Something...?";
                 ArrayType t = k.getDeclaredAnnotation(ArrayType.class);
-                if(t != null) {
-                    if(t.min() > 0) {
+                if (t != null) {
+                    if (t.min() > 0) {
                         prop.put("minItems", t.min());
-                        if(t.min() == 1) {
+                        if (t.min() == 1) {
                             description.add(SYMBOL_LIMIT__N + " At least one entry must be defined, or just remove this list.");
                         } else {
                             description.add(SYMBOL_LIMIT__N + " Requires at least " + t.min() + " entries.");
@@ -393,13 +381,13 @@ public class SchemaBuilder {
 
                     String arrayType = getType(t.type());
 
-                    switch(arrayType) {
+                    switch (arrayType) {
                         case "integer" -> fancyType = "List of Integers";
                         case "number" -> fancyType = "List of Numbers";
                         case "object" -> {
                             fancyType = "List of " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + "s (Objects)";
                             String key = "obj-" + t.type().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-                            if(!definitions.containsKey(key)) {
+                            if (!definitions.containsKey(key)) {
                                 definitions.put(key, new JSONObject());
                                 definitions.put(key, buildProperties(t.type()));
                             }
@@ -410,15 +398,15 @@ public class SchemaBuilder {
                         case "string" -> {
                             fancyType = "List of Text";
 
-                            if(k.isAnnotationPresent(RegistryListResource.class)) {
+                            if (k.isAnnotationPresent(RegistryListResource.class)) {
                                 RegistryListResource rr = k.getDeclaredAnnotation(RegistryListResource.class);
                                 ResourceLoader<?> loader = data.getLoaders().get(rr.value());
 
-                                if(loader != null) {
+                                if (loader != null) {
                                     fancyType = "List<" + loader.getResourceTypeName() + ">";
                                     String key = "erz" + loader.getFolderName();
 
-                                    if(!definitions.containsKey(key)) {
+                                    if (!definitions.containsKey(key)) {
                                         JSONObject j = new JSONObject();
                                         j.put("enum", new JSONArray(loader.getPossibleKeys()));
                                         definitions.put(key, j);
@@ -431,19 +419,19 @@ public class SchemaBuilder {
                                 } else {
                                     Iris.error("Cannot find Registry Loader for type (list schema) " + rr.value() + " used in " + k.getDeclaringClass().getCanonicalName() + " in field " + k.getName());
                                 }
-                            } else if(k.isAnnotationPresent(RegistryListBlockType.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListBlockType.class)) {
                                 fancyType = "List of Block Types";
                                 String key = "enum-block-type";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     JSONArray ja = new JSONArray();
 
-                                    for(String i : data.getBlockLoader().getPossibleKeys()) {
+                                    for (String i : data.getBlockLoader().getPossibleKeys()) {
                                         ja.put(i);
                                     }
 
-                                    for(String i : B.getBlockTypes()) {
+                                    for (String i : B.getBlockTypes()) {
                                         ja.put(i);
                                     }
 
@@ -455,11 +443,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Block Type (use ctrl+space for auto complete!)");
-                            } else if(k.isAnnotationPresent(RegistryListItemType.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListItemType.class)) {
                                 fancyType = "List of Item Types";
                                 String key = "enum-item-type";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", ITEM_TYPES);
                                     definitions.put(key, j);
@@ -469,11 +457,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Item Type (use ctrl+space for auto complete!)");
-                            } else if(k.isAnnotationPresent(RegistryListFont.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListFont.class)) {
                                 String key = "enum-font";
                                 fancyType = "List of Font Families";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", FONT_TYPES);
                                     definitions.put(key, j);
@@ -483,11 +471,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Font Family (use ctrl+space for auto complete!)");
-                            } else if(t.type().equals(Enchantment.class)) {
+                            } else if (k.isAnnotationPresent(RegistryListEnchantment.class)) {
                                 fancyType = "List of Enchantment Types";
                                 String key = "enum-enchantment";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", ENCHANT_TYPES);
                                     definitions.put(key, j);
@@ -497,11 +485,11 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Enchantment Type (use ctrl+space for auto complete!)");
-                            } else if(t.type().equals(PotionEffectType.class)) {
+                            } else if (t.type().equals(PotionEffectType.class)) {
                                 fancyType = "List of Potion Effect Types";
                                 String key = "enum-potion-effect-type";
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put("enum", POTION_TYPES);
                                     definitions.put(key, j);
@@ -511,12 +499,12 @@ public class SchemaBuilder {
                                 items.put("$ref", "#/definitions/" + key);
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Potion Effect Type (use ctrl+space for auto complete!)");
-                            } else if(t.type().isEnum()) {
+                            } else if (t.type().isEnum()) {
                                 fancyType = "List of " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + "s";
                                 JSONArray a = new JSONArray();
                                 boolean advanced = t.type().isAnnotationPresent(Desc.class);
-                                for(Object gg : t.type().getEnumConstants()) {
-                                    if(advanced) {
+                                for (Object gg : t.type().getEnumConstants()) {
+                                    if (advanced) {
                                         try {
                                             JSONObject j = new JSONObject();
                                             String name = ((Enum<?>) gg).name();
@@ -524,7 +512,7 @@ public class SchemaBuilder {
                                             Desc dd = t.type().getField(name).getAnnotation(Desc.class);
                                             j.put("description", dd == null ? ("No Description for " + name) : dd.value());
                                             a.put(j);
-                                        } catch(Throwable e) {
+                                        } catch (Throwable e) {
                                             Iris.reportError(e);
                                             e.printStackTrace();
                                         }
@@ -535,7 +523,7 @@ public class SchemaBuilder {
 
                                 String key = (advanced ? "oneof-" : "") + "enum-" + t.type().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
 
-                                if(!definitions.containsKey(key)) {
+                                if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
                                     j.put(advanced ? "oneOf" : "enum", a);
                                     definitions.put(key, j);
@@ -552,7 +540,8 @@ public class SchemaBuilder {
                     warnings.add("Undefined array type for field " + k.getName() + " (" + k.getType().getSimpleName() + ") in class " + cl.getSimpleName());
                 }
             }
-            default -> warnings.add("Unexpected Schema Type: " + type + " for field " + k.getName() + " (" + k.getType().getSimpleName() + ") in class " + cl.getSimpleName());
+            default ->
+                    warnings.add("Unexpected Schema Type: " + type + " for field " + k.getName() + " (" + k.getType().getSimpleName() + ") in class " + cl.getSimpleName());
         }
 
         KList<String> d = new KList<>();
@@ -562,7 +551,7 @@ public class SchemaBuilder {
         d.add(fancyType);
         d.add(getDescription(k.getType()));
 
-        if(k.getType().isAnnotationPresent(Snippet.class)) {
+        if (k.getType().isAnnotationPresent(Snippet.class)) {
             String sm = k.getType().getDeclaredAnnotation(Snippet.class).value();
             d.add("    ");
             d.add("You can instead specify \"snippet/" + sm + "/some-name.json\" to use a snippet file instead of specifying it here.");
@@ -572,11 +561,11 @@ public class SchemaBuilder {
             k.setAccessible(true);
             Object value = k.get(cl.newInstance());
 
-            if(value != null) {
-                if(value instanceof List) {
+            if (value != null) {
+                if (value instanceof List) {
                     d.add("    ");
                     d.add("* Default Value is an empty list");
-                } else if(!cl.isPrimitive() && !(value instanceof Number) && !(value instanceof String) && !(cl.isEnum())) {
+                } else if (!cl.isPrimitive() && !(value instanceof Number) && !(value instanceof String) && !(cl.isEnum())) {
                     d.add("    ");
                     d.add("* Default Value is a default object (create this object to see default properties)");
                 } else {
@@ -584,7 +573,7 @@ public class SchemaBuilder {
                     d.add("* Default Value is " + value);
                 }
             }
-        } catch(Throwable ignored) {
+        } catch (Throwable ignored) {
 
         }
 
@@ -592,7 +581,7 @@ public class SchemaBuilder {
         prop.put("type", type);
         prop.put("description", d.toString("\n"));
 
-        if(k.getType().isAnnotationPresent(Snippet.class)) {
+        if (k.getType().isAnnotationPresent(Snippet.class)) {
             JSONObject anyOf = new JSONObject();
             JSONArray arr = new JSONArray();
             JSONObject str = new JSONObject();
@@ -600,7 +589,7 @@ public class SchemaBuilder {
             String key = "enum-snippet-" + k.getType().getDeclaredAnnotation(Snippet.class).value();
             str.put("$ref", "#/definitions/" + key);
 
-            if(!definitions.containsKey(key)) {
+            if (!definitions.containsKey(key)) {
                 JSONObject j = new JSONObject();
                 JSONArray snl = new JSONArray();
                 data.getPossibleSnippets(k.getType().getDeclaredAnnotation(Snippet.class).value()).forEach(snl::put);
@@ -623,31 +612,31 @@ public class SchemaBuilder {
     }
 
     private String getType(Class<?> c) {
-        if(c.equals(int.class) || c.equals(Integer.class) || c.equals(long.class) || c.equals(Long.class)) {
+        if (c.equals(int.class) || c.equals(Integer.class) || c.equals(long.class) || c.equals(Long.class)) {
             return "integer";
         }
 
-        if(c.equals(float.class) || c.equals(double.class) || c.equals(Float.class) || c.equals(Double.class)) {
+        if (c.equals(float.class) || c.equals(double.class) || c.equals(Float.class) || c.equals(Double.class)) {
             return "number";
         }
 
-        if(c.equals(boolean.class) || c.equals(Boolean.class)) {
+        if (c.equals(boolean.class) || c.equals(Boolean.class)) {
             return "boolean";
         }
 
-        if(c.equals(String.class) || c.isEnum() || c.equals(Enchantment.class) || c.equals(PotionEffectType.class)) {
+        if (c.equals(String.class) || c.isEnum() || c.equals(Enchantment.class) || c.equals(PotionEffectType.class)) {
             return "string";
         }
 
-        if(c.equals(KList.class)) {
+        if (c.equals(KList.class)) {
             return "array";
         }
 
-        if(c.equals(KMap.class)) {
+        if (c.equals(KMap.class)) {
             return "object";
         }
 
-        if(!c.isAnnotationPresent(Desc.class) && c.getCanonicalName().startsWith("com.volmit.iris.")) {
+        if (!c.isAnnotationPresent(Desc.class) && c.getCanonicalName().startsWith("com.volmit.iris.")) {
             warnings.addIfMissing("Unsupported Type: " + c.getCanonicalName() + " Did you forget @Desc?");
         }
 
@@ -656,12 +645,12 @@ public class SchemaBuilder {
 
     private String getFieldDescription(Field r) {
 
-        if(r.isAnnotationPresent(Desc.class)) {
+        if (r.isAnnotationPresent(Desc.class)) {
             return r.getDeclaredAnnotation(Desc.class).value();
         }
 
         // suppress warnings on bukkit classes
-        if(r.getDeclaringClass().getName().startsWith("org.bukkit.")) {
+        if (r.getDeclaringClass().getName().startsWith("org.bukkit.")) {
             return "Bukkit package classes and enums have no descriptions";
         }
 
@@ -670,11 +659,11 @@ public class SchemaBuilder {
     }
 
     private String getDescription(Class<?> r) {
-        if(r.isAnnotationPresent(Desc.class)) {
+        if (r.isAnnotationPresent(Desc.class)) {
             return r.getDeclaredAnnotation(Desc.class).value();
         }
 
-        if(!r.isPrimitive() && !r.equals(KList.class) && !r.equals(KMap.class) && r.getCanonicalName().startsWith("com.volmit.")) {
+        if (!r.isPrimitive() && !r.equals(KList.class) && !r.equals(KMap.class) && r.getCanonicalName().startsWith("com.volmit.")) {
             warnings.addIfMissing("Missing @Desc on " + r.getSimpleName() + " in " + (r.getDeclaringClass() != null ? r.getDeclaringClass().getCanonicalName() : " NOSRC"));
         }
         return "";

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

@@ -0,0 +1,15 @@
+package com.volmit.iris.core.safeguard;
+
+import com.volmit.iris.Iris;
+
+public class IrisSafeguard {
+    public static boolean unstablemode = false;
+    public static boolean warningmode = false;
+    public static boolean stablemode = false;
+
+    public static void IrisSafeguardSystem() {
+        Iris.info("Enabled Iris SafeGuard");
+        ServerBootSFG.BootCheck();
+    }
+}
+

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

@@ -0,0 +1,80 @@
+package com.volmit.iris.core.safeguard;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.util.format.C;
+
+public class ModesSFG {
+    public static void selectMode() {
+        if (IrisSafeguard.unstablemode) {
+            Iris.safeguard(C.DARK_RED + "Iris is running in Unstable Mode");
+            unstable();
+        }
+        if (IrisSafeguard.warningmode) {
+            Iris.safeguard(C.GOLD + "Iris is running in Warning Mode");
+            warning();
+        }
+        if (IrisSafeguard.stablemode) {
+            stable();
+        }
+    }
+
+    public static void stable() {
+        Iris.safeguard(C.BLUE + "Iris is running Stable");
+    }
+
+    public static void unstable() {
+
+        UtilsSFG.printIncompatibleWarnings();
+
+        if (IrisSafeguard.unstablemode) {
+            Iris.info("");
+            Iris.info(C.DARK_GRAY + "--==<" + C.RED + " IMPORTANT " + C.DARK_GRAY + ">==--");
+            Iris.info(C.RED + "Iris is running in unstable mode which may cause the following issues:");
+            Iris.info(C.DARK_RED + "Server Issues");
+            Iris.info(C.RED + "- Server won't boot");
+            Iris.info(C.RED + "- Data Loss");
+            Iris.info(C.RED + "- Unexpected behavior.");
+            Iris.info(C.RED + "- And More...");
+            Iris.info(C.DARK_RED + "World Issues");
+            Iris.info(C.RED + "- Worlds can't load due to corruption.");
+            Iris.info(C.RED + "- Worlds may slowly corrupt until they can't load.");
+            Iris.info(C.RED + "- World data loss.");
+            Iris.info(C.RED + "- And More...");
+            Iris.info(C.DARK_RED + "ATTENTION: " + C.RED + "While running Iris in unstable mode, you won't be eligible for support.");
+            Iris.info(C.DARK_RED + "CAUSE: " + C.RED + UtilsSFG.MSGIncompatibleWarnings());
+
+            if (IrisSettings.get().getGeneral().ignoreBootMode) {
+                Iris.info(C.DARK_RED + "Boot Unstable is set to true, continuing with the startup process.");
+            } else {
+                Iris.info(C.DARK_RED + "Go to plugins/iris/settings.json and set ignoreBootMode to true if you wish to proceed.");
+                while (true) {
+                    try {
+                        Thread.sleep(1000);
+                    } catch (InterruptedException e) {
+                        // no
+                    }
+                }
+            }
+            Iris.info("");
+        }
+    }
+
+    public static void warning() {
+
+        UtilsSFG.printIncompatibleWarnings();
+
+        if (IrisSafeguard.warningmode) {
+            Iris.info("");
+            Iris.info(C.DARK_GRAY + "--==<" + C.GOLD + " IMPORTANT " + C.DARK_GRAY + ">==--");
+            Iris.info(C.GOLD + "Iris is running in warning mode which may cause the following issues:");
+            Iris.info(C.YELLOW + "- Data Loss");
+            Iris.info(C.YELLOW + "- Errors");
+            Iris.info(C.YELLOW + "- Broken worlds");
+            Iris.info(C.YELLOW + "- Unexpected behavior.");
+            Iris.info(C.YELLOW + "- And perhaps further complications.");
+            Iris.info(C.GOLD + "CAUSE: " + C.YELLOW + UtilsSFG.MSGIncompatibleWarnings());
+            Iris.info("");
+        }
+    }
+}

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

@@ -0,0 +1,8 @@
+package com.volmit.iris.core.safeguard;
+
+public class PerformanceSFG {
+    public static void calculatePerformance() {
+
+
+    }
+}

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

@@ -0,0 +1,163 @@
+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.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+
+import javax.tools.JavaCompiler;
+import javax.tools.ToolProvider;
+import java.io.File;
+import java.nio.channels.FileChannel;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.nio.file.StandardOpenOption;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.StringJoiner;
+
+import static com.volmit.iris.Iris.getJavaVersion;
+import static com.volmit.iris.Iris.instance;
+import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
+
+public class ServerBootSFG {
+    public static final Map<String, Boolean> incompatibilities = new HashMap<>();
+    public static boolean isJDK17 = true;
+    public static boolean hasEnoughDiskSpace = true;
+    public static boolean isJRE = false;
+    public static boolean hasPrivileges = true;
+    public static boolean unsuportedversion = false;
+    protected static boolean safeguardPassed;
+    public static boolean passedserversoftware = true;
+    protected static int count;
+    protected static byte severityLow;
+    protected static byte severityMedium;
+    protected static byte severityHigh;
+    public static String allIncompatibilities;
+
+    public static void BootCheck() {
+        Iris.info("Checking for possible conflicts..");
+        org.bukkit.plugin.PluginManager pluginManager = Bukkit.getPluginManager();
+        Plugin[] plugins = pluginManager.getPlugins();
+
+        incompatibilities.clear();
+        incompatibilities.put("Multiverse-Core", false);
+        incompatibilities.put("dynmap", false);
+        incompatibilities.put("TerraformGenerator", false);
+        incompatibilities.put("Stratos", false);
+
+        String pluginName;
+        for (Plugin plugin : plugins) {
+            pluginName = plugin.getName();
+            Boolean flag = incompatibilities.get(pluginName);
+            if (flag != null && !flag) {
+                severityHigh++;
+                incompatibilities.put(pluginName, true);
+            }
+        }
+
+        StringJoiner joiner = new StringJoiner(", ");
+        for (Map.Entry<String, Boolean> entry : incompatibilities.entrySet()) {
+            if (entry.getValue()) {
+                joiner.add(entry.getKey());
+            }
+        }
+        if (
+                !instance.getServer().getVersion().contains("Purpur") &&
+                        !instance.getServer().getVersion().contains("Paper") &&
+                        !instance.getServer().getVersion().contains("Spigot") &&
+                        !instance.getServer().getVersion().contains("Pufferfish") &&
+                        !instance.getServer().getVersion().contains("Bukkit")) {
+            passedserversoftware = false;
+            joiner.add("Server Software");
+            severityHigh++;
+        }
+
+        if (INMS.get() instanceof NMSBinding1X) {
+            unsuportedversion = true;
+            joiner.add("Unsupported Minecraft Version");
+            severityHigh++;
+        }
+
+        if (getJavaVersion() != 17) {
+            isJDK17 = false;
+            joiner.add("Unsupported Java version");
+            severityMedium++;
+        }
+
+        if (!isJDK()) {
+            isJRE = true;
+            joiner.add("Unsupported JDK");
+            severityMedium++;
+        }
+
+//        if (!hasPrivileges()){
+//            hasPrivileges = false;
+//            joiner.add("Insufficient Privileges");
+//            severityMedium++;
+//        } Some servers dont like this
+
+        if (!enoughDiskSpace()){
+            hasEnoughDiskSpace = false;
+            joiner.add("Insufficient Disk Space");
+            severityMedium++;
+        }
+
+        allIncompatibilities = joiner.toString();
+
+        safeguardPassed = (severityHigh == 0 && severityMedium == 0 && severityLow == 0);
+        count = severityHigh + severityMedium + severityLow;
+        if (safeguardPassed) {
+            stablemode = true;
+            Iris.safeguard("Stable mode has been activated.");
+        }
+        if (!safeguardPassed) {
+            if (severityMedium >= 1 && severityHigh == 0) {
+                warningmode = true;
+                Iris.safeguard("Warning mode has been activated.");
+            }
+            if (severityHigh >= 1) {
+                unstablemode = true;
+                Iris.safeguard("Unstable mode has been activated.");
+            }
+        }
+    }
+
+
+    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)) {
+            if (Files.isReadable(pv) && Files.isWritable(pv)) {
+                return true;
+            }
+        } catch (Exception e) {
+            return false;
+        }
+        return false;
+    }
+
+    public static boolean enoughDiskSpace() {
+        File freeSpace = new File(Bukkit.getWorldContainer() + ".");
+        double gigabytes = freeSpace.getFreeSpace() / (1024.0 * 1024.0 * 1024.0);
+        if (gigabytes > 3){
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private static boolean checkJavac(String path) {
+        return !path.isEmpty() && (new File(path, "javac").exists() || new File(path, "javac.exe").exists());
+    }
+
+}

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

@@ -0,0 +1,68 @@
+package com.volmit.iris.core.safeguard;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.format.C;
+
+public class UtilsSFG {
+    public static void splash() {
+        ModesSFG.selectMode();
+    }
+
+    public static void printIncompatibleWarnings() {
+        // String SupportedIrisVersion = getDescription().getVersion(); //todo Automatic version
+
+        if (ServerBootSFG.safeguardPassed) {
+            Iris.safeguard(C.BLUE + "0 Conflicts found");
+        } else {
+            if (IrisSafeguard.unstablemode) {
+                Iris.safeguard(C.DARK_RED + "" + ServerBootSFG.count + " Conflicts found");
+            }
+            if (IrisSafeguard.warningmode) {
+                Iris.safeguard(C.YELLOW + "" + ServerBootSFG.count + " Conflicts found");
+            }
+
+            if (ServerBootSFG.incompatibilities.get("Multiverse-Core")) {
+                Iris.safeguard(C.RED + "Multiverse");
+                Iris.safeguard(C.RED + "- The plugin Multiverse is not compatible with the server.");
+                Iris.safeguard(C.RED + "- If you want to have a world manager, consider using PhantomWorlds or MyWorlds instead.");
+            }
+            if (ServerBootSFG.incompatibilities.get("dynmap")) {
+                Iris.safeguard(C.RED + "Dynmap");
+                Iris.safeguard(C.RED + "- The plugin Dynmap is not compatible with the server.");
+                Iris.safeguard(C.RED + "- If you want to have a map plugin like Dynmap, consider Bluemap.");
+            }
+            if (ServerBootSFG.incompatibilities.get("TerraformGenerator") || ServerBootSFG.incompatibilities.get("Stratos")) {
+                Iris.safeguard(C.YELLOW + "Terraform Generator / Stratos");
+                Iris.safeguard(C.YELLOW + "- Iris is not compatible with other worldgen plugins.");
+            }
+            if (ServerBootSFG.unsuportedversion) {
+                Iris.safeguard(C.RED + "Server Version");
+                Iris.safeguard(C.RED + "- Iris only supports 1.19.2 > 1.20.4");
+            }
+            if (!ServerBootSFG.passedserversoftware) {
+                Iris.safeguard(C.YELLOW + "Unsupported Server Software");
+                Iris.safeguard(C.YELLOW + "- Please consider using Paper or Purpur instead.");
+            }
+            if (!ServerBootSFG.hasPrivileges) {
+                Iris.safeguard(C.YELLOW + "Insufficient Privileges");
+                Iris.safeguard(C.YELLOW + "- The server has insufficient Privileges to run iris. Please contact support.");
+            }
+            if (!ServerBootSFG.hasEnoughDiskSpace) {
+                Iris.safeguard(C.YELLOW + "Insufficient Disk Space");
+                Iris.safeguard(C.YELLOW + "- The server has insufficient Free DiskSpace to run iris required 3GB+.");
+            }
+            if (!ServerBootSFG.isJDK17) {
+                Iris.safeguard(C.YELLOW + "Unsupported java version");
+                Iris.safeguard(C.YELLOW + "- Please consider using JDK 17 Instead of JDK " + Iris.getJavaVersion());
+            }
+            if (ServerBootSFG.isJRE) {
+                Iris.safeguard(C.YELLOW + "Unsupported Server JDK");
+                Iris.safeguard(C.YELLOW + "- Please consider using JDK 17 Instead of JRE " + Iris.getJavaVersion());
+            }
+        }
+    }
+
+    public static String MSGIncompatibleWarnings() {
+        return ServerBootSFG.allIncompatibilities;
+    }
+}

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

@@ -19,6 +19,7 @@
 package com.volmit.iris.core.service;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
@@ -48,9 +49,9 @@ public class BoardSVC implements IrisService, BoardProvider {
     public void onEnable() {
         J.ar(this::tick, 20);
         manager = new BoardManager(Iris.instance, BoardSettings.builder()
-            .boardProvider(this)
-            .scoreDirection(ScoreDirection.DOWN)
-            .build());
+                .boardProvider(this)
+                .scoreDirection(ScoreDirection.DOWN)
+                .build());
     }
 
     @Override
@@ -70,7 +71,7 @@ public class BoardSVC implements IrisService, BoardProvider {
     }
 
     public void updatePlayer(Player p) {
-        if(IrisToolbelt.isIrisStudioWorld(p.getWorld())) {
+        if (IrisToolbelt.isIrisStudioWorld(p.getWorld())) {
             manager.remove(p);
             manager.setup(p);
         } else {
@@ -85,7 +86,7 @@ public class BoardSVC implements IrisService, BoardProvider {
     }
 
     public void tick() {
-        if(!Iris.service(StudioSVC.class).isProjectOpen()) {
+        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
             return;
         }
 
@@ -95,7 +96,7 @@ public class BoardSVC implements IrisService, BoardProvider {
     @Override
     public List<String> getLines(Player player) {
         PlayerBoard pb = boards.computeIfAbsent(player, PlayerBoard::new);
-        synchronized(pb.lines) {
+        synchronized (pb.lines) {
             return pb.lines;
         }
     }
@@ -112,10 +113,10 @@ public class BoardSVC implements IrisService, BoardProvider {
         }
 
         public void update() {
-            synchronized(lines) {
+            synchronized (lines) {
                 lines.clear();
 
-                if(!IrisToolbelt.isIrisStudioWorld(player.getWorld())) {
+                if (!IrisToolbelt.isIrisStudioWorld(player.getWorld())) {
                     return;
                 }
 
@@ -124,17 +125,32 @@ public class BoardSVC implements IrisService, BoardProvider {
                 int y = player.getLocation().getBlockY() - player.getWorld().getMinHeight();
                 int z = player.getLocation().getBlockZ();
 
-                lines.add("&7&m                   ");
-                lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
-                lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
-                lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
-                lines.add("&7&m                   ");
-                lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
-                lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
-                lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z) + player.getWorld().getMinHeight()));
-                lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
-                lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
-                lines.add("&7&m                   ");
+                if(IrisSettings.get().getGeneral().debug){
+                    lines.add("&7&m                   ");
+                    lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
+                    lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
+                    lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
+                    lines.add(C.LIGHT_PURPLE + "Carving" + C.GRAY + ": " + engine.getMantle().isCarved(x,y,z));
+                    lines.add("&7&m                   ");
+                    lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
+                    lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
+                    lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
+                    lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
+                    lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
+                    lines.add("&7&m                   ");
+                } else {
+                    lines.add("&7&m                   ");
+                    lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
+                    lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
+                    lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
+                    lines.add("&7&m                   ");
+                    lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
+                    lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
+                    lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
+                    lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
+                    lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
+                    lines.add("&7&m                   ");
+                }
             }
         }
     }

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

@@ -38,8 +38,8 @@ import java.util.concurrent.CompletableFuture;
 
 public class CommandSVC implements IrisService, DecreeSystem {
     private final KMap<String, CompletableFuture<String>> futures = new KMap<>();
-    private CompletableFuture<String> consoleFuture = null;
     private final transient AtomicCache<VirtualDecreeCommand> commandCache = new AtomicCache<>();
+    private CompletableFuture<String> consoleFuture = null;
 
     @Override
     public void onEnable() {
@@ -56,18 +56,18 @@ public class CommandSVC implements IrisService, DecreeSystem {
     public void on(PlayerCommandPreprocessEvent e) {
         String msg = e.getMessage().startsWith("/") ? e.getMessage().substring(1) : e.getMessage();
 
-        if(msg.startsWith("irisdecree ")) {
+        if (msg.startsWith("irisdecree ")) {
             String[] args = msg.split("\\Q \\E");
             CompletableFuture<String> future = futures.get(args[1]);
 
-            if(future != null) {
+            if (future != null) {
                 future.complete(args[2]);
                 e.setCancelled(true);
                 return;
             }
         }
 
-        if((msg.startsWith("locate ") || msg.startsWith("locatebiome ")) && IrisToolbelt.isIrisWorld(e.getPlayer().getWorld())) {
+        if ((msg.startsWith("locate ") || msg.startsWith("locatebiome ")) && IrisToolbelt.isIrisWorld(e.getPlayer().getWorld())) {
             new VolmitSender(e.getPlayer()).sendMessage(C.RED + "Locating biomes & objects is disabled in Iris Worlds. Use /iris studio goto <biome>");
             e.setCancelled(true);
         }
@@ -75,8 +75,8 @@ public class CommandSVC implements IrisService, DecreeSystem {
 
     @EventHandler
     public void on(ServerCommandEvent e) {
-        if(consoleFuture != null && !consoleFuture.isCancelled() && !consoleFuture.isDone()) {
-            if(!e.getCommand().contains(" ")) {
+        if (consoleFuture != null && !consoleFuture.isCancelled() && !consoleFuture.isDone()) {
+            if (!e.getCommand().contains(" ")) {
                 String pick = e.getCommand().trim().toLowerCase(Locale.ROOT);
                 consoleFuture.complete(pick);
                 e.setCancelled(true);

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

@@ -20,12 +20,7 @@ package com.volmit.iris.core.service;
 
 import com.google.gson.Gson;
 import com.volmit.iris.Iris;
-import com.volmit.iris.engine.object.IrisDirection;
-import com.volmit.iris.engine.object.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawPieceConnector;
-import com.volmit.iris.engine.object.IrisJigsawPool;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisPosition;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.format.Form;
@@ -60,10 +55,10 @@ public class ConversionSVC implements IrisService {
         converters = new KList<>();
 
         J.s(() ->
-            J.attemptAsync(() ->
-            {
+                J.attemptAsync(() ->
+                {
 
-            }), 5);
+                }), 5);
     }
 
     @Override
@@ -84,13 +79,13 @@ public class ConversionSVC implements IrisService {
         destPools.mkdirs();
         findAllNBT(in, (folder, file) -> {
             total.getAndIncrement();
-            if(roots.addIfMissing(folder)) {
+            if (roots.addIfMissing(folder)) {
                 String b = in.toURI().relativize(folder.toURI()).getPath();
-                if(b.startsWith("/")) {
+                if (b.startsWith("/")) {
                     b = b.substring(1);
                 }
 
-                if(b.endsWith("/")) {
+                if (b.endsWith("/")) {
                     b = b.substring(0, b.length() - 1);
                 }
 
@@ -100,11 +95,11 @@ public class ConversionSVC implements IrisService {
         findAllNBT(in, (folder, file) -> {
             at.getAndIncrement();
             String b = in.toURI().relativize(folder.toURI()).getPath();
-            if(b.startsWith("/")) {
+            if (b.startsWith("/")) {
                 b = b.substring(1);
             }
 
-            if(b.endsWith("/")) {
+            if (b.endsWith("/")) {
                 b = b.substring(0, b.length() - 1);
             }
             IrisJigsawPool jpool = pools.get(b);
@@ -117,7 +112,7 @@ public class ConversionSVC implements IrisService {
                 NamedTag tag = NBTUtil.read(file);
                 CompoundTag compound = (CompoundTag) tag.getTag();
 
-                if(compound.containsKey("blocks") && compound.containsKey("palette") && compound.containsKey("size")) {
+                if (compound.containsKey("blocks") && compound.containsKey("palette") && compound.containsKey("size")) {
                     String id = in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0];
                     @SuppressWarnings("unchecked") ListTag<IntTag> size = (ListTag<IntTag>) compound.getListTag("size");
                     int w = size.get(0).asInt();
@@ -125,14 +120,14 @@ public class ConversionSVC implements IrisService {
                     int d = size.get(2).asInt();
                     KList<BlockData> palette = new KList<>();
                     @SuppressWarnings("unchecked") ListTag<CompoundTag> paletteList = (ListTag<CompoundTag>) compound.getListTag("palette");
-                    for(int i = 0; i < paletteList.size(); i++) {
+                    for (int i = 0; i < paletteList.size(); i++) {
                         CompoundTag cp = paletteList.get(i);
                         palette.add(NBTWorld.getBlockData(cp));
                     }
                     IrisJigsawPiece piece = new IrisJigsawPiece();
                     IrisObject object = new IrisObject(w, h, d);
                     @SuppressWarnings("unchecked") ListTag<CompoundTag> blockList = (ListTag<CompoundTag>) compound.getListTag("blocks");
-                    for(int i = 0; i < blockList.size(); i++) {
+                    for (int i = 0; i < blockList.size(); i++) {
                         CompoundTag cp = blockList.get(i);
                         @SuppressWarnings("unchecked") ListTag<IntTag> pos = (ListTag<IntTag>) cp.getListTag("pos");
                         int x = pos.get(0).asInt();
@@ -140,7 +135,7 @@ public class ConversionSVC implements IrisService {
                         int z = pos.get(2).asInt();
                         BlockData bd = palette.get(cp.getInt("state")).clone();
 
-                        if(bd.getMaterial().equals(Material.JIGSAW) && cp.containsKey("nbt")) {
+                        if (bd.getMaterial().equals(Material.JIGSAW) && cp.containsKey("nbt")) {
                             piece.setObject(in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0]);
                             IrisPosition spos = new IrisPosition(object.getSigned(x, y, z));
                             CompoundTag nbt = cp.getCompoundTag("nbt");
@@ -162,14 +157,14 @@ public class ConversionSVC implements IrisService {
                             connector.getPools().add(poolId);
                             connector.setDirection(IrisDirection.getDirection(((Jigsaw) jd).getOrientation()));
 
-                            if(target.equals("minecraft:building_entrance")) {
+                            if (target.equals("minecraft:building_entrance")) {
                                 connector.setInnerConnector(true);
                             }
 
                             piece.getConnectors().add(connector);
                         }
 
-                        if(!bd.getMaterial().equals(Material.STRUCTURE_VOID) && !bd.getMaterial().equals(Material.AIR)) {
+                        if (!bd.getMaterial().equals(Material.STRUCTURE_VOID) && !bd.getMaterial().equals(Material.AIR)) {
                             object.setUnsigned(x, y, z, bd);
                         }
                     }
@@ -179,16 +174,16 @@ public class ConversionSVC implements IrisService {
                     IO.writeAll(new File(destPieces, file.getName().split("\\Q.\\E")[0] + ".json"), new JSONObject(new Gson().toJson(piece)).toString(4));
                     Iris.info("[Jigsaw]: (" + Form.pc((double) at.get() / (double) total.get(), 0) + ") Exported Piece: " + id);
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
                 Iris.reportError(e);
             }
         });
 
-        for(String i : pools.k()) {
+        for (String i : pools.k()) {
             try {
                 IO.writeAll(new File(destPools, i + ".json"), new JSONObject(new Gson().toJson(pools.get(i))).toString(4));
-            } catch(IOException e) {
+            } catch (IOException e) {
                 e.printStackTrace();
                 Iris.reportError(e);
             }
@@ -198,19 +193,19 @@ public class ConversionSVC implements IrisService {
     }
 
     public void findAllNBT(File path, Consumer2<File, File> inFile) {
-        if(path == null) {
+        if (path == null) {
             return;
         }
 
-        if(path.isFile() && path.getName().endsWith(".nbt")) {
+        if (path.isFile() && path.getName().endsWith(".nbt")) {
             inFile.accept(path.getParentFile(), path);
             return;
         }
 
-        for(File i : path.listFiles()) {
-            if(i.isDirectory()) {
+        for (File i : path.listFiles()) {
+            if (i.isDirectory()) {
                 findAllNBT(i, inFile);
-            } else if(i.isFile() && i.getName().endsWith(".nbt")) {
+            } else if (i.isFile() && i.getName().endsWith(".nbt")) {
                 inFile.accept(path, i);
             }
         }
@@ -220,9 +215,9 @@ public class ConversionSVC implements IrisService {
         int m = 0;
         Iris.instance.getDataFolder("convert");
 
-        for(File i : folder.listFiles()) {
-            for(Converter j : converters) {
-                if(i.getName().endsWith("." + j.getInExtension())) {
+        for (File i : folder.listFiles()) {
+            for (Converter j : converters) {
+                if (i.getName().endsWith("." + j.getInExtension())) {
                     File out = new File(folder, i.getName().replaceAll("\\Q." + j.getInExtension() + "\\E", "." + j.getOutExtension()));
                     m++;
                     j.convert(i, out);
@@ -230,10 +225,10 @@ public class ConversionSVC implements IrisService {
                 }
             }
 
-            if(i.isDirectory() && i.getName().equals("structures")) {
+            if (i.isDirectory() && i.getName().equals("structures")) {
                 File f = new File(folder, "jigsaw");
 
-                if(!f.exists()) {
+                if (!f.exists()) {
                     s.sendMessage("Converting NBT Structures into Iris Jigsaw Structures...");
                     f.mkdirs();
                     J.a(() -> convertStructures(i, f, s));

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

@@ -0,0 +1,93 @@
+/*
+ * 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.core.nms.INMS;
+import com.volmit.iris.core.nms.container.BlockPos;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.documentation.ChunkCoordinates;
+import com.volmit.iris.util.function.Consumer4;
+import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.matter.MatterStructurePOI;
+import com.volmit.iris.util.plugin.IrisService;
+import org.bukkit.Material;
+import org.bukkit.Sound;
+import org.bukkit.SoundCategory;
+import org.bukkit.entity.Dolphin;
+import org.bukkit.entity.EntityType;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.generator.structure.StructureType;
+
+import java.util.concurrent.atomic.AtomicReference;
+
+public class DolphinSVC implements IrisService {
+
+    @Override
+    public void onEnable() {
+
+    }
+
+    @Override
+    public void onDisable() {
+
+    }
+
+    @EventHandler
+    public void on(PlayerInteractEntityEvent event) {
+        if (!IrisToolbelt.isIrisWorld(event.getPlayer().getWorld())) {
+            return;
+        }
+
+        Material hand = event.getPlayer().getInventory().getItem(event.getHand()).getType();
+        if (event.getRightClicked().getType().equals(EntityType.DOLPHIN) && (hand.equals(Material.TROPICAL_FISH) || hand.equals(Material.PUFFERFISH) || hand.equals(Material.COD) || hand.equals(Material.SALMON))) {
+            Engine e = IrisToolbelt.access(event.getPlayer().getWorld()).getEngine();
+            searchNearestTreasure(e, event.getPlayer().getLocation().getBlockX() >> 4, event.getPlayer().getLocation().getBlockZ() >> 4, e.getMantle().getRadius() - 1, StructureType.BURIED_TREASURE, (x, y, z, p) -> {
+                event.setCancelled(true);
+                Dolphin d = (Dolphin) event.getRightClicked();
+                INMS.get().setTreasurePos(d, new BlockPos(x, y, z));
+                d.getWorld().playSound(d, Sound.ENTITY_DOLPHIN_EAT, SoundCategory.NEUTRAL, 1, 1);
+            });
+
+        }
+    }
+
+    @ChunkCoordinates
+    public void findTreasure(Engine engine, int chunkX, int chunkY, StructureType type, Consumer4<Integer, Integer, Integer, MatterStructurePOI> consumer) {
+        AtomicReference<MatterStructurePOI> ref = new AtomicReference<>();
+        engine.getMantle().getMantle().iterateChunk(chunkX, chunkY, MatterStructurePOI.class, ref.get() == null ? (x, y, z, d) -> {
+            if (d.getType().equals(type.getKey().getKey())) {
+                ref.set(d);
+                consumer.accept(x, y, z, d);
+            }
+        } : (x, y, z, d) -> {
+        });
+    }
+
+    @ChunkCoordinates
+    public void searchNearestTreasure(Engine engine, int chunkX, int chunkY, int radius, StructureType type, Consumer4<Integer, Integer, Integer, MatterStructurePOI> consumer) {
+        AtomicReference<MatterStructurePOI> ref = new AtomicReference<>();
+        new Spiraler(radius * 2, radius * 2, (x, z) -> findTreasure(engine, x, z, type, ref.get() == null ? (i, d, g, a) -> {
+            ref.set(a);
+            consumer.accept(i, d, g, a);
+        } : (i, d, g, a) -> {
+        })).setOffset(chunkX, chunkY).drain();
+    }
+}

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

@@ -33,6 +33,7 @@ import org.bukkit.event.world.WorldUnloadEvent;
 
 public class EditSVC implements IrisService {
     private KMap<World, BlockEditor> editors;
+    public static boolean deletingWorld = false;
 
     @Override
     public void onEnable() {
@@ -71,27 +72,28 @@ public class EditSVC implements IrisService {
 
     @EventHandler
     public void on(WorldUnloadEvent e) {
-        if(editors.containsKey(e.getWorld())) {
+        if (editors.containsKey(e.getWorld()) && !deletingWorld) {
             editors.remove(e.getWorld()).close();
         }
     }
 
+
     public void update() {
-        for(World i : editors.k()) {
-            if(M.ms() - editors.get(i).last() > 1000) {
+        for (World i : editors.k()) {
+            if (M.ms() - editors.get(i).last() > 1000) {
                 editors.remove(i).close();
             }
         }
     }
 
     public void flushNow() {
-        for(World i : editors.k()) {
+        for (World i : editors.k()) {
             editors.remove(i).close();
         }
     }
 
     public BlockEditor open(World world) {
-        if(editors.containsKey(world)) {
+        if (editors.containsKey(world)) {
             return editors.get(world);
         }
 

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

@@ -0,0 +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.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]);
+    }
+}

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

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

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

@@ -0,0 +1,123 @@
+package com.volmit.iris.core.service;
+
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.plugin.IrisService;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Marker;
+import org.apache.logging.log4j.core.Filter;
+import org.apache.logging.log4j.core.LogEvent;
+import org.apache.logging.log4j.core.Logger;
+import org.apache.logging.log4j.message.Message;
+
+public class LogFilterSVC implements IrisService, Filter {
+
+    private static final String HEIGHTMAP_MISMATCH = "Ignoring heightmap data for chunk";
+    private static final String RAID_PERSISTENCE = "Could not save data net.minecraft.world.entity.raid.PersistentRaid";
+    private static final String DUPLICATE_ENTITY_UUID = "UUID of added entity already exists";
+
+    private static final KList<String> FILTERS = new KList<>();
+
+    public void onEnable() {
+        FILTERS.add(HEIGHTMAP_MISMATCH, RAID_PERSISTENCE, DUPLICATE_ENTITY_UUID);
+        ((Logger) LogManager.getRootLogger()).addFilter(this);
+    }
+
+    public void initialize() {
+    }
+
+    public void start() {
+    }
+
+    public void stop() {
+    }
+
+    public void onDisable() {
+    }
+
+    public boolean isStarted() {
+        return true;
+    }
+
+    public boolean isStopped() {
+        return false;
+    }
+
+    public State getState() {
+        try {
+            return State.STARTED;
+        } catch (Exception var2) {
+            return null;
+        }
+    }
+
+    public Filter.Result getOnMatch() {
+        return Result.NEUTRAL;
+    }
+
+    public Filter.Result getOnMismatch() {
+        return Result.NEUTRAL;
+    }
+
+    public Result filter(LogEvent event) {
+        return check(event.getMessage().getFormattedMessage());
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, Object msg, Throwable t) {
+        return check(msg.toString());
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, Message msg, Throwable t) {
+        return check(msg.getFormattedMessage());
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object... params) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3, Object p4) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7, Object p8) {
+        return check(message);
+    }
+
+    public Result filter(Logger logger, Level level, Marker marker, String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7, Object p8, Object p9) {
+        return check(message);
+    }
+
+    private Result check(String string) {
+        if (FILTERS.stream().anyMatch(string::contains))
+            return Result.DENY;
+        return Result.NEUTRAL;
+    }
+}

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

@@ -18,9 +18,11 @@
 
 package com.volmit.iris.core.service;
 
+import com.volmit.iris.Iris;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Getter;
+import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 
@@ -54,9 +56,9 @@ public class ObjectSVC implements IrisService {
     }
 
     private void loopChange(int amount) {
-        if(undos.size() > 0) {
+        if (undos.size() > 0) {
             revert(undos.pollLast());
-            if(amount > 1) {
+            if (amount > 1) {
                 J.s(() -> loopChange(amount - 1), 2);
             }
         }
@@ -65,23 +67,25 @@ public class ObjectSVC implements IrisService {
     /**
      * Reverts all the block changes provided, 200 blocks per tick
      *
-     * @param blocks
-     *     The blocks to remove
+     * @param blocks The blocks to remove
      */
     private void revert(Map<Block, BlockData> blocks) {
-        int amount = 0;
         Iterator<Map.Entry<Block, BlockData>> it = blocks.entrySet().iterator();
-        while(it.hasNext()) {
-            Map.Entry<Block, BlockData> entry = it.next();
-            BlockData data = entry.getValue();
-            entry.getKey().setBlockData(data, false);
-            it.remove();
+        Bukkit.getScheduler().runTask(Iris.instance, () -> {
+            int amount = 0;
+            while (it.hasNext()) {
+                Map.Entry<Block, BlockData> entry = it.next();
+                BlockData data = entry.getValue();
+                entry.getKey().setBlockData(data, false);
 
-            amount++;
+                it.remove();
 
-            if(amount > 200) {
-                J.s(() -> revert(blocks), 1);
+                amount++;
+
+                if (amount > 200) {
+                    J.s(() -> revert(blocks), 1);
+                }
             }
-        }
+        });
     }
-}
+}

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

@@ -36,8 +36,8 @@ import java.util.stream.Collectors;
 public class PreservationSVC implements IrisService {
     private final List<Thread> threads = new CopyOnWriteArrayList<>();
     private final List<ExecutorService> services = new CopyOnWriteArrayList<>();
-    private Looper dereferencer;
     private final List<MeteredCache> caches = new CopyOnWriteArrayList<>();
+    private Looper dereferencer;
 
     public void register(Thread t) {
         threads.add(t);
@@ -57,8 +57,8 @@ public class PreservationSVC implements IrisService {
         double p = 0;
         double mf = 0;
 
-        for(MeteredCache i : caches) {
-            if(i.isClosed()) {
+        for (MeteredCache i : caches) {
+            if (i.isClosed()) {
                 continue;
             }
 
@@ -100,22 +100,22 @@ public class PreservationSVC implements IrisService {
         dereference();
 
         postShutdown(() -> {
-            for(Thread i : threads) {
-                if(i.isAlive()) {
+            for (Thread i : threads) {
+                if (i.isAlive()) {
                     try {
                         i.interrupt();
                         Iris.info("Shutdown Thread " + i.getName());
-                    } catch(Throwable e) {
+                    } catch (Throwable e) {
                         Iris.reportError(e);
                     }
                 }
             }
 
-            for(ExecutorService i : services) {
+            for (ExecutorService i : services) {
                 try {
                     i.shutdownNow();
                     Iris.info("Shutdown Executor Service " + i);
-                } catch(Throwable e) {
+                } catch (Throwable e) {
                     Iris.reportError(e);
                 }
             }

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

@@ -57,11 +57,11 @@ public class StudioSVC implements IrisService {
 
     @Override
     public void onEnable() {
-        J.a(() -> {
+        J.s(() -> {
             String pack = IrisSettings.get().getGenerator().getDefaultWorldType();
             File f = IrisPack.packsPack(pack);
 
-            if(!f.exists()) {
+            if (!f.exists()) {
                 Iris.info("Downloading Default Pack " + pack);
                 downloadSearch(Iris.getSender(), pack, false);
             }
@@ -72,9 +72,9 @@ public class StudioSVC implements IrisService {
     public void onDisable() {
         Iris.debug("Studio Mode Active: Closing Projects");
 
-        for(World i : Bukkit.getWorlds()) {
-            if(IrisToolbelt.isIrisWorld(i)) {
-                if(IrisToolbelt.isStudio(i)) {
+        for (World i : Bukkit.getWorlds()) {
+            if (IrisToolbelt.isIrisWorld(i)) {
+                if (IrisToolbelt.isStudio(i)) {
                     IrisToolbelt.evacuate(i);
                     IrisToolbelt.access(i).close();
                 }
@@ -88,9 +88,9 @@ public class StudioSVC implements IrisService {
         File irispack = new File(folder, "iris/pack");
         IrisDimension dim = IrisData.loadAnyDimension(type);
 
-        if(dim == null) {
-            for(File i : getWorkspaceFolder().listFiles()) {
-                if(i.isFile() && i.getName().equals(type + ".iris")) {
+        if (dim == null) {
+            for (File i : getWorkspaceFolder().listFiles()) {
+                if (i.isFile() && i.getName().equals(type + ".iris")) {
                     sender.sendMessage("Found " + type + ".iris in " + WORKSPACE_NAME + " folder");
                     ZipUtil.unpack(i, irispack);
                     break;
@@ -102,29 +102,29 @@ public class StudioSVC implements IrisService {
 
             try {
                 FileUtils.copyDirectory(f, irispack);
-            } catch(IOException e) {
+            } catch (IOException e) {
                 Iris.reportError(e);
             }
         }
 
         File dimf = new File(irispack, "dimensions/" + type + ".json");
 
-        if(!dimf.exists() || !dimf.isFile()) {
+        if (!dimf.exists() || !dimf.isFile()) {
             downloadSearch(sender, type, false);
             File downloaded = getWorkspaceFolder(type);
 
-            for(File i : downloaded.listFiles()) {
-                if(i.isFile()) {
+            for (File i : downloaded.listFiles()) {
+                if (i.isFile()) {
                     try {
                         FileUtils.copyFile(i, new File(irispack, i.getName()));
-                    } catch(IOException e) {
+                    } catch (IOException e) {
                         e.printStackTrace();
                         Iris.reportError(e);
                     }
                 } else {
                     try {
                         FileUtils.copyDirectory(i, new File(irispack, i.getName()));
-                    } catch(IOException e) {
+                    } catch (IOException e) {
                         e.printStackTrace();
                         Iris.reportError(e);
                     }
@@ -134,7 +134,7 @@ public class StudioSVC implements IrisService {
             IO.delete(downloaded);
         }
 
-        if(!dimf.exists() || !dimf.isFile()) {
+        if (!dimf.exists() || !dimf.isFile()) {
             sender.sendMessage("Can't find the " + dimf.getName() + " in the dimensions folder of this pack! Failed!");
             return null;
         }
@@ -142,7 +142,7 @@ public class StudioSVC implements IrisService {
         IrisData dm = IrisData.get(irispack);
         dim = dm.getDimensionLoader().load(type);
 
-        if(dim == null) {
+        if (dim == null) {
             sender.sendMessage("Can't load the dimension! Failed!");
             return null;
         }
@@ -161,7 +161,7 @@ public class StudioSVC implements IrisService {
         try {
             url = getListing(false).get(key);
 
-            if(url == null) {
+            if (url == null) {
                 Iris.warn("ITS ULL for " + key);
             }
 
@@ -171,27 +171,37 @@ public class StudioSVC implements IrisService {
             String[] nodes = url.split("\\Q/\\E");
             String repo = nodes.length == 1 ? "IrisDimensions/" + nodes[0] : nodes[0] + "/" + nodes[1];
             branch = nodes.length > 2 ? nodes[2] : branch;
-            download(sender, repo, branch, trim, forceOverwrite);
-        } catch(Throwable e) {
+            download(sender, repo, branch, trim, forceOverwrite, false);
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
             sender.sendMessage("Failed to download '" + key + "' from " + url + ".");
         }
     }
 
-    public void download(VolmitSender sender, String repo, String branch, boolean trim) throws JsonSyntaxException, IOException {
-        download(sender, repo, branch, trim, false);
+    public void downloadRelease(VolmitSender sender, String url, boolean trim, boolean forceOverwrite) {
+        try {
+            download(sender, "IrisDimensions", url, trim, forceOverwrite, true);
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+            sender.sendMessage("Failed to download 'IrisDimensions/overworld' from " + url + ".");
+        }
     }
 
-    public void download(VolmitSender sender, String repo, String branch, boolean trim, boolean forceOverwrite) throws JsonSyntaxException, IOException {
-        String url = "https://codeload.github.com/" + repo + "/zip/refs/heads/" + branch;
+    public void download(VolmitSender sender, String repo, String branch, boolean trim) throws JsonSyntaxException, IOException {
+        download(sender, repo, branch, trim, false, false);
+    }
+
+    public void download(VolmitSender sender, String repo, String branch, boolean trim, boolean forceOverwrite, boolean directUrl) throws JsonSyntaxException, IOException {
+        String url = directUrl ? branch : "https://codeload.github.com/" + repo + "/zip/refs/heads/" + branch;
         sender.sendMessage("Downloading " + url + " "); //The extra space stops a bug in adventure API from repeating the last letter of the URL
         File zip = Iris.getNonCachedFile("pack-" + trim + "-" + repo, url);
         File temp = Iris.getTemp();
         File work = new File(temp, "dl-" + UUID.randomUUID());
         File packs = getWorkspaceFolder();
 
-        if(zip == null || !zip.exists()) {
+        if (zip == null || !zip.exists()) {
             sender.sendMessage("Failed to find pack at " + url);
             sender.sendMessage("Make sure you specified the correct repo and branch!");
             sender.sendMessage("For example: /iris download IrisDimensions/overworld branch=master");
@@ -200,58 +210,58 @@ public class StudioSVC implements IrisService {
         sender.sendMessage("Unpacking " + repo);
         try {
             ZipUtil.unpack(zip, work);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             e.printStackTrace();
             sender.sendMessage(
-                """
-                    Issue when unpacking. Please check/do the following:
-                    1. Do you have a functioning internet connection?
-                    2. Did the download corrupt?
-                    3. Try deleting the */plugins/iris/packs folder and re-download.
-                    4. Download the pack from the GitHub repo: https://github.com/IrisDimensions/overworld
-                    5. Contact support (if all other options do not help)"""
+                    """
+                            Issue when unpacking. Please check/do the following:
+                            1. Do you have a functioning internet connection?
+                            2. Did the download corrupt?
+                            3. Try deleting the */plugins/iris/packs folder and re-download.
+                            4. Download the pack from the GitHub repo: https://github.com/IrisDimensions/overworld
+                            5. Contact support (if all other options do not help)"""
             );
         }
         File dir = null;
         File[] zipFiles = work.listFiles();
 
-        if(zipFiles == null) {
+        if (zipFiles == null) {
             sender.sendMessage("No files were extracted from the zip file.");
             return;
         }
 
         try {
             dir = zipFiles.length == 1 && zipFiles[0].isDirectory() ? zipFiles[0] : null;
-        } catch(NullPointerException e) {
+        } catch (NullPointerException e) {
             Iris.reportError(e);
             sender.sendMessage("Error when finding home directory. Are there any non-text characters in the file name?");
             return;
         }
 
-        if(dir == null) {
+        if (dir == null) {
             sender.sendMessage("Invalid Format. Missing root folder or too many folders!");
             return;
         }
 
         File dimensions = new File(dir, "dimensions");
 
-        if(!(dimensions.exists() && dimensions.isDirectory())) {
+        if (!(dimensions.exists() && dimensions.isDirectory())) {
             sender.sendMessage("Invalid Format. Missing dimensions folder");
             return;
         }
 
-        if(dimensions.listFiles() == null) {
+        if (dimensions.listFiles() == null) {
             sender.sendMessage("No dimension file found in the extracted zip file.");
             sender.sendMessage("Check it is there on GitHub and report this to staff!");
-        } else if(dimensions.listFiles().length != 1) {
+        } else if (dimensions.listFiles().length != 1) {
             sender.sendMessage("Dimensions folder must have 1 file in it");
             return;
         }
 
         File dim = dimensions.listFiles()[0];
 
-        if(!dim.isFile()) {
+        if (!dim.isFile()) {
             sender.sendMessage("Invalid dimension (folder) in dimensions folder");
             return;
         }
@@ -261,23 +271,23 @@ public class StudioSVC implements IrisService {
         sender.sendMessage("Importing " + d.getName() + " (" + key + ")");
         File packEntry = new File(packs, key);
 
-        if(forceOverwrite) {
+        if (forceOverwrite) {
             IO.delete(packEntry);
         }
 
-        if(IrisData.loadAnyDimension(key) != null) {
+        if (IrisData.loadAnyDimension(key) != null) {
             sender.sendMessage("Another dimension in the packs folder is already using the key " + key + " IMPORT FAILED!");
             return;
         }
 
-        if(packEntry.exists() && packEntry.listFiles().length > 0) {
+        if (packEntry.exists() && packEntry.listFiles().length > 0) {
             sender.sendMessage("Another pack is using the key " + key + ". IMPORT FAILED!");
             return;
         }
 
         FileUtils.copyDirectory(dir, packEntry);
 
-        if(trim) {
+        if (trim) {
             sender.sendMessage("Trimming " + key);
             File cp = compilePackage(sender, key, false, false);
             IO.delete(packEntry);
@@ -292,7 +302,7 @@ public class StudioSVC implements IrisService {
     public KMap<String, String> getListing(boolean cached) {
         JSONObject a;
 
-        if(cached) {
+        if (cached) {
             a = new JSONObject(Iris.getCached("cachedlisting", LISTING));
         } else {
             a = new JSONObject(Iris.getNonCached(true + "listing", LISTING));
@@ -300,8 +310,8 @@ public class StudioSVC implements IrisService {
 
         KMap<String, String> l = new KMap<>();
 
-        for(String i : a.keySet()) {
-            if(a.get(i) instanceof String)
+        for (String i : a.keySet()) {
+            if (a.get(i) instanceof String)
                 l.put(i, a.getString(i));
         }
 
@@ -315,7 +325,6 @@ public class StudioSVC implements IrisService {
         return activeProject != null && activeProject.isOpen();
     }
 
-
     public void open(VolmitSender sender, String dimm) {
         open(sender, 1337, dimm);
     }
@@ -324,7 +333,7 @@ public class StudioSVC implements IrisService {
         try {
             open(sender, seed, dimm, (w) -> {
             });
-        } catch(Exception e) {
+        } catch (Exception e) {
             Iris.reportError(e);
             sender.sendMessage("Error when creating studio world:");
             e.printStackTrace();
@@ -332,7 +341,7 @@ public class StudioSVC implements IrisService {
     }
 
     public void open(VolmitSender sender, long seed, String dimm, Consumer<World> onDone) throws IrisException {
-        if(isProjectOpen()) {
+        if (isProjectOpen()) {
             close();
         }
 
@@ -354,7 +363,7 @@ public class StudioSVC implements IrisService {
     }
 
     public void close() {
-        if(isProjectOpen()) {
+        if (isProjectOpen()) {
             Iris.debug("Closing Active Project");
             activeProject.close();
             activeProject = null;
@@ -369,14 +378,14 @@ public class StudioSVC implements IrisService {
         File importPack = getWorkspaceFolder(existingPack);
         File newPack = getWorkspaceFolder(newName);
 
-        if(importPack.listFiles().length == 0) {
+        if (importPack.listFiles().length == 0) {
             Iris.warn("Couldn't find the pack to create a new dimension from.");
             return;
         }
 
         try {
             FileUtils.copyDirectory(importPack, newPack, pathname -> !pathname.getAbsolutePath().contains(".git"), false);
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -387,7 +396,7 @@ public class StudioSVC implements IrisService {
 
         try {
             FileUtils.copyFile(dimFile, newDimFile);
-        } catch(IOException e) {
+        } catch (IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -397,11 +406,11 @@ public class StudioSVC implements IrisService {
         try {
             JSONObject json = new JSONObject(IO.readAll(newDimFile));
 
-            if(json.has("name")) {
+            if (json.has("name")) {
                 json.put("name", Form.capitalizeWords(newName.replaceAll("\\Q-\\E", " ")));
                 IO.writeAll(newDimFile, json.toString(4));
             }
-        } catch(JSONException | IOException e) {
+        } catch (JSONException | IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -410,7 +419,7 @@ public class StudioSVC implements IrisService {
             IrisProject p = new IrisProject(getWorkspaceFolder(newName));
             JSONObject ws = p.createCodeWorkspaceConfig();
             IO.writeAll(getWorkspaceFile(newName, newName + ".code-workspace"), ws.toString(0));
-        } catch(JSONException | IOException e) {
+        } catch (JSONException | IOException e) {
             Iris.reportError(e);
             e.printStackTrace();
         }
@@ -420,29 +429,29 @@ public class StudioSVC implements IrisService {
         boolean shouldDelete = false;
         File importPack = getWorkspaceFolder(downloadable);
 
-        if(importPack.listFiles().length == 0) {
+        if (importPack.listFiles().length == 0) {
             downloadSearch(sender, downloadable, false);
 
-            if(importPack.listFiles().length > 0) {
+            if (importPack.listFiles().length > 0) {
                 shouldDelete = true;
             }
         }
 
-        if(importPack.listFiles().length == 0) {
+        if (importPack.listFiles().length == 0) {
             sender.sendMessage("Couldn't find the pack to create a new dimension from.");
             return;
         }
 
         File importDimensionFile = new File(importPack, "dimensions/" + downloadable + ".json");
 
-        if(!importDimensionFile.exists()) {
+        if (!importDimensionFile.exists()) {
             sender.sendMessage("Missing Imported Dimension File");
             return;
         }
 
         sender.sendMessage("Importing " + downloadable + " into new Project " + s);
         createFrom(downloadable, s);
-        if(shouldDelete) {
+        if (shouldDelete) {
             importPack.delete();
         }
         open(sender, s);
@@ -457,7 +466,7 @@ public class StudioSVC implements IrisService {
     }
 
     public void updateWorkspace() {
-        if(isProjectOpen()) {
+        if (isProjectOpen()) {
             activeProject.updateWorkspace();
         }
     }

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

@@ -22,15 +22,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IObjectPlacer;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisObjectPlacement;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisTreeModes;
-import com.volmit.iris.engine.object.IrisTreeSize;
-import com.volmit.iris.engine.object.TileData;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
@@ -39,12 +31,7 @@ import com.volmit.iris.util.math.BlockPosition;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.scheduling.J;
-import org.bukkit.Bukkit;
-import org.bukkit.HeightMap;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.TreeType;
-import org.bukkit.World;
+import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.TileState;
@@ -79,23 +66,22 @@ public class TreeSVC implements IrisService {
      * <br>4. Check biome, region and dimension for overrides for that sapling type -> Found -> use</br>
      * <br>5. Exit if none are found, cancel event if one or more are.</br>
      *
-     * @param event
-     *     Checks the given event for sapling overrides
+     * @param event Checks the given event for sapling overrides
      */
     @EventHandler(priority = EventPriority.HIGHEST)
     public void on(StructureGrowEvent event) {
-        if(block || event.isCancelled()) {
+        if (block || event.isCancelled()) {
             return;
         }
         Iris.debug(this.getClass().getName() + " received a structure grow event");
 
-        if(!IrisToolbelt.isIrisWorld(event.getWorld())) {
+        if (!IrisToolbelt.isIrisWorld(event.getWorld())) {
             Iris.debug(this.getClass().getName() + " passed grow event off to vanilla since not an Iris world");
             return;
         }
 
         PlatformChunkGenerator worldAccess = IrisToolbelt.access(event.getWorld());
-        if(worldAccess == null) {
+        if (worldAccess == null) {
             Iris.debug(this.getClass().getName() + " passed it off to vanilla because could not get IrisAccess for this world");
             Iris.reportError(new NullPointerException(event.getWorld().getName() + " could not be accessed despite being an Iris world"));
             return;
@@ -103,7 +89,7 @@ public class TreeSVC implements IrisService {
 
         Engine engine = worldAccess.getEngine();
 
-        if(engine == null) {
+        if (engine == null) {
             Iris.debug(this.getClass().getName() + " passed it off to vanilla because could not get Engine for this world");
             Iris.reportError(new NullPointerException(event.getWorld().getName() + " could not be accessed despite being an Iris world"));
             return;
@@ -111,13 +97,13 @@ public class TreeSVC implements IrisService {
 
         IrisDimension dimension = engine.getDimension();
 
-        if(dimension == null) {
+        if (dimension == null) {
             Iris.debug(this.getClass().getName() + " passed it off to vanilla because could not get Dimension for this world");
             Iris.reportError(new NullPointerException(event.getWorld().getName() + " could not be accessed despite being an Iris world"));
             return;
         }
 
-        if(!dimension.getTreeSettings().isEnabled()) {
+        if (!dimension.getTreeSettings().isEnabled()) {
             Iris.debug(this.getClass().getName() + " cancelled because tree overrides are disabled");
             return;
         }
@@ -129,7 +115,7 @@ public class TreeSVC implements IrisService {
         Iris.debug("Sapling plane is: " + saplingPlane.getSizeX() + " by " + saplingPlane.getSizeZ());
         IrisObjectPlacement placement = getObjectPlacement(worldAccess, event.getLocation(), event.getSpecies(), new IrisTreeSize(1, 1));
 
-        if(placement == null) {
+        if (placement == null) {
             Iris.debug(this.getClass().getName() + " had options but did not manage to find objectPlacements for them");
             return;
         }
@@ -208,13 +194,13 @@ public class TreeSVC implements IrisService {
         };
 
         object.place(
-            saplingPlane.getCenter().getBlockX(),
-            (saplingPlane.getCenter().getBlockY() + object.getH() / 2),
-            saplingPlane.getCenter().getBlockZ(),
-            placer,
-            placement,
-            RNG.r,
-            Objects.requireNonNull(worldAccess).getData()
+                saplingPlane.getCenter().getBlockX(),
+                (saplingPlane.getCenter().getBlockY() + object.getH() / 2),
+                saplingPlane.getCenter().getBlockZ(),
+                placer,
+                placement,
+                RNG.r,
+                Objects.requireNonNull(worldAccess).getData()
         );
 
         event.setCancelled(true);
@@ -226,11 +212,11 @@ public class TreeSVC implements IrisService {
             Bukkit.getServer().getPluginManager().callEvent(iGrow);
             block = false;
 
-            if(!iGrow.isCancelled()) {
-                for(BlockState block : iGrow.getBlocks()) {
+            if (!iGrow.isCancelled()) {
+                for (BlockState block : iGrow.getBlocks()) {
                     Location l = block.getLocation();
 
-                    if(dataCache.containsKey(l)) {
+                    if (dataCache.containsKey(l)) {
                         l.getBlock().setBlockData(dataCache.get(l), false);
                     }
                 }
@@ -242,14 +228,10 @@ public class TreeSVC implements IrisService {
      * Finds a single object placement (which may contain more than one object) for the requirements species, location &
      * size
      *
-     * @param worldAccess
-     *     The world to access (check for biome, region, dimension, etc)
-     * @param location
-     *     The location of the growth event (For biome/region finding)
-     * @param type
-     *     The bukkit TreeType to match
-     * @param size
-     *     The size of the sapling area
+     * @param worldAccess The world to access (check for biome, region, dimension, etc)
+     * @param location    The location of the growth event (For biome/region finding)
+     * @param type        The bukkit TreeType to match
+     * @param size        The size of the sapling area
      * @return An object placement which contains the matched tree, or null if none were found / it's disabled.
      */
     private IrisObjectPlacement getObjectPlacement(PlatformChunkGenerator worldAccess, Location location, TreeType type, IrisTreeSize size) {
@@ -262,7 +244,7 @@ public class TreeSVC implements IrisService {
         placements.addAll(matchObjectPlacements(biome.getObjects(), size, type));
 
         // Add more or find any in the region
-        if(isUseAll || placements.isEmpty()) {
+        if (isUseAll || placements.isEmpty()) {
             IrisRegion region = worldAccess.getEngine().getRegion(location.getBlockX(), location.getBlockZ());
             placements.addAll(matchObjectPlacements(region.getObjects(), size, type));
         }
@@ -274,20 +256,17 @@ public class TreeSVC implements IrisService {
     /**
      * Filters out mismatches and returns matches
      *
-     * @param objects
-     *     The object placements to check
-     * @param size
-     *     The size of the sapling area to filter with
-     * @param type
-     *     The type of the tree to filter with
+     * @param objects The object placements to check
+     * @param size    The size of the sapling area to filter with
+     * @param type    The type of the tree to filter with
      * @return A list of objectPlacements that matched. May be empty.
      */
     private KList<IrisObjectPlacement> matchObjectPlacements(KList<IrisObjectPlacement> objects, IrisTreeSize size, TreeType type) {
 
         KList<IrisObjectPlacement> p = new KList<>();
 
-        for(IrisObjectPlacement i : objects) {
-            if(i.matches(size, type)) {
+        for (IrisObjectPlacement i : objects) {
+            if (i.matches(size, type)) {
                 p.add(i);
             }
         }
@@ -298,12 +277,9 @@ public class TreeSVC implements IrisService {
     /**
      * Get the Cuboid of sapling sizes at a location & blockData predicate
      *
-     * @param at
-     *     this location
-     * @param valid
-     *     with this blockData predicate
-     * @param world
-     *     the world to check in
+     * @param at    this location
+     * @param valid with this blockData predicate
+     * @param world the world to check in
      * @return A cuboid containing only saplings
      */
     public Cuboid getSaplings(Location at, Predicate<BlockData> valid, World world) {
@@ -313,7 +289,7 @@ public class TreeSVC implements IrisService {
         BlockPosition b = new BlockPosition(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);
 
         // Maximise the block position in x and z to get max cuboid bounds
-        for(BlockPosition blockPosition : blockPositions) {
+        for (BlockPosition blockPosition : blockPositions) {
             a.max(blockPosition);
             b.min(blockPosition);
         }
@@ -326,12 +302,12 @@ public class TreeSVC implements IrisService {
         boolean cuboidIsValid = true;
 
         // Loop while the cuboid is larger than 2
-        while(Math.min(cuboid.getSizeX(), cuboid.getSizeZ()) > 0) {
+        while (Math.min(cuboid.getSizeX(), cuboid.getSizeZ()) > 0) {
             checking:
-            for(int i = cuboid.getLowerX(); i < cuboid.getUpperX(); i++) {
-                for(int j = cuboid.getLowerY(); j < cuboid.getUpperY(); j++) {
-                    for(int k = cuboid.getLowerZ(); k < cuboid.getUpperZ(); k++) {
-                        if(!blockPositions.contains(new BlockPosition(i, j, k))) {
+            for (int i = cuboid.getLowerX(); i < cuboid.getUpperX(); i++) {
+                for (int j = cuboid.getLowerY(); j < cuboid.getUpperY(); j++) {
+                    for (int k = cuboid.getLowerZ(); k < cuboid.getUpperZ(); k++) {
+                        if (!blockPositions.contains(new BlockPosition(i, j, k))) {
                             cuboidIsValid = false;
                             break checking;
                         }
@@ -340,7 +316,7 @@ public class TreeSVC implements IrisService {
             }
 
             // Return this cuboid if it's valid
-            if(cuboidIsValid) {
+            if (cuboidIsValid) {
                 return cuboid;
             }
 
@@ -355,18 +331,14 @@ public class TreeSVC implements IrisService {
     /**
      * Grows the blockPosition list by means of checking neighbours in
      *
-     * @param world
-     *     the world to check in
-     * @param center
-     *     the location of this position
-     * @param valid
-     *     validation on blockData to check block with
-     * @param l
-     *     list of block positions to add new neighbors too
+     * @param world  the world to check in
+     * @param center the location of this position
+     * @param valid  validation on blockData to check block with
+     * @param l      list of block positions to add new neighbors too
      */
     private void grow(World world, BlockPosition center, Predicate<BlockData> valid, KList<BlockPosition> l) {
         // Make sure size is less than 50, the block to check isn't already in, and make sure the blockData still matches
-        if(l.size() <= 50 && !l.contains(center) && valid.test(center.toBlock(world).getBlockData())) {
+        if (l.size() <= 50 && !l.contains(center) && valid.test(center.toBlock(world).getBlockData())) {
             l.add(center);
             grow(world, center.add(1, 0, 0), valid, l);
             grow(world, center.add(-1, 0, 0), valid, l);

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

@@ -19,19 +19,16 @@
 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.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisVillagerOverride;
-import com.volmit.iris.engine.object.IrisVillagerTrade;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.plugin.VolmitSender;
 import org.bukkit.Location;
-import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.Villager;
 import org.bukkit.event.EventHandler;
-import org.bukkit.event.entity.VillagerAcquireTradeEvent;
 import org.bukkit.event.entity.VillagerCareerChangeEvent;
 
 import java.util.List;
@@ -74,7 +71,7 @@ public class VillageSVC implements IrisService {
 
             List<Player> playersInWorld = event.getEntity().getWorld().getPlayers();
 
-            String message = C.GOLD + "Iris does not allow cartographers in its world due to crashes.";
+            String message = C.GOLD + IrisSettings.get().getGeneral().cartographerMessage;
 
             Iris.info("Cancelled Cartographer Villager to prevent server crash at " + eventLocation + "!");
 

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

@@ -19,7 +19,9 @@
 package com.volmit.iris.core.service;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.edit.DustRevealer;
+import com.volmit.iris.core.link.WorldEditLink;
 import com.volmit.iris.core.wand.WandSelection;
 import com.volmit.iris.engine.object.IrisObject;
 import com.volmit.iris.util.collection.KList;
@@ -31,17 +33,14 @@ import com.volmit.iris.util.matter.WorldMatter;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Particle;
-import org.bukkit.Sound;
+import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.block.Action;
 import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.inventory.EquipmentSlot;
 import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemFlag;
 import org.bukkit.inventory.ItemStack;
@@ -55,6 +54,7 @@ import java.util.Objects;
 
 public class WandSVC implements IrisService {
     private static ItemStack dust;
+    private static ItemStack wand;
 
     public static void pasteSchematic(IrisObject s, Location at) {
         s.place(at);
@@ -63,21 +63,20 @@ public class WandSVC implements IrisService {
     /**
      * Creates an Iris Object from the 2 coordinates selected with a wand
      *
-     * @param wand
-     *     The wand itemstack
+     * @param p The wand player
      * @return The new object
      */
-    public static IrisObject createSchematic(ItemStack wand) {
-        if(!isWand(wand)) {
+    public static IrisObject createSchematic(Player p) {
+        if (!isHoldingWand(p)) {
             return null;
         }
 
         try {
-            Location[] f = getCuboid(wand);
+            Location[] f = getCuboid(p);
             Cuboid c = new Cuboid(f[0], f[1]);
             IrisObject s = new IrisObject(c.getSizeX(), c.getSizeY(), c.getSizeZ());
-            for(Block b : c) {
-                if(b.getType().equals(Material.AIR)) {
+            for (Block b : c) {
+                if (b.getType().equals(Material.AIR)) {
                     continue;
                 }
 
@@ -86,7 +85,7 @@ public class WandSVC implements IrisService {
             }
 
             return s;
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
             Iris.reportError(e);
         }
@@ -97,20 +96,18 @@ public class WandSVC implements IrisService {
     /**
      * Creates an Iris Object from the 2 coordinates selected with a wand
      *
-     * @param wand
-     *     The wand itemstack
      * @return The new object
      */
-    public static Matter createMatterSchem(Player p, ItemStack wand) {
-        if(!isWand(wand)) {
+    public static Matter createMatterSchem(Player p) {
+        if (!isHoldingWand(p)) {
             return null;
         }
 
         try {
-            Location[] f = getCuboid(wand);
+            Location[] f = getCuboid(p);
 
             return WorldMatter.createMatter(p.getName(), f[0], f[1]);
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
             Iris.reportError(e);
         }
@@ -121,8 +118,7 @@ public class WandSVC implements IrisService {
     /**
      * Converts a user friendly location string to an actual Location
      *
-     * @param s
-     *     The string
+     * @param s The string
      * @return The location
      */
     public static Location stringToLocation(String s) {
@@ -130,7 +126,7 @@ public class WandSVC implements IrisService {
             String[] f = s.split("\\Q in \\E");
             String[] g = f[0].split("\\Q,\\E");
             return new Location(Bukkit.getWorld(f[1]), Integer.parseInt(g[0]), Integer.parseInt(g[1]), Integer.parseInt(g[2]));
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             Iris.reportError(e);
             return null;
         }
@@ -139,12 +135,11 @@ public class WandSVC implements IrisService {
     /**
      * Get a user friendly string of a location
      *
-     * @param loc
-     *     The location
+     * @param loc The location
      * @return The string
      */
     public static String locationToString(Location loc) {
-        if(loc == null) {
+        if (loc == null) {
             return "<#>";
         }
 
@@ -181,8 +176,7 @@ public class WandSVC implements IrisService {
     /**
      * Finds an existing wand in a users inventory
      *
-     * @param inventory
-     *     The inventory to search
+     * @param inventory The inventory to search
      * @return The slot number the wand is in. Or -1 if none are found
      */
     public static int findWand(Inventory inventory) {
@@ -191,14 +185,14 @@ public class WandSVC implements IrisService {
         meta.setLore(new ArrayList<>()); //We are resetting the lore as the lore differs between wands
         wand.setItemMeta(meta);
 
-        for(int s = 0; s < inventory.getSize(); s++) {
+        for (int s = 0; s < inventory.getSize(); s++) {
             ItemStack stack = inventory.getItem(s);
-            if(stack == null) continue;
+            if (stack == null) continue;
             meta = stack.getItemMeta();
             meta.setLore(new ArrayList<>()); //Reset the lore on this too so we can compare them
             stack.setItemMeta(meta);         //We dont need to clone the item as items from .get are cloned
 
-            if(wand.isSimilar(stack)) return s; //If the name, material and NBT is the same
+            if (wand.isSimilar(stack)) return s; //If the name, material and NBT is the same
         }
         return -1;
     }
@@ -206,10 +200,8 @@ public class WandSVC implements IrisService {
     /**
      * Creates an Iris wand. The locations should be the currently selected locations, or null
      *
-     * @param a
-     *     Location A
-     * @param b
-     *     Location B
+     * @param a Location A
+     * @param b Location B
      * @return A new wand
      */
     public static ItemStack createWand(Location a, Location b) {
@@ -225,26 +217,32 @@ public class WandSVC implements IrisService {
         return is;
     }
 
-    /**
-     * Get a pair of locations that are selected in an Iris wand
-     *
-     * @param is
-     *     The wand item
-     * @return An array with the 2 locations
-     */
-    public static Location[] getCuboid(ItemStack is) {
+    public static Location[] getCuboidFromItem(ItemStack is) {
         ItemMeta im = is.getItemMeta();
-        return new Location[] {stringToLocation(im.getLore().get(0)), stringToLocation(im.getLore().get(1))};
+        return new Location[]{stringToLocation(im.getLore().get(0)), stringToLocation(im.getLore().get(1))};
+    }
+
+    public static Location[] getCuboid(Player p) {
+        if (isHoldingIrisWand(p)) {
+            return getCuboidFromItem(p.getInventory().getItemInMainHand());
+        }
+
+        if (IrisSettings.get().getWorld().worldEditWandCUI) {
+            Cuboid c = WorldEditLink.getSelection(p);
+
+            if (c != null) {
+                return new Location[]{c.getLowerNE(), c.getUpperSW()};
+            }
+        }
+
+        return null;
     }
 
-    /**
-     * Is a player holding an Iris wand
-     *
-     * @param p
-     *     The player
-     * @return True if they are
-     */
     public static boolean isHoldingWand(Player p) {
+        return isHoldingIrisWand(p) || (IrisSettings.get().getWorld().worldEditWandCUI && WorldEditLink.getSelection(p) != null);
+    }
+
+    public static boolean isHoldingIrisWand(Player p) {
         ItemStack is = p.getInventory().getItemInMainHand();
         return is != null && isWand(is);
     }
@@ -252,26 +250,24 @@ public class WandSVC implements IrisService {
     /**
      * Is the itemstack passed an Iris wand
      *
-     * @param is
-     *     The itemstack
+     * @param is The itemstack
      * @return True if it is
      */
     public static boolean isWand(ItemStack is) {
-        ItemStack wand = createWand();
-        if(is.getItemMeta() == null) return false;
+        if (is.getItemMeta() == null) return false;
         return is.getType().equals(wand.getType()) &&
-            is.getItemMeta().getDisplayName().equals(wand.getItemMeta().getDisplayName()) &&
-            is.getItemMeta().getEnchants().equals(wand.getItemMeta().getEnchants()) &&
-            is.getItemMeta().getItemFlags().equals(wand.getItemMeta().getItemFlags());
+                is.getItemMeta().getDisplayName().equals(wand.getItemMeta().getDisplayName()) &&
+                is.getItemMeta().getEnchants().equals(wand.getItemMeta().getEnchants()) &&
+                is.getItemMeta().getItemFlags().equals(wand.getItemMeta().getItemFlags());
     }
 
     @Override
     public void onEnable() {
-        ItemStack wand = createWand();
+        wand = createWand();
         dust = createDust();
 
         J.ar(() -> {
-            for(Player i : Bukkit.getOnlinePlayers()) {
+            for (Player i : Bukkit.getOnlinePlayers()) {
                 tick(i);
             }
         }, 0);
@@ -285,14 +281,14 @@ public class WandSVC implements IrisService {
     public void tick(Player p) {
         try {
             try {
-                if(isWand(p.getInventory().getItemInMainHand())) {
-                    Location[] d = getCuboid(p.getInventory().getItemInMainHand());
+                if ((IrisSettings.get().getWorld().worldEditWandCUI && isHoldingWand(p)) || isWand(p.getInventory().getItemInMainHand())) {
+                    Location[] d = getCuboid(p);
                     new WandSelection(new Cuboid(d[0], d[1]), p).draw();
                 }
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 Iris.reportError(e);
             }
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
     }
@@ -300,22 +296,18 @@ public class WandSVC implements IrisService {
     /**
      * Draw the outline of a selected region
      *
-     * @param d
-     *     The cuboid
-     * @param p
-     *     The player to show it to
+     * @param d The cuboid
+     * @param p The player to show it to
      */
     public void draw(Cuboid d, Player p) {
-        draw(new Location[] {d.getLowerNE(), d.getUpperSW()}, p);
+        draw(new Location[]{d.getLowerNE(), d.getUpperSW()}, p);
     }
 
     /**
      * Draw the outline of a selected region
      *
-     * @param d
-     *     A pair of locations
-     * @param p
-     *     The player to show them to
+     * @param d A pair of locations
+     * @param p The player to show them to
      */
     public void draw(Location[] d, Player p) {
         Vector gx = Vector.getRandom().subtract(Vector.getRandom()).normalize().clone().multiply(0.65);
@@ -323,11 +315,11 @@ public class WandSVC implements IrisService {
         Vector gxx = Vector.getRandom().subtract(Vector.getRandom()).normalize().clone().multiply(0.65);
         d[1].getWorld().spawnParticle(Particle.CRIT, d[1], 1, 0.5 + gxx.getX(), 0.5 + gxx.getY(), 0.5 + gxx.getZ(), 0, null, false);
 
-        if(!d[0].getWorld().equals(d[1].getWorld())) {
+        if (!d[0].getWorld().equals(d[1].getWorld())) {
             return;
         }
 
-        if(d[0].distanceSquared(d[1]) > 64 * 64) {
+        if (d[0].distanceSquared(d[1]) > 64 * 64) {
             return;
         }
 
@@ -338,38 +330,38 @@ public class WandSVC implements IrisService {
         int maxy = Math.max(d[0].getBlockY(), d[1].getBlockY());
         int maxz = Math.max(d[0].getBlockZ(), d[1].getBlockZ());
 
-        for(double j = minx - 1; j < maxx + 1; j += 0.25) {
-            for(double k = miny - 1; k < maxy + 1; k += 0.25) {
-                for(double l = minz - 1; l < maxz + 1; l += 0.25) {
-                    if(M.r(0.2)) {
+        for (double j = minx - 1; j < maxx + 1; j += 0.25) {
+            for (double k = miny - 1; k < maxy + 1; k += 0.25) {
+                for (double l = minz - 1; l < maxz + 1; l += 0.25) {
+                    if (M.r(0.2)) {
                         boolean jj = j == minx || j == maxx;
                         boolean kk = k == miny || k == maxy;
                         boolean ll = l == minz || l == maxz;
 
-                        if((jj && kk) || (jj && ll) || (ll && kk)) {
+                        if ((jj && kk) || (jj && ll) || (ll && kk)) {
                             Vector push = new Vector(0, 0, 0);
 
-                            if(j == minx) {
+                            if (j == minx) {
                                 push.add(new Vector(-0.55, 0, 0));
                             }
 
-                            if(k == miny) {
+                            if (k == miny) {
                                 push.add(new Vector(0, -0.55, 0));
                             }
 
-                            if(l == minz) {
+                            if (l == minz) {
                                 push.add(new Vector(0, 0, -0.55));
                             }
 
-                            if(j == maxx) {
+                            if (j == maxx) {
                                 push.add(new Vector(0.55, 0, 0));
                             }
 
-                            if(k == maxy) {
+                            if (k == maxy) {
                                 push.add(new Vector(0, 0.55, 0));
                             }
 
-                            if(l == maxz) {
+                            if (l == maxz) {
                                 push.add(new Vector(0, 0, 0.55));
                             }
 
@@ -388,14 +380,16 @@ public class WandSVC implements IrisService {
 
     @EventHandler
     public void on(PlayerInteractEvent e) {
+        if (e.getHand() != EquipmentSlot.HAND)
+            return;
         try {
-            if(isHoldingWand(e.getPlayer())) {
-                if(e.getAction().equals(Action.LEFT_CLICK_BLOCK)) {
+            if (isHoldingWand(e.getPlayer())) {
+                if (e.getAction().equals(Action.LEFT_CLICK_BLOCK)) {
                     e.setCancelled(true);
                     e.getPlayer().getInventory().setItemInMainHand(update(true, Objects.requireNonNull(e.getClickedBlock()).getLocation(), e.getPlayer().getInventory().getItemInMainHand()));
                     e.getPlayer().playSound(e.getClickedBlock().getLocation(), Sound.BLOCK_END_PORTAL_FRAME_FILL, 1f, 0.67f);
                     e.getPlayer().updateInventory();
-                } else if(e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
+                } else if (e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
                     e.setCancelled(true);
                     e.getPlayer().getInventory().setItemInMainHand(update(false, Objects.requireNonNull(e.getClickedBlock()).getLocation(), e.getPlayer().getInventory().getItemInMainHand()));
                     e.getPlayer().playSound(e.getClickedBlock().getLocation(), Sound.BLOCK_END_PORTAL_FRAME_FILL, 1f, 1.17f);
@@ -403,15 +397,14 @@ public class WandSVC implements IrisService {
                 }
             }
 
-            if(isHoldingDust(e.getPlayer())) {
-                if(e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
+            if (isHoldingDust(e.getPlayer())) {
+                if (e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
                     e.setCancelled(true);
                     e.getPlayer().playSound(Objects.requireNonNull(e.getClickedBlock()).getLocation(), Sound.ENTITY_ENDER_EYE_DEATH, 2f, 1.97f);
                     DustRevealer.spawn(e.getClickedBlock(), new VolmitSender(e.getPlayer(), Iris.instance.getTag()));
-
                 }
             }
-        } catch(Throwable xx) {
+        } catch (Throwable xx) {
             Iris.reportError(xx);
         }
     }
@@ -419,8 +412,7 @@ public class WandSVC implements IrisService {
     /**
      * Is the player holding Dust?
      *
-     * @param p
-     *     The player
+     * @param p The player
      * @return True if they are
      */
     public boolean isHoldingDust(Player p) {
@@ -431,8 +423,7 @@ public class WandSVC implements IrisService {
     /**
      * Is the itemstack passed Iris dust?
      *
-     * @param is
-     *     The itemstack
+     * @param is The itemstack
      * @return True if it is
      */
     public boolean isDust(ItemStack is) {
@@ -442,23 +433,20 @@ public class WandSVC implements IrisService {
     /**
      * Update the location on an Iris wand
      *
-     * @param left
-     *     True for first location, false for second
-     * @param a
-     *     The location
-     * @param item
-     *     The wand
+     * @param left True for first location, false for second
+     * @param a    The location
+     * @param item The wand
      * @return The updated wand
      */
     public ItemStack update(boolean left, Location a, ItemStack item) {
-        if(!isWand(item)) {
+        if (!isWand(item)) {
             return item;
         }
 
-        Location[] f = getCuboid(item);
+        Location[] f = getCuboidFromItem(item);
         Location other = left ? f[1] : f[0];
 
-        if(other != null && !other.getWorld().getName().equals(a.getWorld().getName())) {
+        if (other != null && !other.getWorld().getName().equals(a.getWorld().getName())) {
             other = null;
         }
 

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

@@ -0,0 +1,626 @@
+package com.volmit.iris.core.tools;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.format.C;
+import oshi.SystemInfo;
+import oshi.hardware.CentralProcessor;
+import oshi.hardware.GlobalMemory;
+import oshi.hardware.HWDiskStore;
+import oshi.software.os.OperatingSystem;
+
+import java.io.*;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MemoryMXBean;
+import java.lang.management.MemoryUsage;
+import java.security.SecureRandom;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Base64;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.stream.IntStream;
+import java.util.zip.Deflater;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+
+import static com.google.common.math.LongMath.isPrime;
+import static com.volmit.iris.util.misc.getHardware.getCPUModel;
+import static com.volmit.iris.util.misc.getHardware.getDiskModel;
+public class IrisBenchmarking {
+    static String ServerOS;
+    static String filePath = "benchmark.dat";
+    static double avgWriteSpeedMBps;
+    static double avgReadSpeedMBps;
+    static double highestWriteSpeedMBps;
+    static double highestReadSpeedMBps;
+    static double lowestWriteSpeedMBps;
+    static double lowestReadSpeedMBps;
+    static double calculateIntegerMath;
+    static double calculateFloatingPoint;
+    static double calculatePrimeNumbers;
+    static double calculateStringSorting;
+    static double calculateDataEncryption;
+    static double calculateDataCompression;
+    static String currentRunning = "None";
+    static int BenchmarksCompleted = 0;
+    static int BenchmarksTotal = 7;
+    static int totalTasks = 10;
+    static int currentTasks = 0;
+    static double WindowsCPUCompression;
+    static double WindowsCPUEncryption;
+    static double WindowsCPUCSHA1;
+    static double elapsedTimeNs;
+    static boolean Winsat = false;
+    static boolean WindowsDiskSpeed = false;
+    public static boolean inProgress = false;
+    static double startTime;
+    // Good enough for now. . .
+
+    public static void runBenchmark() throws InterruptedException {
+        inProgress = true;
+        getServerOS();
+        deleteTestFile(filePath);
+        AtomicReference<Double> doneCalculateDiskSpeed = new AtomicReference<>((double) 0);
+        startBenchmarkTimer();
+        Iris.info("Benchmark Started!");
+        Iris.warn("Although it may seem momentarily paused, it's actively processing.");
+        BenchmarksCompleted = 0;
+
+        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+            currentRunning = "calculateDiskSpeed";
+            progressBar();
+            if (ServerOS.contains("Windows") && isRunningAsAdmin()) {
+                WindowsDiskSpeed = true;
+                WindowsDiskSpeedTest();
+            } else {
+                warningFallback();
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException e) {
+                    throw new RuntimeException(e);
+                }
+                doneCalculateDiskSpeed.set(roundToTwoDecimalPlaces(calculateDiskSpeed()));
+                BenchmarksCompleted++;
+            }
+
+
+        }).thenRun(() -> {
+            currentRunning = "WindowsCpuSpeedTest";
+            progressBar();
+            if (ServerOS.contains("Windows") && isRunningAsAdmin()) {
+                Winsat = true;
+                WindowsCpuSpeedTest();
+            } else {
+                Iris.info("Skipping:" + C.BLUE + " Windows System Assessment Tool Benchmarks");
+                if (!ServerOS.contains("Windows")) {
+                    Iris.info("Required Software:" + C.BLUE + " Windows");
+                    BenchmarksTotal = 6;
+                }
+                if (!isRunningAsAdmin()) {
+                    Iris.info(C.RED + "ERROR: " + C.DARK_RED + "Elevated privileges missing");
+                    BenchmarksTotal = 6;
+                }
+            }
+
+        }).thenRun(() -> {
+            currentRunning = "calculateIntegerMath";
+            progressBar();
+            calculateIntegerMath = roundToTwoDecimalPlaces(calculateIntegerMath());
+            BenchmarksCompleted++;
+        }).thenRun(() -> {
+            currentRunning = "calculateFloatingPoint";
+            progressBar();
+            calculateFloatingPoint = roundToTwoDecimalPlaces(calculateFloatingPoint());
+            BenchmarksCompleted++;
+        }).thenRun(() -> {
+            currentRunning = "calculateStringSorting";
+            progressBar();
+            calculateStringSorting = roundToTwoDecimalPlaces(calculateStringSorting());
+            BenchmarksCompleted++;
+        }).thenRun(() -> {
+            currentRunning = "calculatePrimeNumbers";
+            progressBar();
+            calculatePrimeNumbers = roundToTwoDecimalPlaces(calculatePrimeNumbers());
+            BenchmarksCompleted++;
+        }).thenRun(() -> {
+            currentRunning = "calculateDataEncryption";
+            progressBar();
+            calculateDataEncryption = roundToTwoDecimalPlaces(calculateDataEncryption());
+            BenchmarksCompleted++;
+        }).thenRun(() -> {
+            currentRunning = "calculateDataCompression";
+            progressBar();
+            calculateDataCompression = roundToTwoDecimalPlaces(calculateDataCompression());
+            BenchmarksCompleted++;
+        }).thenRun(() -> {
+            elapsedTimeNs = stopBenchmarkTimer();
+            results();
+            inProgress = false;
+        });
+
+        try {
+            future.get();
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void progressBar() {
+        Iris.info("-----------------------------------------------------");
+        Iris.info("Currently Running: " + C.BLUE + currentRunning);
+        // Iris.info("Tasks: " + "Current Tasks: " + C.BLUE + currentTasks + C.WHITE + " / " + "Total Tasks: " + C.BLUE + totalTasks);
+        Iris.info("Benchmarks Completed: " + C.BLUE + BenchmarksCompleted + C.WHITE + " / " + "Total: " + C.BLUE + BenchmarksTotal);
+        Iris.info("-----------------------------------------------------");
+    }
+
+    public static void results() {
+
+        SystemInfo systemInfo = new SystemInfo();
+        GlobalMemory globalMemory = systemInfo.getHardware().getMemory();
+        long totalMemoryMB = globalMemory.getTotal() / (1024 * 1024);
+        long availableMemoryMB = globalMemory.getAvailable() / (1024 * 1024);
+        long totalPageSize = globalMemory.getPageSize() / (1024 * 1024);
+        long usedMemoryMB = totalMemoryMB - availableMemoryMB;
+        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+
+        Iris.info("OS: " + ServerOS);
+        if (!isRunningAsAdmin() || !ServerOS.contains("Windows")) {
+            Iris.info(C.GOLD + "For the full results use Windows + Admin Rights..");
+        }
+        Iris.info("CPU Model: " + getCPUModel());
+        Iris.info("CPU Score: " + "WIP");
+        Iris.info("- Integer Math: " + calculateIntegerMath + " MOps/Sec");
+        Iris.info("- Floating Point Math: " + calculateFloatingPoint + " MOps/Sec");
+        Iris.info("- Find Prime Numbers: " + calculatePrimeNumbers + " Primes/Sec");
+        Iris.info("- Random String Sorting: " + calculateStringSorting + " Thousand Strings/Sec");
+        Iris.info("- Data Encryption: " + formatDouble(calculateDataEncryption) + " MBytes/Sec");
+        Iris.info("- Data Compression: " + formatDouble(calculateDataCompression) + " MBytes/Sec");
+
+        if (WindowsDiskSpeed) {
+            Iris.info("Disk Model: " + getDiskModel());
+            Iris.info(C.BLUE + "- Running with Windows System Assessment Tool");
+            Iris.info("- Sequential 64.0 Write: " + C.BLUE + formatDouble(avgWriteSpeedMBps) + " Mbps");
+            Iris.info("- Sequential 64.0 Read: " + C.BLUE + formatDouble(avgReadSpeedMBps) + " Mbps");
+        } else {
+            Iris.info("Disk Model: " + getDiskModel());
+            Iris.info(C.GREEN + "- Running in Native Mode");
+            Iris.info("- Average Write Speed: " + C.GREEN + formatDouble(avgWriteSpeedMBps) + " Mbps");
+            Iris.info("- Average Read Speed: " + C.GREEN + formatDouble(avgReadSpeedMBps) + " Mbps");
+            Iris.info("- Highest Write Speed: " + formatDouble(highestWriteSpeedMBps) + " Mbps");
+            Iris.info("- Highest Read Speed: " + formatDouble(highestReadSpeedMBps) + " Mbps");
+            Iris.info("- Lowest Write Speed: " + formatDouble(lowestWriteSpeedMBps) + " Mbps");
+            Iris.info("- Lowest Read Speed: " + formatDouble(lowestReadSpeedMBps) + " Mbps");
+        }
+        Iris.info("Ram Usage: ");
+        Iris.info("- Total Ram: " + totalMemoryMB + " MB");
+        Iris.info("- Used Ram: " + usedMemoryMB + " MB");
+        Iris.info("- Total Process Ram: " + C.BLUE + getMaxMemoryUsage() + " MB");
+        Iris.info("- Total Paging Size: " + totalPageSize + " MB");
+        if (Winsat) {
+            Iris.info(C.BLUE + "Windows System Assessment Tool: ");
+            Iris.info("- CPU LZW Compression:" + C.BLUE + formatDouble(WindowsCPUCompression) + " MB/s");
+            Iris.info("- CPU AES256 Encryption: " + C.BLUE + formatDouble(WindowsCPUEncryption) + " MB/s");
+            Iris.info("- CPU SHA1 Hash: " + C.BLUE + formatDouble(WindowsCPUCSHA1) + " MB/s");
+            Iris.info("Duration: " + roundToTwoDecimalPlaces(elapsedTimeNs) + " Seconds");
+        }
+
+    }
+
+    public static long getMaxMemoryUsage() {
+        MemoryMXBean memoryMXBean = ManagementFactory.getMemoryMXBean();
+        MemoryUsage heapMemoryUsage = memoryMXBean.getHeapMemoryUsage();
+        MemoryUsage nonHeapMemoryUsage = memoryMXBean.getNonHeapMemoryUsage();
+        long maxHeapMemory = heapMemoryUsage.getMax();
+        long maxNonHeapMemory = nonHeapMemoryUsage.getMax();
+        long maxMemoryUsageMB = (maxHeapMemory + maxNonHeapMemory) / (1024 * 1024);
+        return maxMemoryUsageMB;
+    }
+
+    public static void getServerOS() {
+        SystemInfo systemInfo = new SystemInfo();
+        OperatingSystem os = systemInfo.getOperatingSystem();
+        ServerOS = os.toString();
+    }
+
+    public static boolean isRunningAsAdmin() {
+        if (ServerOS.contains("Windows")) {
+            try {
+                Process process = Runtime.getRuntime().exec("winsat disk");
+                process.waitFor();
+                return process.exitValue() == 0;
+            } catch (IOException | InterruptedException e) {
+                // Hmm
+            }
+        }
+        return false;
+    }
+
+    public static void warningFallback() {
+        Iris.info(C.RED + "Using the " + C.DARK_RED + "FALLBACK" + C.RED + " method due to compatibility issues. ");
+        Iris.info(C.RED + "Please note that this may result in less accurate results.");
+    }
+
+    private static String formatDouble(double value) {
+        return String.format("%.2f", value);
+    }
+
+    private static void startBenchmarkTimer() {
+        startTime = System.nanoTime();
+    }
+
+    private static double stopBenchmarkTimer() {
+        long endTime = System.nanoTime();
+        return (endTime - startTime) / 1_000_000_000.0;
+    }
+
+    private static double calculateIntegerMath() {
+        final int numIterations = 1_000_000_000;
+        final int numRuns = 30;
+        double totalMopsPerSec = 0;
+
+        for (int run = 0; run < numRuns; run++) {
+            long startTime = System.nanoTime();
+            int result = 0;
+
+            for (int i = 0; i < numIterations; i++) {
+                result += i * 2;
+                result -= i / 2;
+                result ^= i;
+                result <<= 1;
+                result >>= 1;
+            }
+
+            long endTime = System.nanoTime();
+            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+            double mopsPerSec = (numIterations / elapsedSeconds) / 1_000_000.0;
+
+            totalMopsPerSec += mopsPerSec;
+        }
+
+        double averageMopsPerSec = totalMopsPerSec / numRuns;
+        return averageMopsPerSec;
+    }
+
+    private static double calculateFloatingPoint() {
+        long numIterations = 85_000_000;
+        int numRuns = 30;
+        double totalMopsPerSec = 0;
+        for (int run = 0; run < numRuns; run++) {
+            double result = 0;
+            long startTime = System.nanoTime();
+
+            for (int i = 0; i < numIterations; i++) {
+                result += Math.sqrt(i) * Math.sin(i) / (i + 1);
+            }
+
+            long endTime = System.nanoTime();
+            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+            double mopsPerSec = (numIterations / elapsedSeconds) / 1_000_000.0;
+
+            totalMopsPerSec += mopsPerSec;
+        }
+
+        double averageMopsPerSec = totalMopsPerSec / numRuns;
+        return averageMopsPerSec;
+    }
+
+    private static double calculatePrimeNumbers() {
+        int primeCount;
+        long numIterations = 1_000_000;
+        int numRuns = 30;
+        double totalMopsPerSec = 0;
+
+        for (int run = 0; run < numRuns; run++) {
+            primeCount = 0;
+            long startTime = System.nanoTime();
+
+            for (int num = 2; primeCount < numIterations; num++) {
+                if (isPrime(num)) {
+                    primeCount++;
+                }
+            }
+
+            long endTime = System.nanoTime();
+            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+            double mopsPerSec = (primeCount / elapsedSeconds) / 1_000_000.0;
+
+            totalMopsPerSec += mopsPerSec;
+        }
+
+        double averageMopsPerSec = totalMopsPerSec / numRuns;
+        return averageMopsPerSec;
+    }
+
+    private static double calculateStringSorting() {
+        int stringCount = 1_000_000;
+        int stringLength = 100;
+        int numRuns = 30;
+        double totalMopsPerSec = 0;
+
+        for (int run = 0; run < numRuns; run++) {
+            List<String> randomStrings = generateRandomStrings(stringCount, stringLength);
+            long startTime = System.nanoTime();
+            randomStrings.sort(String::compareTo);
+            long endTime = System.nanoTime();
+
+            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+            double mopsPerSec = (stringCount / elapsedSeconds) / 1_000.0;
+
+            totalMopsPerSec += mopsPerSec;
+        }
+
+        double averageMopsPerSec = totalMopsPerSec / numRuns;
+        return averageMopsPerSec;
+    }
+
+    public static double calculateDataEncryption() {
+        int dataSizeMB = 100;
+        byte[] dataToEncrypt = generateRandomData(dataSizeMB * 1024 * 1024);
+        int numRuns = 20;
+        double totalMBytesPerSec = 0;
+
+        for (int run = 0; run < numRuns; run++) {
+            long startTime = System.nanoTime();
+            byte[] encryptedData = performEncryption(dataToEncrypt, 1);
+
+            long endTime = System.nanoTime();
+            double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+            double mbytesPerSec = (dataToEncrypt.length / (1024 * 1024.0)) / elapsedSeconds;
+
+            totalMBytesPerSec += mbytesPerSec;
+        }
+
+        double averageMBytesPerSec = totalMBytesPerSec / numRuns;
+        return averageMBytesPerSec;
+    }
+
+    private static byte[] performEncryption(byte[] data, int numRuns) {
+        byte[] key = "MyEncryptionKey".getBytes();
+        byte[] result = Arrays.copyOf(data, data.length);
+        for (int run = 0; run < numRuns; run++) {
+            for (int i = 0; i < result.length; i++) {
+                result[i] ^= key[i % key.length];
+            }
+        }
+        return result;
+    }
+
+    public static double calculateDataCompression() {
+        int dataSizeMB = 500;
+        byte[] dataToCompress = generateRandomData(dataSizeMB * 1024 * 1024);
+        long startTime = System.nanoTime();
+        byte[] compressedData = performCompression(dataToCompress);
+        long endTime = System.nanoTime();
+
+        double elapsedSeconds = (endTime - startTime) / 1e9;
+        double mbytesPerSec = (compressedData.length / (1024.0 * 1024.0)) / elapsedSeconds;
+
+        return mbytesPerSec;
+    }
+
+    private static byte[] performCompression(byte[] data) {
+        Deflater deflater = new Deflater();
+        deflater.setInput(data);
+        deflater.finish();
+        ByteArrayOutputStream outputStream = new ByteArrayOutputStream(data.length);
+
+        byte[] buffer = new byte[1024];
+        while (!deflater.finished()) {
+            int count = deflater.deflate(buffer);
+            outputStream.write(buffer, 0, count);
+        }
+
+        deflater.end();
+        return outputStream.toByteArray();
+    }
+
+    private static List<String> generateRandomStrings(int count, int length) {
+        SecureRandom random = new SecureRandom();
+        List<String> randomStrings = new ArrayList<>();
+
+        IntStream.range(0, count).forEach(i -> {
+            byte[] bytes = new byte[length];
+            random.nextBytes(bytes);
+            randomStrings.add(Base64.getEncoder().encodeToString(bytes));
+        });
+        return randomStrings;
+    }
+
+    private static byte[] generateRandomData(int size) {
+        SecureRandom random = new SecureRandom();
+        byte[] data = new byte[size];
+        random.nextBytes(data);
+        return data;
+    }
+
+    private static double roundToTwoDecimalPlaces(double value) {
+        return Double.parseDouble(String.format("%.2f", value));
+    }
+
+    private static double calculateCPUScore(long elapsedTimeNs) {
+        return 1.0 / (elapsedTimeNs / 1_000_000.0);
+    }
+
+    public static double calculateDiskSpeed() {
+        int numRuns = 10;
+        int fileSizeMB = 1000;
+
+        double[] writeSpeeds = new double[numRuns];
+        double[] readSpeeds = new double[numRuns];
+
+        for (int run = 0; run < numRuns; run++) {
+            long writeStartTime = System.nanoTime();
+            deleteTestFile(filePath);
+            createTestFile(filePath, fileSizeMB);
+            long writeEndTime = System.nanoTime();
+
+            long readStartTime = System.nanoTime();
+            readTestFile(filePath);
+            long readEndTime = System.nanoTime();
+
+            double writeSpeed = calculateDiskSpeedMBps(fileSizeMB, writeStartTime, writeEndTime);
+            double readSpeed = calculateDiskSpeedMBps(fileSizeMB, readStartTime, readEndTime);
+
+            writeSpeeds[run] = writeSpeed;
+            readSpeeds[run] = readSpeed;
+
+            if (run == 0) {
+                lowestWriteSpeedMBps = writeSpeed;
+                highestWriteSpeedMBps = writeSpeed;
+                lowestReadSpeedMBps = readSpeed;
+                highestReadSpeedMBps = readSpeed;
+            } else {
+                if (writeSpeed < lowestWriteSpeedMBps) {
+                    lowestWriteSpeedMBps = writeSpeed;
+                }
+                if (writeSpeed > highestWriteSpeedMBps) {
+                    highestWriteSpeedMBps = writeSpeed;
+                }
+                if (readSpeed < lowestReadSpeedMBps) {
+                    lowestReadSpeedMBps = readSpeed;
+                }
+                if (readSpeed > highestReadSpeedMBps) {
+                    highestReadSpeedMBps = readSpeed;
+                }
+            }
+        }
+        avgWriteSpeedMBps = calculateAverage(writeSpeeds);
+        avgReadSpeedMBps = calculateAverage(readSpeeds);
+        return 2;
+    }
+
+    public static void createTestFile(String filePath, int fileSizeMB) {
+        try {
+            File file = new File(filePath);
+            byte[] data = new byte[1024 * 1024];
+            Arrays.fill(data, (byte) 0);
+            FileOutputStream fos = new FileOutputStream(file);
+            for (int i = 0; i < fileSizeMB; i++) {
+                fos.write(data);
+            }
+            fos.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void readTestFile(String filePath) {
+        try {
+            File file = new File(filePath);
+            FileInputStream fis = new FileInputStream(file);
+            byte[] buffer = new byte[1024];
+            while (fis.read(buffer) != -1) {
+            }
+            fis.close();
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static void deleteTestFile(String filePath) {
+        File file = new File(filePath);
+        file.delete();
+    }
+
+    public static double calculateDiskSpeedMBps(int fileSizeMB, long startTime, long endTime) {
+        double elapsedSeconds = (endTime - startTime) / 1_000_000_000.0;
+        double writeSpeed = (fileSizeMB / elapsedSeconds);
+        return writeSpeed;
+    }
+
+    public static double calculateAverage(double[] values) {
+        double sum = 0;
+        for (double value : values) {
+            sum += value;
+        }
+        return sum / values.length;
+    }
+
+    public static void WindowsDiskSpeedTest() {
+        try {
+            String command = "winsat disk";
+            Process process = Runtime.getRuntime().exec(command);
+            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
+            String line;
+
+            while ((line = reader.readLine()) != null) {
+                Iris.debug(line);
+
+                if (line.contains("Disk  Sequential 64.0 Read")) {
+                    avgReadSpeedMBps = extractSpeed(line);
+                } else if (line.contains("Disk  Sequential 64.0 Write")) {
+                    avgWriteSpeedMBps = extractSpeed(line);
+                }
+            }
+
+            process.waitFor();
+            process.destroy();
+
+            Iris.debug("Sequential Read Speed: " + avgReadSpeedMBps + " MB/s");
+            Iris.debug("Sequential Write Speed: " + avgWriteSpeedMBps + " MB/s");
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static double extractSpeed(String line) {
+        String[] tokens = line.split("\\s+");
+        for (int i = 0; i < tokens.length; i++) {
+            if (tokens[i].endsWith("MB/s") && i > 0) {
+                try {
+                    return Double.parseDouble(tokens[i - 1]);
+                } catch (NumberFormatException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return 0.0;
+    }
+
+    public static void WindowsCpuSpeedTest() {
+        try {
+            String command = "winsat cpuformal";
+            Process process = Runtime.getRuntime().exec(command);
+            BufferedReader reader = new BufferedReader(new InputStreamReader(process.getInputStream()));
+            String line;
+
+            while ((line = reader.readLine()) != null) {
+                Iris.debug(line);
+
+                if (line.contains("CPU AES256 Encryption")) {
+                    WindowsCPUEncryption = extractCpuInfo(line);
+                }
+                if (line.contains("CPU LZW Compression")) {
+                    WindowsCPUCompression = extractCpuInfo(line);
+                }
+                if (line.contains("CPU SHA1 Hash")) {
+                    WindowsCPUCSHA1 = extractCpuInfo(line);
+                }
+            }
+            process.waitFor();
+            process.destroy();
+
+            Iris.debug("Winsat Encryption: " + WindowsCPUEncryption + " MB/s");
+        } catch (IOException | InterruptedException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static double extractCpuInfo(String line) {
+        String[] tokens = line.split("\\s+");
+        for (int i = 0; i < tokens.length; i++) {
+            if (tokens[i].endsWith("MB/s") && i > 0) {
+                try {
+                    return Double.parseDouble(tokens[i - 1]);
+                } catch (NumberFormatException e) {
+                    e.printStackTrace();
+                }
+            }
+        }
+        return 0.0;
+    }
+
+}

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);
+    }
+}
+
+
+

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

@@ -21,10 +21,13 @@ package com.volmit.iris.core.tools;
 import com.google.common.util.concurrent.AtomicDouble;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import com.volmit.iris.core.safeguard.UtilsSFG;
 import com.volmit.iris.util.exceptions.IrisException;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
@@ -33,17 +36,17 @@ import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
 import lombok.Data;
 import lombok.experimental.Accessors;
-import org.bukkit.Bukkit;
-import org.bukkit.GameRule;
-import org.bukkit.Location;
-import org.bukkit.World;
-import org.bukkit.WorldCreator;
+import org.bukkit.*;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
 
 import java.io.File;
+import java.io.IOException;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
+import static com.volmit.iris.core.safeguard.IrisSafeguard.unstablemode;
 
 /**
  * Makes it a lot easier to setup an engine, world, studio or whatever
@@ -51,59 +54,89 @@ import java.util.function.Supplier;
 @Data
 @Accessors(fluent = true, chain = true)
 public class IrisCreator {
+    private static final File BUKKIT_YML = new File("bukkit.yml");
     /**
      * Specify an area to pregenerate during creation
      */
     private PregenTask pregen;
-
     /**
      * Specify a sender to get updates & progress info + tp when world is created.
      */
     private VolmitSender sender;
-
     /**
      * The seed to use for this generator
      */
     private long seed = 1337;
-
     /**
      * The dimension to use. This can be any online dimension, or a dimension in the
      * packs folder
      */
     private String dimension = IrisSettings.get().getGenerator().getDefaultWorldType();
-
     /**
      * The name of this world.
      */
     private String name = "irisworld";
-
     /**
      * Studio mode makes the engine hotloadable and uses the dimension in
      * your Iris/packs folder instead of copying the dimension files into
      * 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);
+        ConfigurationSection section = yml.getConfigurationSection("worlds");
+        if (section == null) {
+            return false;
+        }
+        section.set(name, null);
+        if (section.getValues(false).keySet().stream().noneMatch(k -> section.get(k) != null)) {
+            yml.set("worlds", null);
+        }
+        yml.save(BUKKIT_YML);
+        return true;
+    }
+    public static boolean worldLoaded(){
+        return true;
+    }
 
     /**
      * Create the IrisAccess (contains the world)
      *
      * @return the IrisAccess
-     * @throws IrisException
-     *     shit happens
+     * @throws IrisException shit happens
      */
+
     public World create() throws IrisException {
-        if(Bukkit.isPrimaryThread()) {
+        if (unstablemode){
+            Iris.info(C.RED + "Your server is experiencing an incompatibility with the Iris plugin. Please rectify this problem to avoid further complications.");
+            Iris.info(C.RED + "----------------------------------------------------------------");
+            Iris.info(C.RED + "Operation ran: Loading Iris World..");
+            UtilsSFG.printIncompatibleWarnings();
+            Iris.info(C.RED + "----------------------------------------------------------------");
+        }
+        if (Bukkit.isPrimaryThread()) {
             throw new IrisException("You cannot invoke create() on the main thread.");
         }
 
         IrisDimension d = IrisToolbelt.getDimension(dimension());
 
-        if(d == null) {
+        if (d == null) {
             throw new IrisException("Dimension cannot be found null for id " + dimension());
         }
 
-        if(!studio()) {
-            Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(name()));
+        if (sender == null)
+            sender = Iris.getSender();
+
+        if (!studio()) {
+            Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(Bukkit.getWorldContainer(), name()));
+        }
+        if (benchmark) {
+            Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(Bukkit.getWorldContainer(), name()));
         }
 
         PlatformChunkGenerator access = null;
@@ -112,11 +145,12 @@ public class IrisCreator {
         O<Boolean> done = new O<>();
         done.set(false);
         WorldCreator wc = new IrisWorldCreator()
-            .dimension(dimension)
-            .name(name)
-            .seed(seed)
-            .studio(studio)
-            .create();
+                .dimension(dimension)
+                .name(name)
+                .seed(seed)
+                .studio(studio)
+                .create();
+        ServerConfigurator.installDataPacks(false);
 
         access = (PlatformChunkGenerator) wc.generator();
         PlatformChunkGenerator finalAccess1 = access;
@@ -130,15 +164,16 @@ public class IrisCreator {
                 }
                 return finalAccess1.getEngine().getGenerated();
             };
-            while(g.get() < req) {
-                double v = (double) g.get() / (double) req;
-
-                if(sender.isPlayer()) {
-                    sender.sendProgress(v, "Generating");
-                    J.sleep(16);
-                } else {
-                    sender.sendMessage(C.WHITE + "Generating " + Form.pc(v) + ((C.GRAY + " (" + (req - g.get()) + " Left)")));
-                    J.sleep(1000);
+            if(!benchmark) {
+                while (g.get() < req) {
+                    double v = (double) g.get() / (double) req;
+                    if (sender.isPlayer()) {
+                        sender.sendProgress(v, "Generating");
+                        J.sleep(16);
+                    } else {
+                        sender.sendMessage(C.WHITE + "Generating " + Form.pc(v) + ((C.GRAY + " (" + (req - g.get()) + " Left)")));
+                        J.sleep(1000);
+                    }
                 }
             }
         });
@@ -148,47 +183,48 @@ public class IrisCreator {
             J.sfut(() -> {
                 world.set(wc.createWorld());
             }).get();
-        } catch(Throwable e) {
+        } catch (Throwable e) {
             e.printStackTrace();
         }
 
-        if(access == null) {
+        if (access == null) {
             throw new IrisException("Access is null. Something bad happened.");
         }
 
         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));
             });
         }
 
-        if(studio) {
+        if (studio || benchmark) {
             J.s(() -> {
                 Iris.linkMultiverseCore.removeFromConfig(world.get());
 
-                if(IrisSettings.get().getStudio().isDisableTimeAndWeather()) {
+                if (IrisSettings.get().getStudio().isDisableTimeAndWeather()) {
                     world.get().setGameRule(GameRule.DO_WEATHER_CYCLE, false);
                     world.get().setGameRule(GameRule.DO_DAYLIGHT_CYCLE, false);
                     world.get().setTime(6000);
                 }
             });
-        }
+        } else
+            addToBukkitYml();
 
-        if(pregen != null) {
+        if (pregen != null) {
             CompletableFuture<Boolean> ff = new CompletableFuture<>();
 
             IrisToolbelt.pregenerate(pregen, access)
-                .onProgress(pp::set)
-                .whenDone(() -> ff.complete(true));
+                    .onProgress(pp::set)
+                    .whenDone(() -> ff.complete(true));
 
             try {
                 AtomicBoolean dx = new AtomicBoolean(false);
 
                 J.a(() -> {
-                    while(!dx.get()) {
-                        if(sender.isPlayer()) {
+                    while (!dx.get()) {
+                        if (sender.isPlayer()) {
                             sender.sendProgress(pp.get(), "Pregenerating");
                             J.sleep(16);
                         } else {
@@ -200,11 +236,26 @@ public class IrisCreator {
 
                 ff.get();
                 dx.set(true);
-            } catch(Throwable e) {
+            } catch (Throwable e) {
                 e.printStackTrace();
             }
         }
-
         return world.get();
     }
+
+    private void addToBukkitYml() {
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
+        String gen = "Iris:" + dimension;
+        ConfigurationSection section = yml.contains("worlds") ? yml.getConfigurationSection("worlds") : yml.createSection("worlds");
+        if (!section.contains(name)) {
+            section.createSection(name).set("generator", gen);
+            try {
+                yml.save(BUKKIT_YML);
+                Iris.info("Registered \"" + name + "\" in bukkit.yml");
+            } catch (IOException e) {
+                Iris.error("Failed to update bukkit.yml!");
+                e.printStackTrace();
+            }
+        }
+    }
 }