Merge pull request #1049 from RePixelatedMC/Pixeldev

[ Ready ] SAFEGUARD

.github/ISSUE_TEMPLATE/bug.yml

@@ -40,6 +40,9 @@ body:
         - 1.17.1
         - 1.18
         - 1.19
+        - 1.20
+        - 1.21
+        - 1.22
     validations:
       required: true
   - type: input

.gitignore

@@ -10,4 +10,4 @@ libs/
 
 collection/
 
-src/main/java/com/volmit/iris/util/uniques/
+/core/src/main/java/com/volmit/iris/util/uniques/

build.gradle

@@ -19,18 +19,12 @@
 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.7.0-1.20.0'
-def nmsVersion = '1.20' //[NMS]
-def apiVersion = '1.20'
+version '3.0.0-1.19.2-1.20.2'
 def specialSourceVersion = '1.11.0' //[NMS]
-def spigotJarVersion = '1.20-R0.1-SNAPSHOT' //[NMS]
-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 =============================
@@ -40,62 +34,161 @@ registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/s
 registerCustomOutputTask('Coco', 'D://mcsm/plugins')
 registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
 registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
+registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
+registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.1 - Iris Coding/plugins')
 // ========================== UNIX ==============================
 registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/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()
+def NMS_BINDINGS = Map.of(
+        "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'
+        apply plugin: 'java-library'
+        apply plugin: 'de.undercouch.download'
 
-/**
- * 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")
+        dependencies {
+            implementation project(":core")
+            implementation "org.spigotmc:spigot-api:${value}"
+            implementation "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 =============================
+        Runnable downloadBuildtools = () -> {
+            if (!buildToolsJar.exists()) {
+                download.run {
+                    src 'https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar'
+                    dest buildToolsJar
+                }
+            }
+        }
+
+        Runnable downloadSpecialSource = () -> {
+            if (!specialSourceJar.exists()) {
+                download.run {
+                    src 'https://repo.maven.apache.org/maven2/net/md-5/SpecialSource/' + specialSourceVersion + '/SpecialSource-'+specialSourceVersion+'-shaded.jar'
+                    dest specialSourceJar
+                }
+            }
+        }
+
+        Runnable executeBuildTools = () -> {
+            if (!buildToolsHint.exists()) {
+                downloadBuildtools.run()
+                buildToolsFolder.mkdirs()
+                javaexec {
+                    classpath = files(buildToolsJar)
+                    workingDir = buildToolsFolder
+                    args = [
+                            "--rev",
+                            nms,
+                            "--compile",
+                            "craftbukkit",
+                            "--remap"
+                    ]
+                }
+            }
+        }
+
+        tasks.register("executeBuildTools") {
+            doFirst {
+                executeBuildTools.run()
+            }
+        }
+
+        tasks.register("copyBuildToSpecialSource", Copy) {
+            doFirst {
+                downloadSpecialSource.run()
+                specialSourceFolder.mkdirs();
+            }
+
+            group "remapping"
+            from outputJar
+            into specialSourceFolder
+            dependsOn(jar)
+        }
+
+        tasks.register("specialSourceRemapObfuscate", JavaExec) {
+            group "remapping"
+            dependsOn(copyBuildToSpecialSource)
+            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",
+            ]
+        }
+
+        tasks.register("specialSourceRemap", JavaExec) {
+            group "remapping"
+            dependsOn(specialSourceRemapObfuscate)
+            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"
+            ]
+        }
+
+        tasks.register("copySpecialSourceToBuild", Copy) {
+            group "remapping"
+            from ssJar
+            into outputJar.getParentFile()
+            rename {
+                outputJar.getName()
+            }
+            dependsOn(specialSourceRemap)
+        }
+
+        tasks.build.dependsOn(copySpecialSourceToBuild)
+        executeBuildTools.run()
     }
-    mavenCentral()
-    maven { url "https://arcanearts.jfrog.io/artifactory/archives" }
-    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" }
 }
 
-/**
- * We need parameter meta for the decree command system
- */
-compileJava {
-    options.compilerArgs << '-parameters'
-}
-
-/**
- * Configure Iris for shading
- */
 shadowJar {
+    NMS_BINDINGS.each {dependsOn(":nms:${it.key}:build")}
+
     //minimize()
     append("plugin.yml")
     relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
@@ -105,6 +198,16 @@ shadowJar {
         include(dependency('io.papermc:paperlib'))
         include(dependency('com.dfsek:Paralithic'))
         include(dependency('net.kyori:'))
+        include(project(":core"))
+        NMS_BINDINGS.each {include(project(":nms:${it.key}"))}
+    }
+    archiveFileName.set("Iris-${project.version}.jar")
+}
+
+dependencies {
+    implementation project(':core')
+    NMS_BINDINGS.each {
+        implementation project(":nms:${it.key}")
     }
 }
 
@@ -113,51 +216,63 @@ configurations.all {
     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.24'
-    annotationProcessor 'org.projectlombok:lombok:1.18.24'
-    implementation 'org.spigotmc:spigot-api:1.20-R0.1-SNAPSHOT'
-    implementation 'org.bukkit:craftbukkit:1.20-R0.1-SNAPSHOT:remapped-mojang' //[NMS]
+allprojects {
+    getPlugins().apply("java")
 
-    // Third Party Integrations
-    implementation 'com.github.oraxen:oraxen:1.152.5'
-    implementation 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
-    implementation 'me.clip:placeholderapi:2.11.3'
-    //implementation files('libs/CustomItems.jar')
+    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"}
 
-    // 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.0'
-    implementation 'net.kyori:adventure-api:4.13.1'
-    implementation 'io.lumine:Mythic-Dist:5.2.1'
+        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/' }
+    }
 
-    // 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'
+    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.0'
+        implementation 'net.kyori:adventure-api:4.13.1'
+        implementation 'io.lumine:Mythic-Dist:5.2.1'
+
+        // 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'
+    }
+
+    /**
+     * We need parameter meta for the decree command system
+     */
+    compileJava {
+        options.compilerArgs << '-parameters'
+        options.encoding = "UTF-8"
+    }
 }
 
 if (JavaVersion.current().toString() != "17") {
@@ -178,123 +293,18 @@ if (JavaVersion.current().toString() != "17") {
     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/' + specialSourceVersion + '/SpecialSource-'+specialSourceVersion+'-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)
-
-compileJava {
-    options.encoding = "UTF-8"
-}
-
-task setup()
-{
-    group("iris")
-    dependsOn(clean, executeBuildTools)
-}
-
-task iris(type: Copy)
-{
+task iris(type: Copy) {
     group "iris"
-    from ssJar
+    from new File(buildDir, "libs/Iris-${version}.jar")
     into buildDir
-    rename { String fileName ->
-        fileName.replace('Iris-' + version + '-rma.jar', "Iris-" + version + ".jar")
+    dependsOn(build)
+}
+
+task setup() {
+    group "iris"
+    NMS_BINDINGS.each {
+        dependsOn(project(":nms:${it.key}").executeBuildTools)
     }
-    dependsOn(specialSourceRemap)
 }
 
 def registerCustomOutputTask(name, path) {
@@ -330,3 +340,5 @@ def registerCustomOutputTaskUnix(name, path) {
         }
     }
 }
+
+tasks.build.dependsOn(shadowJar)

core/build.gradle

@@ -0,0 +1,85 @@
+/*
+ * 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"
+}
+
+/**
+ * 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
+    implementation 'org.spigotmc:spigot-api:1.20.1-R0.1-SNAPSHOT'
+    implementation 'org.apache.logging.log4j:log4j-api:2.19.0'
+    implementation 'org.apache.logging.log4j:log4j-core:2.19.0'
+    implementation 'commons-lang:commons-lang:2.6'
+    implementation 'com.github.oshi:oshi-core:5.8.5'
+
+    // Third Party Integrations
+    implementation 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
+    implementation 'com.github.oraxen:oraxen:1.158.0'
+    implementation 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
+    implementation 'com.github.PlaceholderAPI:placeholderapi:2.11.3'
+    implementation 'com.github.Ssomar-Developement:SCore:4.23.10.8'
+    //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()
+        )
+    }
+}
+
+tasks.compileJava.dependsOn(delombok)

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

@@ -28,8 +28,9 @@ 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.v20.NMSBinding1_20;
+import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.service.ChunkHandlerSVC;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.EnginePanic;
@@ -38,6 +39,8 @@ 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.engine.safeguard.IrisSafeguard;
+import com.volmit.iris.engine.safeguard.UtilsSFG;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.exceptions.IrisException;
@@ -50,6 +53,7 @@ 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;
@@ -85,13 +89,20 @@ 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 static com.volmit.iris.engine.safeguard.IrisSafeguard.unstablemode;
+import static com.volmit.iris.engine.safeguard.ServerBootSFG.passedserversoftware;
+import static com.volmit.iris.util.misc.getHardware.getCPUModel;
+import static com.volmit.iris.util.misc.getHardware.getCPUThreads;
+
 @SuppressWarnings("CanBeFinal")
 public class Iris extends VolmitPlugin implements Listener {
-    public static final String OVERWORLD_TAG = "3003";
+    public static final String OVERWORLD_TAG = "3800";
 
     private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
 
@@ -308,6 +319,9 @@ public class Iris extends VolmitPlugin implements Listener {
     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) {
@@ -428,7 +442,7 @@ public class Iris extends VolmitPlugin implements Listener {
     private static void fixShading() {
         ShadeFix.fix(ComponentSerializer.class);
     }
-
+    private ChunkHandlerSVC chunkHandlerSVC;
     private void enable() {
         instance = this;
         services = new KMap<>();
@@ -436,6 +450,7 @@ public class Iris extends VolmitPlugin implements Listener {
         INMS.get();
         IO.delete(new File("iris"));
         setupAudience();
+        IrisSafeguard.IrisSafeguardSystem();
         sender = new VolmitSender(Bukkit.getConsoleSender());
         sender.setTag(getTag());
         instance = this;
@@ -455,6 +470,14 @@ public class Iris extends VolmitPlugin implements Listener {
             J.s(this::setupPapi);
             J.a(ServerConfigurator::configure, 20);
             splash();
+            UtilsSFG.UnstableMode();
+            UtilsSFG.SupportedServerSoftware();
+            UtilsSFG.printIncompatibleWarnings();
+            UtilsSFG.unstablePrompt();
+            if(IrisSettings.get().getGeneral().useIntegratedChunkHandler) {
+                chunkHandlerSVC = new ChunkHandlerSVC(this);
+                Iris.info(C.LIGHT_PURPLE + "Started Intergrated ChunkHandlerSVC");
+            }
             autoStartStudio();
             checkForBukkitWorlds();
             IrisToolbelt.retainMantleDataForSlice(String.class.getCanonicalName());
@@ -573,19 +596,24 @@ public class Iris extends VolmitPlugin implements Listener {
 
     @Override
     public String getTag(String subTag) {
-        return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.IRIS + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+        if (unstablemode) {
+            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.RED + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
+        }
+        else {
+            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 (!instance.getServer().getBukkitVersion().contains(NMSBinding1_20.NMS_VERSION)) {
+        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.\nPlease use " + NMSBinding1_20.NMS_VERSION + " or use an older version of Iris.");
+            Iris.warn("Iris is not compatible with this version of Minecraft.");
             Iris.warn("=");
             Iris.warn("=");
             Iris.warn("=");
@@ -714,12 +742,14 @@ public class Iris extends VolmitPlugin implements Listener {
             return;
         }
 
-        // @NoArgsConstructor
         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(),
-        };
-        String[] splash = {
+        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()};
+        }
+
+        String[] splashstable = {
                 padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
                 padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.IRIS + "   .(((()))).                     ",
                 padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.IRIS + "  .((((((())))))).                  ",
@@ -732,8 +762,44 @@ public class Iris extends VolmitPlugin implements Listener {
                 padd + C.GRAY + "" + C.IRIS + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
                 padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
         };
-        //@done
-        Iris.info("Server type & version: " + Bukkit.getVersion());
+
+        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[] splash = unstablemode ? splashunstable : splashstable; // Choose the appropriate splash array based on unstablemode
+
+
+        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("Server OS: " + osName + " (" + osArch + ")");
+
+        if(unstablemode) Iris.info("Server Cpu: " + C.DARK_RED + getCPUModel());
+
+        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("Intel") && !getCPUModel().contains("Ryzen")) Iris.info("Server Cpu: " + C.DARK_GRAY + getCPUModel());
+
+        Iris.info("Process Threads: " + getCPUThreads());
+        Iris.info("Process Memory: " + getHardware.getProcessMemory() + " MB");
+        if (getHardware.getProcessMemory() < 5999) {
+            Iris.warn("6GB+ Ram is recommended");
+        }
         Iris.info("Bukkit version: " + Bukkit.getBukkitVersion());
         Iris.info("Java version: " + getJavaVersion());
         Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());

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

@@ -145,6 +145,8 @@ public class IrisSettings {
 
     @Data
     public static class IrisSettingsGeneral {
+        public boolean bootUnstable = false;
+        public boolean useIntegratedChunkHandler = false;
         public boolean commandSounds = true;
         public boolean debug = false;
         public boolean disableNMS = false;

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

@@ -61,13 +61,12 @@ public class ServerConfigurator {
         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)");
+            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("config/paper-global.yml");
         FileConfiguration f = new YamlConfiguration();
@@ -75,7 +74,7 @@ public class ServerConfigurator {
         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)");
+            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("watchdog.early-warning-delay", TimeUnit.MINUTES.toMillis(3));
             f.save(spigotConfig);

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

@@ -21,32 +21,46 @@ package com.volmit.iris.core.commands;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisBenchmarking;
+import com.volmit.iris.core.tools.IrisCreator;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import com.volmit.iris.engine.safeguard.UtilsSFG;
 import com.volmit.iris.util.collection.KList;
 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;
 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.format.Form;
+import com.volmit.iris.util.mantle.MantleChunk;
 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.jobs.QueueJob;
+import lombok.Getter;
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;
 
 import java.io.File;
 import java.io.IOException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 
+import static com.volmit.iris.core.service.EditSVC.deletingWorld;
+import static com.volmit.iris.core.tools.IrisBenchmarking.inProgress;
+import static com.volmit.iris.engine.safeguard.IrisSafeguard.unstablemode;
+import static com.volmit.iris.engine.safeguard.ServerBootSFG.incompatiblePlugins;
+
 @Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
 public class CommandIris implements DecreeExecutor {
     private CommandStudio studio;
@@ -57,6 +71,9 @@ public class CommandIris implements DecreeExecutor {
     private CommandWhat what;
     private CommandEdit edit;
     private CommandFind find;
+    private CommandWorldManager manager;
+
+    public static @Getter String BenchDimension;
 
     @Decree(description = "Create a new world", aliases = {"+", "c"})
     public void create(
@@ -67,11 +84,34 @@ public class CommandIris implements DecreeExecutor {
             @Param(description = "The seed to generate the world with", defaultValue = "1337")
             long seed
     ) {
-        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(sender() instanceof Player) {
+            if (incompatiblePlugins.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 && !incompatiblePlugins.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!");
@@ -96,7 +136,87 @@ public class CommandIris implements DecreeExecutor {
         sender().sendMessage(C.GREEN + "Successfully created your world!");
     }
 
-    @Decree(description = "Remove an Iris world", aliases = {"del", "rm"}, sync = true)
+    @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");
+    }
+    @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 Fix PREGEN
+    @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();
+    } */
+
+    /*  /todo Different approach this feels useless atm
+    @Decree(description = "Check for instabilities", origin = DecreeOrigin.CONSOLE)
+    public void fixunstable() throws InterruptedException {
+        if (unstablemode){
+            sender().sendMessage(C.RED + "Incompatibilities are posted in console..");
+
+            Iris.info(C.RED + "Your server is experiencing an incompatibility with the Iris plugin.");
+            Iris.info(C.RED + "Please rectify this problem to avoid further complications.");
+            Iris.info(C.RED + "----------------------------------------------------------------");
+            Iris.info(C.RED + "Command ran: /iris fixunstable");
+            UtilsSFG.printIncompatibleWarnings();
+            Iris.info(C.RED + "----------------------------------------------------------------");
+     } else {
+            Iris.info(C.BLUE + "Iris is running stable..");
+            sender().sendMessage("Iris is running stable..");
+        }
+    } */
+
+    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
+    public void height() {
+        sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
+        sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
+    }
+
+    @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 = "Remove an Iris world", aliases = {"del", "rm", "delete"}, sync = true)
     public void remove(
             @Param(description = "The world to remove")
             World world,
@@ -119,29 +239,42 @@ public class CommandIris implements DecreeExecutor {
             e.printStackTrace();
         }
         IrisToolbelt.evacuate(world, "Deleting world");
+        deletingWorld = true;
         Bukkit.unloadWorld(world, false);
-        if (delete && world.getWorldFolder().delete()) {
-            sender().sendMessage(C.GREEN + "Successfully removed world folder");
-        } else {
-            sender().sendMessage(C.RED + "Failed to remove world folder");
+        int retries = 10;
+        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;
+                    }
+                    sender().sendMessage(C.GREEN + "DEBUG1");
+                    retries--;
+                    if (retries == 0){
+                        sender().sendMessage(C.RED + "Failed to remove world folder");
+                        break;
+                    }
+                    J.sleep(2000);
+                }
+            }
         }
+        deletingWorld = false;
     }
 
-    @Decree(description = "Print version information")
-    public void version() {
-        sender().sendMessage(C.GREEN + "Iris v" + Iris.instance.getDescription().getVersion() + " by Volmit Software");
-    }
-
-    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
-    public void height() {
-        sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
-        sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
-    }
-
-    @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");
+    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")

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

@@ -341,7 +341,7 @@ public class CommandObject implements DecreeExecutor {
                 }
             }
         } else {
-            sender().sendMessage("Placed " + object);
+            sender().sendMessage(C.IRIS + "Placed " + object);
         }
     }
 
@@ -413,7 +413,7 @@ public class CommandObject implements DecreeExecutor {
         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)

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

@@ -0,0 +1,128 @@
+/*
+ * 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.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;
+
+@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")
+            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 = "method", description = "The pregen method that will get used. Lazy or Async", defaultValue = "async")
+            String method
+    ) {
+        if(method.equals("async") || method.equals("lazy")){
+            if (method.equalsIgnoreCase("async")) {
+                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.");
+                    }
+                    radius = Math.max(radius, 1024);
+                    int w = (radius >> 9 + 1) * 2;
+                    IrisToolbelt.pregenerate(PregenTask
+                            .builder()
+                            .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                            .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) {
+                    sender().sendMessage(C.RED + "Epic fail. See console.");
+                    Iris.reportError(e);
+                    e.printStackTrace();
+                }
+            }
+            if (method.equalsIgnoreCase("lazy")) {
+                String worldName = world.getName();
+                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(999999999)
+                            .radiusBlocks(radius)
+                            .position(0)
+                            .build();
+
+                    LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, new File("plugins/Iris/lazygen.json"));
+                    pregenerator.start();
+
+                    String msg = C.GREEN + "Pregen 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();
+                }
+            }
+        } else {
+            sender().sendMessage(C.RED + "Please use a valid method.");
+
+        }
+
+    }
+
+    @Decree(description = "Stop the active pregeneration task", aliases = "x")
+    public void stop() {
+        if (PregeneratorJob.shutdownInstance()) {
+            Iris.info( C.BLUE + "Finishing up mca region...");
+            sender().sendMessage(C.DARK_BLUE + "Stopped pregeneration task");
+        } 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() {
+        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

@@ -281,6 +281,7 @@ public class CommandStudio implements DecreeExecutor {
             @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);

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

@@ -0,0 +1,250 @@
+/*
+ * 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.IrisToolbelt;
+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.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.plugin.VolmitSender;
+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.generator.ChunkGenerator;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.io.File;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+import static com.volmit.iris.Iris.service;
+
+// Not done yet but works
+@Decree(name = "worldmanager", origin = DecreeOrigin.PLAYER, description = "Iris World Manager", aliases = {"manager"})
+public class CommandWorldManager implements DecreeExecutor {
+    public Difficulty difficulty = Difficulty.NORMAL;
+    String WorldToLoad;
+    String WorldEngine;
+    String worldNameToCheck = "YourWorldName";
+    VolmitSender sender = Iris.getSender();
+    @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(", ", Bukkit.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 + "\\iris\\pack\\dimensions\\";
+            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(", ", Bukkit.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/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/IrisPapiExpansion.java

@@ -46,7 +46,7 @@ public class IrisPapiExpansion extends PlaceholderExpansion {
 
     @Override
     public boolean persist() {
-        return false;
+        return true;
     }
 
     @Override

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

@@ -1,77 +1,74 @@
-/*
- * 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.nms;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.nms.v20.NMSBinding1_20;
-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_20_R1", NMSBinding1_20.class);
-    //@done
-    private static final INMSBinding binding = bind();
-
-    public static INMSBinding get() {
-        return binding;
-    }
-
-    public static String getNMSTag() {
-        if (IrisSettings.get().getGeneral().isDisableNMS()) {
-            return "BUKKIT";
-        }
-
-        try {
-            return Bukkit.getServer().getClass().getCanonicalName().split("\\Q.\\E")[3];
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.error("Failed to determine server nms version!");
-            e.printStackTrace();
-        }
-
-        return "BUKKIT";
-    }
-
-    private static INMSBinding bind() {
-        String code = getNMSTag();
-        Iris.info("Locating NMS Binding for " + code);
-
-        if (bindings.containsKey(code)) {
-            try {
-                INMSBinding b = bindings.get(code).getConstructor().newInstance();
-                Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
-
-                return b;
-            } catch (Throwable e) {
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-        }
-
-        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.");
-        Iris.warn("Note: If this is a new version, expect an update soon.");
-
-        return new NMSBinding1X();
-    }
-}
+/*
+ * 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.nms;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.nms.v1X.NMSBinding1X;
+import org.bukkit.Bukkit;
+
+public class INMS {
+    //@done
+    private static final INMSBinding binding = bind();
+
+    public static INMSBinding get() {
+        return binding;
+    }
+
+    public static String getNMSTag() {
+        if (IrisSettings.get().getGeneral().isDisableNMS()) {
+            return "BUKKIT";
+        }
+
+        try {
+            return Bukkit.getServer().getClass().getCanonicalName().split("\\Q.\\E")[3];
+        } catch (Throwable e) {
+            Iris.reportError(e);
+            Iris.error("Failed to determine server nms version!");
+            e.printStackTrace();
+        }
+
+        return "BUKKIT";
+    }
+
+    private static INMSBinding bind() {
+        String code = getNMSTag();
+        Iris.info("Locating NMS Binding for " + code);
+
+        try {
+            Class<?> clazz = Class.forName("com.volmit.iris.core.nms."+code+".NMSBinding");
+            try {
+                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.");
+        Iris.warn("Note: If this is a new version, expect an update soon.");
+
+        return new NMSBinding1X();
+    }
+}

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

@@ -18,6 +18,8 @@
 
 package com.volmit.iris.core.nms;
 
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
@@ -27,8 +29,10 @@ 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.generator.ChunkGenerator;
+import org.bukkit.inventory.ItemStack;
 
 public interface INMSBinding {
     boolean hasTile(Location l);
@@ -90,4 +94,10 @@ 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;
 }

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,6 +20,9 @@ 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.KMap;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
@@ -28,8 +31,10 @@ 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.generator.ChunkGenerator;
+import org.bukkit.inventory.ItemStack;
 
 public class NMSBinding1X implements INMSBinding {
     private static final boolean supportsCustomHeight = testCustomHeight();
@@ -64,6 +69,21 @@ public class NMSBinding1X implements INMSBinding {
 
     }
 
+    @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 {
+
+    }
+
     @Override
     public void deserializeTile(CompoundTag s, Location newPosition) {
 

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

@@ -19,7 +19,9 @@
 package com.volmit.iris.core.pregenerator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisPackBenchmarking;
 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;
@@ -28,12 +30,16 @@ import com.volmit.iris.util.math.RollingSequence;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.Looper;
+import lombok.Getter;
+import lombok.Setter;
 
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 import java.util.concurrent.atomic.AtomicReference;
 
+import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmark;
+
 public class IrisPregenerator {
     private final PregenTask task;
     private final PregeneratorMethod generator;
@@ -44,10 +50,10 @@ public class IrisPregenerator {
     private final RollingSequence chunksPerSecond;
     private final RollingSequence chunksPerMinute;
     private final RollingSequence regionsPerMinute;
-    private final AtomicInteger generated;
+    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;
@@ -56,6 +62,8 @@ public class IrisPregenerator {
     private final KSet<Position2> net;
     private final ChronoLatch cl;
     private final ChronoLatch saveLatch = new ChronoLatch(30000);
+    static long long_generatedChunks = 0;
+    static long long_totalChunks = 0;
 
     public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
         this.listener = listenify(listener);
@@ -92,6 +100,8 @@ public class IrisPregenerator {
                     chunksPerMinute.put(minuteGenerated);
                     regionsPerMinute.put((double) minuteGenerated / 1024D);
                 }
+                long_generatedChunks = generated.get();
+                long_totalChunks = totalChunks.get();
 
                 listener.onTick(chunksPerSecond.getAverage(), chunksPerMinute.getAverage(),
                         regionsPerMinute.getAverage(),
@@ -102,19 +112,34 @@ public class IrisPregenerator {
 
                 if (cl.flip()) {
                     double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
-                    Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2), percentage);
+                    if(benchmark) {
+                        Iris.info(C.GREEN +"Benchmark: " + C.WHITE + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2), percentage);
+                    } else {
+                        Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2), percentage);
+                    }
                 }
-
                 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 static long getLongGeneratedChunks() {
+        return long_generatedChunks;
+    }
+    public static long getLongTotalChunks() {
+        return long_totalChunks;
+    }
+
+
     public void close() {
         shutdown.set(true);
     }

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

@@ -2,9 +2,12 @@ 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;
@@ -20,6 +23,7 @@ import org.bukkit.event.world.WorldUnloadEvent;
 import java.io.File;
 import java.io.IOException;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
 
 public class LazyPregenerator extends Thread implements Listener {
     private final LazyPregenJob job;
@@ -28,6 +32,11 @@ public class LazyPregenerator extends Thread implements Listener {
     private final 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;
 
     public LazyPregenerator(LazyPregenJob job, File destination) {
         this.job = job;
@@ -36,7 +45,15 @@ public class LazyPregenerator extends Thread implements Listener {
         }).count();
         this.world = Bukkit.getWorld(job.getWorld());
         this.rate = Math.round((1D / (job.chunksPerMinute / 60D)) * 1000D);
-        this.latch = new ChronoLatch(60000);
+        this.latch = new ChronoLatch(6000);
+        startTime = new AtomicLong(M.ms());
+        chunksPerSecond = new RollingSequence(10);
+        lazyGeneratedChunks = new AtomicInteger(0);
+        generatedLast = new AtomicInteger(0);
+        lazyTotalChunks = new AtomicInteger();
+
+        int radius = job.getRadiusBlocks();
+        lazyTotalChunks.set((int) Math.ceil(Math.pow((2.0 * radius) / 16, 2)));
     }
 
     public LazyPregenerator(File file) throws IOException {
@@ -81,17 +98,26 @@ public class LazyPregenerator extends Thread implements Listener {
 
     public void tick() {
         if (latch.flip()) {
+            long eta = computeETA();
             save();
-            Iris.info("LazyGen: " + world.getName() + " RTT: " + Form.duration((Math.pow((job.radiusBlocks / 16D), 2) / job.chunksPerMinute) * 60 * 1000, 2));
+            int secondGenerated = lazyGeneratedChunks.get() - generatedLast.get();
+            generatedLast.set(lazyGeneratedChunks.get());
+            secondGenerated = secondGenerated / 6;
+            chunksPerSecond.put(secondGenerated);
+            Iris.info("LazyGen: " + C.IRIS + world.getName() + C.RESET + " RTT: " + Form.f(lazyGeneratedChunks.get()) + " of " + Form.f(lazyTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
+            //Iris.info("Debug: " + maxPosition);
+            //Iris.info("Debug1: " + job.getPosition());
+
+            // todo: Maxpos borked
         }
 
-        if (job.getPosition() >= maxPosition) {
+        if (lazyGeneratedChunks.get() >= lazyTotalChunks.get()) {
             if (job.isHealing()) {
                 int pos = (job.getHealingPosition() + 1) % maxPosition;
                 job.setHealingPosition(pos);
                 tickRegenerate(getChunk(pos));
             } else {
-                Iris.verbose("Completed Lazy Gen!");
+                Iris.info("Completed Lazy Gen!");
                 interrupt();
             }
         } else {
@@ -101,6 +127,15 @@ public class LazyPregenerator extends Thread implements Listener {
         }
     }
 
+    private long computeETA() {
+        return (long) (lazyTotalChunks.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)
+                ((lazyTotalChunks.get() - lazyGeneratedChunks.get()) * ((double) (M.ms() - startTime.get()) / (double) lazyGeneratedChunks.get())) :
+                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
+                ((lazyTotalChunks.get() - lazyGeneratedChunks.get()) / chunksPerSecond.getAverage()) * 1000 //
+        );
+    }
+
     private void tickGenerate(Position2 chunk) {
         if (PaperLib.isPaper()) {
             PaperLib.getChunkAtAsync(world, chunk.getX(), chunk.getZ(), true).thenAccept((i) -> Iris.verbose("Generated Async " + chunk));
@@ -108,6 +143,7 @@ public class LazyPregenerator extends Thread implements Listener {
             J.s(() -> world.getChunkAt(chunk.getX(), chunk.getZ()));
             Iris.verbose("Generated " + chunk);
         }
+        lazyGeneratedChunks.addAndGet(1);
     }
 
     private void tickRegenerate(Position2 chunk) {

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

@@ -0,0 +1,163 @@
+package com.volmit.iris.core.service;
+
+import com.volmit.iris.core.tools.IrisToolbelt;
+import org.bukkit.Bukkit;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.world.ChunkLoadEvent;
+import org.bukkit.event.world.ChunkUnloadEvent;
+import org.bukkit.event.world.WorldLoadEvent;
+import org.bukkit.event.world.WorldUnloadEvent;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.bukkit.scheduler.BukkitRunnable;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.TimeUnit;
+public class ChunkHandlerSVC implements Listener {
+    // Idk how it works but it works lol
+    private final JavaPlugin plugin;
+    private static BukkitTask task;
+    private final Map<World, ChunkUnloader> worlds = new ConcurrentHashMap<>();
+
+    private static final Map<Chunk, Set<Player>> playersInChunk = new ConcurrentHashMap<>();
+
+    public ChunkHandlerSVC(JavaPlugin plugin) {
+        this.plugin = plugin;
+        Bukkit.getPluginManager().registerEvents(this, plugin);
+
+        for (World world : Bukkit.getWorlds()) {
+            if (IrisToolbelt.isIrisWorld(world)) {
+                worlds.put(world, new ChunkUnloader(plugin, world));
+            }
+        }
+
+        startTask();
+    }
+
+    private void startTask() {
+        if (task == null) {
+            task = new BukkitRunnable() {
+                @Override
+                public void run() {
+                    worlds.values().forEach(ChunkUnloader::update);
+                }
+            }.runTaskTimerAsynchronously(plugin, 0L, 1L);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerMove(PlayerMoveEvent event) {
+        Player player = event.getPlayer();
+        Chunk previousChunk = event.getFrom().getChunk();
+        Chunk currentChunk = event.getTo().getChunk();
+
+        if (!previousChunk.equals(currentChunk)) {
+            playersInChunk.computeIfAbsent(previousChunk, k -> ConcurrentHashMap.newKeySet()).remove(player);
+            playersInChunk.computeIfAbsent(currentChunk, k -> ConcurrentHashMap.newKeySet()).add(player);
+        }
+    }
+
+    public static void exit() {
+        if (task != null) {
+            task.cancel();
+        }
+    }
+
+    @EventHandler
+    public void onWorldLoad(WorldLoadEvent event) {
+        World world = event.getWorld();
+        if (IrisToolbelt.isIrisWorld(world)) {
+            worlds.put(world, new ChunkUnloader(plugin, world));
+        }
+    }
+
+    @EventHandler
+    public void onWorldUnload(WorldUnloadEvent event) {
+        worlds.remove(event.getWorld());
+    }
+
+    @EventHandler
+    public void onChunkLoad(ChunkLoadEvent event) {
+        World world = event.getWorld();
+        if (worlds.containsKey(world)) {
+            worlds.get(world).onChunkLoad(event.getChunk());
+        }
+    }
+
+    @EventHandler
+    public void onChunkUnload(ChunkUnloadEvent event) {
+        World world = event.getWorld();
+        if (worlds.containsKey(world)) {
+            worlds.get(world).onChunkUnload(event.getChunk());
+        }
+    }
+
+    private static class ChunkUnloader {
+        private final JavaPlugin plugin;
+        private final World world;
+        private final Map<Chunk, Long> chunks = new ConcurrentHashMap<>();
+
+        private ChunkUnloader(JavaPlugin plugin, World world) {
+            this.plugin = plugin;
+            this.world = world;
+        }
+
+        public void onChunkLoad(Chunk chunk) {
+            // System.out.printf("%s > Loaded Chunk [x=%s, z=%s]%n", world.getName(), chunk.getX(), chunk.getZ());
+            chunks.put(chunk, System.currentTimeMillis() + TimeUnit.MINUTES.toMillis(3));
+        }
+
+        public void onChunkUnload(Chunk chunk) {
+            chunks.remove(chunk);
+            playersInChunk.remove(chunk);
+        }
+
+        public void update() {
+            try {
+                long currentTime = System.currentTimeMillis();
+                Set<Chunk> chunkSet = new HashSet<>(chunks.keySet());
+                for (Chunk chunk : chunkSet) {
+                    if (!chunk.isLoaded()) {
+                        continue;
+                    }
+
+                    if (isChunkNearby(chunk)) {
+                        chunks.put(chunk, currentTime + TimeUnit.MINUTES.toMillis(3));
+                    } else if (chunks.get(chunk) <= currentTime) {
+                        unloadChunk(chunk);
+                    }
+                }
+            } catch (Exception e) {
+                // Log the error message
+                System.out.println("Error in update method: " + e.getMessage());
+            }
+        }
+
+
+        private boolean isChunkNearby(Chunk chunk) {
+            Set<Player> players = playersInChunk.get(chunk);
+            if (players == null) {
+                players = ConcurrentHashMap.newKeySet();
+                playersInChunk.put(chunk, players);
+            }
+            return !players.isEmpty();
+        }
+
+        private void unloadChunk(Chunk chunk) {
+            try {
+               // System.out.printf("%s > Unloading Chunk [x=%s, z=%s]%n", world.getName(), chunk.getX(), chunk.getZ());
+                Bukkit.getScheduler().runTask(plugin, () -> chunk.unload(true));
+            } catch (Exception e) {
+                System.out.println("Error unloading chunk: " + e.getMessage());
+            }
+        }
+    }
+}

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

@@ -18,6 +18,8 @@
 
 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;
@@ -25,11 +27,9 @@ 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 net.minecraft.core.BlockPos;
 import org.bukkit.Material;
 import org.bukkit.Sound;
 import org.bukkit.SoundCategory;
-import org.bukkit.craftbukkit.v1_20_R1.entity.CraftDolphin;
 import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.EventHandler;
@@ -62,10 +62,8 @@ public class DolphinSVC implements IrisService {
             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();
-                CraftDolphin cd = (CraftDolphin) d;
+                INMS.get().setTreasurePos(d, new BlockPos(x, y, z));
                 d.getWorld().playSound(d, Sound.ENTITY_DOLPHIN_EAT, SoundCategory.NEUTRAL, 1, 1);
-                cd.getHandle().setTreasurePos(new BlockPos(x, y, z));
-                cd.getHandle().setGotFish(true);
             });
 
         }

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,11 +72,12 @@ 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) {

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

@@ -19,10 +19,7 @@
 package com.volmit.iris.core.service;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.link.ItemAdderDataProvider;
-import com.volmit.iris.core.link.OraxenDataProvider;
+import com.volmit.iris.core.link.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.plugin.IrisService;
 import lombok.Data;
@@ -53,6 +50,10 @@ public class ExternalDataSVC implements IrisService {
         if (Bukkit.getPluginManager().getPlugin("ItemAdder") != null) {
             Iris.info("ItemAdder found, loading ItemAdderDataProvider...");
         }
+        providers.add(new ExecutableItemsDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("ExecutableItems") != null) {
+            Iris.info("ExecutableItems found, loading ExecutableItemsDataProvider...");
+        }
 
         for (ExternalDataProvider p : providers) {
             if (p.isReady()) {

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;
 
@@ -68,19 +70,22 @@ public class ObjectSVC implements IrisService {
      * @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/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/IrisCreator.java

@@ -26,6 +26,7 @@ import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import com.volmit.iris.engine.safeguard.UtilsSFG;
 import com.volmit.iris.util.exceptions.IrisException;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
@@ -45,6 +46,9 @@ import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
 
+import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmark;
+import static com.volmit.iris.engine.safeguard.IrisSafeguard.unstablemode;
+
 /**
  * Makes it a lot easier to setup an engine, world, studio or whatever
  */
@@ -93,6 +97,9 @@ public class IrisCreator {
         yml.save(BUKKIT_YML);
         return true;
     }
+    public static boolean worldLoaded(){
+        return true;
+    }
 
     /**
      * Create the IrisAccess (contains the world)
@@ -100,7 +107,15 @@ public class IrisCreator {
      * @return the IrisAccess
      * @throws IrisException shit happens
      */
+    IrisPackBenchmarking PackBench = new IrisPackBenchmarking();
     public World create() throws IrisException {
+        if (unstablemode){
+            Iris.info(C.RED + "Your server is experiencing an incompatibility with the Iris plugin. Please rectify this problem to avoid further complications.");
+            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.");
         }
@@ -117,6 +132,9 @@ public class IrisCreator {
         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;
         AtomicReference<World> world = new AtomicReference<>();
@@ -143,17 +161,19 @@ 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);
+                    }
                 }
             }
+            //if (benchmark){loaded = true;}
         });
 
 
@@ -177,7 +197,7 @@ public class IrisCreator {
             });
         }
 
-        if (studio) {
+        if (studio || benchmark) {
             J.s(() -> {
                 Iris.linkMultiverseCore.removeFromConfig(world.get());
 

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

@@ -0,0 +1,170 @@
+package com.volmit.iris.core.tools;
+
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.IrisPregenerator;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.util.exceptions.IrisException;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.Position2;
+
+import com.volmit.iris.util.scheduling.J;
+import org.apache.commons.io.FileUtils;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+import static com.volmit.iris.core.commands.CommandIris.BenchDimension;
+
+
+public class IrisPackBenchmarking {
+    public static boolean loaded = false;
+    public static boolean benchmark = false;
+    static boolean cancelled = false;
+    static boolean pregenInProgress = false;
+    static long startTime;
+    static long totalChunks;
+    static long generatedChunks;
+    static double elapsedTimeNs;
+
+    public static void runBenchmark() {
+        // IrisPackBenchmarking IrisPackBenchmarking = new IrisPackBenchmarking();
+        benchmark = true;
+        Iris.info(C.BLUE + "Benchmarking Dimension: " + C.AQUA + BenchDimension);
+        //progress();
+        CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {
+            Iris.info(C.GOLD + "Setting everything up..");
+            try {
+                String BenchmarkFolder = "\\Benchmark";
+                File folder = new File(BenchmarkFolder);
+                if (folder.exists() && folder.isDirectory()) {
+                    FileUtils.deleteDirectory(folder);
+                    Iris.debug("Deleted old Benchmark");
+                } else {
+                    Iris.info(C.GOLD + "Old Benchmark not found!");
+                    if(folder.exists()){
+                        Iris.info(C.RED + "FAILED To remove old Benchmark!");
+                        //cancelled = true;
+
+                    }
+                }
+            } catch (Exception e) {
+                throw new RuntimeException();
+            }
+
+        }).thenRun(() -> {
+            Iris.info(C.GOLD + "Creating Benchmark Environment");
+            createBenchmark();
+
+        }).thenRun(() -> {
+            Iris.info( C.BLUE + "Benchmark Started!");
+            boolean done = false;
+            startBenchmarkTimer();
+            startBenchmark();
+            basicScheduler();
+        }).thenRun(() -> {
+
+        });
+       // cancelled = future.cancel(true);
+        try {
+            future.get();
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private static void results(){
+        double averageCps = calculateAverageCPS();
+        Iris.info("Benchmark Dimension: " + BenchDimension);
+        Iris.info("Speeds");
+        Iris.info("- Average CPS: " + roundToTwoDecimalPlaces(averageCps));
+        Iris.info("Duration: " +  roundToTwoDecimalPlaces(elapsedTimeNs));
+
+    }
+    private static void basicScheduler() {
+        while (true) {
+            totalChunks = IrisPregenerator.getLongTotalChunks();
+            generatedChunks = IrisPregenerator.getLongGeneratedChunks();
+            if(totalChunks > 0) {
+                if (generatedChunks >= totalChunks) {
+                    Iris.info("Benchmark Completed!");
+                    elapsedTimeNs = stopBenchmarkTimer();
+                    results();
+                    break;
+                }
+            }
+            //J.sleep(100); test
+        }
+    }
+     static void createBenchmark(){
+        try {
+            IrisToolbelt.createWorld()
+                    .dimension(BenchDimension)
+                    .name("Benchmark")
+                    .seed(1337)
+                    .studio(false)
+                    .create();
+        } catch (IrisException e) {
+            throw new RuntimeException(e);
+        }
+    }
+     static void startBenchmark(){
+        int x = 0;
+        int z = 0;
+            IrisToolbelt.pregenerate(PregenTask
+                    .builder()
+                    .center(new Position2(x, z))
+                    .width(5)
+                    .height(5)
+                    .build(), Bukkit.getWorld("Benchmark")
+            );
+    }
+    static void startLazyBenchmark(){
+        int x = 0;
+        int z = 0;
+        LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
+                //.world("Benchmark")
+                .healingPosition(0)
+                .healing(false)
+                .chunksPerMinute(3200)
+                .radiusBlocks(5000)
+                .position(0)
+                .build();
+
+        LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, new File("plugins/Iris/lazygen.json"));
+        pregenerator.start();
+    }
+    public static double calculateAverageCPS() {
+        double elapsedTimeSec = elapsedTimeNs / 1_000_000_000.0;  // Convert to seconds
+        return generatedChunks / elapsedTimeSec;
+    }
+
+    private static void startBenchmarkTimer() {
+        startTime = System.nanoTime();
+    }
+
+    private static double stopBenchmarkTimer() {
+        long endTime = System.nanoTime();
+        return (endTime - startTime) / 1_000_000_000.0;
+    }
+
+    public static void deleteDirectory(File dir) {
+        File[] files = dir.listFiles();
+        if(files != null) {
+            for(File file: files) {
+                if(file.isDirectory()) {
+                    deleteDirectory(file);
+                } else {
+                    file.delete();
+                }
+            }
+        }
+        dir.delete();
+    }
+    private static double roundToTwoDecimalPlaces(double value) {
+        return Double.parseDouble(String.format("%.2f", value));
+    }
+}

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

@@ -24,6 +24,8 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.events.IrisEngineHotloadEvent;
 import com.volmit.iris.core.gui.PregeneratorJob;
+import com.volmit.iris.core.nms.container.BlockPos;
+import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.PreservationSVC;
 import com.volmit.iris.engine.data.cache.AtomicCache;
@@ -48,12 +50,10 @@ 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 net.minecraft.core.BlockPos;
 import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.command.CommandSender;
-import oshi.util.tuples.Pair;
 
 import java.io.File;
 import java.io.IOException;

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

@@ -19,6 +19,8 @@
 package com.volmit.iris.engine;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.mantle.EngineMantle;
@@ -31,6 +33,7 @@ import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.parallel.BurstExecutor;
@@ -42,6 +45,9 @@ import java.io.IOException;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicInteger;
 
+import static com.volmit.iris.core.tools.IrisPackBenchmarking.benchmark;
+import static com.volmit.iris.engine.safeguard.PerformanceSFG.lowPerformance;
+
 @Data
 public class IrisEngineMantle implements EngineMantle {
     private final Engine engine;
@@ -280,10 +286,21 @@ public class IrisEngineMantle implements EngineMantle {
         x = Math.max(x, c);
         x = (Math.max(x, 16) + 16) >> 4;
         x = x % 2 == 0 ? x + 1 : x;
-        Iris.info("Mantle Size: " + x + " Chunks");
-        Iris.info("  Object Mantle Size: " + u + " (" + ((Math.max(u, 16) + 16) >> 4) + ")");
-        Iris.info("  Jigsaw Mantle Size: " + jig + " (" + ((Math.max(jig, 16) + 16) >> 4) + ")");
-        Iris.info("  Carving Mantle Size: " + c + " (" + ((Math.max(c, 16) + 16) >> 4) + ")");
+        if (benchmark){
+            x = 4;
+            Iris.info("Mantle Size: " + x + " Chunks " + C.BLUE + "BENCHMARK MODE");
+        } else {
+            if(lowPerformance){
+                x = 4;
+                Iris.info("Mantle Size: " + x + " Chunks" + C.GOLD + "LOW PERFORMANCE MODE");
+            } else {
+                Iris.info("Mantle Size: " + x + " Chunks");
+                Iris.info("  Object Mantle Size: " + u + " (" + ((Math.max(u, 16) + 16) >> 4) + ")");
+                Iris.info("  Jigsaw Mantle Size: " + jig + " (" + ((Math.max(jig, 16) + 16) >> 4) + ")");
+                Iris.info("  Carving Mantle Size: " + c + " (" + ((Math.max(c, 16) + 16) >> 4) + ")");
+            }
+        }
+
 
         return x;
     }