suppress unchecked cast warning for the ChunkedDataCache

# Conflicts:
#	build.gradle.kts
#	core/src/main/java/com/volmit/iris/Iris.java

README.md

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

build.gradle

@@ -1,234 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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/>.
- */
-
-buildscript() {
-    repositories {
-        maven { url 'https://jitpack.io'}
-    }
-    dependencies {
-        classpath 'com.github.VolmitSoftware:NMSTools:1.0.1'
-    }
-}
-
-plugins {
-    id 'java'
-    id 'java-library'
-    id "io.github.goooler.shadow" version "8.1.7"
-    id "de.undercouch.download" version "5.0.1"
-}
-
-version '4.0-1.19.2-1.21.1'
-
-// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
-// ======================== WINDOWS =============================
-registerCustomOutputTask('Cyberpwn', 'C://Users/cyberpwn/Documents/development/server/plugins')
-registerCustomOutputTask('Psycho', 'C://Dan/MinecraftDevelopment/Server/plugins')
-registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
-registerCustomOutputTask('Coco', 'D://mcsm/plugins')
-registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
-registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
-registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
-registerCustomOutputTask('Pixel', 'D://Iris Dimension Engine/1.20.4 - Development/plugins')
-// ========================== UNIX ==============================
-registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
-registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Developer/RemoteGit/Server/plugins')
-registerCustomOutputTaskUnix('PixelMac', '/Users/test/Desktop/mcserver/plugins')
-registerCustomOutputTaskUnix('CrazyDev22LT', '/home/julian/Desktop/server/plugins')
-// ==============================================================
-
-def NMS_BINDINGS = Map.of(
-        "v1_21_R1", "1.21-R0.1-SNAPSHOT",
-        "v1_20_R4", "1.20.6-R0.1-SNAPSHOT",
-        "v1_20_R3", "1.20.4-R0.1-SNAPSHOT",
-        "v1_20_R2", "1.20.2-R0.1-SNAPSHOT",
-        "v1_20_R1", "1.20.1-R0.1-SNAPSHOT",
-        "v1_19_R3", "1.19.4-R0.1-SNAPSHOT",
-        "v1_19_R2", "1.19.3-R0.1-SNAPSHOT",
-        "v1_19_R1", "1.19.2-R0.1-SNAPSHOT"
-)
-def JVM_VERSION = Map.of(
-        "v1_21_R1", 21,
-        "v1_20_R4", 21,
-)
-def entryPoint = 'com.volmit.iris.server.EntryPoint'
-NMS_BINDINGS.each { nms ->
-    project(":nms:${nms.key}") {
-        apply plugin: 'java'
-        apply plugin: 'com.volmit.nmstools'
-
-        nmsTools {
-            it.jvm = JVM_VERSION.getOrDefault(nms.key, 17)
-            it.version = nms.value
-        }
-
-        dependencies {
-            implementation project(":core")
-        }
-    }
-}
-
-shadowJar {
-    NMS_BINDINGS.each {
-        dependsOn(":nms:${it.key}:remap")
-        from("${project(":nms:${it.key}").layout.buildDirectory.asFile.get()}/libs/${it.key}-mapped.jar")
-    }
-    //dependsOn(':com.volmit.gui:build')
-
-    //minimize()
-    append("plugin.yml")
-    relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
-    relocate 'io.papermc.lib', 'com.volmit.iris.util.paper'
-    relocate 'net.kyori', 'com.volmit.iris.util.kyori'
-    archiveFileName.set("Iris-${project.version}.jar")
-
-    manifest {
-        attributes 'Main-Class': entryPoint
-    }
-}
-
-dependencies {
-    implementation project(':core')
-}
-
-configurations.configureEach {
-    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
-    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
-}
-
-allprojects {
-    apply plugin: 'java'
-
-    repositories {
-        mavenCentral()
-        maven { url "https://repo.papermc.io/repository/maven-public/"}
-        maven { url "https://repo.codemc.org/repository/maven-public" }
-        maven { url "https://mvn.lumine.io/repository/maven-public/" }
-        maven { url "https://jitpack.io"}
-
-        maven { url "https://s01.oss.sonatype.org/content/repositories/snapshots" }
-        maven { url "https://mvn.lumine.io/repository/maven/" }
-        maven { url "https://repo.triumphteam.dev/snapshots" }
-        maven { url "https://repo.mineinabyss.com/releases" }
-        maven { url 'https://hub.jeff-media.com/nexus/repository/jeff-media-public/' }
-        maven { url "https://repo.oraxen.com/releases" }
-    }
-
-    dependencies {
-        // Provided or Classpath
-        compileOnly 'org.projectlombok:lombok:1.18.34'
-        annotationProcessor 'org.projectlombok:lombok:1.18.34'
-
-        // Shaded
-        implementation 'com.dfsek:Paralithic:0.4.0'
-        implementation 'io.papermc:paperlib:1.0.5'
-        implementation "net.kyori:adventure-text-minimessage:4.17.0"
-        implementation 'net.kyori:adventure-platform-bukkit:4.3.4'
-        implementation 'net.kyori:adventure-api:4.17.0'
-        //implementation 'org.bytedeco:javacpp:1.5.10'
-        //implementation 'org.bytedeco:cuda-platform:12.3-8.9-1.5.10'
-        //implementation "org.deeplearning4j:deeplearning4j-core:1.0.0-M2.1"
-        compileOnly 'io.lumine:Mythic-Dist:5.2.1'
-
-        // Dynamically Loaded
-        compileOnly 'io.timeandspace:smoothie-map:2.0.2'
-        compileOnly 'it.unimi.dsi:fastutil:8.5.8'
-        compileOnly 'com.googlecode.concurrentlinkedhashmap:concurrentlinkedhashmap-lru:1.4.2'
-        compileOnly 'org.zeroturnaround:zt-zip:1.14'
-        compileOnly 'com.google.code.gson:gson:2.10.1'
-        compileOnly 'org.ow2.asm:asm:9.2'
-        compileOnly 'com.google.guava:guava:33.0.0-jre'
-        compileOnly 'bsf:bsf:2.4.0'
-        compileOnly 'rhino:js:1.7R2'
-        compileOnly 'com.github.ben-manes.caffeine:caffeine:3.0.6'
-        compileOnly 'org.apache.commons:commons-lang3:3.12.0'
-        compileOnly 'net.bytebuddy:byte-buddy:1.14.14'
-        compileOnly 'net.bytebuddy:byte-buddy-agent:1.12.8'
-        compileOnly 'org.bytedeco:javacpp:1.5.10'
-        compileOnly 'org.bytedeco:cuda-platform:12.3-8.9-1.5.10'
-        compileOnly 'io.netty:netty-all:4.1.112.Final'
-    }
-
-    /**
-     * We need parameter meta for the decree command system
-     */
-    compileJava {
-        options.compilerArgs << '-parameters'
-        options.encoding = "UTF-8"
-    }
-}
-
-if (JavaVersion.current().toString() != "17") {
-    System.err.println()
-    System.err.println("=========================================================================================================")
-    System.err.println("You must run gradle on Java 17. You are using " + JavaVersion.current())
-    System.err.println()
-    System.err.println("=== For IDEs ===")
-    System.err.println("1. Configure the project for Java 17")
-    System.err.println("2. Configure the bundled gradle to use Java 17 in settings")
-    System.err.println()
-    System.err.println("=== For Command Line (gradlew) ===")
-    System.err.println("1. Install JDK 17 from https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html")
-    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:/Program Files/Java/jdk-17.0.1")
-    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
-    System.err.println("=========================================================================================================")
-    System.err.println()
-    System.exit(69);
-}
-
-task iris(type: Copy) {
-    group "iris"
-    from new File(layout.buildDirectory.asFile.get(), "libs/Iris-${version}.jar")
-    into layout.buildDirectory.asFile.get()
-    dependsOn(build)
-}
-
-def registerCustomOutputTask(name, path) {
-    if (!System.properties['os.name'].toLowerCase().contains('windows')) {
-        return;
-    }
-
-    tasks.register('build' + name, Copy) {
-        group('development')
-        outputs.upToDateWhen { false }
-        dependsOn(iris)
-        from(new File(buildDir, "Iris-" + version + ".jar"))
-        into(file(path))
-        rename { String fileName ->
-            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
-        }
-    }
-}
-
-def registerCustomOutputTaskUnix(name, path) {
-    if (System.properties['os.name'].toLowerCase().contains('windows')) {
-        return;
-    }
-
-    tasks.register('build' + name, Copy) {
-        group('development')
-        outputs.upToDateWhen { false }
-        dependsOn(iris)
-        from(new File(buildDir, "Iris-" + version + ".jar"))
-        into(file(path))
-        rename { String fileName ->
-            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
-        }
-    }
-}
-
-tasks.build.dependsOn(shadowJar)

build.gradle.kts

@@ -0,0 +1,283 @@
+import de.undercouch.gradle.tasks.download.Download
+import xyz.jpenilla.runpaper.task.RunServer
+import kotlin.system.exitProcess
+
+/*
+ * 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/>.
+ */
+
+buildscript {
+    repositories.maven("https://jitpack.io")
+    dependencies.classpath("com.github.VolmitSoftware:NMSTools:c88961416f")
+}
+
+plugins {
+    java
+    `java-library`
+    alias(libs.plugins.download)
+    alias(libs.plugins.runPaper)
+}
+
+group = "com.volmit"
+version = "3.8.0-1.20.1-1.21.10"
+
+apply<ApiGenerator>()
+
+// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
+// ======================== WINDOWS =============================
+registerCustomOutputTask("Cyberpwn", "C://Users/cyberpwn/Documents/development/server/plugins")
+registerCustomOutputTask("Psycho", "C://Dan/MinecraftDevelopment/Server/plugins")
+registerCustomOutputTask("ArcaneArts", "C://Users/arcane/Documents/development/server/plugins")
+registerCustomOutputTask("Coco", "D://mcsm/plugins")
+registerCustomOutputTask("Strange", "D://Servers/1.17 Test Server/plugins")
+registerCustomOutputTask("Vatuu", "D://Minecraft/Servers/1.19.4/plugins")
+registerCustomOutputTask("CrazyDev22", "C://Users/Julian/Desktop/server/plugins")
+registerCustomOutputTask("PixelFury", "C://Users/repix/workplace/Iris/1.21.3 - Development-Public-v3/plugins")
+registerCustomOutputTask("PixelFuryDev", "C://Users/repix/workplace/Iris/1.21 - Development-v3/plugins")
+// ========================== UNIX ==============================
+registerCustomOutputTaskUnix("CyberpwnLT", "/Users/danielmills/development/server/plugins")
+registerCustomOutputTaskUnix("PsychoLT", "/Users/brianfopiano/Developer/RemoteGit/Server/plugins")
+registerCustomOutputTaskUnix("PixelMac", "/Users/test/Desktop/mcserver/plugins")
+registerCustomOutputTaskUnix("CrazyDev22LT", "/home/julian/Desktop/server/plugins")
+// ==============================================================
+
+val serverMinHeap = "10G"
+val serverMaxHeap = "10G"
+val additionalFlags = "-XX:+AlwaysPreTouch"
+//Valid values are: none, truecolor, indexed256, indexed16, indexed8
+val color = "truecolor"
+val errorReporting = "true" == findProperty("errorReporting")
+
+val nmsBindings = mapOf(
+        "v1_21_R6" to "1.21.10-R0.1-SNAPSHOT",
+        "v1_21_R5" to "1.21.8-R0.1-SNAPSHOT",
+        "v1_21_R4" to "1.21.5-R0.1-SNAPSHOT",
+        "v1_21_R3" to "1.21.4-R0.1-SNAPSHOT",
+        "v1_21_R2" to "1.21.3-R0.1-SNAPSHOT",
+        "v1_21_R1" to "1.21.1-R0.1-SNAPSHOT",
+        "v1_20_R4" to "1.20.6-R0.1-SNAPSHOT",
+        "v1_20_R3" to "1.20.4-R0.1-SNAPSHOT",
+        "v1_20_R2" to "1.20.2-R0.1-SNAPSHOT",
+        "v1_20_R1" to "1.20.1-R0.1-SNAPSHOT",
+)
+val jvmVersion = mapOf<String, Int>()
+nmsBindings.forEach { (key, value) ->
+    project(":nms:$key") {
+        apply<JavaPlugin>()
+
+        nmsBinding {
+            jvm = jvmVersion.getOrDefault(key, 21)
+            version = value
+            type = NMSBinding.Type.DIRECT
+        }
+
+        dependencies {
+            compileOnly(project(":core"))
+            compileOnly(rootProject.libs.annotations)
+            compileOnly(rootProject.libs.byteBuddy.core)
+        }
+    }
+
+    tasks.register<RunServer>("runServer-$key") {
+        group = "servers"
+        minecraftVersion(value.split("-")[0])
+        minHeapSize = serverMinHeap
+        maxHeapSize = serverMaxHeap
+        pluginJars(tasks.jar.flatMap { it.archiveFile })
+        javaLauncher = javaToolchains.launcherFor { languageVersion = JavaLanguageVersion.of(jvmVersion.getOrDefault(key, 21))}
+        runDirectory.convention(layout.buildDirectory.dir("run/$key"))
+        systemProperty("disable.watchdog", "true")
+        systemProperty("net.kyori.ansi.colorLevel", color)
+        systemProperty("com.mojang.eula.agree", true)
+        systemProperty("iris.suppressReporting", !errorReporting)
+        jvmArgs("-javaagent:${project(":core:agent").tasks.jar.flatMap { it.archiveFile }.get().asFile.absolutePath}")
+        jvmArgs(additionalFlags.split(' '))
+    }
+}
+
+val included: Configuration by configurations.creating
+val jarJar: Configuration by configurations.creating
+dependencies {
+    for (key in nmsBindings.keys) {
+        included(project(":nms:$key", "reobf"))
+    }
+    included(project(":core", "shadow"))
+    jarJar(project(":core:agent"))
+}
+
+tasks {
+    jar {
+        inputs.files(included)
+        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+        from(jarJar, provider { included.resolve().map(::zipTree) })
+        archiveFileName.set("Iris-${project.version}.jar")
+    }
+
+    register<Copy>("iris") {
+        group = "iris"
+        dependsOn("jar")
+        from(layout.buildDirectory.file("libs/Iris-${project.version}.jar"))
+        into(layout.buildDirectory)
+    }
+
+    register<Copy>("irisDev") {
+        group = "iris"
+        from(project(":core").layout.buildDirectory.files("libs/core-javadoc.jar", "libs/core-sources.jar"))
+        rename { it.replace("core", "Iris-${project.version}") }
+        into(layout.buildDirectory)
+        dependsOn(":core:sourcesJar")
+        dependsOn(":core:javadocJar")
+    }
+
+    val cli = file("sentry-cli.exe")
+    register<Download>("downloadCli") {
+        group = "io.sentry"
+        src("https://release-registry.services.sentry.io/apps/sentry-cli/latest?response=download&arch=x86_64&platform=${System.getProperty("os.name")}&package=sentry-cli")
+        dest(cli)
+
+        doLast {
+            cli.setExecutable(true)
+        }
+    }
+
+    register("release") {
+        group = "io.sentry"
+        dependsOn("downloadCli")
+        doLast {
+            val url = "http://sentry.volmit.com:8080"
+            val authToken = project.findProperty("sentry.auth.token") ?: System.getenv("SENTRY_AUTH_TOKEN")
+            val org = "sentry"
+            val projectName = "iris"
+            exec(cli, "--url", url , "--auth-token", authToken, "releases", "new", "-o", org, "-p", projectName, version)
+            exec(cli, "--url", url , "--auth-token", authToken, "releases", "set-commits", "-o", org, "-p", projectName, version, "--auto", "--ignore-missing")
+            //exec(cli, "--url", url, "--auth-token", authToken, "releases", "finalize", "-o", org, "-p", projectName, version)
+            cli.delete()
+        }
+    }
+}
+
+fun exec(vararg command: Any) {
+    val p = ProcessBuilder(command.map { it.toString() })
+        .start()
+    p.inputStream.reader().useLines { it.forEach(::println) }
+    p.errorStream.reader().useLines { it.forEach(::println) }
+    p.waitFor()
+}
+
+configurations.configureEach {
+    resolutionStrategy.cacheChangingModulesFor(60, "minutes")
+    resolutionStrategy.cacheDynamicVersionsFor(60, "minutes")
+}
+
+allprojects {
+    apply<JavaPlugin>()
+
+    repositories {
+        mavenCentral()
+        maven("https://repo.papermc.io/repository/maven-public/")
+        maven("https://repo.codemc.org/repository/maven-public/")
+
+        maven("https://jitpack.io") // EcoItems, score
+        maven("https://repo.nexomc.com/releases/") // nexo
+        maven("https://maven.devs.beer/") // itemsadder
+        maven("https://repo.extendedclip.com/releases/") // placeholderapi
+        maven("https://mvn.lumine.io/repository/maven-public/") // mythic
+        maven("https://nexus.phoenixdevt.fr/repository/maven-public/") //MMOItems
+        maven("https://repo.onarandombox.com/content/groups/public/") //Multiverse Core
+    }
+
+    dependencies {
+        // Provided or Classpath
+        compileOnly(rootProject.libs.lombok)
+        annotationProcessor(rootProject.libs.lombok)
+    }
+
+    /**
+     * We need parameter meta for the decree command system
+     */
+    tasks {
+        compileJava {
+            options.compilerArgs.add("-parameters")
+            options.encoding = "UTF-8"
+        }
+
+        javadoc {
+            options.encoding = "UTF-8"
+            options.quiet()
+            //options.addStringOption("Xdoclint:none") // TODO: Re-enable this
+        }
+
+        register<Jar>("sourcesJar") {
+            archiveClassifier.set("sources")
+            from(sourceSets.main.map { it.allSource })
+        }
+
+        register<Jar>("javadocJar") {
+            archiveClassifier.set("javadoc")
+            from(javadoc.map { it.destinationDir!! })
+        }
+    }
+}
+
+if (JavaVersion.current().toString() != "21") {
+    System.err.println()
+    System.err.println("=========================================================================================================")
+    System.err.println("You must run gradle on Java 21. You are using " + JavaVersion.current())
+    System.err.println()
+    System.err.println("=== For IDEs ===")
+    System.err.println("1. Configure the project for Java 21")
+    System.err.println("2. Configure the bundled gradle to use Java 21 in settings")
+    System.err.println()
+    System.err.println("=== For Command Line (gradlew) ===")
+    System.err.println("1. Install JDK 21 from https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html")
+    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-21.0.4")
+    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
+    System.err.println("=========================================================================================================")
+    System.err.println()
+    exitProcess(69)
+}
+
+
+fun registerCustomOutputTask(name: String, path: String) {
+    if (!System.getProperty("os.name").lowercase().contains("windows")) {
+        return
+    }
+
+    tasks.register<Copy>("build$name") {
+        group = "development"
+        outputs.upToDateWhen { false }
+        dependsOn("iris")
+        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
+        into(file(path))
+        rename { "Iris.jar" }
+    }
+}
+
+fun registerCustomOutputTaskUnix(name: String, path: String) {
+    if (System.getProperty("os.name").lowercase().contains("windows")) {
+        return
+    }
+
+    tasks.register<Copy>("build$name") {
+        group = "development"
+        outputs.upToDateWhen { false }
+        dependsOn("iris")
+        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
+        into(file(path))
+        rename { "Iris.jar" }
+    }
+}

buildSrc/build.gradle.kts

@@ -0,0 +1,16 @@
+plugins {
+    kotlin("jvm") version embeddedKotlinVersion
+}
+
+repositories {
+    mavenCentral()
+    gradlePluginPortal()
+    maven("https://jitpack.io")
+}
+
+dependencies {
+    implementation("org.ow2.asm:asm:9.8")
+    implementation("com.github.VolmitSoftware:NMSTools:c88961416f")
+    implementation("io.papermc.paperweight:paperweight-userdev:2.0.0-beta.18")
+    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
+}

buildSrc/src/main/kotlin/ApiGenerator.kt

@@ -0,0 +1,121 @@
+import org.gradle.api.DefaultTask
+import org.gradle.api.Plugin
+import org.gradle.api.Project
+import org.gradle.api.publish.PublishingExtension
+import org.gradle.api.publish.maven.MavenPublication
+import org.gradle.api.tasks.InputFile
+import org.gradle.api.tasks.OutputFile
+import org.gradle.api.tasks.TaskAction
+import org.gradle.jvm.tasks.Jar
+import org.objectweb.asm.*
+import java.io.File
+import java.util.jar.JarFile
+import java.util.jar.JarOutputStream
+
+class ApiGenerator : Plugin<Project> {
+    override fun apply(target: Project): Unit = with(target) {
+        plugins.apply("maven-publish")
+        val task = tasks.register("irisApi", GenerateApiTask::class.java)
+        extensions.findByType(PublishingExtension::class.java)!!.apply {
+            repositories.maven {
+                it.name = "deployDir"
+                it.url = targetDirectory.toURI()
+            }
+
+            publications.create("maven", MavenPublication::class.java) {
+                it.groupId = name
+                it.version = version.toString()
+                it.artifact(task)
+            }
+        }
+    }
+}
+
+abstract class GenerateApiTask : DefaultTask() {
+    init {
+        group = "iris"
+        dependsOn("jar")
+        finalizedBy("publishMavenPublicationToDeployDirRepository")
+        doLast {
+            logger.lifecycle("The API is located at ${outputFile.absolutePath}")
+        }
+    }
+
+    @InputFile
+    val inputFile: File = project.tasks
+        .named("jar", Jar::class.java)
+        .get()
+        .archiveFile
+        .get()
+        .asFile
+
+    @OutputFile
+    val outputFile: File = project.targetDirectory.resolve(inputFile.name)
+
+    @TaskAction
+    fun generate() {
+        JarFile(inputFile).use { jar ->
+            JarOutputStream(outputFile.apply { parentFile?.mkdirs() }.outputStream()).use { out ->
+                jar.stream()
+                    .parallel()
+                    .filter { !it.isDirectory }
+                    .filter { it.name.endsWith(".class") }
+                    .forEach {
+                        val bytes = jar.getInputStream(it).use { input ->
+                            val writer = ClassWriter(ClassWriter.COMPUTE_MAXS)
+                            val visitor = MethodClearingVisitor(writer)
+                            ClassReader(input).accept(visitor, 0)
+                            writer.toByteArray()
+                        }
+
+                        synchronized(out) {
+                            out.putNextEntry(it)
+                            out.write(bytes)
+                            out.closeEntry()
+                        }
+                    }
+            }
+        }
+    }
+}
+
+val Project.targetDirectory: File get() {
+    val dir = System.getenv("DEPLOY_DIR") ?: return project.layout.buildDirectory.dir("api").get().asFile
+    return File(dir)
+}
+
+private class MethodClearingVisitor(
+    cv: ClassVisitor
+) : ClassVisitor(Opcodes.ASM9, cv) {
+
+    override fun visitMethod(
+        access: Int,
+        name: String?,
+        descriptor: String?,
+        signature: String?,
+        exceptions: Array<out String>?
+    ) = ExceptionThrowingMethodVisitor(super.visitMethod(access, name, descriptor, signature, exceptions))
+}
+
+private class ExceptionThrowingMethodVisitor(
+    mv: MethodVisitor
+) : MethodVisitor(Opcodes.ASM9, mv) {
+
+    override fun visitCode() {
+        if (mv == null) return
+        mv.visitCode()
+
+        mv.visitTypeInsn(Opcodes.NEW, "java/lang/IllegalStateException")
+        mv.visitInsn(Opcodes.DUP)
+        mv.visitLdcInsn("Only API")
+        mv.visitMethodInsn(
+            Opcodes.INVOKESPECIAL,
+            "java/lang/IllegalStateException",
+            "<init>", "(Ljava/lang/String;)V", false
+        )
+        mv.visitInsn(Opcodes.ATHROW)
+
+        mv.visitMaxs(0, 0)
+        mv.visitEnd()
+    }
+}

buildSrc/src/main/kotlin/NMSBinding.kt

@@ -0,0 +1,182 @@
+import NMSBinding.Type
+import com.volmit.nmstools.NMSToolsExtension
+import com.volmit.nmstools.NMSToolsPlugin
+import io.papermc.paperweight.userdev.PaperweightUser
+import io.papermc.paperweight.userdev.PaperweightUserDependenciesExtension
+import io.papermc.paperweight.userdev.PaperweightUserExtension
+import io.papermc.paperweight.userdev.attribute.Obfuscation
+import io.papermc.paperweight.util.constants.REOBF_CONFIG
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.launch
+import kotlinx.coroutines.runBlocking
+import org.gradle.api.*
+import org.gradle.api.attributes.Bundling
+import org.gradle.api.attributes.Category
+import org.gradle.api.attributes.LibraryElements
+import org.gradle.api.attributes.Usage
+import org.gradle.api.model.ObjectFactory
+import org.gradle.api.plugins.JavaPluginExtension
+import org.gradle.api.tasks.TaskAction
+import org.gradle.internal.extensions.core.extra
+import org.gradle.jvm.toolchain.JavaLanguageVersion
+import org.gradle.jvm.toolchain.JavaToolchainService
+import org.gradle.work.DisableCachingByDefault
+import java.io.RandomAccessFile
+import javax.inject.Inject
+
+class NMSBinding : Plugin<Project> {
+    override fun apply(target: Project): Unit = with(target) {
+        val config = extra["nms"] as? Config ?: throw GradleException("No NMS binding configuration found")
+        val jvm = config.jvm
+        val type = config.type
+
+        if (type == Type.USER_DEV) {
+            plugins.apply(PaperweightUser::class.java)
+            dependencies.extensions.findByType(PaperweightUserDependenciesExtension::class.java)
+                ?.paperDevBundle(config.version)
+
+            val java = extensions.findByType(JavaPluginExtension::class.java) ?: throw GradleException("Java plugin not found")
+            java.toolchain.languageVersion.set(JavaLanguageVersion.of(jvm))
+
+            val javaToolchains = project.extensions.getByType(JavaToolchainService::class.java) ?: throw GradleException("Java toolchain service not found")
+            extensions.configure(PaperweightUserExtension::class.java) {
+                it.javaLauncher.set(javaToolchains.launcherFor(java.toolchain))
+            }
+        } else {
+            extra["nmsTools.useBuildTools"] = type == Type.BUILD_TOOLS
+            plugins.apply(NMSToolsPlugin::class.java)
+            extensions.configure(NMSToolsExtension::class.java) {
+                it.jvm.set(jvm)
+                it.version.set(config.version)
+            }
+
+            configurations.register(REOBF_CONFIG) { conf ->
+                conf.isCanBeConsumed = true
+                conf.isCanBeResolved = false
+                conf.attributes {
+                    it.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
+                    it.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
+                    it.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
+                    it.attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
+                    it.attribute(Obfuscation.OBFUSCATION_ATTRIBUTE, objects.named(Obfuscation.OBFUSCATED))
+                }
+                conf.outgoing.artifact(tasks.named("remap"))
+            }
+        }
+
+        val (major, minor) = config.version.parseVersion()
+        if (major <= 20 && minor <= 4) return@with
+        tasks.register("convert", ConversionTask::class.java, type)
+        tasks.named("compileJava") { it.dependsOn("convert") }
+        rootProject.tasks.named("prepareKotlinBuildScriptModel") { it.dependsOn("$path:convert") }
+    }
+
+    @DisableCachingByDefault
+    abstract class ConversionTask @Inject constructor(type: Type) : DefaultTask() {
+        private val pattern: Regex
+        private val replacement: String
+
+        init {
+            group = "nms"
+            inputs.property("type", type)
+            val java = project.extensions.findByType(JavaPluginExtension::class.java) ?: throw GradleException("Java plugin not found")
+            val source = java.sourceSets.named("main").map { it.allJava }
+            inputs.files(source)
+            outputs.files(source)
+
+            if (type == Type.USER_DEV) {
+                pattern = "org\\.bukkit\\.craftbukkit\\.${project.name}".toRegex()
+                replacement = "org.bukkit.craftbukkit"
+            } else {
+                pattern = "org\\.bukkit\\.craftbukkit\\.(?!${project.name})".toRegex()
+                replacement = "org.bukkit.craftbukkit.${project.name}."
+            }
+        }
+
+        @TaskAction
+        fun process() {
+            val dispatcher = Dispatchers.IO.limitedParallelism(16)
+            runBlocking {
+                for (file in inputs.files) {
+                    if (file.extension !in listOf("java"))
+                        continue
+
+                    launch(dispatcher) {
+                        val output = ArrayList<String>()
+                        var changed = false
+
+                        file.bufferedReader().use {
+                            for (line in it.lines()) {
+                                if (line.startsWith("package") || line.isBlank()) {
+                                    output += line
+                                    continue
+                                }
+
+                                if (!line.startsWith("import")) {
+                                    if (!changed) return@launch
+                                    else {
+                                        output += line
+                                        continue
+                                    }
+                                }
+
+                                if (!line.contains(pattern)) {
+                                    output += line
+                                    continue
+                                }
+
+                                output += line.replace(pattern, replacement)
+                                changed = true
+                            }
+                        }
+
+                        if (changed) {
+                            RandomAccessFile(file, "r").use { raf ->
+                                val bytes = ByteArray(NEW_LINE_BYTES.size)
+                                raf.seek(raf.length() - bytes.size)
+                                raf.readFully(bytes)
+                                if (bytes.contentEquals(NEW_LINE_BYTES))
+                                    output += ""
+                            }
+
+                            file.writer().use {
+                                val iterator = output.iterator()
+                                while (iterator.hasNext()) {
+                                    it.append(iterator.next())
+                                    if (iterator.hasNext())
+                                        it.append(NEW_LINE)
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    enum class Type {
+        USER_DEV,
+        BUILD_TOOLS,
+        DIRECT,
+    }
+}
+
+private val NEW_LINE = System.lineSeparator()
+private val NEW_LINE_BYTES = NEW_LINE.encodeToByteArray()
+private fun String.parseVersion() = substringBefore('-').split(".").let {
+    it[1].toInt() to it[2].toInt()
+}
+
+class Config(
+    var jvm: Int = 21,
+    var type: Type = Type.DIRECT
+) {
+    lateinit var version: String
+}
+
+fun Project.nmsBinding(action: Config.() -> Unit) {
+    extra["nms"] = Config().apply(action)
+    plugins.apply(NMSBinding::class.java)
+}
+
+private inline fun <reified T : Named> ObjectFactory.named(name: String): T = named(T::class.java, name)

core/agent/build.gradle.kts

@@ -0,0 +1,12 @@
+plugins {
+    java
+}
+
+tasks.jar {
+    manifest.attributes(
+        "Agent-Class" to "com.volmit.iris.util.agent.Installer",
+        "Premain-Class" to "com.volmit.iris.util.agent.Installer",
+        "Can-Redefine-Classes" to true,
+        "Can-Retransform-Classes" to true
+    )
+}

core/agent/src/main/java/com/volmit/iris/util/agent/Installer.java

@@ -0,0 +1,29 @@
+package com.volmit.iris.util.agent;
+
+import java.lang.instrument.Instrumentation;
+
+public class Installer {
+    private static volatile Instrumentation instrumentation;
+
+    public static Instrumentation getInstrumentation() {
+        Instrumentation instrumentation = Installer.instrumentation;
+        if (instrumentation == null) {
+            throw new IllegalStateException("The agent is not loaded or this method is not called via the system class loader");
+        }
+        return instrumentation;
+    }
+
+    public static void premain(String arguments, Instrumentation instrumentation) {
+        doMain(instrumentation);
+    }
+
+    public static void agentmain(String arguments, Instrumentation instrumentation) {
+        doMain(instrumentation);
+    }
+
+    private static synchronized void doMain(Instrumentation instrumentation) {
+        if (Installer.instrumentation != null)
+            return;
+        Installer.instrumentation = instrumentation;
+    }
+}

core/build.gradle

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

core/build.gradle.kts

@@ -0,0 +1,215 @@
+import io.github.slimjar.func.slimjarHelper
+import io.github.slimjar.resolver.data.Mirror
+import org.ajoberstar.grgit.Grgit
+import java.net.URI
+
+/*
+ * 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 {
+    java
+    `java-library`
+    alias(libs.plugins.shadow)
+    alias(libs.plugins.sentry)
+    alias(libs.plugins.slimjar)
+    alias(libs.plugins.grgit)
+    alias(libs.plugins.kotlin.jvm)
+    alias(libs.plugins.kotlin.lombok)
+}
+
+val apiVersion = "1.19"
+val main = "com.volmit.iris.Iris"
+val lib = "com.volmit.iris.util"
+
+/**
+ * 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(libs.spigot)
+    compileOnly(libs.log4j.api)
+    compileOnly(libs.log4j.core)
+
+    // Third Party Integrations
+    compileOnly(libs.nexo)
+    compileOnly(libs.itemsadder)
+    compileOnly(libs.placeholderApi)
+    compileOnly(libs.score)
+    compileOnly(libs.mmoitems)
+    compileOnly(libs.ecoitems)
+    compileOnly(libs.mythic)
+    compileOnly(libs.mythicChrucible)
+    compileOnly(libs.kgenerators) {
+        isTransitive = false
+    }
+    compileOnly(libs.multiverseCore)
+
+    // Shaded
+    implementation(slimjarHelper("spigot"))
+
+    // Dynamically Loaded
+    slim(libs.paralithic)
+    slim(libs.paperlib)
+    slim(libs.adventure.api)
+    slim(libs.adventure.minimessage)
+    slim(libs.adventure.platform)
+    slim(libs.bstats)
+    slim(libs.sentry)
+
+    slim(libs.commons.io)
+    slim(libs.commons.lang)
+    slim(libs.commons.lang3)
+    slim(libs.commons.math3)
+    slim(libs.oshi)
+    slim(libs.lz4)
+    slim(libs.fastutil)
+    slim(libs.lru)
+    slim(libs.zip)
+    slim(libs.gson)
+    slim(libs.asm)
+    slim(libs.caffeine)
+    slim(libs.byteBuddy.core)
+    slim(libs.byteBuddy.agent)
+    slim(libs.dom4j)
+    slim(libs.jaxen)
+
+    // Script Engine
+    slim(libs.kotlin.stdlib)
+    slim(libs.kotlin.coroutines)
+    slim(libs.kotlin.scripting.common)
+    slim(libs.kotlin.scripting.jvm)
+    slim(libs.kotlin.scripting.jvm.host)
+    slim(libs.kotlin.scripting.dependencies.maven) {
+        constraints {
+            slim(libs.mavenCore)
+        }
+    }
+}
+
+java {
+    disableAutoTargetJvm()
+}
+
+sentry {
+    url = "http://sentry.volmit.com:8080"
+    autoInstallation.enabled = false
+    includeSourceContext = true
+
+    org = "sentry"
+    projectName = "iris"
+    authToken = findProperty("sentry.auth.token") as String? ?: System.getenv("SENTRY_AUTH_TOKEN")
+}
+
+slimJar {
+    mirrors = listOf(Mirror(
+        URI.create("https://maven-central.storage-download.googleapis.com/maven2").toURL(),
+        URI.create("https://repo.maven.apache.org/maven2/").toURL()
+    ))
+
+    relocate("com.dfsek.paralithic", "$lib.paralithic")
+    relocate("io.papermc.lib", "$lib.paper")
+    relocate("net.kyori", "$lib.kyori")
+    relocate("org.bstats", "$lib.metrics")
+    relocate("io.sentry", "$lib.sentry")
+    relocate("org.apache.maven", "$lib.maven")
+    relocate("org.codehaus.plexus", "$lib.plexus")
+    relocate("org.eclipse.sisu", "$lib.sisu")
+    relocate("org.eclipse.aether", "$lib.aether")
+    relocate("com.google.inject", "$lib.guice")
+    relocate("org.dom4j", "$lib.dom4j")
+    relocate("org.jaxen", "$lib.jaxen")
+    relocate("com.github.benmanes.caffeine", "$lib.caffeine")
+}
+
+tasks {
+    /**
+     * We need parameter meta for the decree command system
+     */
+    compileJava {
+        options.compilerArgs.add("-parameters")
+        options.encoding = "UTF-8"
+    }
+
+    /**
+     * Expand properties into plugin yml
+     */
+    processResources {
+        inputs.properties(
+            "name" to rootProject.name,
+            "version" to rootProject.version,
+            "apiVersion" to apiVersion,
+            "main" to main,
+        )
+        filesMatching("**/plugin.yml") {
+            expand(inputs.properties)
+        }
+    }
+
+    shadowJar {
+        mergeServiceFiles()
+        //minimize()
+        relocate("io.github.slimjar", "$lib.slimjar")
+        exclude("modules/loader-agent.isolated-jar")
+    }
+
+    sentryCollectSourcesJava {
+        dependsOn(generateTemplates)
+    }
+}
+
+val templateSource = file("src/main/templates")
+val templateDest = layout.buildDirectory.dir("generated/sources/templates")
+val generateTemplates = tasks.register<Copy>("generateTemplates") {
+    inputs.properties(
+        "environment" to if (project.hasProperty("release")) "production" else "development",
+        "commit" to provider {
+            val res = runCatching { project.extensions.getByType<Grgit>().head().id }
+            res.getOrDefault("")
+                .takeIf { it.length == 40 } ?: run {
+                this.logger.error("Git commit hash not found", res.exceptionOrNull())
+                "unknown"
+            }
+        },
+    )
+
+    from(templateSource)
+    into(templateDest)
+    rename { "com/volmit/iris/$it" }
+    expand(inputs.properties)
+}
+
+tasks.generateSentryBundleIdJava {
+    dependsOn(generateTemplates)
+}
+
+rootProject.tasks.named("prepareKotlinBuildScriptModel") {
+    dependsOn(generateTemplates)
+}
+
+sourceSets.main {
+    java.srcDir(generateTemplates.map { it.outputs })
+}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -22,32 +22,26 @@ import com.google.gson.JsonObject;
 import com.google.gson.JsonParseException;
 import com.google.gson.JsonParser;
 import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.IrisWorlds;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.link.IrisPapiExpansion;
 import com.volmit.iris.core.link.MultiverseCoreLink;
-import com.volmit.iris.core.link.MythicMobsLink;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.safeguard.IrisSafeguard;
-import com.volmit.iris.core.safeguard.UtilsSFG;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.EnginePanic;
-import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisCompat;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
-import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.core.safeguard.IrisSafeguard;
-import com.volmit.iris.server.master.IrisMasterServer;
+import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.server.node.IrisServer;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.exceptions.IrisException;
 import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.function.NastyRunnable;
 import com.volmit.iris.util.io.FileWatcher;
 import com.volmit.iris.util.io.IO;
@@ -55,34 +49,23 @@ 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.misc.Bindings;
+import com.volmit.iris.util.misc.SlimJar;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.IrisService;
-import com.volmit.iris.util.plugin.Metrics;
 import com.volmit.iris.util.plugin.VolmitPlugin;
 import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.reflect.ShadeFix;
+import com.volmit.iris.util.plugin.chunk.ChunkTickets;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.Queue;
 import com.volmit.iris.util.scheduling.ShurikenQueue;
-import io.papermc.lib.PaperLib;
+import lombok.NonNull;
-import net.bytebuddy.agent.ByteBuddyAgent;
-import net.kyori.adventure.platform.bukkit.BukkitAudiences;
-import net.kyori.adventure.text.serializer.ComponentSerializer;
-import org.apache.commons.io.FileUtils;
-import org.apache.commons.io.filefilter.IOFileFilter;
-import org.apache.commons.io.filefilter.TrueFileFilter;
 import org.bukkit.*;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
-import org.bukkit.event.Event;
+import org.bukkit.event.*;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.Listener;
 import org.bukkit.generator.BiomeProvider;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.plugin.IllegalPluginAccessException;
@@ -94,29 +77,25 @@ import java.io.*;
 import java.lang.annotation.Annotation;
 import java.net.URL;
 import java.util.*;
+import java.util.function.Predicate;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 
-import static com.volmit.iris.core.safeguard.IrisSafeguard.InitializeSafeguard;
-
 @SuppressWarnings("CanBeFinal")
 public class Iris extends VolmitPlugin implements Listener {
-    public static final String OVERWORLD_TAG = "3800";
-
     private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
 
     public static Iris instance;
-    public static BukkitAudiences audiences;
+    public static Bindings.Adventure audiences;
     public static MultiverseCoreLink linkMultiverseCore;
-    public static MythicMobsLink linkMythicMobs;
     public static IrisCompat compat;
     public static FileWatcher configWatcher;
-    private static IrisServer server;
+    public static ChunkTickets tickets;
     private static VolmitSender sender;
+    private static Thread shutdownHook;
 
     static {
         try {
-            fixShading();
             InstanceState.updateInstanceId();
         } catch (Throwable ignored) {
 
@@ -324,10 +303,6 @@ public class Iris extends VolmitPlugin implements Listener {
         msg(C.WHITE + String.format(format, args));
     }
 
-    public static void safeguard(String format, Object... args) {
-        msg(C.RESET + String.format(format, args));
-    }
-
     @SuppressWarnings("deprecation")
     public static void later(NastyRunnable object) {
         try {
@@ -394,6 +369,8 @@ public class Iris extends VolmitPlugin implements Listener {
     }
 
     public static void reportError(Throwable e) {
+        Bindings.capture(e);
+        if (IrisSettings.get().getGeneral().isDebug()) {
             String n = e.getClass().getCanonicalName() + "-" + e.getStackTrace()[0].getClassName() + "-" + e.getStackTrace()[0].getLineNumber();
 
             if (e.getCause() != null) {
@@ -414,6 +391,7 @@ public class Iris extends VolmitPlugin implements Listener {
 
             Iris.debug("Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
         }
+    }
 
     public static void dump() {
         try {
@@ -449,61 +427,29 @@ public class Iris extends VolmitPlugin implements Listener {
         EnginePanic.add(s, v);
     }
 
-    private static void fixShading() {
+    public Iris() {
-        ShadeFix.fix(ComponentSerializer.class);
+        instance = this;
+        SlimJar.load();
     }
 
     private void enable() {
-        instance = this;
-        InitializeSafeguard();
-        ByteBuddyAgent.install();
         services = new KMap<>();
         setupAudience();
+        Bindings.setupSentry();
         initialize("com.volmit.iris.core.service").forEach((i) -> services.put((Class<? extends IrisService>) i.getClass(), (IrisService) i));
-        INMS.get();
         IO.delete(new File("iris"));
-        IrisSafeguard.instance.IrisSafeguardSystem();
-        getSender().setTag(getTag());
-        INMS.get().injectBukkit();
-        if (IrisSafeguard.instance.unstablemode && !IrisSafeguard.instance.acceptUnstable)
-            IrisSafeguard.instance.earlySplash();
         compat = IrisCompat.configured(getDataFile("compat.json"));
+        ServerConfigurator.configure();
+        IrisSafeguard.execute();
+        getSender().setTag(getTag());
+        IrisSafeguard.splash();
+        tickets = new ChunkTickets();
         linkMultiverseCore = new MultiverseCoreLink();
-        linkMythicMobs = new MythicMobsLink();
         configWatcher = new FileWatcher(getDataFile("settings.json"));
         services.values().forEach(IrisService::onEnable);
         services.values().forEach(this::registerListener);
-        ServerConfigurator.setupDataPack();
+        addShutdownHook();
-        installMainDimension();
-        try {
-            info("Starting server...");
-            try {
-                int port = Integer.parseInt(System.getProperty("com.volmit.iris.server.port"));
-                String[] remote = Optional.ofNullable(System.getProperty("com.volmit.iris.server.remote"))
-                        .map(String::trim)
-                        .map(s -> s.isBlank() ? null : s.split(","))
-                        .orElse(new String[0]);
-                server = remote.length > 0 ? new IrisMasterServer(port, remote) : new IrisServer(port);
-            } catch (NullPointerException | NumberFormatException ignored) {
-                var serverSettings = IrisSettings.get().getServer();
-                if (serverSettings.isActive()) {
-                    server = serverSettings.isRemote() ?
-                            new IrisMasterServer(serverSettings.getPort(), serverSettings.remote) :
-                            new IrisServer(serverSettings.getPort());
-                }
-            }
-        } catch (InterruptedException ignored) {
-        } catch (Throwable e) {
-            error("Failed to start server: " + e.getClass().getSimpleName());
-            e.printStackTrace();
-        }
-
-        if (!IrisSafeguard.instance.acceptUnstable && IrisSafeguard.instance.unstablemode) {
-            Iris.info(C.RED + "World loading has been disabled until the incompatibility is resolved.");
-            Iris.info(C.DARK_RED + "Alternatively, go to plugins/iris/settings.json and set ignoreBootMode to true.");
-        } else {
         J.s(() -> {
-                J.a(() -> PaperLib.suggestPaper(this));
             J.a(() -> IO.delete(getTemp()));
             J.a(LazyPregenerator::loadLazyGenerators, 100);
             J.a(this::bstats);
@@ -511,83 +457,57 @@ public class Iris extends VolmitPlugin implements Listener {
             J.sr(this::tickQueue, 0);
             J.s(this::setupPapi);
             J.a(ServerConfigurator::configure, 20);
-                splash();
+
-                UtilsSFG.splash();
             autoStartStudio();
-                checkForBukkitWorlds();
+            checkForBukkitWorlds(s -> true);
             IrisToolbelt.retainMantleDataForSlice(String.class.getCanonicalName());
             IrisToolbelt.retainMantleDataForSlice(BlockData.class.getCanonicalName());
         });
     }
+
+    public void addShutdownHook() {
+        if (shutdownHook != null) {
+            Runtime.getRuntime().removeShutdownHook(shutdownHook);
+        }
+        shutdownHook = new Thread(() -> {
+            Bukkit.getWorlds()
+                    .stream()
+                    .map(IrisToolbelt::access)
+                    .filter(Objects::nonNull)
+                    .forEach(PlatformChunkGenerator::close);
+
+            MultiBurst.burst.close();
+            MultiBurst.ioBurst.close();
+            services.clear();
+        });
+        Runtime.getRuntime().addShutdownHook(shutdownHook);
     }
 
-    private void checkForBukkitWorlds() {
+    public void checkForBukkitWorlds(Predicate<String> filter) {
-        FileConfiguration fc = new YamlConfiguration();
         try {
-            fc.load(new File("bukkit.yml"));
+            IrisWorlds.readBukkitWorlds().forEach((s, generator) -> {
-            ConfigurationSection section = fc.getConfigurationSection("worlds");
-            if (section == null) {
-                return;
-            }
-
-            for (String s : section.getKeys(false)) {
                 try {
+                    if (Bukkit.getWorld(s) != null || !filter.test(s)) return;
 
-                    ConfigurationSection entry = section.getConfigurationSection(s);
+                    Iris.info("Loading World: %s | Generator: %s", s, generator);
-                    if (!entry.contains("backup-generator", true)) {
+                    var gen = getDefaultWorldGenerator(s, generator);
-                        continue;
+                    var dim = loadDimension(s, generator);
-                    }
+                    assert dim != null && gen != null;
-
-                    String generator = entry.getString("backup-generator");
-                    if (!generator.startsWith("Iris")) {
-                        continue;
-                    }
-
-                    if (new File(Bukkit.getWorldContainer().getPath() + "/" + s).exists()) {
-                        File world = new File(Bukkit.getWorldContainer().getPath() + "/" + s + "/iris/engine-data/");
-                        IOFileFilter jsonFilter = org.apache.commons.io.filefilter.FileFilterUtils.suffixFileFilter(".json");
-                        Collection<File> files = FileUtils.listFiles(world, jsonFilter, TrueFileFilter.INSTANCE);
-                        if (files.size() != 1) {
-                            Iris.info(C.DARK_GRAY + "------------------------------------------");
-                            Iris.info(C.RED + "Failed to load " + C.GRAY + s + C.RED + ". No valid engine-data file was found.");
-                            Iris.info(C.DARK_GRAY + "------------------------------------------");
-                            continue;
-                        }
-
-                        for (File file : files) {
-                            int lastDotIndex = file.getName().lastIndexOf(".");
-                            generator = file.getName().substring(0, lastDotIndex);
-                        }
-                    } else {
-                        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)
+                    WorldCreator c = new WorldCreator(s)
-                            .generator(getDefaultWorldGenerator(s, generator))
+                            .generator(gen)
-                            .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                            .environment(dim.getEnvironment());
-                            .createWorld();
+                    INMS.get().createWorld(c);
                     Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
-                } catch (Exception e) {
+                } catch (Throwable e) {
-                    Iris.info(C.DARK_GRAY + "------------------------------------------");
+                    Iris.error("Failed to load world " + s + "!");
-                    Iris.info(C.RED + "Failed to load " + C.GRAY + s);
+                    e.printStackTrace();
-                    Iris.info(C.DARK_GRAY + "------------------------------------------");
-                }
                 }
+            });
         } catch (Throwable e) {
             e.printStackTrace();
+            reportError(e);
         }
     }
 
@@ -598,21 +518,22 @@ public class Iris extends VolmitPlugin implements Listener {
                 Player r = new KList<>(getServer().getOnlinePlayers()).getRandom();
                 Iris.service(StudioSVC.class).open(r != null ? new VolmitSender(r) : getSender(), 1337, IrisSettings.get().getGenerator().getDefaultWorldType(), (w) -> {
                     J.s(() -> {
+                        var spawn = w.getSpawnLocation();
                         for (Player i : getServer().getOnlinePlayers()) {
                             i.setGameMode(GameMode.SPECTATOR);
-                            i.teleport(new Location(w, 0, 200, 0));
+                            i.teleport(spawn);
                         }
                     });
                 });
             } catch (IrisException e) {
-                e.printStackTrace();
+                reportError(e);
             }
         }
     }
 
     private void setupAudience() {
         try {
-            audiences = BukkitAudiences.create(this);
+            audiences = new Bindings.Adventure(this);
         } catch (Throwable e) {
             e.printStackTrace();
             IrisSettings.get().getGeneral().setUseConsoleCustomColors(false);
@@ -629,23 +550,17 @@ public class Iris extends VolmitPlugin implements Listener {
         enable();
         super.onEnable();
         Bukkit.getPluginManager().registerEvents(this, this);
-        setupChecks();
     }
 
     public void onDisable() {
-        Bukkit.getWorlds().stream()
+        if (IrisSafeguard.isForceShutdown()) return;
-                .filter(IrisToolbelt::isIrisWorld)
-                .forEach(w -> {
-                    Engine engine = IrisToolbelt.access(w).getEngine();
-                    engine.close();
-                });
         services.values().forEach(IrisService::onDisable);
         Bukkit.getScheduler().cancelTasks(this);
         HandlerList.unregisterAll((Plugin) this);
         postShutdown.forEach(Runnable::run);
-        services.clear();
-        MultiBurst.burst.close();
         super.onDisable();
+
+        J.attempt(new JarScanner(instance.getJarFile(), "", false)::scanAll);
     }
 
     private void setupPapi() {
@@ -666,39 +581,7 @@ public class Iris extends VolmitPlugin implements Listener {
 
     @Override
     public String getTag(String subTag) {
-        if (IrisSafeguard.instance.unstablemode) {
+        return IrisSafeguard.mode().tag(subTag);
-            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.RED + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
-        }
-        if (IrisSafeguard.instance.warningmode) {
-            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.GOLD + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
-        }
-        return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.IRIS + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
-
-    }
-
-    private boolean setupChecks() {
-        boolean passed = true;
-        Iris.info("Server type & version: " + instance.getServer().getVersion() + " | " + instance.getServer().getBukkitVersion());
-        if (INMS.get() instanceof NMSBinding1X) {
-            passed = false;
-            Iris.warn("============================================");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("Iris is not compatible with this version of Minecraft.");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("============================================");
-        }
-        if (!instance.getServer().getVersion().contains("Purpur")) {
-            passed = false;
-            Iris.info("We recommend using Purpur for the best experience with Iris.");
-            Iris.info("Purpur is a fork of Paper that is optimized for performance and stability.");
-            Iris.info("Plugins that work on Spigot / Paper work on Purpur.");
-            Iris.info("You can download it here: https://purpurmc.org");
-        }
-        return passed;
     }
 
     private void checkConfigHotload() {
@@ -731,7 +614,7 @@ public class Iris extends VolmitPlugin implements Listener {
 
     private void bstats() {
         if (IrisSettings.get().getGeneral().isPluginMetrics()) {
-            J.s(() -> new Metrics(Iris.instance, 8757));
+            Bindings.setupBstats(this);
         }
     }
 
@@ -744,48 +627,6 @@ public class Iris extends VolmitPlugin implements Listener {
         s.sendMessage(C.IRIS + "[" + C.DARK_GRAY + "Iris" + C.IRIS + "]" + C.GRAY + ": " + msg);
     }
 
-    private void installMainDimension() {
-        try {
-            Properties props = new Properties();
-            props.load(new FileInputStream("server.properties"));
-            String world = props.getProperty("level-name");
-            if (world == null) return;
-
-            FileConfiguration fc = new YamlConfiguration();
-            fc.load(new File("bukkit.yml"));
-            String id = fc.getString("worlds." + world + ".generator");
-            if (id.startsWith("Iris:")) {
-                id = id.split("\\Q:\\E")[1];
-            } else if (id.equalsIgnoreCase("Iris")) {
-                id = IrisSettings.get().getGenerator().getDefaultWorldType();
-            } else {
-                return;
-            }
-
-            IrisDimension dim;
-            if (id == null || id.isEmpty()) {
-                dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
-            } else {
-                dim = IrisData.loadAnyDimension(id);
-            }
-
-            File w = new File(Bukkit.getWorldContainer(), world);
-            File packFolder = new File(w, "/iris/pack");
-            if (!packFolder.exists() || packFolder.listFiles().length == 0) {
-                packFolder.mkdirs();
-                service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w);
-            }
-            if (packFolder.exists()) {
-                IrisDimension worldDim = IrisData.get(packFolder).getDimensionLoader().load(id);
-                if (worldDim != null) dim = worldDim;
-            }
-
-            INMS.get().registerDimension("overworld", dim);
-        } catch (Throwable e) {
-
-        }
-    }
-
     @Nullable
     @Override
     public BiomeProvider getDefaultBiomeProvider(@NotNull String worldName, @Nullable String id) {
@@ -796,42 +637,11 @@ public class Iris extends VolmitPlugin implements Listener {
     @Override
     public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
         Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
-        if (worldName.equals("test")) {
+        if (id == null || id.isEmpty()) id = IrisSettings.get().getGenerator().getDefaultWorldType();
-            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");
-
+        IrisDimension dim = loadDimension(worldName, id);
-        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.");
-            }
-        }
-        File packFolder = new File(Bukkit.getWorldContainer(), worldName + "/iris/pack");
-        if (packFolder.exists()) {
-            IrisDimension worldDim = IrisData.get(packFolder).getDimensionLoader().load(id);
-            if (worldDim != null) dim = worldDim;
         }
 
         Iris.debug("Assuming IrisDimension: " + dim.getName());
@@ -848,88 +658,42 @@ public class Iris extends VolmitPlugin implements Listener {
         Iris.debug("Generator Config: " + w.toString());
 
         File ff = new File(w.worldFolder(), "iris/pack");
-        if (!ff.exists() || ff.listFiles().length == 0) {
+        var files = ff.listFiles();
+        if (files == null || files.length == 0)
+            IO.delete(ff);
+
+        if (!ff.exists()) {
             ff.mkdirs();
             service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
         }
-        if (!INMS.get().registerDimension(worldName, dim)) {
-            throw new IllegalStateException("Unable to register dimension " + dim.getName());
-        }
-        INMS.get().reconnectAll();
 
         return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
     }
 
+    @Nullable
+    public static IrisDimension loadDimension(@NonNull String worldName, @NonNull String id) {
+        File pack = new File(Bukkit.getWorldContainer(), String.join(File.separator, worldName, "iris", "pack"));
+        var dimension = pack.isDirectory() ? IrisData.get(pack).getDimensionLoader().load(id) : null;
+        if (dimension == null) dimension = IrisData.loadAnyDimension(id, null);
+        if (dimension == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+            Iris.service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, false);
+            dimension = IrisData.loadAnyDimension(id, null);
+
+            if (dimension != null) {
+                Iris.info("Resolved missing dimension, proceeding.");
+            }
+        }
+
+        return dimension;
+    }
+
     public void splash() {
-        if (!IrisSettings.get().getGeneral().isSplashLogoStartup()) {
+        Iris.info("Server type & version: " + Bukkit.getName() + " v" + Bukkit.getVersion());
-            return;
-        }
-
-        String padd = Form.repeat(" ", 8);
-        String padd2 = Form.repeat(" ", 4);
-
-        String colorIris, colorVolmit, colorVersion;
-        if (IrisSafeguard.instance.unstablemode) {
-            colorIris = String.valueOf(C.RED);
-            colorVolmit = String.valueOf(C.DARK_RED);
-            colorVersion = String.valueOf(C.RED);
-        } else if (IrisSafeguard.instance.warningmode) {
-            colorIris = String.valueOf(C.GOLD);
-            colorVolmit = String.valueOf(C.GOLD);
-            colorVersion = String.valueOf(C.GOLD);
-        } else {
-            colorIris = String.valueOf(C.IRIS);
-            colorVolmit = "<rainbow>";
-            colorVersion = String.valueOf(C.IRIS);
-        }
-
-        String[] info = {
-                "",
-                "",
-                "",
-                "",
-                "",
-                padd2 + colorIris + " Iris",
-                padd2 + C.GRAY + " by " + colorVolmit + "Volmit Software",
-                padd2 + C.GRAY + " v" + colorVersion + getDescription().getVersion()
-        };
-
-        String[] splash = {
-                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
-                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + colorIris + "   .(((()))).                     ",
-                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + colorIris + "  .((((((())))))).                  ",
-                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + colorIris + "  ((((((((()))))))))               " + C.GRAY + " @",
-                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + colorIris + "    ((((((((-)))))))))              " + C.GRAY + " @@",
-                padd + C.GRAY + "@@@&&" + colorIris + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
-                padd + C.GRAY + "@@" + colorIris + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
-                padd + C.GRAY + "@" + colorIris + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
-                padd + C.GRAY + "" + colorIris + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
-                padd + C.GRAY + "" + colorIris + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
-                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
-        };
-
-        setupChecks();
-        Iris.info("Java: " + getJava());
-        if (!instance.getServer().getVersion().contains("Purpur")) {
-            if (instance.getServer().getVersion().contains("Spigot") && instance.getServer().getVersion().contains("Bukkit")) {
-                Iris.info(C.RED + " Iris requires paper or above to function properly..");
-            } else {
-                Iris.info(C.YELLOW + "Purpur is recommended to use with iris.");
-            }
-        }
-        if (getHardware.getProcessMemory() < 5999) {
-            Iris.warn("6GB+ Ram is recommended");
-            Iris.warn("Process Memory: " + getHardware.getProcessMemory() + " MB");
-        }
-        Iris.info("Bukkit distro: " + Bukkit.getName());
         Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
         printPacks();
 
-        for (int i = 0; i < info.length; i++) {
+        IrisSafeguard.mode().trySplash();
-            splash[i] += info[i];
-        }
-
-        Iris.info("\n\n " + new KList<>(splash).toString("\n") + "\n");
     }
 
     private void printPacks() {

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -23,8 +23,11 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONException;
 import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.misc.getHardware;
 import com.volmit.iris.util.plugin.VolmitSender;
+import lombok.AllArgsConstructor;
 import lombok.Data;
+import lombok.NoArgsConstructor;
 
 import java.io.File;
 import java.io.IOException;
@@ -33,7 +36,6 @@ import java.io.IOException;
 @Data
 public class IrisSettings {
     public static IrisSettings settings;
-    private IrisSafeGuard safeguard = new IrisSafeGuard();
     private IrisSettingsGeneral general = new IrisSettingsGeneral();
     private IrisSettingsWorld world = new IrisSettingsWorld();
     private IrisSettingsGUI gui = new IrisSettingsGUI();
@@ -42,16 +44,15 @@ public class IrisSettings {
     private IrisSettingsConcurrency concurrency = new IrisSettingsConcurrency();
     private IrisSettingsStudio studio = new IrisSettingsStudio();
     private IrisSettingsPerformance performance = new IrisSettingsPerformance();
-    private IrisWorldDump worldDump = new IrisWorldDump();
+    private IrisSettingsUpdater updater = new IrisSettingsUpdater();
-    private IrisWorldSettings irisWorldSettings = new IrisWorldSettings();
+    private IrisSettingsPregen pregen = new IrisSettingsPregen();
-    private IrisServerSettings server = new IrisServerSettings();
+    private IrisSettingsSentry sentry = new IrisSettingsSentry();
 
     public static int getThreadCount(int c) {
-        return switch (c) {
+        return Math.max(switch (c) {
             case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
-            case 0, 1, 2 -> 1;
             default -> Math.max(c, 2);
-        };
+        }, 1);
     }
 
     public static IrisSettings get() {
@@ -105,12 +106,6 @@ public class IrisSettings {
         }
     }
 
-    @Data
-    public static class IrisSafeGuard {
-        public boolean ignoreBootMode = false;
-        public boolean userUnstableWarning = true;
-    }
-
     @Data
     public static class IrisSettingsAutoconfiguration {
         public boolean configureSpigotTimeoutTime = true;
@@ -136,39 +131,97 @@ public class IrisSettings {
         public boolean markerEntitySpawningSystem = true;
         public boolean effectSystem = true;
         public boolean worldEditWandCUI = true;
+        public boolean globalPregenCache = false;
     }
 
     @Data
     public static class IrisSettingsConcurrency {
         public int parallelism = -1;
+        public int ioParallelism = -2;
+        public int worldGenParallelism = -1;
+
+        public int getWorldGenThreads() {
+            return getThreadCount(worldGenParallelism);
+        }
+    }
+
+    @Data
+    public static class IrisSettingsPregen {
+        public boolean useCacheByDefault = true;
+        public boolean useHighPriority = false;
+        public boolean useVirtualThreads = false;
+        public boolean useTicketQueue = true;
+        public int maxConcurrency = 256;
     }
 
     @Data
     public static class IrisSettingsPerformance {
+        private IrisSettingsEngineSVC engineSVC = new IrisSettingsEngineSVC();
         public boolean trimMantleInStudio = false; 
         public int mantleKeepAlive = 30;
-        public int headlessKeepAlive = 10;
+        public int noiseCacheSize = 1_024;
-        public int cacheSize = 4_096;
         public int resourceLoaderCacheSize = 1_024;
         public int objectLoaderCacheSize = 4_096;
         public int scriptLoaderCacheSize = 512;
+        public int tectonicPlateSize = -1;
+        public int mantleCleanupDelay = 200;
+
+        public int getTectonicPlateSize() {
+            if (tectonicPlateSize > 0)
+                return tectonicPlateSize;
+
+            return (int) (getHardware.getProcessMemory() / 200L);
+        }
+    }
+
+    @Data
+    public static class IrisSettingsUpdater {
+        public int maxConcurrency = 256;
+        public boolean nativeThreads = false;
+        public double threadMultiplier = 2;
+
+        public double chunkLoadSensitivity = 0.7;
+        public MsRange emptyMsRange = new MsRange(80, 100);
+        public MsRange defaultMsRange = new MsRange(20, 40);
+
+        public int getMaxConcurrency() {
+            return Math.max(Math.abs(maxConcurrency), 1);
+        }
+
+        public double getThreadMultiplier() {
+            return Math.min(Math.abs(threadMultiplier), 0.1);
+        }
+
+        public double getChunkLoadSensitivity() {
+            return Math.min(chunkLoadSensitivity, 0.9);
+        }
+    }
+
+    @Data
+    @NoArgsConstructor
+    @AllArgsConstructor
+    public static class MsRange {
+        public int min = 20;
+        public int max = 40;
     }
 
     @Data
     public static class IrisSettingsGeneral {
+        public boolean DoomsdayAnnihilationSelfDestructMode = false;
         public boolean commandSounds = true;
         public boolean debug = false;
+        public boolean dumpMantleOnError = false;
         public boolean disableNMS = false;
         public boolean pluginMetrics = true;
         public boolean splashLogoStartup = true;
         public boolean useConsoleCustomColors = true;
         public boolean useCustomColorsIngame = true;
+        public boolean adjustVanillaHeight = false;
         public String forceMainWorld = "";
         public int spinh = -20;
         public int spins = 7;
         public int spinb = 8;
         public String cartographerMessage = "Iris does not allow cartographers in its world due to crashes.";
-        public String[] dataPackPaths = new String[0];
 
 
         @SuppressWarnings("BooleanMethodIsAlwaysInverted")
@@ -177,6 +230,13 @@ public class IrisSettings {
         }
     }
 
+    @Data
+    public static class IrisSettingsSentry {
+        public boolean includeServerId = true;
+        public boolean disableAutoReporting = false;
+        public boolean debug = false;
+    }
+
     @Data
     public static class IrisSettingsGUI {
         public boolean useServerLaunchedGuis = true;
@@ -189,6 +249,10 @@ public class IrisSettings {
         public String defaultWorldType = "overworld";
         public int maxBiomeChildDepth = 4;
         public boolean preventLeafDecay = true;
+        public boolean useMulticore = false;
+        public boolean useMulticoreMantle = false;
+        public boolean offsetNoiseTypes = false;
+        public boolean earlyCustomBlocks = false;
     }
 
     @Data
@@ -200,26 +264,13 @@ public class IrisSettings {
     }
 
     @Data
-    public static class IrisWorldDump {
+    public static class IrisSettingsEngineSVC {
-        public int mcaCacheSize = 3;
+        public boolean useVirtualThreads = true;
+        public boolean forceMulticoreWrite = false;
+        public int priority = Thread.NORM_PRIORITY;
+
+        public int getPriority() {
+            return Math.max(Math.min(priority, Thread.MAX_PRIORITY), Thread.MIN_PRIORITY);
         }
-
-    @Data
-    public static class IrisServerSettings {
-        public boolean active = false;
-        public int port = 1337;
-        public String[] remote = new String[0];
-
-        public boolean isRemote() {
-            return remote.length != 0;
-        }
-    }
-
-    // todo: Goal:Have these as the default world settings and when put in bukkit.yml it will again overwrite that world from these.
-    @Data
-    public static class IrisWorldSettings {
-        public boolean dynamicEntityAdjustments;
-
-
     }
 }

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

@@ -0,0 +1,126 @@
+package com.volmit.iris.core;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.engine.data.cache.AtomicCache;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.io.IO;
+import com.volmit.iris.util.misc.ServerProperties;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.lang.reflect.Type;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+public class IrisWorlds {
+    private static final AtomicCache<IrisWorlds> cache = new AtomicCache<>();
+    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
+    private static final Type TYPE = TypeToken.getParameterized(KMap.class, String.class, String.class).getType();
+    private final KMap<String, String> worlds;
+    private volatile boolean dirty = false;
+
+    private IrisWorlds(KMap<String, String> worlds) {
+        this.worlds = worlds;
+        readBukkitWorlds().forEach(this::put0);
+        save();
+    }
+
+    public static IrisWorlds get() {
+        return cache.aquire(() -> {
+            File file = Iris.instance.getDataFile("worlds.json");
+            if (!file.exists()) {
+                return new IrisWorlds(new KMap<>());
+            }
+
+            try {
+                String json = IO.readAll(file);
+                KMap<String, String> worlds = GSON.fromJson(json, TYPE);
+                return new IrisWorlds(Objects.requireNonNullElseGet(worlds, KMap::new));
+            } catch (Throwable e) {
+                Iris.error("Failed to load worlds.json!");
+                e.printStackTrace();
+                Iris.reportError(e);
+            }
+
+            return new IrisWorlds(new KMap<>());
+        });
+    }
+
+    public void put(String name, String type) {
+        put0(name, type);
+        save();
+    }
+
+    private void put0(String name, String type) {
+        String old = worlds.put(name, type);
+        if (!type.equals(old))
+            dirty = true;
+    }
+
+    public KMap<String, String> getWorlds() {
+        clean();
+        return readBukkitWorlds().put(worlds);
+    }
+
+    public Stream<IrisData> getPacks() {
+        return getDimensions()
+                .map(IrisDimension::getLoader)
+                .filter(Objects::nonNull);
+    }
+
+    public Stream<IrisDimension> getDimensions() {
+        return getWorlds()
+                .entrySet()
+                .stream()
+                .map(entry -> Iris.loadDimension(entry.getKey(), entry.getValue()))
+                .filter(Objects::nonNull);
+    }
+
+    public void clean() {
+        dirty = worlds.entrySet().removeIf(entry -> !new File(Bukkit.getWorldContainer(), entry.getKey() + "/iris/pack/dimensions/" + entry.getValue() + ".json").exists());
+    }
+
+    public synchronized void save() {
+        clean();
+        if (!dirty) return;
+        try {
+            IO.write(Iris.instance.getDataFile("worlds.json"), OutputStreamWriter::new, writer -> GSON.toJson(worlds, TYPE, writer));
+            dirty = false;
+        } catch (IOException e) {
+            Iris.error("Failed to save worlds.json!");
+            e.printStackTrace();
+            Iris.reportError(e);
+        }
+    }
+
+    public static KMap<String, String> readBukkitWorlds() {
+        var bukkit = YamlConfiguration.loadConfiguration(ServerProperties.BUKKIT_YML);
+        var worlds = bukkit.getConfigurationSection("worlds");
+        if (worlds == null) return new KMap<>();
+
+        var result = new KMap<String, String>();
+        for (String world : worlds.getKeys(false)) {
+            var gen = worlds.getString(world + ".generator");
+            if (gen == null) continue;
+
+            String loadKey;
+            if (gen.equalsIgnoreCase("iris")) {
+                loadKey = IrisSettings.get().getGenerator().getDefaultWorldType();
+            } else if (gen.startsWith("Iris:")) {
+                loadKey = gen.substring(5);
+            } else continue;
+
+            result.put(world, loadKey);
+        }
+
+        return result;
+    }
+}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -21,19 +21,33 @@ package com.volmit.iris.core;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.core.nms.datapack.IDataFixer;
+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.misc.ServerProperties;
+import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
+import lombok.NonNull;
+import lombok.SneakyThrows;
+import org.bukkit.Bukkit;
 import org.bukkit.configuration.InvalidConfigurationException;
 import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Arrays;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.util.Objects;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicIntegerArray;
+import java.util.stream.Stream;
 
 public class ServerConfigurator {
     public static void configure() {
@@ -45,6 +59,8 @@ public class ServerConfigurator {
         if (s.isConfigurePaperWatchdogDelay()) {
             J.attempt(ServerConfigurator::increasePaperWatchdog);
         }
+
+        installDataPacks(true);
     }
 
     private static void increaseKeepAliveSpigot() throws IOException, InvalidConfigurationException {
@@ -53,80 +69,246 @@ public class ServerConfigurator {
         f.load(spigotConfig);
         long tt = f.getLong("settings.timeout-time");
 
-        if (tt < TimeUnit.MINUTES.toSeconds(5)) {
+        long spigotTimeout = TimeUnit.MINUTES.toSeconds(5);
-            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + TimeUnit.MINUTES.toSeconds(20) + " (5 minutes)");
+
+        if (tt < spigotTimeout) {
+            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + spigotTimeout + " (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.set("settings.timeout-time", spigotTimeout);
             f.save(spigotConfig);
         }
     }
-
     private static void increasePaperWatchdog() throws IOException, InvalidConfigurationException {
         File spigotConfig = new File("config/paper-global.yml");
         FileConfiguration f = new YamlConfiguration();
         f.load(spigotConfig);
         long tt = f.getLong("watchdog.early-warning-delay");
 
-        if (tt < TimeUnit.MINUTES.toMillis(3)) {
+        long watchdog = TimeUnit.MINUTES.toMillis(3);
-            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + TimeUnit.MINUTES.toMillis(15) + " (3 minutes)");
+        if (tt < watchdog) {
+            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + watchdog + " (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.set("watchdog.early-warning-delay", watchdog);
             f.save(spigotConfig);
         }
     }
 
-    private static File[] getDataPacksFolder() {
+    private static KList<File> getDatapacksFolder() {
-        KList<File> files = new KList<>();
+        if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
-        files.add(new File("plugins/Iris/datapack"));
+            return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
-        Arrays.stream(IrisSettings.get().getGeneral().dataPackPaths)
+        }
-                .map(File::new)
+        KList<File> worlds = new KList<>();
-                .forEach(files::add);
+        Bukkit.getServer().getWorlds().forEach(w -> worlds.add(new File(w.getWorldFolder(), "datapacks")));
-        return files.toArray(File[]::new);
+        if (worlds.isEmpty()) worlds.add(new File(Bukkit.getWorldContainer(), ServerProperties.LEVEL_NAME + "/datapacks"));
+        return worlds;
     }
 
-    public static void setupDataPack() {
+    public static boolean installDataPacks(boolean fullInstall) {
-        File packs = new File("plugins/Iris/packs");
+        return installDataPacks(DataVersion.getDefault(), fullInstall);
-        if (!packs.exists()) {
-            disableDataPack();
-            return;
     }
-        for (File i : packs.listFiles()) {
-            if (!i.isDirectory()) continue;
 
-            Iris.verbose("Checking Pack: " + i.getPath());
+    public static boolean installDataPacks(IDataFixer fixer, boolean fullInstall) {
-            IrisData data = IrisData.get(i);
+        if (fixer == null) {
-            File dims = new File(i, "dimensions");
+            Iris.error("Unable to install datapacks, fixer is null!");
+            return false;
+        }
+        Iris.info("Checking Data Packs...");
+        DimensionHeight height = new DimensionHeight(fixer);
+        KList<File> folders = getDatapacksFolder();
+        KMap<String, KSet<String>> biomes = new KMap<>();
 
-            if (dims.exists()) {
+        try (Stream<IrisData> stream = allPacks()) {
-                for (File j : dims.listFiles((f, s) -> s.endsWith(".json"))) {
+            stream.flatMap(height::merge)
-                    if (!j.isFile()) continue;
+                    .parallel()
-                    IrisDimension dim = data.getDimensionLoader().load(j.getName().split("\\Q.\\E")[0]);
+                    .forEach(dim -> {
-                    if (dim == null) continue;
+                        Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
+                        dim.installBiomes(fixer, dim::getLoader, folders, biomes.computeIfAbsent(dim.getLoadKey(), k -> new KSet<>()));
+                        dim.installDimensionType(fixer, folders);
+                    });
+        }
+        IrisDimension.writeShared(folders, height);
+        Iris.info("Data Packs Setup!");
 
-                    dim.getAllBiomes(() -> data)
+        return fullInstall && verifyDataPacksPost(IrisSettings.get().getAutoConfiguration().isAutoRestartOnCustomBiomeInstall());
+    }
+
+    private static boolean verifyDataPacksPost(boolean allowRestarting) {
+        try (Stream<IrisData> stream = allPacks()) {
+            boolean bad = stream
+                    .map(data -> {
+                        Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
+                        var loader = data.getDimensionLoader();
+                        return loader.loadAll(loader.getPossibleKeys())
                                 .stream()
-                            .map(IrisBiome::getCustomDerivitives)
                                 .filter(Objects::nonNull)
-                            .flatMap(KList::stream)
+                                .map(ServerConfigurator::verifyDataPackInstalled)
-                            .forEach(b -> INMS.get().registerBiome(dim.getLoadKey(), b, false));
+                                .toList()
-                }
+                                .contains(false);
-            }
+                    })
-        }
+                    .toList()
-        dumpDataPack();
+                    .contains(true);
+            if (!bad) return false;
         }
 
-    public static void dumpDataPack() {
+
-        if (!INMS.get().dumpRegistry(getDataPacksFolder())) {
+        if (allowRestarting) {
-            return;
+            restart();
+        } else if (INMS.get().supportsDataPacks()) {
+            Iris.error("============================================================================");
+            Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
+            Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
+            Iris.error("----------------------------------------------------------------------------");
+            Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
+            Iris.error("============================================================================");
+
+            for (Player i : Bukkit.getOnlinePlayers()) {
+                if (i.isOp() || i.hasPermission("iris.all")) {
+                    VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
+                    sender.sendMessage("There are some Iris Packs that have custom biomes in them");
+                    sender.sendMessage("You need to restart your server to use these packs.");
                 }
-        disableDataPack();
             }
 
-    public static void disableDataPack() {
+            J.sleep(3000);
-        var packs = INMS.get().getPackRepository();
+        }
-        packs.reload();
+        return true;
-        if (!packs.removePack("file/iris"))
+    }
-            return;
+
-        packs.reloadWorldData();
+    public static void restart() {
+        J.s(() -> {
+            Iris.warn("New data pack entries have been installed in Iris! Restarting server!");
+            Iris.warn("This will only happen when your pack changes (updates/first time setup)");
+            Iris.warn("(You can disable this auto restart in iris settings)");
+            J.s(() -> {
+                Iris.warn("Looks like the restart command didn't work. Stopping the server instead!");
+                Bukkit.shutdown();
+            }, 100);
+            Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "restart");
+        });
+    }
+
+    public static boolean verifyDataPackInstalled(IrisDimension dimension) {
+        KSet<String> keys = new KSet<>();
+        boolean warn = false;
+
+        for (IrisBiome i : dimension.getAllBiomes(dimension::getLoader)) {
+            if (i.isCustom()) {
+                for (IrisBiomeCustom j : i.getCustomDerivitives()) {
+                    keys.add(dimension.getLoadKey() + ":" + j.getId());
+                }
+            }
+        }
+        String key = getWorld(dimension.getLoader());
+        if (key == null) key = dimension.getLoadKey();
+        else key += "/" + dimension.getLoadKey();
+
+        if (!INMS.get().supportsDataPacks()) {
+            if (!keys.isEmpty()) {
+                Iris.warn("===================================================================================");
+                Iris.warn("Pack " + key + " has " + keys.size() + " custom biome(s). ");
+                Iris.warn("Your server version does not yet support datapacks for iris.");
+                Iris.warn("The world will generate these biomes as backup biomes.");
+                Iris.warn("====================================================================================");
+            }
+
+            return true;
+        }
+
+        for (String i : keys) {
+            Object o = INMS.get().getCustomBiomeBaseFor(i);
+
+            if (o == null) {
+                Iris.warn("The Biome " + i + " is not registered on the server.");
+                warn = true;
+            }
+        }
+
+        if (INMS.get().missingDimensionTypes(dimension.getDimensionTypeKey())) {
+            Iris.warn("The Dimension Type for " + dimension.getLoadFile() + " is not registered on the server.");
+            warn = true;
+        }
+
+        if (warn) {
+            Iris.error("The Pack " + key + " is INCAPABLE of generating custom biomes");
+            Iris.error("If not done automatically, restart your server before generating with this pack!");
+        }
+
+        return !warn;
+    }
+
+    public static Stream<IrisData> allPacks() {
+        return Stream.concat(listFiles(Iris.instance.getDataFolder("packs"))
+                .filter(File::isDirectory)
+                .filter( base -> {
+                    var content = new File(base, "dimensions").listFiles();
+                    return content != null && content.length > 0;
+                })
+                .map(IrisData::get), IrisWorlds.get().getPacks());
+    }
+
+    @Nullable
+    public static String getWorld(@NonNull IrisData data) {
+        String worldContainer = Bukkit.getWorldContainer().getAbsolutePath();
+        if (!worldContainer.endsWith(File.separator)) worldContainer += File.separator;
+        
+        String path = data.getDataFolder().getAbsolutePath();
+        if (!path.startsWith(worldContainer)) return null;
+        int l = path.endsWith(File.separator) ? 11 : 10;
+        return path.substring(worldContainer.length(), path.length() - l);
+    }
+
+    @SneakyThrows
+    private static Stream<File> listFiles(File parent) {
+        if (!parent.isDirectory()) return Stream.empty();
+        return Files.walk(parent.toPath()).map(Path::toFile);
+    }
+
+    public static class DimensionHeight {
+        private final IDataFixer fixer;
+        private final AtomicIntegerArray[] dimensions = new AtomicIntegerArray[3];
+
+        public DimensionHeight(IDataFixer fixer) {
+            this.fixer = fixer;
+            for (int i = 0; i < 3; i++) {
+                dimensions[i] = new AtomicIntegerArray(new int[]{
+                        Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE
+                });
+            }
+        }
+
+        public Stream<IrisDimension> merge(IrisData data) {
+            Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
+            var loader = data.getDimensionLoader();
+            return loader.loadAll(loader.getPossibleKeys())
+                    .stream()
+                    .filter(Objects::nonNull)
+                    .peek(this::merge);
+        }
+
+        public void merge(IrisDimension dimension) {
+            AtomicIntegerArray array = dimensions[dimension.getBaseDimension().ordinal()];
+            array.updateAndGet(0, min -> Math.min(min, dimension.getMinHeight()));
+            array.updateAndGet(1, max -> Math.max(max, dimension.getMaxHeight()));
+            array.updateAndGet(2, logical -> Math.max(logical, dimension.getLogicalHeight()));
+        }
+
+        public String[] jsonStrings() {
+            var dims = IDataFixer.Dimension.values();
+            var arr = new String[3];
+            for (int i = 0; i < 3; i++) {
+                arr[i] = jsonString(dims[i]);
+            }
+            return arr;
+        }
+
+        public String jsonString(IDataFixer.Dimension dimension) {
+            var data = dimensions[dimension.ordinal()];
+            int minY = data.get(0);
+            int maxY = data.get(1);
+            int logicalHeight = data.get(2);
+            if (minY == Integer.MAX_VALUE || maxY == Integer.MIN_VALUE || Integer.MIN_VALUE == logicalHeight)
+                return null;
+            return fixer.createDimension(dimension, minY, maxY - minY, logicalHeight, null).toString(4);
+        }
     }
 }

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -18,27 +18,44 @@
 
 package com.volmit.iris.core.commands;
 
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.datapack.DataVersion;
+import com.volmit.iris.core.service.IrisEngineSVC;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.core.tools.IrisWorldDump;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.framework.EnginePlayer;
 import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.service.EngineStatusSVC;
+import com.volmit.iris.engine.object.IrisPosition;
-import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.engine.object.annotations.Snippet;
 import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.context.IrisContext;
+import com.volmit.iris.engine.object.IrisJigsawStructurePlacement;
+import com.volmit.iris.util.collection.KList;
 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.NullableDimensionHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.io.CountingDataInputStream;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.mantle.TectonicPlate;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.matter.Matter;
+import com.volmit.iris.util.nbt.mca.MCAFile;
+import com.volmit.iris.util.nbt.mca.MCAUtil;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.jobs.Job;
+import lombok.SneakyThrows;
 import net.jpountz.lz4.LZ4BlockInputStream;
 import net.jpountz.lz4.LZ4BlockOutputStream;
 import net.jpountz.lz4.LZ4FrameInputStream;
@@ -51,91 +68,366 @@ import org.bukkit.World;
 import java.io.*;
 import java.net.InetAddress;
 import java.net.NetworkInterface;
+import java.nio.file.Files;
 import java.util.*;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;
 
 @Decree(name = "Developer", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"dev"})
 public class CommandDeveloper implements DecreeExecutor {
     private CommandTurboPregen turboPregen;
-    private CommandUpdater updater;
+    private CommandLazyPregen lazyPregen;
 
-    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, aliases = "status", sync = true)
+    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
     public void EngineStatus() {
-        var status = EngineStatusSVC.getStatus();
+        Iris.service(IrisEngineSVC.class)
+                .engineStatus(sender());
+    }
 
-        sender().sendMessage("-------------------------");
+    @Decree(description = "Send a test exception to sentry")
-        sender().sendMessage(C.DARK_PURPLE + "Engine Status");
+    public void Sentry() {
-        sender().sendMessage(C.DARK_PURPLE + "Total Engines: " + C.LIGHT_PURPLE + status.engineCount());
+        Engine engine = engine();
-        sender().sendMessage(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + status.loadedChunks());
+        if (engine != null) IrisContext.getOr(engine);
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + status.tectonicLimit());
+        Iris.reportError(new Exception("This is a test"));
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + status.tectonicPlates());
+    }
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + status.activeTectonicPlates());
+
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + status.queuedTectonicPlates());
+    @Decree(description = "Dev cmd to fix all the broken objects caused by faulty shrinkwarp")
-        sender().sendMessage(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.minTectonicUnloadDuration()));
+    public void fixObjects(
-        sender().sendMessage(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.maxTectonicUnloadDuration()));
+            @Param(aliases = "dimension", description = "The dimension type to create the world with")
-        sender().sendMessage(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
+            IrisDimension type
-        sender().sendMessage("-------------------------");
+    ) {
+        if (type == null) {
+            sender().sendMessage("Type cant be null?");
+            return;
+        }
+
+        IrisData dm = IrisData.get(Iris.instance.getDataFolder("packs", type.getLoadKey()));
+        var loader = dm.getObjectLoader();
+        var processed = new KMap<String, IrisPosition>();
+
+        var objects = loader.getPossibleKeys();
+        var pieces = dm.getJigsawPieceLoader().getPossibleKeys();
+        var sender = sender();
+
+        sender.sendMessage(C.IRIS + "Found " + objects.length + " objects in " + type.getLoadKey());
+        sender.sendMessage(C.IRIS + "Found " + pieces.length + " jigsaw pieces in " + type.getLoadKey());
+
+        final int total = objects.length;
+        final AtomicInteger completed = new AtomicInteger();
+        final AtomicInteger changed = new AtomicInteger();
+
+        new Job() {
+            @Override
+            public String getName() {
+                return "Fixing Objects";
+            }
+
+            @Override
+            public void execute() {
+                Arrays.stream(pieces).parallel()
+                        .map(dm.getJigsawPieceLoader()::load)
+                        .filter(Objects::nonNull)
+                        .forEach(piece -> {
+                            var offset = processed.compute(piece.getObject(), (key, o) -> {
+                                if (o != null) return o;
+                                var obj = loader.load(key);
+                                if (obj == null) return new IrisPosition();
+
+                                obj.shrinkwrap();
+                                try {
+                                    if (!obj.getShrinkOffset().isZero()) {
+                                        changed.incrementAndGet();
+                                        obj.write(obj.getLoadFile());
+                                    }
+                                    completeWork();
+                                } catch (IOException e) {
+                                    Iris.error("Failed to write object " + obj.getLoadKey());
+                                    e.printStackTrace();
+                                    return new IrisPosition();
+                                }
+
+                                return new IrisPosition(obj.getShrinkOffset());
+                            });
+                            if (offset.getX() == 0 && offset.getY() == 0 && offset.getZ() == 0)
+                                return;
+
+                            piece.getConnectors().forEach(connector -> connector.setPosition(connector.getPosition().add(offset)));
+
+                            try {
+                                IO.writeAll(piece.getLoadFile(), dm.getGson().toJson(piece));
+                            } catch (IOException e) {
+                                Iris.error("Failed to write jigsaw piece " + piece.getLoadKey());
+                                e.printStackTrace();
+                            }
+                        });
+
+                Arrays.stream(loader.getPossibleKeys()).parallel()
+                        .filter(key -> !processed.containsKey(key))
+                        .map(loader::load)
+                        .forEach(obj -> {
+                            if (obj == null) {
+                                completeWork();
+                                return;
+                            }
+
+                            obj.shrinkwrap();
+                            if (obj.getShrinkOffset().isZero()) {
+                                completeWork();
+                                return;
+                            }
+
+                            try {
+                                obj.write(obj.getLoadFile());
+                                completeWork();
+                                changed.incrementAndGet();
+                            } catch (IOException e) {
+                                Iris.error("Failed to write object " + obj.getLoadKey());
+                                e.printStackTrace();
+                            }
+                        });
+            }
+
+            @Override
+            public void completeWork() {
+                completed.incrementAndGet();
+            }
+
+            @Override
+            public int getTotalWork() {
+                return total;
+            }
+
+            @Override
+            public int getWorkCompleted() {
+                return completed.get();
+            }
+        }.execute(sender, () -> {
+            var failed = total - completed.get();
+            if (failed != 0) sender.sendMessage(C.IRIS + "" + failed + " objects failed!");
+            if (changed.get() != 0) sender.sendMessage(C.IRIS + "" + changed.get() + " objects had their offsets changed!");
+            else sender.sendMessage(C.IRIS + "No objects had their offsets changed!");
+        });
     }
 
     @Decree(description = "Test")
-    public void benchmarkMantle(
+    public void mantle(@Param(defaultValue = "false") boolean plate, @Param(defaultValue = "21474836474") String name) throws Throwable {
-            @Param(description = "The world to bench", aliases = {"world"})
+        var base = Iris.instance.getDataFile("dump", "pv." + name + ".ttp.lz4b.bin");
-            World world
+        var section = Iris.instance.getDataFile("dump", "pv." + name + ".section.bin");
-    ) throws IOException, ClassNotFoundException {
-        Engine engine = IrisToolbelt.access(world).getEngine();
-        int maxHeight = engine.getTarget().getHeight();
-        File folder = new File(Bukkit.getWorldContainer(), world.getName());
-        int c = 0;
-        //MCAUtil.read()
 
-        File tectonicplates = new File(folder, "mantle");
+        //extractSection(base, section, 5604930, 4397);
-        for (File i : Objects.requireNonNull(tectonicplates.listFiles())) {
-            TectonicPlate.read(maxHeight, i);
-            c++;
-            sender().sendMessage("Loaded count: " + c);
 
+        if (plate) {
+            try (var in = CountingDataInputStream.wrap(new BufferedInputStream(new FileInputStream(base)))) {
+                new TectonicPlate(1088, in, true);
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        } else Matter.read(section);
+        if (!TectonicPlate.hasError())
+            Iris.info("Read " + (plate ? base : section).length() + " bytes from " + (plate ? base : section).getAbsolutePath());
     }
 
+    private void extractSection(File source, File target, long offset, int length) throws IOException {
+        var raf = new RandomAccessFile(source, "r");
+        var bytes = new byte[length];
+        raf.seek(offset);
+        raf.readFully(bytes);
+        raf.close();
+        Files.write(target.toPath(), bytes);
+    }
+
+    @Decree(description = "Test")
+    public void dumpThreads() {
+        try {
+            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
+            FileOutputStream fos = new FileOutputStream(fi);
+            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
+            PrintWriter pw = new PrintWriter(fos);
+
+            pw.println(Thread.activeCount() + "/" + f.size());
+            var run = Runtime.getRuntime();
+            pw.println("Memory:");
+            pw.println("\tMax: " + run.maxMemory());
+            pw.println("\tTotal: " + run.totalMemory());
+            pw.println("\tFree: " + run.freeMemory());
+            pw.println("\tUsed: " + (run.totalMemory() - run.freeMemory()));
+
+            for (Thread i : f.keySet()) {
+                pw.println("========================================");
+                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
+
+                for (StackTraceElement j : f.get(i)) {
+                    pw.println("    @ " + j.toString());
+                }
+
+                pw.println("========================================");
+                pw.println();
+                pw.println();
+            }
+
+            pw.close();
+            Iris.info("DUMPED! See " + fi.getAbsolutePath());
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    @SneakyThrows
+    @Decree(description = "Generate Iris structures for all loaded datapack structures")
+    public void generateStructures(
+            @Param(description = "The pack to add the generated structures to", aliases = "pack", defaultValue = "null", customHandler = NullableDimensionHandler.class)
+            IrisDimension dimension,
+            @Param(description = "Ignore existing structures", defaultValue = "false")
+            boolean force
+    ) {
+        var map = INMS.get().collectStructures();
+        if (map.isEmpty()) {
+            sender().sendMessage(C.IRIS + "No structures found");
+            return;
+        }
+
+        sender().sendMessage(C.IRIS + "Found " + map.size() + " structures");
+
+        final File dataDir;
+        final IrisData data;
+        final Set<String> existingStructures;
+        final Map<String, Set<String>> snippets;
+        final File dimensionFile;
+        final File structuresFolder;
+        final File snippetsFolder;
+
+        var dimensionObj = new JsonObject();
+
+        if (dimension == null) {
+            dataDir = Iris.instance.getDataFolder("structures");
+            IO.delete(dataDir);
+            data = IrisData.get(dataDir);
+            existingStructures = Set.of();
+            snippets = Map.of();
+            dimensionFile = new File(dataDir, "structures.json");
+        } else {
+            data = dimension.getLoader();
+            dataDir = data.getDataFolder();
+            existingStructures = new KSet<>(data.getJigsawStructureLoader().getPossibleKeys());
+
+            dimensionObj = data.getGson().fromJson(IO.readAll(dimension.getLoadFile()), JsonObject.class);
+            snippets = Optional.ofNullable(dimensionObj.getAsJsonArray("jigsawStructures"))
+                    .map(array -> array.asList()
+                            .stream()
+                            .filter(JsonElement::isJsonPrimitive)
+                            .collect(Collectors.toMap(element -> data.getGson()
+                                            .fromJson(element, IrisJigsawStructurePlacement.class)
+                                            .getStructure(),
+                                    element -> Set.of(element.getAsString()),
+                                    KSet::merge)))
+                    .orElse(Map.of());
+
+            dimensionFile = dimension.getLoadFile();
+        }
+        structuresFolder = new File(dataDir, "jigsaw-structures");
+        snippetsFolder = new File(dataDir, "snippet" + "/" + IrisJigsawStructurePlacement.class.getAnnotation(Snippet.class).value());
+
+        var gson = data.getGson();
+        var jigsawStructures = Optional.ofNullable(dimensionObj.getAsJsonArray("jigsawStructures"))
+                .orElse(new JsonArray(map.size()));
+
+        map.forEach((key, placement) -> {
+            String loadKey = "datapack/" + key.namespace() + "/" + key.key();
+            if (existingStructures.contains(loadKey) && !force)
+                return;
+
+            var structures = placement.structures();
+            var obj = placement.toJson(loadKey);
+            if (obj == null || structures.isEmpty()) {
+                sender().sendMessage(C.RED + "Failed to generate hook for " + key);
+                return;
+            }
+            File snippetFile = new File(snippetsFolder, loadKey + ".json");
+            try {
+                IO.writeAll(snippetFile, gson.toJson(obj));
+            } catch (IOException e) {
+                sender().sendMessage(C.RED + "Failed to generate snippet for " + key);
+                e.printStackTrace();
+                return;
+            }
+
+            Set<String> loadKeys = snippets.getOrDefault(loadKey, Set.of(loadKey));
+            jigsawStructures.asList().removeIf(e -> loadKeys.contains((e.isJsonObject() ? e.getAsJsonObject().get("structure") : e).getAsString()));
+            jigsawStructures.add("snippet/" + loadKey);
+
+            String structureKey;
+            if (structures.size() > 1) {
+                KList<String> common = new KList<>();
+                for (int i = 0; i < structures.size(); i++) {
+                    var tags = structures.get(i).tags();
+                    if (i == 0) common.addAll(tags);
+                    else common.removeIf(tag -> !tags.contains(tag));
+                }
+                structureKey = common.isNotEmpty() ? "#" + common.getFirst() : structures.getFirst().key();
+            } else structureKey = structures.getFirst().key();
+
+            JsonArray array = new JsonArray();
+            if (structures.size() > 1) {
+                structures.stream()
+                        .flatMap(structure -> {
+                            String[] arr = new String[structure.weight()];
+                            Arrays.fill(arr, structure.key());
+                            return Arrays.stream(arr);
+                        })
+                        .forEach(array::add);
+            } else array.add(structureKey);
+
+            obj = new JsonObject();
+            obj.addProperty("structureKey", structureKey);
+            obj.add("datapackStructures", array);
+
+            File out = new File(structuresFolder, loadKey + ".json");
+            out.getParentFile().mkdirs();
+            try {
+                IO.writeAll(out, gson.toJson(obj));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        });
+
+        dimensionObj.add("jigsawStructures", jigsawStructures);
+        IO.writeAll(dimensionFile, gson.toJson(dimensionObj));
+
+        data.hotloaded();
     }
 
     @Decree(description = "Test")
     public void packBenchmark(
-            @Param(description = "The pack to bench", defaultValue = "overworld", aliases = {"pack"})
+            @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
             IrisDimension dimension,
-            @Param(description = "The address to use", defaultValue = "-")
+            @Param(description = "Radius in regions", defaultValue = "2048")
-            String address,
+            int radius,
-            @Param(description = "Headless", defaultValue = "true")
+            @Param(description = "Open GUI while benchmarking", defaultValue = "false")
-            boolean headless,
+            boolean gui
-            @Param(description = "GUI", defaultValue = "false")
-            boolean gui,
-            @Param(description = "Diameter in regions", defaultValue = "5")
-            int diameter
     ) {
-        int rb = diameter << 9;
+        new IrisPackBenchmarking(dimension, radius, gui);
-        Iris.info("Benchmarking pack " + dimension.getName() + " with diameter: " + rb + "(" + diameter + ")");
+    }
-        IrisPackBenchmarking benchmark = new IrisPackBenchmarking(dimension, address.replace("-", "").trim(), diameter, headless, gui);
+
-        benchmark.runBenchmark();
+    @Decree(description = "Upgrade to another Minecraft version")
+    public void upgrade(
+            @Param(description = "The version to upgrade to", defaultValue = "latest") DataVersion version) {
+        sender().sendMessage(C.GREEN + "Upgrading to " + version.getVersion() + "...");
+        ServerConfigurator.installDataPacks(version.get(), false);
+        sender().sendMessage(C.GREEN + "Done upgrading! You can now update your server version to " + version.getVersion());
     }
 
     @Decree(description = "test")
-    public void mca(
+    public void mca (
-            @Param(description = "String") World world) {
+            @Param(description = "String") String world) {
         try {
-            IrisWorldDump dump = new IrisWorldDump(world, sender());
+            File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
-            dump.start();
+            for (File mca : McaFiles) {
-
+                MCAFile MCARegion = MCAUtil.read(mca);
-        } catch (Exception e) {
-            e.printStackTrace();
             }
-
-    }
-
-    @Decree(description = "test")
-    public void test() {
-        try {
-
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -201,40 +493,13 @@ public class CommandDeveloper implements DecreeExecutor {
         }
     }
 
-    @Decree(description = "All players in iris worlds")
-    public void getPlayers() {
-        KList<World> IrisWorlds = new KList<>();
-        for (World w : Bukkit.getServer().getWorlds()) {
-            if(IrisToolbelt.isIrisWorld(w)) {
-                IrisWorlds.add(w);
-            }
-        }
-
-        if (sender().isPlayer()) {
-            sender().sendMessage(C.BLUE + "Iris Worlds: ");
-            for (World IrisWorld : IrisWorlds.copy()) {
-                sender().sendMessage(C.IRIS + "- " + IrisWorld.getName() + C.GRAY + ", " + IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers().stream().count() + " players");
-                for (EnginePlayer player : IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers()) {
-                    sender().sendMessage(C.DARK_GRAY + "> " + player.getPlayer().getName());
-                }
-            }
-        } else {
-            Iris.info(C.BLUE + "Iris Worlds: ");
-            for (World IrisWorld : IrisWorlds.copy()) {
-                Iris.info(C.IRIS + "- " + IrisWorld.getName() + C.GRAY + ", " + IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers().stream().count() + " players");
-                for (EnginePlayer player : IrisToolbelt.access(IrisWorld).getEngine().getEnginePlayers()) {
-                    Iris.info(C.DARK_GRAY + "> " + player.getPlayer().getName());
-                }
-            }
-        }
-    }
-
     @Decree(description = "Test the compression algorithms")
     public void compression(
             @Param(description = "base IrisWorld") World world,
             @Param(description = "raw TectonicPlate File") String path,
             @Param(description = "Algorithm to Test") String algorithm,
-            @Param(description = "Amount of Tests") int amount) {
+            @Param(description = "Amount of Tests") int amount,
+            @Param(description = "Is versioned", defaultValue = "false") boolean versioned) {
         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;
@@ -244,13 +509,14 @@ public class CommandDeveloper implements DecreeExecutor {
         if (!file.exists()) return;
 
         Engine engine = IrisToolbelt.access(world).getEngine();
-        if (engine != null) {
+        if(engine != null) {
             int height = engine.getTarget().getHeight();
+            ExecutorService service = Executors.newFixedThreadPool(1);
             VolmitSender sender = sender();
-            new Thread(() -> {
+            service.submit(() -> {
                 try {
-                    DataInputStream raw = new DataInputStream(new FileInputStream(file));
+                    CountingDataInputStream raw = CountingDataInputStream.wrap(new FileInputStream(file));
-                    TectonicPlate plate = new TectonicPlate(height, raw);
+                    TectonicPlate plate = new TectonicPlate(height, raw, versioned);
                     raw.close();
 
                     double d1 = 0;
@@ -268,29 +534,30 @@ public class CommandDeveloper implements DecreeExecutor {
                         if (size == 0)
                             size = tmp.length();
                         start = System.currentTimeMillis();
-                        DataInputStream din = createInput(tmp, algorithm);
+                        CountingDataInputStream din = createInput(tmp, algorithm);
-                        new TectonicPlate(height, din);
+                        new TectonicPlate(height, din, true);
                         din.close();
                         d2 += System.currentTimeMillis() - start;
                         tmp.delete();
                     }
                     IO.delete(folder);
                     sender.sendMessage(algorithm + " is " + Form.fileSize(size) + " big after compression");
-                    sender.sendMessage(algorithm + " Took " + d2 / amount + "ms to read");
+                    sender.sendMessage(algorithm + " Took " + d2/amount + "ms to read");
-                    sender.sendMessage(algorithm + " Took " + d1 / amount + "ms to write");
+                    sender.sendMessage(algorithm + " Took " + d1/amount + "ms to write");
                 } catch (Throwable e) {
                     e.printStackTrace();
                 }
-            }, "Compression Test").start();
+            });
+            service.shutdown();
 		} else {
             Iris.info(C.RED + "Engine is null!");
         }
     }
 
-    private DataInputStream createInput(File file, String algorithm) throws Throwable {
+    private CountingDataInputStream createInput(File file, String algorithm) throws Throwable {
         FileInputStream in = new FileInputStream(file);
 
-        return new DataInputStream(switch (algorithm) {
+        return CountingDataInputStream.wrap(switch (algorithm) {
             case "gzip" -> new GZIPInputStream(in);
             case "lz4f" -> new LZ4FrameInputStream(in);
             case "lz4b" -> new LZ4BlockInputStream(in);

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -19,17 +19,13 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.NullableBiomeHandler;
-import com.volmit.iris.util.decree.specialhandlers.NullableRegionHandler;
 import com.volmit.iris.util.format.C;
-import org.bukkit.block.Biome;
 
 import java.awt.*;
 
@@ -55,31 +51,12 @@ public class CommandEdit implements DecreeExecutor {
 
 
     @Decree(description = "Edit the biome you specified", aliases = {"b"}, origin = DecreeOrigin.PLAYER)
-    public void biome(@Param(contextual = false, description = "The biome to edit", defaultValue = "---", customHandler = NullableBiomeHandler.class) IrisBiome biome) {
+    public void biome(@Param(contextual = false, description = "The biome to edit") IrisBiome biome) {
         if (noStudio()) {
             return;
         }
-        if (biome == null) {
         try {
-                IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
+            if (biome == null || biome.getLoadFile() == null) {
-                Desktop.getDesktop().open(b.getLoadFile());
-                sender().sendMessage(C.GREEN + "Opening " + b.getTypeName() + " " + b.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-            } catch (Throwable e) {
-                Iris.reportError(e);
-                sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
-                if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
-                    try {
-                        sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
-                    } catch (Throwable ee) {
-                        Iris.reportError(ee);
-                    }
-                }
-            }
-            return;
-        }
-
-        try {
-            if (biome.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
                 return;
             }
@@ -92,20 +69,10 @@ public class CommandEdit implements DecreeExecutor {
     }
 
     @Decree(description = "Edit the region you specified", aliases = {"r"}, origin = DecreeOrigin.PLAYER)
-    public void region(@Param(contextual = false, description = "The region to edit", defaultValue = "---", customHandler = NullableRegionHandler.class) IrisRegion region) {
+    public void region(@Param(contextual = false, description = "The region to edit") IrisRegion region) {
         if (noStudio()) {
             return;
         }
-        if (region == null) {
-            try {
-                IrisRegion r = engine().getRegion(player().getLocation().getBlockX(), player().getLocation().getBlockZ());
-                Desktop.getDesktop().open(r.getLoadFile());
-                sender().sendMessage(C.GREEN + "Opening " + r.getTypeName() + " " + r.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-            } catch (Throwable e) {
-                sender().sendMessage(C.RED + "Failed to get region.");
-            }
-            return;
-        }
         try {
             if (region == null || region.getLoadFile() == null) {
                 sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -20,16 +20,11 @@ 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.nms.INMS;
-import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisWorld;
-import com.volmit.iris.engine.platform.BukkitChunkGenerator;
-import com.volmit.iris.engine.platform.DummyChunkGenerator;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
@@ -37,39 +32,29 @@ 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.io.IO;
+import com.volmit.iris.util.misc.ServerProperties;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
-import org.apache.commons.io.FileUtils;
+import lombok.SneakyThrows;
-import org.apache.commons.io.filefilter.IOFileFilter;
-import org.apache.commons.io.filefilter.TrueFileFilter;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
-import org.bukkit.WorldCreator;
 import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.FileConfiguration;
 import org.bukkit.configuration.file.YamlConfiguration;
 import org.bukkit.entity.Player;
-import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.scheduler.BukkitRunnable;
 
-import java.io.File;
+import java.io.*;
-import java.io.IOException;
-import java.util.Collection;
-import java.util.Collections;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicReference;
 
-import static com.volmit.iris.Iris.service;
 import static com.volmit.iris.core.service.EditSVC.deletingWorld;
-import static com.volmit.iris.core.tools.IrisBenchmarking.inProgress;
+import static com.volmit.iris.util.misc.ServerProperties.BUKKIT_YML;
 import static org.bukkit.Bukkit.getServer;
 
 @Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
 public class CommandIris implements DecreeExecutor {
-    public static boolean worldCreation = false;
+    private CommandUpdater updater;
-    String WorldEngine;
-    String worldNameToCheck = "YourWorldName";
-    VolmitSender sender = Iris.getSender();
     private CommandStudio studio;
     private CommandPregen pregen;
     private CommandSettings settings;
@@ -78,21 +63,12 @@ public class CommandIris implements DecreeExecutor {
     private CommandWhat what;
     private CommandEdit edit;
     private CommandFind find;
-    private CommandSupport support;
     private CommandDeveloper developer;
-
+    public static boolean worldCreation = false;
-    public static boolean deleteDirectory(File dir) {
+    private static final AtomicReference<Thread> mainWorld = new AtomicReference<>();
-        if (dir.isDirectory()) {
+    String WorldEngine;
-            File[] children = dir.listFiles();
+    String worldNameToCheck = "YourWorldName";
-            for (int i = 0; i < children.length; i++) {
+    VolmitSender sender = Iris.getSender();
-                boolean success = deleteDirectory(children[i]);
-                if (!success) {
-                    return false;
-                }
-            }
-        }
-        return dir.delete();
-    }
 
     @Decree(description = "Create a new world", aliases = {"+", "c"})
     public void create(
@@ -102,19 +78,17 @@ public class CommandIris implements DecreeExecutor {
             IrisDimension type,
             @Param(description = "The seed to generate the world with", defaultValue = "1337")
             long seed,
-            @Param(description = "The radius of chunks to generate in headless mode (-1 to disable)", defaultValue = "10", aliases = "radius")
+            @Param(aliases = "main-world", description = "Whether or not to automatically use this world as the main world", defaultValue = "false")
-            int headlessRadius,
+            boolean main
-            @Param(description = "If it should convert the dimension to match the vanilla height system.", defaultValue = "false")
-            boolean vanillaheight
     ) {
-
+        if (name.equalsIgnoreCase("iris")) {
-        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.");
+        if (name.equalsIgnoreCase("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;
         }
@@ -132,8 +106,13 @@ public class CommandIris implements DecreeExecutor {
                     .seed(seed)
                     .sender(sender())
                     .studio(false)
-                    .headlessRadius(headlessRadius)
                     .create();
+            if (main) {
+                Runtime.getRuntime().addShutdownHook(mainWorld.updateAndGet(old -> {
+                    if (old != null) Runtime.getRuntime().removeShutdownHook(old);
+                    return new Thread(() -> updateMainWorld(name));
+                }));
+            }
         } catch (Throwable e) {
             sender().sendMessage(C.RED + "Exception raised during creation. See the console for more details.");
             Iris.error("Exception raised during world creation: " + e.getMessage());
@@ -143,6 +122,24 @@ public class CommandIris implements DecreeExecutor {
         }
         worldCreation = false;
         sender().sendMessage(C.GREEN + "Successfully created your world!");
+        if (main) sender().sendMessage(C.GREEN + "Your world will automatically be set as the main world when the server restarts.");
+    }
+
+    @SneakyThrows
+    private void updateMainWorld(String newName) {
+        File worlds = Bukkit.getWorldContainer();
+        var data = ServerProperties.DATA;
+        try (var in = new FileInputStream(ServerProperties.SERVER_PROPERTIES)) {
+            data.load(in);
+        }
+        for (String sub : List.of("datapacks", "playerdata", "advancements", "stats")) {
+            IO.copyDirectory(new File(worlds, ServerProperties.LEVEL_NAME + "/" + sub).toPath(), new File(worlds, newName + "/" + sub).toPath());
+        }
+
+        data.setProperty("level-name", newName);
+        try (var out = new FileOutputStream(ServerProperties.SERVER_PROPERTIES)) {
+            data.store(out, null);
+        }
     }
 
     @Decree(description = "Teleport to another world", aliases = {"tp"}, sync = true)
@@ -188,16 +185,6 @@ public class CommandIris implements DecreeExecutor {
         IrisPackBenchmarking.runBenchmark();
     } */
 
-    //todo Move to React
-    @Decree(description = "Benchmark your server", origin = DecreeOrigin.CONSOLE)
-    public void serverbenchmark() throws InterruptedException {
-        if (!inProgress) {
-            IrisBenchmarking.runBenchmark();
-        } else {
-            Iris.info(C.RED + "Benchmark already is in progress.");
-        }
-    }
-
     @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
     public void height() {
         if (sender().isPlayer()) {
@@ -235,20 +222,20 @@ public class CommandIris implements DecreeExecutor {
         if (sender().isPlayer()) {
             sender().sendMessage(C.BLUE + "Iris Worlds: ");
             for (World IrisWorld : IrisWorlds.copy()) {
-                sender().sendMessage(C.IRIS + "- " + IrisWorld.getName());
+                sender().sendMessage(C.IRIS + "- " +IrisWorld.getName());
             }
             sender().sendMessage(C.GOLD + "Bukkit Worlds: ");
             for (World BukkitWorld : BukkitWorlds.copy()) {
-                sender().sendMessage(C.GRAY + "- " + BukkitWorld.getName());
+                sender().sendMessage(C.GRAY + "- " +BukkitWorld.getName());
             }
         } else {
             Iris.info(C.BLUE + "Iris Worlds: ");
             for (World IrisWorld : IrisWorlds.copy()) {
-                Iris.info(C.IRIS + "- " + IrisWorld.getName());
+                Iris.info(C.IRIS + "- " +IrisWorld.getName());
             }
             Iris.info(C.GOLD + "Bukkit Worlds: ");
             for (World BukkitWorld : BukkitWorlds.copy()) {
-                Iris.info(C.GRAY + "- " + BukkitWorld.getName());
+                Iris.info(C.GRAY + "- " +BukkitWorld.getName());
             }
             
         }
@@ -266,6 +253,17 @@ public class CommandIris implements DecreeExecutor {
             return;
         }
         sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
+
+        if (!IrisToolbelt.evacuate(world)) {
+            sender().sendMessage(C.RED + "Failed to evacuate world: " + world.getName());
+            return;
+        }
+
+        if (!Bukkit.unloadWorld(world, false)) {
+            sender().sendMessage(C.RED + "Failed to unload world: " + world.getName());
+            return;
+        }
+
         try {
             if (IrisToolbelt.removeWorld(world)) {
                 sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
@@ -278,45 +276,45 @@ public class CommandIris implements DecreeExecutor {
         }
         IrisToolbelt.evacuate(world, "Deleting world");
         deletingWorld = true;
-        Bukkit.unloadWorld(world, false);
+        if (!delete) {
+            deletingWorld = false;
+            return;
+        }
+        VolmitSender sender = sender();
+        J.a(() -> {
             int retries = 12;
-        if (delete) {
+
             if (deleteDirectory(world.getWorldFolder())) {
-                sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                sender.sendMessage(C.GREEN + "Successfully removed world folder");
             } else {
-                while (true) {
+                while(true){
-                    if (deleteDirectory(world.getWorldFolder())) {
+                    if (deleteDirectory(world.getWorldFolder())){
-                        sender().sendMessage(C.GREEN + "Successfully removed world folder");
+                        sender.sendMessage(C.GREEN + "Successfully removed world folder");
                         break;
                     }
                     retries--;
-                    if (retries == 0) {
+                    if (retries == 0){
-                        sender().sendMessage(C.RED + "Failed to remove world folder");
+                        sender.sendMessage(C.RED + "Failed to remove world folder");
                         break;
                     }
                     J.sleep(3000);
                 }
             }
-        }
             deletingWorld = false;
+        });
     }
 
-    @Decree(description = "Updates all chunk in the specified world")
+    public static boolean deleteDirectory(File dir) {
-    public void updater(
+        if (dir.isDirectory()) {
-            @Param(description = "World to update chunks at")
+            File[] children = dir.listFiles();
-            World world
+            for (int i = 0; i < children.length; i++) {
-    ) {
+                boolean success = deleteDirectory(children[i]);
-        if (!IrisToolbelt.isIrisWorld(world)) {
+                if (!success) {
-            sender().sendMessage(C.GOLD + "This is not an Iris world");
+                    return false;
-            return;
                 }
-        ChunkUpdater updater = new ChunkUpdater(world);
-        if (sender().isPlayer()) {
-            sender().sendMessage(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
-        } else {
-            Iris.info(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
             }
-        updater.start();
+        }
+        return dir.delete();
     }
 
     @Decree(description = "Set aura spins")
@@ -371,20 +369,22 @@ public class CommandIris implements DecreeExecutor {
         sender().sendMessage(C.GREEN + "Set debug to: " + to);
     }
 
+    //TODO fix pack trimming
     @Decree(description = "Download a project.", aliases = "dl")
     public void download(
             @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
             String pack,
             @Param(name = "branch", description = "The branch to download from", defaultValue = "main")
             String branch,
-            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            //@Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
-            boolean trim,
+            //boolean trim,
             @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
             boolean overwrite
     ) {
+        boolean trim = false;
         sender().sendMessage(C.GREEN + "Downloading pack: " + pack + "/" + branch + (trim ? " trimmed" : "") + (overwrite ? " overwriting" : ""));
         if (pack.equals("overworld")) {
-            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + Iris.OVERWORLD_TAG + "/overworld.zip";
+            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + INMS.OVERWORLD_TAG + "/overworld.zip";
             Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
         } else {
             Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
@@ -444,8 +444,8 @@ public class CommandIris implements DecreeExecutor {
         Iris.service(StudioSVC.class).installIntoWorld(sender(), pack.getLoadKey(), folder);
     }
 
-    @Decree(description = "Unload an Iris World", sync = true)
+    @Decree(description = "Unload an Iris World", origin = DecreeOrigin.PLAYER, sync = true)
-    public void unload(
+    public void unloadWorld(
             @Param(description = "The world to unload")
             World world
     ) {
@@ -465,76 +465,60 @@ public class CommandIris implements DecreeExecutor {
     }
 
     @Decree(description = "Load an Iris World", origin = DecreeOrigin.PLAYER, sync = true, aliases = {"import"})
-    public void load(
+    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;
 
-        FileConfiguration fc = new YamlConfiguration();
+        if (!worldExists) {
-        try {
+            sender().sendMessage(C.YELLOW + world + " Doesnt exist on the server.");
-            fc.load(new File("bukkit.yml"));
-            ConfigurationSection section = fc.getConfigurationSection("worlds");
-            if (section == null) {
             return;
         }
 
-            for (String s : section.getKeys(false)) {
+        String pathtodim = world + File.separator +"iris"+File.separator +"pack"+File.separator +"dimensions"+File.separator;
-                try {
+        File directory = new File(Bukkit.getWorldContainer(), pathtodim);
-
-                    ConfigurationSection entry = section.getConfigurationSection(s);
-                    if (!entry.contains("backup-generator", true)) {
-                        continue;
-                    }
-
-                    String generator = entry.getString("backup-generator");
-                    if (!generator.startsWith("Iris")) {
-                        continue;
-                    }
-
-                    if (!s.equalsIgnoreCase(world)) {
-                        continue;
-                    }
-
-                    File worldFolder = new File(Bukkit.getWorldContainer().getPath() + "/" + s + "/iris/engine-data/");
-                    IOFileFilter jsonFilter = org.apache.commons.io.filefilter.FileFilterUtils.suffixFileFilter(".json");
-                    Collection<File> files = FileUtils.listFiles(worldFolder, jsonFilter, TrueFileFilter.INSTANCE);
-                    if (files.size() != 1) {
-                        Iris.info(C.DARK_GRAY + "------------------------------------------");
-                        Iris.info(C.RED + "Failed to load " + C.GRAY + s + C.RED + ". No valid engine-data file was found.");
-                        Iris.info(C.DARK_GRAY + "------------------------------------------");
-                        continue;
-                    }
 
+        String dimension = null;
+        if (directory.exists() && directory.isDirectory()) {
+            File[] files = directory.listFiles();
+            if (files != null) {
                 for (File file : files) {
-                        int lastDotIndex = file.getName().lastIndexOf(".");
+                    if (file.isFile()) {
-                        generator = file.getName().substring(0, lastDotIndex);
+                        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);
 
-                    Iris.info("2 World: %s | Generator: %s", s, generator);
+        YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
-
+        String gen = "Iris:" + dimension;
-                    if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+        ConfigurationSection section = yml.contains("worlds") ? yml.getConfigurationSection("worlds") : yml.createSection("worlds");
-                        continue;
+        if (!section.contains(world)) {
-                    }
+            section.createSection(world).set("generator", gen);
-
+            try {
-                    Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                yml.save(BUKKIT_YML);
-                    new WorldCreator(s)
+                Iris.info("Registered \"" + world + "\" in bukkit.yml");
-                            .generator(getDefaultWorldGenerator(s, generator))
+            } catch (IOException e) {
-                            .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                Iris.error("Failed to update bukkit.yml!");
-                            .createWorld();
-                    Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
-                    break;
-                } catch (Exception e) {
-                    Iris.info(C.DARK_GRAY + "------------------------------------------");
-                    Iris.info(C.RED + "Failed to load " + C.GRAY + s);
-                    Iris.info(C.DARK_GRAY + "------------------------------------------");
-                }
-                sender().sendMessage(C.GOLD + "Failed to find world: " + C.DARK_GRAY + world);
-            }
-        } catch (Throwable e) {
                 e.printStackTrace();
+                return;
             }
         }
-
+        Iris.instance.checkForBukkitWorlds(world::equals);
+        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")
@@ -553,98 +537,4 @@ public class CommandIris implements DecreeExecutor {
         File worldDirectory = new File(worldContainer, worldName);
         return worldDirectory.exists() && worldDirectory.isDirectory();
     }
-
-    private void checkForBukkitWorlds(String world) {
-        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(world);
-
-            for (String s : section.getKeys(false)) {
-                if (!worldsToLoad.contains(s)) {
-                    continue;
-                }
-                ConfigurationSection entry = section.getConfigurationSection(s);
-                if (!entry.contains("generator", true)) {
-                    continue;
-                }
-                String generator = entry.getString("generator");
-                if (generator.startsWith("Iris:")) {
-                    generator = generator.split("\\Q:\\E")[1];
-                } else if (generator.equalsIgnoreCase("Iris")) {
-                    generator = IrisSettings.get().getGenerator().getDefaultWorldType();
-                } else {
-                    continue;
-                }
-                Iris.info("2 World: %s | Generator: %s", s, generator);
-                if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
-                    continue;
-                }
-                Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
-                new WorldCreator(s)
-                        .generator(getDefaultWorldGenerator(s, generator))
-                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
-                        .createWorld();
-                Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
-            }
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
-        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
-        if (worldName.equals("test")) {
-            try {
-                throw new RuntimeException();
-            } catch (Throwable e) {
-                Iris.info(e.getStackTrace()[1].getClassName());
-                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
-                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
-                    return new DummyChunkGenerator();
-                }
-            }
-        }
-        IrisDimension dim;
-        if (id == null || id.isEmpty()) {
-            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
-        } else {
-            dim = IrisData.loadAnyDimension(id);
-        }
-        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
-
-        if (dim == null) {
-            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
-
-            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
-            dim = IrisData.loadAnyDimension(id);
-
-            if (dim == null) {
-                throw new RuntimeException("Can't find dimension " + id + "!");
-            } else {
-                Iris.info("Resolved missing dimension, proceeding with generation.");
-            }
-        }
-        Iris.debug("Assuming IrisDimension: " + dim.getName());
-        IrisWorld w = IrisWorld.builder()
-                .name(worldName)
-                .seed(1337)
-                .environment(dim.getEnvironment())
-                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
-                .minHeight(dim.getMinHeight())
-                .maxHeight(dim.getMaxHeight())
-                .build();
-        Iris.debug("Generator Config: " + w.toString());
-        File ff = new File(w.worldFolder(), "iris/pack");
-        if (!ff.exists() || ff.listFiles().length == 0) {
-            ff.mkdirs();
-            service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
-        }
-        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
-    }
 }

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -48,7 +48,7 @@ public class CommandJigsaw implements DecreeExecutor {
             IrisJigsawPiece piece
     ) {
         File dest = piece.getLoadFile();
-        new JigsawEditor(player(), piece, IrisData.loadAnyObject(piece.getObject()), dest);
+        new JigsawEditor(player(), piece, IrisData.loadAnyObject(piece.getObject(), data()), dest);
     }
 
     @Decree(description = "Place a jigsaw structure")
@@ -60,7 +60,7 @@ public class CommandJigsaw implements DecreeExecutor {
         try {
             var world = world();
             WorldObjectPlacer placer = new WorldObjectPlacer(world);
-            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG());
+            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG(), true);
             VolmitSender sender = sender();
             sender.sendMessage(C.GREEN + "Generated " + ps.getPieces().size() + " pieces in " + Form.duration(p.getMilliseconds(), 2));
             ps.place(placer, failed -> sender.sendMessage(failed ? C.GREEN + "Placed the structure!" : C.RED + "Failed to place the structure!"));
@@ -78,7 +78,7 @@ public class CommandJigsaw implements DecreeExecutor {
             @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
             String object
     ) {
-        IrisObject o = IrisData.loadAnyObject(object);
+        IrisObject o = IrisData.loadAnyObject(object, data());
 
         if (object == null) {
             sender().sendMessage(C.RED + "Failed to find existing object");

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -19,11 +19,16 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.gui.PregeneratorJob;
 import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.pregenerator.PregenTask;
+import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.math.Position2;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.util.Vector;
@@ -34,7 +39,6 @@ import java.io.IOException;
 @Decree(name = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
 public class CommandLazyPregen implements DecreeExecutor {
     public String worldName;
-
     @Decree(description = "Pregenerate a world")
     public void start(
             @Param(description = "The radius of the pregen in blocks", aliases = "size")

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -28,6 +28,8 @@ import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.registry.Materials;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -36,12 +38,8 @@ import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.Direction;
 import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.misc.E;
-import com.volmit.iris.util.scheduling.Queue;
 import org.bukkit.*;
 import org.bukkit.block.Block;
-import org.bukkit.block.BlockState;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.util.Vector;
@@ -54,7 +52,7 @@ import java.util.*;
 @Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
 public class CommandObject implements DecreeExecutor {
 
-    private static final Set<Material> skipBlocks = Set.of(E.getOrDefault(Material.class, "GRASS", "SHORT_GRASS"), Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
+    private static final Set<Material> skipBlocks = Set.of(Materials.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
             Material.POPPY, Material.DANDELION);
 
     public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
@@ -75,12 +73,14 @@ public class CommandObject implements DecreeExecutor {
                 Block block = world.getBlockAt(x, y, z);
 
                 //Prevent blocks being set in or bellow bedrock
-                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK)
+                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
-                    return;
 
                 futureBlockChanges.put(block, block.getBlockData());
 
-                block.setBlockData(d);
+                if (d instanceof IrisCustomData data) {
+                    block.setBlockData(data.getBase(), false);
+                    Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
+                } else block.setBlockData(d, false);
             }
 
             @Override
@@ -123,6 +123,16 @@ public class CommandObject implements DecreeExecutor {
                 tile.toBukkitTry(world.getBlockAt(xx, yy, zz));
             }
 
+            @Override
+            public <T> void setData(int xx, int yy, int zz, T data) {
+
+            }
+
+            @Override
+            public <T> T getData(int xx, int yy, int zz, Class<T> t) {
+                return null;
+            }
+
             @Override
             public Engine getEngine() {
                 return null;
@@ -135,11 +145,11 @@ public class CommandObject implements DecreeExecutor {
             @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
             String object
     ) {
-        IrisObject o = IrisData.loadAnyObject(object);
+        IrisObject o = IrisData.loadAnyObject(object, data());
         sender().sendMessage("Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD() + "");
         sender().sendMessage("Blocks Used: " + NumberFormat.getIntegerInstance().format(o.getBlocks().size()));
 
-        Queue<BlockData> queue = o.getBlocks().enqueueValues();
+        var queue = o.getBlocks().values();
         Map<Material, Set<BlockData>> unsorted = new HashMap<>();
         Map<BlockData, Integer> amounts = new HashMap<>();
         Map<Material, Integer> materials = new HashMap<>();
@@ -200,7 +210,7 @@ public class CommandObject implements DecreeExecutor {
 
     @Decree(description = "Shrink an object to its minimum size")
     public void shrink(@Param(description = "The object to shrink", customHandler = ObjectHandler.class) String object) {
-        IrisObject o = IrisData.loadAnyObject(object);
+        IrisObject o = IrisData.loadAnyObject(object, data());
         sender().sendMessage("Current Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
         o.shrinkwrap();
         sender().sendMessage("New Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
@@ -240,7 +250,8 @@ public class CommandObject implements DecreeExecutor {
 
 
         Location[] b = WandSVC.getCuboid(player());
-        if (b == null) {
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
             return;
         }
         Location a1 = b[0].clone();
@@ -323,7 +334,7 @@ public class CommandObject implements DecreeExecutor {
 //            @Param(description = "The scale interpolator to use", defaultValue = "none")
 //            IrisObjectPlacementScaleInterpolator interpolator
     ) {
-        IrisObject o = IrisData.loadAnyObject(object);
+        IrisObject o = IrisData.loadAnyObject(object, data());
         double maxScale = Double.max(10 - o.getBlocks().size() / 10000d, 1);
         if (scale > maxScale) {
             sender().sendMessage(C.YELLOW + "Indicated scale exceeds maximum. Downscaled to maximum: " + maxScale);
@@ -377,9 +388,11 @@ public class CommandObject implements DecreeExecutor {
             @Param(description = "The file to store it in, can use / for subfolders")
             String name,
             @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
-            boolean overwrite
+            boolean overwrite,
+            @Param(description = "Use legacy TileState serialization if possible", defaultValue = "true")
+            boolean legacy
     ) {
-        IrisObject o = WandSVC.createSchematic(player());
+        IrisObject o = WandSVC.createSchematic(player(), legacy);
 
         if (o == null) {
             sender().sendMessage(C.YELLOW + "You need to hold your wand!");
@@ -414,6 +427,10 @@ public class CommandObject implements DecreeExecutor {
         }
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
+            return;
+        }
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
@@ -438,7 +455,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(C.BLUE + "Reverted " + actualReverts + C.BLUE + " 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)
@@ -474,6 +491,10 @@ public class CommandObject implements DecreeExecutor {
         }
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
+            return;
+        }
         Location a1 = b[0].clone();
         Location a2 = b[1].clone();
         Location a1x = b[0].clone();
@@ -521,6 +542,10 @@ public class CommandObject implements DecreeExecutor {
         }
 
         Location[] b = WandSVC.getCuboid(player());
+        if (b == null || b[0] == null || b[1] == null) {
+            sender().sendMessage("No area selected.");
+            return;
+        }
         b[0].add(new Vector(0, 1, 0));
         b[1].add(new Vector(0, 1, 0));
         Location a1 = b[0].clone();

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -19,16 +19,9 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.PregeneratorJob;
 import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.pregenerator.methods.HeadlessPregenMethod;
-import com.volmit.iris.core.pregenerator.methods.HybridPregenMethod;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.IrisEngine;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.framework.EngineTarget;
-import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
@@ -37,8 +30,6 @@ import com.volmit.iris.util.math.Position2;
 import org.bukkit.World;
 import org.bukkit.util.Vector;
 
-import java.awt.*;
-
 @Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
 public class CommandPregen implements DecreeExecutor {
     @Decree(description = "Pregenerate a world")
@@ -49,13 +40,8 @@ public class CommandPregen implements DecreeExecutor {
             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 = "headless", description = "Toggle headless pregeneration", defaultValue = "true")
+            @Param(description = "Open the Iris pregen gui", defaultValue = "true")
-            boolean headless,
+            boolean gui
-            @Param(aliases = "gui", description = "Enable or disable the Iris GUI.", defaultValue = "true")
-            boolean gui,
-            @Param(aliases = "resetCache", description = "If it should reset the generated region cache", defaultValue = "false")
-            boolean resetCache
-
             ) {
         try {
             if (sender().isPlayer() && access() == null) {
@@ -63,24 +49,13 @@ public class CommandPregen implements DecreeExecutor {
                 sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
             }
             radius = Math.max(radius, 1024);
-            int w = (radius >> 9 + 1) * 2;
-
-           Engine engine = IrisToolbelt.access(world).getEngine();
-           if(!engine.setEngineHeadless()) {
-               Iris.error("Failed to enable headless engine!");
-               return;
-           }
-
             IrisToolbelt.pregenerate(PregenTask
                     .builder()
-                    .resetCache(resetCache)
+                    .center(new Position2(center.getBlockX(), center.getBlockZ()))
-                    .center(new Position2(center.getBlockX() >> 9, center.getBlockZ() >> 9))
+                    .gui(gui)
-                    .gui(!GraphicsEnvironment.isHeadless() && gui)
+                    .radiusX(radius)
-                    .width(w)
+                    .radiusZ(radius)
-                    .height(w)
+                    .build(), world);
-                    .build(), headless ? new HeadlessPregenMethod(engine) : new HybridPregenMethod(engine.getWorld().realWorld(),
-                    IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())), engine);
-           if (headless) sender().sendMessage("Using the headless Pregenerator.");
             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);
@@ -94,7 +69,7 @@ public class CommandPregen implements DecreeExecutor {
     @Decree(description = "Stop the active pregeneration task", aliases = "x")
     public void stop() {
         if (PregeneratorJob.shutdownInstance()) {
-            Iris.info(C.BLUE + "Finishing up mca region...");
+            Iris.info( C.BLUE + "Finishing up mca region...");
         } else {
             sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
         }

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -22,10 +22,10 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.gui.NoiseExplorerGUI;
 import com.volmit.iris.core.gui.VisionGUI;
+import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.ConversionSVC;
 import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisNoiseBenchmark;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
@@ -41,24 +41,28 @@ import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.function.Function2;
+import com.volmit.iris.util.function.NoiseProvider;
+import com.volmit.iris.util.interpolation.InterpolationMethod;
+import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
+import com.volmit.iris.util.mantle.MantleChunk;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.math.Spiraler;
-import com.volmit.iris.util.parallel.BurstExecutor;
+import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.parallel.SyncExecutor;
 import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
-import com.volmit.iris.util.scheduling.jobs.QueueJob;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
+import com.volmit.iris.util.scheduling.jobs.ParallelRadiusJob;
 import io.papermc.lib.PaperLib;
 import org.bukkit.*;
 import org.bukkit.event.inventory.InventoryType;
 import org.bukkit.inventory.Inventory;
-import org.bukkit.scheduler.BukkitRunnable;
 import org.bukkit.util.BlockVector;
 import org.bukkit.util.Vector;
 
@@ -73,9 +77,8 @@ import java.time.temporal.ChronoUnit;
 import java.util.Arrays;
 import java.util.Date;
 import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Executors;
-import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Supplier;
 
@@ -83,23 +86,25 @@ import java.util.function.Supplier;
 public class CommandStudio implements DecreeExecutor {
     private CommandFind find;
     private CommandEdit edit;
+    //private CommandDeepSearch deepSearch;
 
     public static String hrf(Duration duration) {
         return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
     }
 
+    //TODO fix pack trimming
     @Decree(description = "Download a project.", aliases = "dl")
     public void download(
             @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
             String pack,
             @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
             String branch,
-            @Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
+            //@Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
-            boolean trim,
+            //boolean trim,
             @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
             boolean overwrite
     ) {
-        new CommandIris().download(pack, branch, trim, overwrite);
+        new CommandIris().download(pack, branch, overwrite);
     }
 
     @Decree(description = "Open a new studio world", aliases = "o", sync = true)
@@ -158,71 +163,74 @@ public class CommandStudio implements DecreeExecutor {
             @Param(name = "radius", description = "The radius of nearby cunks", defaultValue = "5")
             int radius
     ) {
-        if (IrisToolbelt.isIrisWorld(player().getWorld())) {
+        World world = player().getWorld();
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
+        }
+
         VolmitSender sender = sender();
+        var loc = player().getLocation().clone();
+
         J.a(() -> {
-                DecreeContext.touch(sender);
+            PlatformChunkGenerator plat = IrisToolbelt.access(world);
-                PlatformChunkGenerator plat = IrisToolbelt.access(player().getWorld());
             Engine engine = plat.getEngine();
-                try {
+            DecreeContext.touch(sender);
-                    Chunk cx = player().getLocation().getChunk();
+            try (SyncExecutor executor = new SyncExecutor(20);
-                    KList<Runnable> js = new KList<>();
+                 var service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
-                    BurstExecutor b = MultiBurst.burst.burst();
+            ) {
-                    b.setMulticore(false);
+                int x = loc.getBlockX() >> 4;
-                    int rad = engine.getMantle().getRealRadius();
+                int z = loc.getBlockZ() >> 4;
-                    for (int i = -(radius + rad); i <= radius + rad; i++) {
-                        for (int j = -(radius + rad); j <= radius + rad; j++) {
-                            engine.getMantle().getMantle().deleteChunk(i + cx.getX(), j + cx.getZ());
-                        }
-                    }
 
-                    for (int i = -radius; i <= radius; i++) {
+                int rad = engine.getMantle().getRadius();
-                        for (int j = -radius; j <= radius; j++) {
+                var mantle = engine.getMantle().getMantle();
-                            int finalJ = j;
+                var chunkMap = new KMap<Position2, MantleChunk>();
-                            int finalI = i;
+                ParallelRadiusJob prep = new ParallelRadiusJob(Integer.MAX_VALUE, service) {
-                            b.queue(() -> plat.injectChunkReplacement(player().getWorld(), finalI + cx.getX(), finalJ + cx.getZ(), (f) -> {
+                    @Override
-                                synchronized (js) {
+                    protected void execute(int rX, int rZ) {
-                                    js.add(f);
+                        if (Math.abs(rX) <= radius && Math.abs(rZ) <= radius) {
+                            mantle.deleteChunk(rX + x, rZ + z);
+                            return;
                         }
-                            }));
+                        rX += x;
+                        rZ += z;
+                        chunkMap.put(new Position2(rX, rZ), mantle.getChunk(rX, rZ));
+                        mantle.deleteChunk(rX, rZ);
                     }
-                    }
-
-                    b.complete();
-                    sender().sendMessage(C.GREEN + "Regenerating " + Form.f(js.size()) + " Sections");
-                    QueueJob<Runnable> r = new QueueJob<>() {
-                        final KList<Future<?>> futures = new KList<>();
 
                     @Override
-                        public void execute(Runnable runnable) {
+                    public String getName() {
-                            futures.add(J.sfut(runnable));
+                        return "Preparing Mantle";
+                    }
+                }.retarget(radius + rad, 0, 0);
+                CountDownLatch pLatch = new CountDownLatch(1);
+                prep.execute(sender(), pLatch::countDown);
+                pLatch.await();
 
-                            if (futures.size() > 64) {
+
-                                while (futures.isNotEmpty()) {
+                ParallelRadiusJob job = new ParallelRadiusJob(Integer.MAX_VALUE, service) {
-                                    try {
+                    @Override
-                                        futures.remove(0).get();
+                    protected void execute(int x, int z) {
-                                    } catch (InterruptedException |
+                        plat.injectChunkReplacement(world, x, z, executor);
-                                             ExecutionException e) {
-                                        e.printStackTrace();
-                                    }
-                                }
-                            }
                     }
 
                     @Override
                     public String getName() {
                         return "Regenerating";
                     }
-                    };
+                }.retarget(radius, x, z);
-                    r.queue(js);
+                CountDownLatch latch = new CountDownLatch(1);
-                    r.execute(sender());
+                job.execute(sender(), latch::countDown);
+                latch.await();
+
+                chunkMap.forEach((pos, chunk) ->
+                        mantle.getChunk(pos.getX(), pos.getZ()).copyFrom(chunk));
             } catch (Throwable e) {
-                    sender().sendMessage("Unable to parse view-distance");
+                sender().sendMessage("Error while regenerating chunks");
+                e.printStackTrace();
+            } finally {
+                DecreeContext.remove();
             }
         });
-        } else {
-            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
-        }
     }
 
     @Decree(description = "Convert objects in the \"convert\" folder")
@@ -283,8 +291,8 @@ public class CommandStudio implements DecreeExecutor {
             sender().sendMessage(C.RED + "No studio world open!");
             return;
         }
-        var provider = Iris.service(StudioSVC.class).getActiveProject().getActiveProvider();
+        Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getEngine().hotload();
-        provider.getEngine().hotload();
+        sender().sendMessage(C.GREEN + "Hotloaded");
     }
 
     @Decree(description = "Show loot if a chest were right here", origin = DecreeOrigin.PLAYER, sync = true)
@@ -300,7 +308,7 @@ public class CommandStudio implements DecreeExecutor {
         Inventory inv = Bukkit.createInventory(null, 27 * 2);
 
         try {
-            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getWorld(), player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
         } catch (Throwable e) {
             Iris.reportError(e);
             sender().sendMessage(C.RED + "Cannot add items to virtual inventory because of: " + e.getMessage());
@@ -311,11 +319,15 @@ public class CommandStudio implements DecreeExecutor {
         O<Integer> ta = new O<>();
         ta.set(-1);
 
+        var sender = sender();
+        var player = player();
+        var engine = engine();
+
         ta.set(Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, () ->
         {
-            if (!player().getOpenInventory().getType().equals(InventoryType.CHEST)) {
+            if (!player.getOpenInventory().getType().equals(InventoryType.CHEST)) {
                 Bukkit.getScheduler().cancelTask(ta.get());
-                sender().sendMessage(C.GREEN + "Opened inventory!");
+                sender.sendMessage(C.GREEN + "Opened inventory!");
                 return;
             }
 
@@ -323,13 +335,49 @@ public class CommandStudio implements DecreeExecutor {
                 inv.clear();
             }
 
-            engine().addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
+            engine.addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player.getWorld(), player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ(), 1);
         }, 0, fast ? 5 : 35));
 
         sender().sendMessage(C.GREEN + "Opening inventory now!");
         player().openInventory(inv);
     }
 
+    @Decree(description = "Calculate the chance for each region to generate", origin = DecreeOrigin.PLAYER)
+    public void regions(@Param(description = "The radius in chunks", defaultValue = "500") int radius) {
+        var engine = engine();
+        if (engine == null) {
+            sender().sendMessage(C.RED + "Only works in an Iris world!");
+            return;
+        }
+        var sender = sender();
+        var player = player();
+        Thread.ofVirtual()
+                .start(() -> {
+                    int d = radius * 2;
+                    KMap<String, AtomicInteger> data = new KMap<>();
+                    engine.getDimension().getRegions().forEach(key -> data.put(key, new AtomicInteger(0)));
+                    var multiBurst = new MultiBurst("Region Sampler");
+                    var executor = multiBurst.burst(radius * radius);
+                    sender.sendMessage(C.GRAY + "Generating data...");
+                    var loc = player.getLocation();
+                    int totalTasks = d * d;
+                    AtomicInteger completedTasks = new AtomicInteger(0);
+                    int c = J.ar(() -> sender.sendProgress((double) completedTasks.get() / totalTasks, "Finding regions"), 0);
+                    new Spiraler(d, d, (x, z) -> executor.queue(() -> {
+                        var region = engine.getRegion((x << 4) + 8, (z << 4) + 8);
+                        data.computeIfAbsent(region.getLoadKey(), (k) -> new AtomicInteger(0))
+                                .incrementAndGet();
+                        completedTasks.incrementAndGet();
+                    })).setOffset(loc.getBlockX(), loc.getBlockZ()).drain();
+                    executor.complete();
+                    multiBurst.close();
+                    J.car(c);
+
+                    sender.sendMessage(C.GREEN + "Done!");
+                    var loader = engine.getData().getRegionLoader();
+                    data.forEach((k, v) -> sender.sendMessage(C.GREEN + k + ": " + loader.load(k).getRarity() + " / " + Form.f((double) v.get() / totalTasks * 100, 2) + "%"));
+                });
+    }
 
     @Decree(description = "Get all structures in a radius of chunks", aliases = "dist", origin = DecreeOrigin.PLAYER)
     public void distances(@Param(description = "The radius in chunks") int radius) {
@@ -341,7 +389,7 @@ public class CommandStudio implements DecreeExecutor {
         var sender = sender();
         int d = radius * 2;
         KMap<String, KList<Position2>> data = new KMap<>();
-        var multiBurst = new MultiBurst("Distance Sampler", Thread.MIN_PRIORITY);
+        var multiBurst = new MultiBurst("Distance Sampler");
         var executor = multiBurst.burst(radius * radius);
 
         sender.sendMessage(C.GRAY + "Generating data...");
@@ -398,10 +446,18 @@ public class CommandStudio implements DecreeExecutor {
 
 
     @Decree(description = "Render a world map (External GUI)", aliases = "render")
-    public void map() {
+    public void map(
+            @Param(name = "world", description = "The world to open the generator for", contextual = true)
+            World world
+    ) {
         if (noGUI()) return;
-        if (noStudio()) return;
+
-        VisionGUI.launch(IrisToolbelt.access(player().getWorld()).getEngine(), 0);
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "You need to be in or specify an Iris-generated world!");
+            return;
+        }
+
+        VisionGUI.launch(IrisToolbelt.access(world).getEngine(), 0);
         sender().sendMessage(C.GREEN + "Opening map!");
     }
 
@@ -422,8 +478,188 @@ public class CommandStudio implements DecreeExecutor {
             @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
             IrisDimension dimension
     ) {
-        IrisNoiseBenchmark noiseBenchmark = new IrisNoiseBenchmark(dimension, sender());
+        // Todo: Make this more accurate
-        noiseBenchmark.runAll();
+        File pack = dimension.getLoadFile().getParentFile().getParentFile();
+        File report = Iris.instance.getDataFile("profile.txt");
+        IrisProject project = new IrisProject(pack);
+        IrisData data = IrisData.get(pack);
+
+        KList<String> fileText = new KList<>();
+
+        KMap<NoiseStyle, Double> styleTimings = new KMap<>();
+        KMap<InterpolationMethod, Double> interpolatorTimings = new KMap<>();
+        KMap<String, Double> generatorTimings = new KMap<>();
+        KMap<String, Double> biomeTimings = new KMap<>();
+        KMap<String, Double> regionTimings = new KMap<>();
+
+        sender().sendMessage("Calculating Performance Metrics for Noise generators");
+
+        for (NoiseStyle i : NoiseStyle.values()) {
+            CNG c = i.create(new RNG(i.hashCode()));
+
+            for (int j = 0; j < 3000; j++) {
+                c.noise(j, j + 1000, j * j);
+                c.noise(j, -j);
+            }
+
+            PrecisionStopwatch px = PrecisionStopwatch.start();
+
+            for (int j = 0; j < 100000; j++) {
+                c.noise(j, j + 1000, j * j);
+                c.noise(j, -j);
+            }
+
+            styleTimings.put(i, px.getMilliseconds());
+        }
+
+        fileText.add("Noise Style Performance Impacts: ");
+
+        for (NoiseStyle i : styleTimings.sortKNumber()) {
+            fileText.add(i.name() + ": " + styleTimings.get(i));
+        }
+
+        fileText.add("");
+
+        sender().sendMessage("Calculating Interpolator Timings...");
+
+        for (InterpolationMethod i : InterpolationMethod.values()) {
+            IrisInterpolator in = new IrisInterpolator();
+            in.setFunction(i);
+            in.setHorizontalScale(8);
+
+            NoiseProvider np = (x, z) -> Math.random();
+
+            for (int j = 0; j < 3000; j++) {
+                in.interpolate(j, -j, np);
+            }
+
+            PrecisionStopwatch px = PrecisionStopwatch.start();
+
+            for (int j = 0; j < 100000; j++) {
+                in.interpolate(j + 10000, -j - 100000, np);
+            }
+
+            interpolatorTimings.put(i, px.getMilliseconds());
+        }
+
+        fileText.add("Noise Interpolator Performance Impacts: ");
+
+        for (InterpolationMethod i : interpolatorTimings.sortKNumber()) {
+            fileText.add(i.name() + ": " + interpolatorTimings.get(i));
+        }
+
+        fileText.add("");
+
+        sender().sendMessage("Processing Generator Scores: ");
+
+        KMap<String, KList<String>> btx = new KMap<>();
+
+        for (String i : data.getGeneratorLoader().getPossibleKeys()) {
+            KList<String> vv = new KList<>();
+            IrisGenerator g = data.getGeneratorLoader().load(i);
+            KList<IrisNoiseGenerator> composites = g.getAllComposites();
+            double score = 0;
+            int m = 0;
+            for (IrisNoiseGenerator j : composites) {
+                m++;
+                score += styleTimings.get(j.getStyle().getStyle());
+                vv.add("Composite Noise Style " + m + " " + j.getStyle().getStyle().name() + ": " + styleTimings.get(j.getStyle().getStyle()));
+            }
+
+            score += interpolatorTimings.get(g.getInterpolator().getFunction());
+            vv.add("Interpolator " + g.getInterpolator().getFunction().name() + ": " + interpolatorTimings.get(g.getInterpolator().getFunction()));
+            generatorTimings.put(i, score);
+            btx.put(i, vv);
+        }
+
+        fileText.add("Project Generator Performance Impacts: ");
+
+        for (String i : generatorTimings.sortKNumber()) {
+            fileText.add(i + ": " + generatorTimings.get(i));
+
+            btx.get(i).forEach((ii) -> fileText.add("  " + ii));
+        }
+
+        fileText.add("");
+
+        KMap<String, KList<String>> bt = new KMap<>();
+
+        for (String i : data.getBiomeLoader().getPossibleKeys()) {
+            KList<String> vv = new KList<>();
+            IrisBiome b = data.getBiomeLoader().load(i);
+            double score = 0;
+
+            int m = 0;
+            for (IrisBiomePaletteLayer j : b.getLayers()) {
+                m++;
+                score += styleTimings.get(j.getStyle().getStyle());
+                vv.add("Palette Layer " + m + ": " + styleTimings.get(j.getStyle().getStyle()));
+            }
+
+            score += styleTimings.get(b.getBiomeStyle().getStyle());
+            vv.add("Biome Style: " + styleTimings.get(b.getBiomeStyle().getStyle()));
+            score += styleTimings.get(b.getChildStyle().getStyle());
+            vv.add("Child Style: " + styleTimings.get(b.getChildStyle().getStyle()));
+            biomeTimings.put(i, score);
+            bt.put(i, vv);
+        }
+
+        fileText.add("Project Biome Performance Impacts: ");
+
+        for (String i : biomeTimings.sortKNumber()) {
+            fileText.add(i + ": " + biomeTimings.get(i));
+
+            bt.get(i).forEach((ff) -> fileText.add("  " + ff));
+        }
+
+        fileText.add("");
+
+        for (String i : data.getRegionLoader().getPossibleKeys()) {
+            IrisRegion b = data.getRegionLoader().load(i);
+            double score = 0;
+
+            score += styleTimings.get(b.getLakeStyle().getStyle());
+            score += styleTimings.get(b.getRiverStyle().getStyle());
+            regionTimings.put(i, score);
+        }
+
+        fileText.add("Project Region Performance Impacts: ");
+
+        for (String i : regionTimings.sortKNumber()) {
+            fileText.add(i + ": " + regionTimings.get(i));
+        }
+
+        fileText.add("");
+
+        double m = 0;
+        for (double i : biomeTimings.v()) {
+            m += i;
+        }
+        m /= biomeTimings.size();
+        double mm = 0;
+        for (double i : generatorTimings.v()) {
+            mm += i;
+        }
+        mm /= generatorTimings.size();
+        m += mm;
+        double mmm = 0;
+        for (double i : regionTimings.v()) {
+            mmm += i;
+        }
+        mmm /= regionTimings.size();
+        m += mmm;
+
+        fileText.add("Average Score: " + m);
+        sender().sendMessage("Score: " + Form.duration(m, 0));
+
+        try {
+            IO.writeAll(report, fileText.toString("\n"));
+        } catch (IOException e) {
+            Iris.reportError(e);
+            e.printStackTrace();
+        }
+
+        sender().sendMessage(C.GREEN + "Done! " + report.getPath());
     }
 
     @Decree(description = "Spawn an Iris entity", aliases = "summon", origin = DecreeOrigin.PLAYER)
@@ -452,8 +688,14 @@ public class CommandStudio implements DecreeExecutor {
         }
 
         sender().sendMessage(C.GREEN + "Sending you to the studio world!");
-        player().teleport(Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getTarget().getWorld().spawnLocation());
+        var player = player();
-        player().setGameMode(GameMode.SPECTATOR);
+        PaperLib.teleportAsync(player(), Iris.service(StudioSVC.class)
+                .getActiveProject()
+                .getActiveProvider()
+                .getTarget()
+                .getWorld()
+                .spawnLocation()
+        ).thenRun(() -> player.setGameMode(GameMode.SPECTATOR));
     }
 
     @Decree(description = "Update your dimension projects VSCode workspace")

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

@@ -1,48 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.misc.Hastebin;
-
-@Decree(name = "Support", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"support"})
-public class CommandSupport implements DecreeExecutor {
-
-    @Decree(description = "report")
-    public void report() {
-        try {
-            if (sender().isPlayer())
-                sender().sendMessage(C.GOLD + "Creating report..");
-            if (!sender().isPlayer()) Iris.info(C.GOLD + "Creating report..");
-            Hastebin.enviornment(sender());
-
-        } catch (Exception e) {
-            Iris.info(C.RED + "Something went wrong: ");
-            e.printStackTrace();
-        }
-    }
-
-
-}
-
-

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -19,6 +19,8 @@
 package com.volmit.iris.core.commands;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.LazyPregenerator;
+import com.volmit.iris.core.pregenerator.TurboPregenerator;
 import com.volmit.iris.core.pregenerator.TurboPregenerator;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.annotations.Decree;
@@ -34,7 +36,6 @@ import java.io.IOException;
 @Decree(name = "turbopregen", aliases = "turbo", description = "Pregenerate your Iris worlds!")
 public class CommandTurboPregen implements DecreeExecutor {
     public String worldName;
-
     @Decree(description = "Pregenerate a world")
     public void start(
             @Param(description = "The radius of the pregen in blocks", aliases = "size")
@@ -56,7 +57,7 @@ public class CommandTurboPregen implements DecreeExecutor {
             } else {
                 try {
                     TurboFile.delete();
-                } catch (Exception e) {
+                } catch (Exception e){
                    Iris.error("Failed to delete the old instance file of Turbo Pregen!");
                    return;
                 }
@@ -118,7 +119,7 @@ public class CommandTurboPregen implements DecreeExecutor {
         } else {
             File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
             File TurboFile = new File(worldDirectory, "turbogen.json");
-            if (TurboFile.exists()) {
+            if (TurboFile.exists()){
                 TurboPregenerator.loadTurboGenerator(world.getName());
                 sender().sendMessage(C.YELLOW + "Started Turbo Pregen back up!");
             } else {

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -18,6 +18,9 @@
 
 package com.volmit.iris.core.commands;
 
+import lombok.Synchronized;
+import org.bukkit.World;
+
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.tools.IrisToolbelt;
@@ -27,11 +30,11 @@ import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
-import org.bukkit.World;
 
 @Decree(name = "updater", origin = DecreeOrigin.BOTH, description = "Iris World Updater")
 public class CommandUpdater implements DecreeExecutor {
-    private ChunkUpdater chunkUpdater;
+    private final Object lock = new Object();
+    private transient ChunkUpdater chunkUpdater;
 
     @Decree(description = "Updates all chunk in the specified world")
     public void start(
@@ -42,6 +45,11 @@ public class CommandUpdater implements DecreeExecutor {
             sender().sendMessage(C.GOLD + "This is not an Iris world");
             return;
         }
+        synchronized (lock) {
+            if (chunkUpdater != null) {
+                chunkUpdater.stop();
+            }
+
             chunkUpdater = new ChunkUpdater(world);
             if (sender().isPlayer()) {
                 sender().sendMessage(C.GREEN + "Updating " + world.getName()  + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
@@ -50,16 +58,11 @@ public class CommandUpdater implements DecreeExecutor {
             }
             chunkUpdater.start();
         }
-
-    @Decree(description = "Pause the updater")
-    public void pause(
-            @Param(description = "World to pause the Updater at")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.GOLD + "This is not an Iris world");
-            return;
     }
+
+    @Synchronized("lock")
+    @Decree(description = "Pause the updater")
+    public void pause( ) {
         if (chunkUpdater == null) {
             sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
             return;
@@ -67,40 +70,33 @@ public class CommandUpdater implements DecreeExecutor {
         boolean status = chunkUpdater.pause();
         if (sender().isPlayer()) {
             if (status) {
-                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
             } else {
-                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
             }
         } else {
             if (status) {
-                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
             } else {
-                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
             }
         }
     }
 
+    @Synchronized("lock")
     @Decree(description = "Stops the updater")
-    public void stop(
+    public void stop() {
-            @Param(description = "World to stop the Updater at")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.GOLD + "This is not an Iris world");
-            return;
-        }
         if (chunkUpdater == null) {
             sender().sendMessage(C.GOLD + "You cant stop something that doesnt exist?");
             return;
         }
         if (sender().isPlayer()) {
-            sender().sendMessage("Stopping Updater for: " + C.GRAY + world.getName());
+            sender().sendMessage("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
         } else {
-            Iris.info("Stopping Updater for: " + C.GRAY + world.getName());
+            Iris.info("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
         }
         chunkUpdater.stop();
     }
-
 }
 
 

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -22,6 +22,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.edit.BlockSignal;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisBiome;
 import com.volmit.iris.engine.object.IrisRegion;
 import com.volmit.iris.util.data.B;
@@ -38,6 +39,7 @@ import org.bukkit.Material;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
 
 @Decree(name = "what", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris What?")
@@ -86,7 +88,8 @@ public class CommandWhat implements DecreeExecutor {
     @Decree(description = "What region am i in?", origin = DecreeOrigin.PLAYER)
     public void region() {
         try {
-            IrisRegion r = engine().getRegion(player().getLocation());
+            Chunk chunk = world().getChunkAt(player().getLocation().getBlockZ() / 16, player().getLocation().getBlockZ() /  16);
+            IrisRegion r = engine().getRegion(chunk);
             sender().sendMessage("IRegion: " + r.getLoadKey() + " (" + r.getName() + ")");
 
         } catch (Throwable e) {

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -61,14 +61,14 @@ public class JigsawEditor implements Listener {
     private Location target;
 
     public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
-        if (editors.containsKey(player)) {
+        if (object == null) throw new RuntimeException("Object is null! " + piece.getObject());
-            editors.get(player).close();
+        editors.compute(player, ($, current) -> {
+            if (current != null) {
+                current.exit();
             }
+            return this;
+        });
 
-        editors.put(player, this);
-        if (object == null) {
-            throw new RuntimeException("Object is null! " + piece.getObject());
-        }
         this.object = object;
         this.player = player;
         origin = player.getLocation().clone().add(0, 7, 0);

core/src/main/java/com/volmit/iris/core/events/IrisEngineEvent.java

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

core/src/main/java/com/volmit/iris/core/events/IrisEngineHotloadEvent.java

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

core/src/main/java/com/volmit/iris/core/events/IrisLootEvent.java

@@ -0,0 +1,113 @@
+package com.volmit.iris.core.events;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.object.InventorySlotType;
+import com.volmit.iris.engine.object.IrisLootTable;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.scheduling.J;
+import lombok.Getter;
+import org.bukkit.*;
+import org.bukkit.block.Block;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.world.LootGenerateEvent;
+
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.loot.LootContext;
+import org.bukkit.loot.LootTable;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Random;
+
+@Getter
+public class IrisLootEvent extends Event {
+    private static final HandlerList handlers = new HandlerList();
+    private static final LootTable EMPTY = new LootTable() {
+        @NotNull
+        @Override
+        public NamespacedKey getKey() {
+            return new NamespacedKey(Iris.instance, "empty");
+        }
+
+        @NotNull
+        @Override
+        public Collection<ItemStack> populateLoot(@Nullable Random random, @NotNull LootContext context) {
+            return List.of();
+        }
+
+        @Override
+        public void fillInventory(@NotNull Inventory inventory, @Nullable Random random, @NotNull LootContext context) {
+        }
+    };
+
+    private final Engine engine;
+    private final Block block;
+    private final InventorySlotType slot;
+    private final KList<IrisLootTable> tables;
+
+    /**
+     * Constructor for IrisLootEvent with mode selection.
+     *
+     * @param engine The engine instance.
+     * @param block The block associated with the event.
+     * @param slot The inventory slot type.
+     * @param tables The list of IrisLootTables. (mutable*)
+     */
+    public IrisLootEvent(Engine engine, Block block, InventorySlotType slot, KList<IrisLootTable> tables) {
+        this.engine = engine;
+        this.block = block;
+        this.slot = slot;
+        this.tables = tables;
+    }
+
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+
+    /**
+     * Required method to get the HandlerList for this event.
+     *
+     * @return The HandlerList.
+     */
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+
+    /**
+     * Triggers the corresponding Bukkit loot event.
+     * This method integrates your custom IrisLootTables with Bukkit's LootGenerateEvent,
+     * allowing other plugins to modify or cancel the loot generation.
+     *
+     * @return true when the event was canceled
+     */
+    public static boolean callLootEvent(KList<ItemStack> loot, Inventory inv, World world, int x, int y, int z) {
+        InventoryHolder holder = inv.getHolder();
+        Location loc = new Location(world, x, y, z);
+        if (holder == null) {
+            holder = new InventoryHolder() {
+                @NotNull
+                @Override
+                public Inventory getInventory() {
+                    return inv;
+                }
+            };
+        }
+
+        LootContext context = new LootContext.Builder(loc).build();
+        LootGenerateEvent event = new LootGenerateEvent(world, null, holder, EMPTY, context, loot, true);
+        if (!Bukkit.isPrimaryThread()) {
+            Iris.warn("LootGenerateEvent was not called on the main thread, please report this issue.");
+            Thread.dumpStack();
+            J.sfut(() -> Bukkit.getPluginManager().callEvent(event)).join();
+        } else Bukkit.getPluginManager().callEvent(event);
+
+        return event.isCancelled();
+    }
+}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -276,9 +276,7 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
 
                         try {
                             //Color color = colorMode ? Color.getHSBColor((float) (n), 1f - (float) (n * n * n * n * n * n), 1f - (float) n) : Color.getHSBColor(0f, 0f, (float) n);
-                            //Color color = colorMode ? Color.getHSBColor((float) (n), (float) (n * n * n * n * n * n), (float) n) : Color.getHSBColor(0f, 0f, (float) n);
+                            Color color = colorMode ? Color.getHSBColor((float) (0.666f - n * 0.666f), 1f, (float) (1f - n * 0.8f)) : Color.getHSBColor(0f, 0f, (float) n);
-                            Color color = colorMode ? Color.getHSBColor((float) n, (float) (n * n * n * n * n * n), (float) n) : Color.getHSBColor(0f, 0f, (float) n);
-
                             int rgb = color.getRGB();
                             img.setRGB(xx, z, rgb);
                         } catch (Throwable ignored) {

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -34,15 +34,16 @@ import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
 
 import javax.swing.*;
 import java.awt.*;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
 import java.awt.image.BufferedImage;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.function.Consumer;
 
@@ -55,7 +56,7 @@ public class PregeneratorJob implements PregenListener {
     private static final Color COLOR_NETWORK_GENERATING = parseColor("#836b8c");
     private static final Color COLOR_GENERATED = parseColor("#65c295");
     private static final Color COLOR_CLEANED = parseColor("#34eb93");
-    public static PregeneratorJob instance;
+    private static final AtomicReference<PregeneratorJob> instance = new AtomicReference<>();
     private final MemoryMonitor monitor;
     private final PregenTask task;
     private final boolean saving;
@@ -66,26 +67,33 @@ public class PregeneratorJob implements PregenListener {
     private final Position2 max;
     private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
     private final Engine engine;
+    private final ExecutorService service;
     private JFrame frame;
     private PregenRenderer renderer;
     private int rgc = 0;
     private String[] info;
 
     public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
+        instance.updateAndGet(old -> {
+            if (old != null) {
+                old.pregenerator.close();
+                old.close();
+            }
+            return this;
+        });
         this.engine = engine;
-        instance = this;
         monitor = new MemoryMonitor(50);
         saving = false;
         info = new String[]{"Initializing..."};
         this.task = task;
         this.pregenerator = new IrisPregenerator(task, method, this);
         max = new Position2(0, 0);
-        min = new Position2(0, 0);
+        min = new Position2(Integer.MAX_VALUE, Integer.MAX_VALUE);
-        task.iterateRegions((xx, zz) -> {
+        task.iterateAllChunks((xx, zz) -> {
-            min.setX(Math.min(xx << 5, min.getX()));
+            min.setX(Math.min(xx, min.getX()));
-            min.setZ(Math.min(zz << 5, min.getZ()));
+            min.setZ(Math.min(zz, min.getZ()));
-            max.setX(Math.max((xx << 5) + 31, max.getX()));
+            max.setX(Math.max(xx, max.getX()));
-            max.setZ(Math.max((zz << 5) + 31, max.getZ()));
+            max.setZ(Math.max(zz, max.getZ()));
         });
 
         if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
@@ -98,41 +106,44 @@ public class PregeneratorJob implements PregenListener {
         }, "Iris Pregenerator");
         t.setPriority(Thread.MIN_PRIORITY);
         t.start();
+        service = Executors.newVirtualThreadPerTaskExecutor();
     }
 
-
     public static boolean shutdownInstance() {
-        if (instance == null) {
+        PregeneratorJob inst = instance.get();
+        if (inst == null) {
             return false;
         }
 
-        J.a(() -> instance.pregenerator.close());
+        J.a(inst.pregenerator::close);
         return true;
     }
 
     public static PregeneratorJob getInstance() {
-        return instance;
+        return instance.get();
     }
 
     public static boolean pauseResume() {
-        if (instance == null) {
+        PregeneratorJob inst = instance.get();
+        if (inst == null) {
             return false;
         }
 
         if (isPaused()) {
-            instance.pregenerator.resume();
+            inst.pregenerator.resume();
         } else {
-            instance.pregenerator.pause();
+            inst.pregenerator.pause();
         }
         return true;
     }
 
     public static boolean isPaused() {
-        if (instance == null) {
+        PregeneratorJob inst = instance.get();
+        if (inst == null) {
             return true;
         }
 
-        return instance.paused();
+        return inst.paused();
     }
 
     private static Color parseColor(String c) {
@@ -162,7 +173,7 @@ public class PregeneratorJob implements PregenListener {
     }
 
     public void drawRegion(int x, int z, Color color) {
-        J.a(() -> PregenTask.iterateRegion(x, z, (xx, zz) -> {
+        J.a(() -> task.iterateChunks(x, z, (xx, zz) -> {
             draw(xx, zz, color);
             J.sleep(3);
         }));
@@ -182,7 +193,7 @@ public class PregeneratorJob implements PregenListener {
         J.a(() -> {
             pregenerator.close();
             close();
-            instance = null;
+            instance.compareAndSet(this, null);
         });
     }
 
@@ -222,10 +233,10 @@ public class PregeneratorJob implements PregenListener {
     }
 
     @Override
-    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
+    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached) {
         info = new String[]{
                 (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
-                "Speed: " + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
+                "Speed: " + (cached ? "Cached " : "") + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
                 Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
                 "Generation Method: " + method,
                 "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
@@ -243,40 +254,22 @@ public class PregeneratorJob implements PregenListener {
     }
 
     @Override
-    public void onChunkGenerated(int x, int z) {
+    public void onChunkGenerated(int x, int z, boolean cached) {
+        if (renderer == null || frame == null || !frame.isVisible()) return;
+        service.submit(() -> {
             if (engine != null) {
                 draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
                 return;
             }
 
             draw(x, z, COLOR_GENERATED);
+        });
     }
 
     @Override
     public void onRegionGenerated(int x, int z) {
         shouldGc();
         rgc++;
-
-        // Each region is 32x32 chunks
-        for (int chunkOffsetX = 0; chunkOffsetX < 32; chunkOffsetX++) {
-            for (int chunkOffsetZ = 0; chunkOffsetZ < 32; chunkOffsetZ++) {
-                // Calculate actual chunk coordinates
-                int chunkX = (x << 5) + chunkOffsetX;
-                int chunkZ = (z << 5) + chunkOffsetZ;
-
-                if (engine != null) {
-                    // Calculate the center block of the chunk
-                    int centerBlockX = (chunkX << 4) + 8;
-                    int centerBlockZ = (chunkZ << 4) + 8;
-
-                    // Draw the chunk
-                    draw(chunkX, chunkZ, engine.draw(centerBlockX, centerBlockZ));
-                } else {
-                    // If engine is null, use the default color
-                    draw(chunkX, chunkZ, COLOR_GENERATED);
-                }
-            }
-        }
     }
 
     private void shouldGc() {
@@ -328,8 +321,9 @@ public class PregeneratorJob implements PregenListener {
     @Override
     public void onClose() {
         close();
-        instance = null;
+        instance.compareAndSet(this, null);
         whenDone.forEach(Runnable::run);
+        service.shutdownNow();
     }
 
     @Override

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -39,7 +39,6 @@ import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import org.bukkit.Location;
-import org.bukkit.attribute.Attribute;
 import org.bukkit.entity.LivingEntity;
 import org.bukkit.entity.Player;
 
@@ -56,6 +55,8 @@ import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.function.BiFunction;
 
+import static com.volmit.iris.util.data.registry.Attributes.MAX_HEALTH;
+
 public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener, MouseMotionListener, MouseInputListener {
     private static final long serialVersionUID = 2094606939770332040L;
     private final KList<LivingEntity> lastEntities = new KList<>();
@@ -80,7 +81,6 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private boolean lowtile = false;
     private boolean follow = false;
     private boolean alt = false;
-    private boolean dragging = false;
     private IrisRenderer renderer;
     private IrisWorld world;
     private double velocity = 0;
@@ -202,7 +202,6 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
     @Override
     public void mouseDragged(MouseEvent e) {
-        dragging = true;
         Point cp = e.getPoint();
         ox += (lx - cp.getX()) * scale;
         oz += (lz - cp.getY()) * scale;
@@ -414,7 +413,6 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     }
 
     private double getWorldX(double screenX) {
-        //return (mscale * screenX) + ((oxp / scale) * mscale);
         return (mscale * screenX) + ((oxp / scale) * mscale);
     }
 
@@ -485,6 +483,13 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             hz += Math.abs(hz - lz) * 0.36;
         }
 
+        if (Math.abs(lx - hx) < 0.5) {
+            hx = lx;
+        }
+        if (Math.abs(lz - hz) < 0.5) {
+            hz = lz;
+        }
+
         if (centities.flip()) {
             J.s(() -> {
                 synchronized (lastEntities) {
@@ -509,8 +514,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
         int iscale = (int) scale;
         g.setColor(Color.white);
         g.clearRect(0, 0, w, h);
-        int posX = (int) oxp;
+        double offsetX = oxp / scale;
-        int posZ = (int) ozp;
+        double offsetZ = ozp / scale;
         m.set(3);
 
         for (int r = 0; r < Math.max(w, h); r += iscale) {
@@ -519,10 +524,14 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
                     int a = i - (w / 2);
                     int b = j - (h / 2);
                     if (a * a + b * b <= r * r) {
-                        BufferedImage t = getTile(gg, iscale, Math.floorDiv((posX / iscale) + i, iscale) * iscale, Math.floorDiv((posZ / iscale) + j, iscale) * iscale, m);
+                        int tx = (int) (Math.floor((offsetX + i) / iscale) * iscale);
+                        int tz = (int) (Math.floor((offsetZ + j) / iscale) * iscale);
+                        BufferedImage t = getTile(gg, iscale, tx, tz, m);
 
                         if (t != null) {
-                            g.drawImage(t, i - ((posX / iscale) % (iscale)), j - ((posZ / iscale) % (iscale)), iscale, iscale, (img, infoflags, x, y, width, height) -> true);
+                            int rx = Math.floorMod((int) Math.floor(offsetX), iscale);
+                            int rz = Math.floorMod((int) Math.floor(offsetZ), iscale);
+                            g.drawImage(t, i - rx, j - rz, iscale, iscale, (img, infoflags, x, y, width, height) -> true);
                         }
                     }
                 }
@@ -638,7 +647,7 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
 
                 k.add("Pos: " + h.getLocation().getBlockX() + ", " + h.getLocation().getBlockY() + ", " + h.getLocation().getBlockZ());
                 k.add("UUID: " + h.getUniqueId());
-                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(Attribute.GENERIC_MAX_HEALTH).getValue());
+                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(MAX_HEALTH).getValue());
 
                 drawCardTR(g, k);
             }
@@ -650,8 +659,8 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
     private void animateTo(double wx, double wz) {
         double cx = getWorldX(getWidth() / 2);
         double cz = getWorldZ(getHeight() / 2);
-        ox += (wx - cx);
+        ox += ((wx - cx) / mscale) * scale;
-        oz += (wz - cz);
+        oz += ((wz - cz) / mscale) * scale;
     }
 
     private void renderPosition(Graphics2D g, double x, double z) {
@@ -806,11 +815,28 @@ public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener
             return;
         }
 
-        //Iris.info("Blocks/Pixel: " + (mscale) + ", Blocks Wide: " + (w * mscale));
+        double m0 = mscale;
+        double m1 = m0 + ((0.25 * m0) * notches);
+        m1 = Math.max(m1, 0.00001);
+        if (m1 == m0) {
+            return;
+        }
+
         positions.clear();
         fastpositions.clear();
-        mscale = mscale + ((0.25 * mscale) * notches);
+
-        mscale = Math.max(mscale, 0.00001);
+        Point p = e.getPoint();
+        double sx = p.getX();
+        double sz = p.getY();
+
+        double newOxp = scale * ((m0 / m1) * (sx + (oxp / scale)) - sx);
+        double newOzp = scale * ((m0 / m1) * (sz + (ozp / scale)) - sz);
+
+        mscale = m1;
+        oxp = newOxp;
+        ozp = newOzp;
+        ox = oxp;
+        oz = ozp;
     }
 
     @Override

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -55,10 +55,10 @@ public class IrisRenderer {
                 IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
                 IrisBiomeGeneratorLink g = b.getGenerators().get(0);
                 Color c;
-                if (g.getMax(renderer) <= 0) {
+                if (g.getMax() <= 0) {
                     // Max is below water level, so it is most likely an ocean biome
                     c = Color.BLUE;
-                } else if (g.getMin(renderer) < 0) {
+                } else if (g.getMin() < 0) {
                     // Min is below water level, but max is not, so it is most likely a shore biome
                     c = Color.YELLOW;
                 } else {

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,91 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.reflect.WrappedField;
-import com.willfp.ecoitems.items.EcoItem;
-import com.willfp.ecoitems.items.EcoItems;
-import org.bukkit.NamespacedKey;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.MissingResourceException;
-
-public class EcoItemsDataProvider extends ExternalDataProvider {
-    private WrappedField<EcoItem, ItemStack> itemStack;
-    private WrappedField<EcoItem, NamespacedKey> id;
-
-    public EcoItemsDataProvider() {
-        super("EcoItems");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up EcoItems Link...");
-        itemStack = new WrappedField<>(EcoItem.class, "_itemStack");
-        if (this.itemStack.hasFailed()) {
-            Iris.error("Failed to set up EcoItems Link: Unable to fetch ItemStack field!");
-        }
-        id = new WrappedField<>(EcoItem.class, "id");
-        if (this.id.hasFailed()) {
-            Iris.error("Failed to set up EcoItems Link: Unable to fetch id field!");
-        }
-    }
-
-    @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
-        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        EcoItem item = EcoItems.INSTANCE.getByID(itemId.key());
-        if (item == null)
-            throw new MissingResourceException("Failed to find Item!", itemId.namespace(), itemId.key());
-        return itemStack.get(item).clone();
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        return new Identifier[0];
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> names = new KList<>();
-        for (EcoItem item : EcoItems.INSTANCE.values()) {
-            try {
-                Identifier key = Identifier.fromNamespacedKey(id.get(item));
-                if (getItemStack(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
-        return id.namespace().equalsIgnoreCase("ecoitems") && isItem;
-    }
-}

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

@@ -1,77 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.ssomar.score.api.executableitems.ExecutableItemsAPI;
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-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, KMap<String, String> state) throws MissingResourceException {
-        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        return ExecutableItemsAPI.getExecutableItemsManager().getExecutableItem(itemId.key())
-                .map(item -> item.buildItem(1, Optional.empty()))
-                .orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()));
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        return new Identifier[0];
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : ExecutableItemsAPI.getExecutableItemsManager().getExecutableItemIdsList()) {
-            try {
-                Identifier key = new Identifier("executable_items", name);
-                if (getItemStack(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier key, boolean isItem) {
-        return key.namespace().equalsIgnoreCase("executable_items") && isItem;
-    }
-}

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

@@ -1,41 +1,42 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 package com.volmit.iris.core.link;
 
+import com.volmit.iris.core.link.data.DataType;
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.nms.container.BlockProperty;
+import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.math.RNG;
 import lombok.Getter;
+import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 import org.bukkit.Bukkit;
+import org.bukkit.Location;
 import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.Listener;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
 import java.util.MissingResourceException;
 
+@Getter
 @RequiredArgsConstructor
-public abstract class ExternalDataProvider {
+public abstract class ExternalDataProvider implements Listener {
 
-    @Getter
+    @NonNull
     private final String pluginId;
 
+    @Nullable
     public Plugin getPlugin() {
         return Bukkit.getPluginManager().getPlugin(pluginId);
     }
@@ -46,24 +47,124 @@ public abstract class ExternalDataProvider {
 
     public abstract void init();
 
-    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
+    /**
+     * @see ExternalDataProvider#getBlockData(Identifier, KMap)
+     */
+    @NotNull
+    public BlockData getBlockData(@NotNull Identifier blockId) throws MissingResourceException {
         return getBlockData(blockId, new KMap<>());
     }
 
-    public abstract BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException;
+    /**
+     * This method returns a {@link BlockData} corresponding to the blockID
+     * it is used in any place Iris accepts {@link BlockData}
+     *
+     * @param blockId The id of the block to get
+     * @param state The state of the block to get
+     * @return Corresponding {@link BlockData} to the blockId
+     *         may return {@link IrisCustomData} for blocks that need a world for placement
+     * @throws MissingResourceException when the blockId is invalid
+     */
+    @NotNull
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
 
-    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
+    /**
+     * Retrieves a list of all {@link BlockProperty} objects associated with the specified block identifier.
+     *
+     * @param blockId The identifier of the block whose properties are to be retrieved. Must not be null.
+     * @return A list of {@link BlockProperty} objects representing the properties of the block.
+     * @throws MissingResourceException If the specified block identifier is invalid or cannot be found.
+     */
+    @NotNull
+    public List<BlockProperty> getBlockProperties(@NotNull Identifier blockId) throws MissingResourceException {
+        return List.of();
+    }
+
+    /**
+     * @see ExternalDataProvider#getItemStack(Identifier)
+     */
+    @NotNull
+    public ItemStack getItemStack(@NotNull Identifier itemId) throws MissingResourceException {
         return getItemStack(itemId, new KMap<>());
     }
 
-    public abstract ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException;
+    /**
-
+     * This method returns a {@link ItemStack} corresponding to the itemID
-    public void processUpdate(Engine engine, Block block, Identifier blockId) {
+     * it is used in loot tables
+     *
+     * @param itemId The id of the item to get
+     * @param customNbt Custom nbt to apply to the item
+     * @return Corresponding {@link ItemStack} to the itemId
+     * @throws MissingResourceException when the itemId is invalid
+     */
+    @NotNull
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
     }
 
-    public abstract Identifier[] getBlockTypes();
+    /**
+     * This method is used for placing blocks that need to use the plugins api
+     * it will only be called when the {@link ExternalDataProvider#getBlockData(Identifier, KMap)} returned a {@link IrisCustomData}
+     *
+     * @param engine The engine of the world the block is being placed in
+     * @param block The block where the block should be placed
+     * @param blockId The blockId to place
+     */
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {}
 
-    public abstract Identifier[] getItemTypes();
+    /**
+     * Spawns a mob in the specified location using the given engine and entity identifier.
+     *
+     * @param location The location in the world where the mob should spawn. Must not be null.
+     * @param entityId The identifier of the mob entity to spawn. Must not be null.
+     * @return The spawned {@link Entity} if successful, or null if the mob could not be spawned.
+     */
+    @Nullable
+    public Entity spawnMob(@NotNull Location location, @NotNull Identifier entityId) throws MissingResourceException {
+        throw new MissingResourceException("Failed to find Entity!", entityId.namespace(), entityId.key());
+    }
 
-    public abstract boolean isValidProvider(Identifier id, boolean isItem);
+    public abstract @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType);
+
+    public abstract boolean isValidProvider(@NotNull Identifier id, DataType dataType);
+
+    protected static Pair<Float, BlockFace> parseYawAndFace(@NotNull Engine engine, @NotNull Block block, @NotNull KMap<@NotNull String, @NotNull String> state) {
+        float yaw = 0;
+        BlockFace face = BlockFace.NORTH;
+
+        long seed = engine.getSeedManager().getSeed() + Cache.key(block.getX(), block.getZ()) + block.getY();
+        RNG rng = new RNG(seed);
+        if ("true".equals(state.get("randomYaw"))) {
+            yaw = rng.f(0, 360);
+        } else if (state.containsKey("yaw")) {
+            yaw = Float.parseFloat(state.get("yaw"));
+        }
+        if ("true".equals(state.get("randomFace"))) {
+            BlockFace[] faces = BlockFace.values();
+            face = faces[rng.i(0, faces.length - 1)];
+        } else if (state.containsKey("face")) {
+            face = BlockFace.valueOf(state.get("face").toUpperCase());
+        }
+        if (face == BlockFace.SELF) {
+            face = BlockFace.NORTH;
+        }
+
+        return new Pair<>(yaw, face);
+    }
+
+    protected static List<BlockProperty> YAW_FACE_BIOME_PROPERTIES = List.of(
+            BlockProperty.ofEnum(BiomeColor.class, "matchBiome", null),
+            BlockProperty.ofBoolean("randomYaw", false),
+            BlockProperty.ofFloat("yaw", 0, 0, 360f, false, true),
+            BlockProperty.ofBoolean("randomFace", true),
+            new BlockProperty(
+                    "face",
+                    BlockFace.class,
+                    BlockFace.NORTH,
+                    Arrays.asList(BlockFace.values()).subList(0, BlockFace.values().length - 1),
+                    BlockFace::name
+            )
+    );
 }

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

@@ -1,157 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.reflect.WrappedField;
-import com.volmit.iris.util.reflect.WrappedReturningMethod;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.type.Leaves;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.Map;
-import java.util.MissingResourceException;
-import java.util.function.Supplier;
-
-public class HMCLeavesDataProvider extends ExternalDataProvider {
-    private Object apiInstance;
-    private WrappedReturningMethod<Object, Material> worldBlockType;
-    private WrappedReturningMethod<Object, Boolean> setCustomBlock;
-    private Map<String, Object> blockDataMap = Map.of();
-    private Map<String, Supplier<ItemStack>> itemDataField = Map.of();
-
-    public HMCLeavesDataProvider() {
-        super("HMCLeaves");
-    }
-
-    @Override
-    public String getPluginId() {
-        return "HMCLeaves";
-    }
-
-    @Override
-    public void init() {
-        try {
-            worldBlockType = new WrappedReturningMethod<>((Class<Object>) Class.forName("io.github.fisher2911.hmcleaves.data.BlockData"), "worldBlockType");
-            apiInstance = getApiInstance(Class.forName("io.github.fisher2911.hmcleaves.api.HMCLeavesAPI"));
-            setCustomBlock = new WrappedReturningMethod<>((Class<Object>) apiInstance.getClass(), "setCustomBlock", Location.class, String.class, boolean.class);
-            Object config = getLeavesConfig(apiInstance.getClass());
-            blockDataMap = getMap(config, "blockDataMap");
-            itemDataField = getMap(config, "itemSupplierMap");
-        } catch (Throwable e) {
-            Iris.error("Failed to initialize HMCLeavesDataProvider: " + e.getMessage());
-        }
-    }
-
-    @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
-        Object o = blockDataMap.get(blockId.key());
-        if (o == null)
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        Material material = worldBlockType.invoke(o, new Object[0]);
-        if (material == null)
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        BlockData blockData = Bukkit.createBlockData(material);
-        if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
-            leaves.setPersistent(true);
-        return new IrisCustomData(blockData, ExternalDataSVC.buildState(blockId, state));
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        if (!itemDataField.containsKey(itemId.key()))
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        return itemDataField.get(itemId.key()).get();
-    }
-
-    @Override
-    public void processUpdate(Engine engine, Block block, Identifier blockId) {
-        var pair = ExternalDataSVC.parseState(blockId);
-        blockId = pair.getA();
-        Boolean result = setCustomBlock.invoke(apiInstance, new Object[]{block.getLocation(), blockId.key(), false});
-        if (result == null || !result)
-            Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
-        else if (IrisSettings.get().getGenerator().preventLeafDecay) {
-            BlockData blockData = block.getBlockData();
-            if (blockData instanceof Leaves leaves)
-                leaves.setPersistent(true);
-        }
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : blockDataMap.keySet()) {
-            try {
-                Identifier key = new Identifier("hmcleaves", name);
-                if (getBlockData(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : itemDataField.keySet()) {
-            try {
-                Identifier key = new Identifier("hmcleaves", name);
-                if (getItemStack(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
-        return (isItem ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
-    }
-
-    private <C, T> Map<String, T> getMap(C config, String name) {
-        WrappedField<C, Map<String, T>> field = new WrappedField<>((Class<C>) config.getClass(), name);
-        return field.get(config);
-    }
-
-    private <A> A getApiInstance(Class<A> apiClass) {
-        WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
-        return instance.invoke();
-    }
-
-    private <A, C> C getLeavesConfig(Class<A> apiClass) {
-        WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
-        WrappedField<A, C> config = new WrappedField<>(apiClass, "config");
-        return config.get(instance.invoke());
-    }
-}

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

@@ -1,21 +1,3 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 package com.volmit.iris.core.link;
 
 import org.bukkit.NamespacedKey;

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,89 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import dev.lone.itemsadder.api.CustomBlock;
-import dev.lone.itemsadder.api.CustomStack;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.MissingResourceException;
-
-public class ItemAdderDataProvider extends ExternalDataProvider {
-
-    private KList<String> itemNamespaces, blockNamespaces;
-
-    public ItemAdderDataProvider() {
-        super("ItemsAdder");
-    }
-
-    @Override
-    public void init() {
-        this.itemNamespaces = new KList<>();
-        this.blockNamespaces = new KList<>();
-
-        for (Identifier i : getItemTypes()) {
-            itemNamespaces.addIfMissing(i.namespace());
-        }
-        for (Identifier i : getBlockTypes()) {
-            blockNamespaces.addIfMissing(i.namespace());
-            Iris.info("Found ItemAdder Block: " + i);
-        }
-    }
-
-    @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
-        return CustomBlock.getBaseBlockData(blockId.toString());
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        CustomStack stack = CustomStack.getInstance(itemId.toString());
-        if (stack == null) {
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        }
-        return stack.getItemStack();
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        KList<Identifier> keys = new KList<>();
-        for (String s : CustomBlock.getNamespacedIdsInRegistry()) {
-            keys.add(Identifier.fromString(s));
-        }
-        return keys.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> keys = new KList<>();
-        for (String s : CustomStack.getNamespacedIdsInRegistry()) {
-            keys.add(Identifier.fromString(s));
-        }
-        return keys.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
-        return isItem ? this.itemNamespaces.contains(id.namespace()) : this.blockNamespaces.contains(id.namespace());
-    }
-}

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

@@ -1,155 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.scheduling.J;
-import net.Indyuce.mmoitems.MMOItems;
-import net.Indyuce.mmoitems.api.ItemTier;
-import net.Indyuce.mmoitems.api.Type;
-import net.Indyuce.mmoitems.api.block.CustomBlock;
-import org.bukkit.Bukkit;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-
-import java.util.MissingResourceException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-
-public class MMOItemsDataProvider extends ExternalDataProvider {
-
-    public MMOItemsDataProvider() {
-        super("MMOItems");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up MMOItems Link...");
-    }
-
-    @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
-        int id = -1;
-        try {
-            id = Integer.parseInt(blockId.key());
-        } catch (NumberFormatException ignored) {
-        }
-        CustomBlock block = api().getCustomBlocks().getBlock(id);
-        if (block == null)
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        return block.getState().getBlockData();
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        String[] parts = itemId.namespace().split("_", 2);
-        if (parts.length != 2)
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        CompletableFuture<ItemStack> future = new CompletableFuture<>();
-        Runnable run = () -> {
-            try {
-                var type = api().getTypes().get(parts[1]);
-                int level = -1;
-                ItemTier tier = null;
-
-                if (customNbt != null) {
-                    level = (int) customNbt.getOrDefault("level", -1);
-                    tier = api().getTiers().get(String.valueOf(customNbt.get("tier")));
-                }
-
-                ItemStack itemStack;
-                if (type == null) {
-                    future.complete(null);
-                    return;
-                }
-
-                if (level != -1 && tier != null) {
-                    itemStack = api().getItem(type, itemId.key(), level, tier);
-                } else {
-                    itemStack = api().getItem(type, itemId.key());
-                }
-                future.complete(itemStack);
-            } catch (Throwable e) {
-                future.completeExceptionally(e);
-            }
-        };
-        if (Bukkit.isPrimaryThread()) run.run();
-        else J.s(run);
-        ItemStack item = null;
-        try {
-            item = future.get();
-        } catch (InterruptedException | ExecutionException ignored) {
-        }
-        if (item == null)
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        return item;
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        KList<Identifier> names = new KList<>();
-        for (Integer id : api().getCustomBlocks().getBlockIds()) {
-            try {
-                Identifier key = new Identifier("mmoitems", String.valueOf(id));
-                if (getBlockData(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> names = new KList<>();
-        Runnable run = () -> {
-            for (Type type : api().getTypes().getAll()) {
-                for (String name : api().getTemplates().getTemplateNames(type)) {
-                    try {
-                        Identifier key = new Identifier("mmoitems_" + type.getId(), name);
-                        if (getItemStack(key) != null)
-                            names.add(key);
-                    } catch (MissingResourceException ignored) {
-                    }
-                }
-            }
-        };
-        if (Bukkit.isPrimaryThread()) run.run();
-        else {
-            try {
-                J.sfut(run).get();
-            } catch (InterruptedException | ExecutionException e) {
-                Iris.error("Failed getting MMOItems item types!");
-                Iris.reportError(e);
-            }
-        }
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier id, boolean isItem) {
-        return isItem ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
-    }
-
-    private MMOItems api() {
-        return MMOItems.plugin;
-    }
-}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -18,126 +18,60 @@
 
 package com.volmit.iris.core.link;
 
-import com.volmit.iris.Iris;
+import lombok.SneakyThrows;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.util.collection.KMap;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
-import org.bukkit.WorldType;
+import org.mvplugins.multiverse.core.MultiverseCoreApi;
-import org.bukkit.plugin.Plugin;
+import org.mvplugins.multiverse.core.world.MultiverseWorld;
-
+import org.mvplugins.multiverse.core.world.WorldManager;
-import java.lang.reflect.Field;
+import org.mvplugins.multiverse.core.world.options.ImportWorldOptions;
-import java.lang.reflect.Method;
-import java.util.Map;
 
 public class MultiverseCoreLink {
-    private final KMap<String, String> worldNameTypes = new KMap<>();
+    private final boolean active;
 
     public MultiverseCoreLink() {
-
+        active = Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null;
-    }
-
-    public boolean addWorld(String worldName, IrisDimension dim, String seed) {
-        if (!isSupported()) {
-            return false;
-        }
-
-        try {
-            Plugin p = getMultiverse();
-            Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
-            Method m = mvWorldManager.getClass().getDeclaredMethod("addWorld",
-
-                    String.class, World.Environment.class, String.class, WorldType.class, Boolean.class, String.class, boolean.class);
-            boolean b = (boolean) m.invoke(mvWorldManager, worldName, dim.getEnvironment(), seed, WorldType.NORMAL, false, "Iris", false);
-            saveConfig();
-            return b;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-
-        return false;
-    }
-
-    @SuppressWarnings("unchecked")
-    public Map<String, ?> getList() {
-        try {
-            Plugin p = getMultiverse();
-            Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
-            Field f = mvWorldManager.getClass().getDeclaredField("worldsFromTheConfig");
-            f.setAccessible(true);
-            return (Map<String, ?>) f.get(mvWorldManager);
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-
-        return null;
     }
 
     public void removeFromConfig(World world) {
-        if (!isSupported()) {
+        removeFromConfig(world.getName());
-            return;
-        }
-
-        getList().remove(world.getName());
-        saveConfig();
     }
 
     public void removeFromConfig(String world) {
-        if (!isSupported()) {
+        if (!active) return;
-            return;
+        var manager = worldManager();
+        manager.removeWorld(world).onSuccess(manager::saveWorldsConfig);
     }
 
-        getList().remove(world);
+    @SneakyThrows
-        saveConfig();
+    public void updateWorld(World bukkitWorld, String pack) {
+        if (!active) return;
+        var generator = "Iris:" + pack;
+        var manager = worldManager();
+        var world = manager.getWorld(bukkitWorld).getOrElse(() -> {
+            var options = ImportWorldOptions.worldName(bukkitWorld.getName())
+                    .generator(generator)
+                    .environment(bukkitWorld.getEnvironment())
+                    .useSpawnAdjust(false);
+            return manager.importWorld(options).get();
+        });
+
+        world.setAutoLoad(false);
+        if (!generator.equals(world.getGenerator())) {
+            var field = MultiverseWorld.class.getDeclaredField("worldConfig");
+            field.setAccessible(true);
+
+            var config = field.get(world);
+            config.getClass()
+                    .getDeclaredMethod("setGenerator", String.class)
+                    .invoke(config, generator);
         }
 
-    public void saveConfig() {
+        manager.saveWorldsConfig();
-        try {
-            Plugin p = getMultiverse();
-            Object mvWorldManager = p.getClass().getDeclaredMethod("getMVWorldManager").invoke(p);
-            mvWorldManager.getClass().getDeclaredMethod("saveWorldsConfig").invoke(mvWorldManager);
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
     }
 
-    public void assignWorldType(String worldName, String type) {
+    private WorldManager worldManager() {
-        worldNameTypes.put(worldName, type);
+        var api = MultiverseCoreApi.get();
-    }
+        return api.getWorldManager();
-
-    public String getWorldNameType(String worldName, String defaultType) {
-        try {
-            String t = worldNameTypes.get(worldName);
-            return t == null ? defaultType : t;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            return defaultType;
-        }
-    }
-
-    public boolean isSupported() {
-        return getMultiverse() != null;
-    }
-
-    public Plugin getMultiverse() {
-
-        return Bukkit.getPluginManager().getPlugin("Multiverse-Core");
-    }
-
-    public String envName(World.Environment environment) {
-        if (environment == null) {
-            return "normal";
-        }
-
-        return switch (environment) {
-            case NORMAL -> "normal";
-            case NETHER -> "nether";
-            case THE_END -> "end";
-            default -> environment.toString().toLowerCase();
-        };
-
     }
 }

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

@@ -1,59 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import io.lumine.mythic.bukkit.MythicBukkit;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.plugin.Plugin;
-
-import javax.annotation.Nullable;
-import java.util.Collection;
-
-public class MythicMobsLink {
-
-    public MythicMobsLink() {
-
-    }
-
-    public boolean isEnabled() {
-        return getPlugin() != null;
-    }
-
-    public Plugin getPlugin() {
-        return Bukkit.getPluginManager().getPlugin("MythicMobs");
-    }
-
-    /**
-     * Spawn a mythic mob at this location
-     *
-     * @param mob      The mob
-     * @param location The location
-     * @return The mob, or null if it can't be spawned
-     */
-    public @Nullable
-    Entity spawnMob(String mob, Location location) {
-        return isEnabled() ? MythicBukkit.inst().getMobManager().spawnMob(mob, location).getEntity().getBukkitEntity() : null;
-    }
-
-    public Collection<String> getMythicMobTypes() {
-        return isEnabled() ? MythicBukkit.inst().getMobManager().getMobNames() : null;
-    }
-}

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

@@ -1,214 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.data.cache.Cache;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.reflect.WrappedField;
-import io.th0rgal.oraxen.api.OraxenItems;
-import io.th0rgal.oraxen.items.ItemBuilder;
-import io.th0rgal.oraxen.mechanics.Mechanic;
-import io.th0rgal.oraxen.mechanics.MechanicFactory;
-import io.th0rgal.oraxen.mechanics.MechanicsManager;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.block.BlockMechanic;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.block.BlockMechanicFactory;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.furniture.FurnitureFactory;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.furniture.FurnitureMechanic;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.noteblock.NoteBlockMechanicFactory;
-import io.th0rgal.oraxen.mechanics.provided.gameplay.stringblock.StringBlockMechanicFactory;
-import org.bukkit.Bukkit;
-import org.bukkit.Color;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.MultipleFacing;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.ItemDisplay;
-import org.bukkit.entity.ItemFrame;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.PotionMeta;
-
-import java.util.Map;
-import java.util.MissingResourceException;
-import java.util.Optional;
-import java.util.function.Consumer;
-
-public class OraxenDataProvider extends ExternalDataProvider {
-
-    private static final String FIELD_FACTORIES_MAP = "FACTORIES_BY_MECHANIC_ID";
-
-    private WrappedField<MechanicsManager, Map<String, MechanicFactory>> factories;
-
-    public OraxenDataProvider() {
-        super("Oraxen");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up Oraxen Link...");
-        this.factories = new WrappedField<>(MechanicsManager.class, FIELD_FACTORIES_MAP);
-        if (this.factories.hasFailed()) {
-            Iris.error("Failed to set up Oraxen Link: Unable to fetch MechanicFactoriesMap!");
-        }
-    }
-
-    @Override
-    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
-        MechanicFactory factory = getFactory(blockId);
-        if (factory instanceof NoteBlockMechanicFactory f)
-            return f.createNoteBlockData(blockId.key());
-        else if (factory instanceof BlockMechanicFactory f) {
-            MultipleFacing newBlockData = (MultipleFacing) Bukkit.createBlockData(Material.MUSHROOM_STEM);
-            BlockMechanic.setBlockFacing(newBlockData, ((BlockMechanic) f.getMechanic(blockId.key())).getCustomVariation());
-            return newBlockData;
-        } else if (factory instanceof StringBlockMechanicFactory f) {
-            return f.createTripwireData(blockId.key());
-        } else if (factory instanceof FurnitureFactory) {
-            return new IrisCustomData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
-        } else
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @Override
-    public ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException {
-        Optional<ItemBuilder> opt = OraxenItems.getOptionalItemById(itemId.key());
-        return opt.orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key())).build();
-    }
-
-    @Override
-    public void processUpdate(Engine engine, Block block, Identifier blockId) {
-        var pair = ExternalDataSVC.parseState(blockId);
-        var state = pair.getB();
-        blockId = pair.getA();
-        Mechanic mechanic = getFactory(blockId).getMechanic(blockId.key());
-        if (mechanic instanceof FurnitureMechanic f) {
-            float yaw = 0;
-            BlockFace face = BlockFace.NORTH;
-
-            long seed = engine.getSeedManager().getSeed() + Cache.key(block.getX(), block.getZ()) + block.getY();
-            RNG rng = new RNG(seed);
-            if ("true".equals(state.get("randomYaw"))) {
-                yaw = rng.f(0, 360);
-            } else if (state.containsKey("yaw")) {
-                yaw = Float.parseFloat(state.get("yaw"));
-            }
-            if ("true".equals(state.get("randomFace"))) {
-                BlockFace[] faces = BlockFace.values();
-                face = faces[rng.i(0, faces.length - 1)];
-            } else if (state.containsKey("face")) {
-                face = BlockFace.valueOf(state.get("face").toUpperCase());
-            }
-            if (face == BlockFace.SELF) {
-                face = BlockFace.NORTH;
-            }
-            ItemStack itemStack = OraxenItems.getItemById(f.getItemID()).build();
-            Entity entity = f.place(block.getLocation(), itemStack, yaw, face, false);
-
-            Consumer<ItemStack> setter = null;
-            if (entity instanceof ItemFrame frame) {
-                itemStack = frame.getItem();
-                setter = frame::setItem;
-            } else if (entity instanceof ItemDisplay display) {
-                itemStack = display.getItemStack();
-                setter = display::setItemStack;
-            }
-            if (setter == null || itemStack == null) return;
-
-            BiomeColor type = null;
-            try {
-                type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
-            } catch (NullPointerException | IllegalArgumentException ignored) {
-            }
-
-            if (type != null) {
-                var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
-                if (biomeColor == null) return;
-                var potionColor = Color.fromARGB(biomeColor.getAlpha(), biomeColor.getRed(), biomeColor.getGreen(), biomeColor.getBlue());
-                if (itemStack.getItemMeta() instanceof PotionMeta meta) {
-                    meta.setColor(potionColor);
-                    itemStack.setItemMeta(meta);
-                }
-            }
-            setter.accept(itemStack);
-        }
-    }
-
-    @Override
-    public Identifier[] getBlockTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : OraxenItems.getItemNames()) {
-            try {
-                Identifier key = new Identifier("oraxen", name);
-                if (getBlockData(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public Identifier[] getItemTypes() {
-        KList<Identifier> names = new KList<>();
-        for (String name : OraxenItems.getItemNames()) {
-            try {
-                Identifier key = new Identifier("oraxen", name);
-                if (getItemStack(key) != null)
-                    names.add(key);
-            } catch (MissingResourceException ignored) {
-            }
-        }
-
-        return names.toArray(new Identifier[0]);
-    }
-
-    @Override
-    public boolean isReady() {
-        if (super.isReady()) {
-            if (factories == null) {
-                this.factories = new WrappedField<>(MechanicsManager.class, FIELD_FACTORIES_MAP);
-            }
-            return super.isReady() && !factories.hasFailed();
-        }
-        return false;
-    }
-
-    @Override
-    public boolean isValidProvider(Identifier key, boolean isItem) {
-        return key.namespace().equalsIgnoreCase("oraxen");
-    }
-
-    private MechanicFactory getFactory(Identifier key) throws MissingResourceException {
-        return factories.get().values().stream()
-                .filter(i -> i.getItems().contains(key.key()))
-                .findFirst()
-                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", key.namespace(), key.key()));
-    }
-}

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

@@ -1,31 +1,16 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
 package com.volmit.iris.core.link;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.util.data.Cuboid;
+import com.volmit.iris.util.data.KCache;
 import org.bukkit.Bukkit;
 import org.bukkit.World;
 import org.bukkit.entity.Player;
 
 import java.lang.reflect.InvocationTargetException;
+import java.time.Duration;
+import java.util.UUID;
 
 public class WorldEditLink {
     private static final AtomicCache<Boolean> active = new AtomicCache<>();
@@ -46,8 +31,7 @@ public class WorldEditLink {
             Object region = null;
             try {
                 region = localSession.getClass().getDeclaredMethod("getSelection", Class.forName("com.sk89q.worldedit.world.World")).invoke(localSession, world);
-            } catch (InvocationTargetException ignored) {
+            } catch (InvocationTargetException ignored) {}
-            }
             if (region == null) return null;
 
             Object min = region.getClass().getDeclaredMethod("getMinimumPoint").invoke(region);
@@ -63,6 +47,7 @@ public class WorldEditLink {
         } catch (Throwable e) {
             Iris.error("Could not get selection");
             e.printStackTrace();
+            Iris.reportError(e);
             active.reset();
             active.aquire(() -> false);
         }

core/src/main/java/com/volmit/iris/core/link/data/DataType.java

@@ -0,0 +1,33 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+
+import java.util.MissingResourceException;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+
+public enum DataType implements BiPredicate<ExternalDataProvider, Identifier> {
+    ITEM,
+    BLOCK,
+    ENTITY;
+
+    @Override
+    public boolean test(ExternalDataProvider dataProvider, Identifier identifier) {
+        if (!dataProvider.isValidProvider(identifier, this)) return false;
+        try {
+            switch (this) {
+                case ITEM -> dataProvider.getItemStack(identifier);
+                case BLOCK -> dataProvider.getBlockData(identifier);
+                case ENTITY -> {}
+            }
+            return true;
+        } catch (MissingResourceException e) {
+            return false;
+        }
+    }
+
+    public Predicate<Identifier> asPredicate(ExternalDataProvider dataProvider) {
+        return i -> test(dataProvider, i);
+    }
+}

core/src/main/java/com/volmit/iris/core/link/data/EcoItemsDataProvider.java

@@ -0,0 +1,61 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.reflect.WrappedField;
+import com.willfp.ecoitems.items.EcoItem;
+import com.willfp.ecoitems.items.EcoItems;
+import org.bukkit.NamespacedKey;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.MissingResourceException;
+
+public class EcoItemsDataProvider extends ExternalDataProvider {
+    private WrappedField<EcoItem, ItemStack> itemStack;
+    private WrappedField<EcoItem, NamespacedKey> id;
+
+    public EcoItemsDataProvider() {
+        super("EcoItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up EcoItems Link...");
+        itemStack = new WrappedField<>(EcoItem.class, "_itemStack");
+        if (this.itemStack.hasFailed()) {
+            Iris.error("Failed to set up EcoItems Link: Unable to fetch ItemStack field!");
+        }
+        id = new WrappedField<>(EcoItem.class, "id");
+        if (this.id.hasFailed()) {
+            Iris.error("Failed to set up EcoItems Link: Unable to fetch id field!");
+        }
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        EcoItem item = EcoItems.INSTANCE.getByID(itemId.key());
+        if (item == null) throw new MissingResourceException("Failed to find Item!", itemId.namespace(), itemId.key());
+        return itemStack.get(item).clone();
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        if (dataType != DataType.ITEM) return List.of();
+        return EcoItems.INSTANCE.values()
+                .stream()
+                .map(x -> Identifier.fromNamespacedKey(id.get(x)))
+                .filter(dataType.asPredicate(this))
+                .toList();
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+        return id.namespace().equalsIgnoreCase("ecoitems") && dataType == DataType.ITEM;
+    }
+}

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

@@ -0,0 +1,49 @@
+package com.volmit.iris.core.link.data;
+
+import com.ssomar.score.api.executableitems.ExecutableItemsAPI;
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.util.collection.KMap;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+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...");
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) 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 @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        if (dataType != DataType.ITEM) return List.of();
+        return ExecutableItemsAPI.getExecutableItemsManager()
+                .getExecutableItemIdsList()
+                .stream()
+                .map(name -> new Identifier("executable_items", name))
+                .filter(dataType.asPredicate(this))
+                .toList();
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier key, DataType dataType) {
+        return key.namespace().equalsIgnoreCase("executable_items") && dataType == DataType.ITEM;
+    }
+}

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

@@ -0,0 +1,126 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.reflect.WrappedField;
+import com.volmit.iris.util.reflect.WrappedReturningMethod;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.type.Leaves;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.MissingResourceException;
+import java.util.function.Supplier;
+
+public class HMCLeavesDataProvider extends ExternalDataProvider {
+	private Object apiInstance;
+	private WrappedReturningMethod<Object, Material> worldBlockType;
+	private WrappedReturningMethod<Object, Boolean> setCustomBlock;
+	private Map<String, Object> blockDataMap = Map.of();
+	private Map<String, Supplier<ItemStack>> itemDataField = Map.of();
+
+	public HMCLeavesDataProvider() {
+		super("HMCLeaves");
+	}
+
+	@Override
+	public String getPluginId() {
+		return "HMCLeaves";
+	}
+
+	@Override
+	public void init() {
+		try {
+			worldBlockType = new WrappedReturningMethod<>((Class<Object>) Class.forName("io.github.fisher2911.hmcleaves.data.BlockData"), "worldBlockType");
+			apiInstance = getApiInstance(Class.forName("io.github.fisher2911.hmcleaves.api.HMCLeavesAPI"));
+			setCustomBlock = new WrappedReturningMethod<>((Class<Object>) apiInstance.getClass(), "setCustomBlock", Location.class, String.class, boolean.class);
+			Object config = getLeavesConfig(apiInstance.getClass());
+			blockDataMap = getMap(config, "blockDataMap");
+			itemDataField = getMap(config, "itemSupplierMap");
+		} catch (Throwable e) {
+			Iris.error("Failed to initialize HMCLeavesDataProvider: " + e.getMessage());
+		}
+	}
+
+	@NotNull
+	@Override
+	public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+		Object o = blockDataMap.get(blockId.key());
+		if (o == null)
+			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+		Material material = worldBlockType.invoke(o, new Object[0]);
+		if (material == null)
+			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+		BlockData blockData = Bukkit.createBlockData(material);
+		if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
+			leaves.setPersistent(true);
+		return IrisCustomData.of(blockData, ExternalDataSVC.buildState(blockId, state));
+	}
+
+	@NotNull
+	@Override
+	public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+		if (!itemDataField.containsKey(itemId.key()))
+			throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+		return itemDataField.get(itemId.key()).get();
+	}
+
+	@Override
+	public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+		var pair = ExternalDataSVC.parseState(blockId);
+		blockId = pair.getA();
+		Boolean result = setCustomBlock.invoke(apiInstance, new Object[]{block.getLocation(), blockId.key(), false});
+		if (result == null || !result)
+			Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
+		else if (IrisSettings.get().getGenerator().preventLeafDecay) {
+			BlockData blockData = block.getBlockData();
+			if (blockData instanceof Leaves leaves)
+				leaves.setPersistent(true);
+		}
+	}
+
+	@Override
+	public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+		if (dataType == DataType.ENTITY) return List.of();
+		return (dataType == DataType.BLOCK ? blockDataMap.keySet() : itemDataField.keySet())
+				.stream()
+				.map(x -> new Identifier("hmcleaves", x))
+				.filter(dataType.asPredicate(this))
+				.toList();
+	}
+
+	@Override
+	public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+		if (dataType == DataType.ENTITY) return false;
+		return (dataType == DataType.ITEM ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
+	}
+
+	private <C, T> Map<String, T> getMap(C config, String name) {
+		WrappedField<C, Map<String, T>> field = new WrappedField<>((Class<C>) config.getClass(), name);
+		return field.get(config);
+	}
+
+	private <A> A getApiInstance(Class<A> apiClass) {
+		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+		return instance.invoke();
+	}
+
+	private <A, C> C getLeavesConfig(Class<A> apiClass) {
+		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
+		WrappedField<A, C> config = new WrappedField<>(apiClass, "config");
+		return config.get(instance.invoke());
+	}
+}

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

@@ -0,0 +1,107 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.data.IrisCustomData;
+import dev.lone.itemsadder.api.CustomBlock;
+import dev.lone.itemsadder.api.CustomStack;
+import dev.lone.itemsadder.api.Events.ItemsAdderLoadDataEvent;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.event.EventHandler;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.MissingResourceException;
+import java.util.stream.Collectors;
+
+public class ItemAdderDataProvider extends ExternalDataProvider {
+
+    private final KSet<String> itemNamespaces = new KSet<>();
+    private final KSet<String> blockNamespaces = new KSet<>();
+
+    public ItemAdderDataProvider() {
+        super("ItemsAdder");
+    }
+
+    @Override
+    public void init() {
+        updateNamespaces();
+    }
+
+    @EventHandler
+    public void onLoadData(ItemsAdderLoadDataEvent event) {
+        updateNamespaces();
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        CustomBlock block = CustomBlock.getInstance(blockId.toString());
+        if (block == null) {
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        }
+        return IrisCustomData.of(block.getBaseBlockData(), blockId);
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        CustomStack stack = CustomStack.getInstance(itemId.toString());
+        if (stack == null) {
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        }
+        return stack.getItemStack();
+    }
+
+    @Override
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+        CustomBlock custom;
+        if ((custom = CustomBlock.place(blockId.toString(), block.getLocation())) == null)
+            return;
+        block.setBlockData(custom.getBaseBlockData(), false);
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        return switch (dataType) {
+            case ENTITY -> List.of();
+            case ITEM -> CustomStack.getNamespacedIdsInRegistry()
+                    .stream()
+                    .map(Identifier::fromString)
+                    .toList();
+            case BLOCK -> CustomBlock.getNamespacedIdsInRegistry()
+                    .stream()
+                    .map(Identifier::fromString)
+                    .toList();
+        };
+    }
+
+    private void updateNamespaces() {
+        try {
+            updateNamespaces(DataType.ITEM);
+            updateNamespaces(DataType.BLOCK);
+        } catch (Throwable e) {
+            Iris.warn("Failed to update ItemAdder namespaces: " + e.getMessage());
+        }
+    }
+
+    private void updateNamespaces(DataType dataType) {
+        var namespaces = getTypes(dataType).stream().map(Identifier::namespace).collect(Collectors.toSet());
+        var currentNamespaces = dataType == DataType.ITEM ? itemNamespaces : blockNamespaces;
+        currentNamespaces.removeIf(n -> !namespaces.contains(n));
+        currentNamespaces.addAll(namespaces);
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+        if (dataType == DataType.ENTITY) return false;
+        return dataType == DataType.ITEM ? itemNamespaces.contains(id.namespace()) : blockNamespaces.contains(id.namespace());
+    }
+}

core/src/main/java/com/volmit/iris/core/link/data/KGeneratorsDataProvider.java

@@ -0,0 +1,74 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
+import me.kryniowesegryderiusz.kgenerators.Main;
+import me.kryniowesegryderiusz.kgenerators.api.KGeneratorsAPI;
+import me.kryniowesegryderiusz.kgenerators.generators.locations.objects.GeneratorLocation;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.MissingResourceException;
+
+public class KGeneratorsDataProvider extends ExternalDataProvider {
+    public KGeneratorsDataProvider() {
+        super("KGenerators");
+    }
+
+    @Override
+    public void init() {
+
+    }
+
+    @Override
+    public @NotNull BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        if (Main.getGenerators().get(blockId.key()) == null) throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        return IrisCustomData.of(Material.STRUCTURE_VOID.createBlockData(), ExternalDataSVC.buildState(blockId, state));
+    }
+
+    @Override
+    public @NotNull ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        var gen = Main.getGenerators().get(itemId.key());
+        if (gen == null) throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        return gen.getGeneratorItem();
+    }
+
+    @Override
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+        if (block.getType() != Material.STRUCTURE_VOID) return;
+        var existing = KGeneratorsAPI.getLoadedGeneratorLocation(block.getLocation());
+        if (existing != null) return;
+        block.setBlockData(B.getAir(), false);
+        var gen = Main.getGenerators().get(blockId.key());
+        if (gen == null) return;
+        var loc = new GeneratorLocation(-1, gen, block.getLocation(), Main.getPlacedGenerators().getChunkInfo(block.getChunk()), null, null);
+        Main.getDatabases().getDb().saveGenerator(loc);
+        Main.getPlacedGenerators().addLoaded(loc);
+        Main.getSchedules().schedule(loc, true);
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        if (dataType == DataType.ENTITY) return List.of();
+        return Main.getGenerators().getAll().stream()
+                .map(gen -> new Identifier("kgenerators", gen.getId()))
+                .filter(dataType.asPredicate(this))
+                .toList();
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+        if (dataType == DataType.ENTITY) return false;
+        return "kgenerators".equalsIgnoreCase(id.namespace());
+    }
+}

core/src/main/java/com/volmit/iris/core/link/data/MMOItemsDataProvider.java

@@ -0,0 +1,125 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.scheduling.J;
+import net.Indyuce.mmoitems.MMOItems;
+import net.Indyuce.mmoitems.api.ItemTier;
+import net.Indyuce.mmoitems.api.block.CustomBlock;
+import org.bukkit.Bukkit;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.MissingResourceException;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+import java.util.function.Supplier;
+
+public class MMOItemsDataProvider extends ExternalDataProvider {
+
+    public MMOItemsDataProvider() {
+        super("MMOItems");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up MMOItems Link...");
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        int id = -1;
+        try {
+            id = Integer.parseInt(blockId.key());
+        } catch (NumberFormatException ignored) {}
+        CustomBlock block = api().getCustomBlocks().getBlock(id);
+        if (block == null) throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        return block.getState().getBlockData();
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        String[] parts = itemId.namespace().split("_", 2);
+        if (parts.length != 2)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        CompletableFuture<ItemStack> future = new CompletableFuture<>();
+        Runnable run = () -> {
+            try {
+                var type = api().getTypes().get(parts[1]);
+                int level = -1;
+                ItemTier tier = null;
+
+                if (customNbt != null) {
+                    level = (int) customNbt.getOrDefault("level", -1);
+                    tier = api().getTiers().get(String.valueOf(customNbt.get("tier")));
+                }
+
+                ItemStack itemStack;
+                if (type == null) {
+                    future.complete(null);
+                    return;
+                }
+
+                if (level != -1 && tier != null) {
+                    itemStack = api().getItem(type, itemId.key(), level, tier);
+                } else {
+                    itemStack = api().getItem(type, itemId.key());
+                }
+                future.complete(itemStack);
+            } catch (Throwable e) {
+                future.completeExceptionally(e);
+            }
+        };
+        if (Bukkit.isPrimaryThread()) run.run();
+        else J.s(run);
+        ItemStack item = null;
+        try {
+            item = future.get();
+        } catch (InterruptedException | ExecutionException ignored) {}
+        if (item == null)
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        return item;
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        return switch (dataType) {
+            case ENTITY -> List.of();
+            case BLOCK -> api().getCustomBlocks().getBlockIds().stream().map(id -> new Identifier("mmoitems", String.valueOf(id)))
+                    .filter(dataType.asPredicate(this))
+                    .toList();
+            case ITEM -> {
+                Supplier<Collection<Identifier>> supplier = () -> api().getTypes()
+                        .getAll()
+                        .stream()
+                        .flatMap(type -> api()
+                                .getTemplates()
+                                .getTemplateNames(type)
+                                .stream()
+                                .map(name -> new Identifier("mmoitems_" + type.getId(), name)))
+                        .filter(dataType.asPredicate(this))
+                        .toList();
+
+                if (Bukkit.isPrimaryThread()) yield supplier.get();
+                else yield J.sfut(supplier).join();
+            }
+        };
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+        if (dataType == DataType.ENTITY) return false;
+        return dataType == DataType.ITEM ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
+    }
+
+    private MMOItems api() {
+        return MMOItems.plugin;
+    }
+}

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

@@ -0,0 +1,144 @@
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.nms.container.BlockProperty;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
+import io.lumine.mythic.bukkit.BukkitAdapter;
+import io.lumine.mythic.bukkit.utils.serialize.Chroma;
+import io.lumine.mythiccrucible.MythicCrucible;
+import io.lumine.mythiccrucible.items.CrucibleItem;
+import io.lumine.mythiccrucible.items.ItemManager;
+import io.lumine.mythiccrucible.items.blocks.CustomBlockItemContext;
+import io.lumine.mythiccrucible.items.furniture.FurnitureItemContext;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.MissingResourceException;
+import java.util.Optional;
+
+public class MythicCrucibleDataProvider extends ExternalDataProvider {
+
+    private ItemManager itemManager;
+
+    public MythicCrucibleDataProvider() {
+        super("MythicCrucible");
+    }
+
+    @Override
+    public void init() {
+        Iris.info("Setting up MythicCrucible Link...");
+        try {
+            this.itemManager = MythicCrucible.inst().getItemManager();
+        } catch (Exception e) {
+            Iris.error("Failed to set up MythicCrucible Link: Unable to fetch MythicCrucible instance!");
+        }
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        CrucibleItem crucibleItem = this.itemManager.getItem(blockId.key())
+                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key()));
+        CustomBlockItemContext blockItemContext = crucibleItem.getBlockData();
+        FurnitureItemContext furnitureItemContext = crucibleItem.getFurnitureData();
+        if (furnitureItemContext != null) {
+            return IrisCustomData.of(B.getAir(), ExternalDataSVC.buildState(blockId, state));
+        } else if (blockItemContext != null) {
+            return blockItemContext.getBlockData();
+        }
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @Override
+    public @NotNull List<BlockProperty> getBlockProperties(@NotNull Identifier blockId) throws MissingResourceException {
+        CrucibleItem crucibleItem = this.itemManager.getItem(blockId.key())
+                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key()));
+
+        if (crucibleItem.getFurnitureData() != null) {
+            return YAW_FACE_BIOME_PROPERTIES;
+        } else if (crucibleItem.getBlockData() != null) {
+            return List.of();
+        }
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        Optional<CrucibleItem> opt = this.itemManager.getItem(itemId.key());
+        return BukkitAdapter.adapt(opt.orElseThrow(() ->
+                new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()))
+                .getMythicItem()
+                .generateItemStack(1));
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        return itemManager.getItems()
+                .stream()
+                .map(i -> new Identifier("crucible", i.getInternalName()))
+                .filter(dataType.asPredicate(this))
+                .toList();
+    }
+
+    @Override
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+        var parsedState = ExternalDataSVC.parseState(blockId);
+        var state = parsedState.getB();
+        blockId = parsedState.getA();
+
+        Optional<CrucibleItem> item = itemManager.getItem(blockId.key());
+        if (item.isEmpty()) return;
+        FurnitureItemContext furniture = item.get().getFurnitureData();
+        if (furniture == null) return;
+
+        var pair = parseYawAndFace(engine, block, state);
+        BiomeColor type = null;
+        Chroma color = null;
+        try {
+            type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
+        } catch (NullPointerException | IllegalArgumentException ignored) {}
+        if (type != null) {
+            var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
+            if (biomeColor == null) return;
+            color = Chroma.of(biomeColor.getRGB());
+        }
+        furniture.place(block, pair.getB(), pair.getA(), color);
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier key, DataType dataType) {
+        if (dataType == DataType.ENTITY) return false;
+        return key.namespace().equalsIgnoreCase("crucible");
+    }
+}

core/src/main/java/com/volmit/iris/core/link/data/MythicMobsDataProvider.java

@@ -0,0 +1,130 @@
+package com.volmit.iris.core.link.data;
+
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import io.lumine.mythic.api.adapters.AbstractLocation;
+import io.lumine.mythic.api.config.MythicLineConfig;
+import io.lumine.mythic.api.mobs.entities.SpawnReason;
+import io.lumine.mythic.api.skills.conditions.ILocationCondition;
+import io.lumine.mythic.bukkit.BukkitAdapter;
+import io.lumine.mythic.bukkit.MythicBukkit;
+import io.lumine.mythic.bukkit.adapters.BukkitWorld;
+import io.lumine.mythic.bukkit.events.MythicConditionLoadEvent;
+import io.lumine.mythic.core.mobs.ActiveMob;
+import io.lumine.mythic.core.mobs.MobStack;
+import io.lumine.mythic.core.skills.SkillCondition;
+import io.lumine.mythic.core.utils.annotations.MythicCondition;
+import io.lumine.mythic.core.utils.annotations.MythicField;
+import org.bukkit.Location;
+import org.bukkit.entity.Entity;
+import org.bukkit.event.EventHandler;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.stream.Stream;
+
+public class MythicMobsDataProvider extends ExternalDataProvider {
+    public MythicMobsDataProvider() {
+        super("MythicMobs");
+    }
+
+    @Override
+    public void init() {
+    }
+
+    @Override
+    public @Nullable Entity spawnMob(@NotNull Location location, @NotNull Identifier entityId) throws MissingResourceException {
+        var mm = spawnMob(BukkitAdapter.adapt(location), entityId);
+        return mm == null ? null : mm.getEntity().getBukkitEntity();
+    }
+
+    private ActiveMob spawnMob(AbstractLocation location, Identifier entityId) throws MissingResourceException {
+        var manager = MythicBukkit.inst().getMobManager();
+        var mm = manager.getMythicMob(entityId.key()).orElse(null);
+        if (mm == null) {
+            var stack = manager.getMythicMobStack(entityId.key());
+            if (stack == null) throw new MissingResourceException("Failed to find Mob!", entityId.namespace(), entityId.key());
+            return stack.spawn(location, 1d, SpawnReason.OTHER, null);
+        }
+        return mm.spawn(location, 1d, SpawnReason.OTHER, null, null);
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        if (dataType != DataType.ENTITY) return List.of();
+        var manager = MythicBukkit.inst().getMobManager();
+        return Stream.concat(manager.getMobNames().stream(),
+                        manager.getMobStacks()
+                                .stream()
+                                .map(MobStack::getName)
+                )
+                .distinct()
+                .map(name -> new Identifier("mythicmobs", name))
+                .toList();
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+        return id.namespace().equalsIgnoreCase("mythicmobs") && dataType == DataType.ENTITY;
+    }
+
+    @EventHandler
+    public void on(MythicConditionLoadEvent event) {
+        switch (event.getConditionName()) {
+            case "irisbiome" -> event.register(new IrisBiomeCondition(event.getConditionName(), event.getConfig()));
+            case "irisregion" -> event.register(new IrisRegionCondition(event.getConditionName(), event.getConfig()));
+        }
+    }
+
+    @MythicCondition(author = "CrazyDev22", name = "irisbiome", description = "Tests if the target is within the given list of biomes")
+    public static class IrisBiomeCondition extends SkillCondition implements ILocationCondition {
+        @MythicField(name = "biome", aliases = {"b"}, description = "A list of biomes to check")
+        private Set<String> biomes = ConcurrentHashMap.newKeySet();
+        @MythicField(name = "surface", aliases = {"s"}, description = "If the biome check should only be performed on the surface")
+        private boolean surface;
+
+        public IrisBiomeCondition(String line, MythicLineConfig mlc) {
+            super(line);
+            String b = mlc.getString(new String[]{"biome", "b"}, "");
+            biomes.addAll(Arrays.asList(b.split(",")));
+            surface = mlc.getBoolean(new String[]{"surface", "s"}, false);
+        }
+
+        @Override
+        public boolean check(AbstractLocation target) {
+            var access = IrisToolbelt.access(((BukkitWorld) target.getWorld()).getBukkitWorld());
+            if (access == null) return false;
+            var engine = access.getEngine();
+            if (engine == null) return false;
+            var biome = surface ?
+                    engine.getSurfaceBiome(target.getBlockX(), target.getBlockZ()) :
+                    engine.getBiomeOrMantle(target.getBlockX(), target.getBlockY() - engine.getMinHeight(), target.getBlockZ());
+            return biomes.contains(biome.getLoadKey());
+        }
+    }
+
+    @MythicCondition(author = "CrazyDev22", name = "irisregion", description = "Tests if the target is within the given list of biomes")
+    public static class IrisRegionCondition extends SkillCondition implements ILocationCondition {
+        @MythicField(name = "region", aliases = {"r"}, description = "A list of regions to check")
+        private Set<String> regions = ConcurrentHashMap.newKeySet();
+
+        public IrisRegionCondition(String line, MythicLineConfig mlc) {
+            super(line);
+            String b = mlc.getString(new String[]{"region", "r"}, "");
+            regions.addAll(Arrays.asList(b.split(",")));
+        }
+
+        @Override
+        public boolean check(AbstractLocation target) {
+            var access = IrisToolbelt.access(((BukkitWorld) target.getWorld()).getBukkitWorld());
+            if (access == null) return false;
+            var engine = access.getEngine();
+            if (engine == null) return false;
+            var region = engine.getRegion(target.getBlockX(), target.getBlockZ());
+            return regions.contains(region.getLoadKey());
+        }
+    }
+}

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

@@ -0,0 +1,140 @@
+package com.volmit.iris.core.link.data;
+
+import com.nexomc.nexo.api.NexoBlocks;
+import com.nexomc.nexo.api.NexoFurniture;
+import com.nexomc.nexo.api.NexoItems;
+import com.nexomc.nexo.items.ItemBuilder;
+import com.volmit.iris.core.link.ExternalDataProvider;
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.container.BiomeColor;
+import com.volmit.iris.core.nms.container.BlockProperty;
+import com.volmit.iris.core.service.ExternalDataSVC;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisCustomData;
+import org.bukkit.Color;
+import org.bukkit.block.Block;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.ItemDisplay;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.LeatherArmorMeta;
+import org.bukkit.inventory.meta.MapMeta;
+import org.bukkit.inventory.meta.PotionMeta;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.MissingResourceException;
+
+public class NexoDataProvider extends ExternalDataProvider {
+    public NexoDataProvider() {
+        super("Nexo");
+    }
+
+    @Override
+    public void init() {
+    }
+
+    @NotNull
+    @Override
+    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+        if (!NexoItems.exists(blockId.key())) {
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        }
+
+        Identifier blockState = ExternalDataSVC.buildState(blockId, state);
+        if (NexoBlocks.isCustomBlock(blockId.key())) {
+            BlockData data = NexoBlocks.blockData(blockId.key());
+            if (data == null)
+                throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+            return IrisCustomData.of(data, blockState);
+        } else if (NexoFurniture.isFurniture(blockId.key())) {
+            return IrisCustomData.of(B.getAir(), blockState);
+        }
+
+        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+    }
+
+    @Override
+    public @NotNull List<BlockProperty> getBlockProperties(@NotNull Identifier blockId) throws MissingResourceException {
+        if (!NexoItems.exists(blockId.key())) {
+            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
+        }
+
+        return NexoFurniture.isFurniture(blockId.key()) ? YAW_FACE_BIOME_PROPERTIES : List.of();
+    }
+
+    @NotNull
+    @Override
+    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+        ItemBuilder builder = NexoItems.itemFromId(itemId.key());
+        if (builder == null) {
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        }
+        try {
+            return builder.build();
+        } catch (Exception e) {
+            e.printStackTrace();
+            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
+        }
+    }
+
+    @Override
+    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+        var statePair = ExternalDataSVC.parseState(blockId);
+        var state = statePair.getB();
+        blockId = statePair.getA();
+
+        if (NexoBlocks.isCustomBlock(blockId.key())) {
+            NexoBlocks.place(blockId.key(), block.getLocation());
+            return;
+        }
+
+        if (!NexoFurniture.isFurniture(blockId.key()))
+            return;
+
+        var pair = parseYawAndFace(engine, block, state);
+        ItemDisplay display = NexoFurniture.place(blockId.key(), block.getLocation(), pair.getA(), pair.getB());
+        if (display == null) return;
+        ItemStack itemStack = display.getItemStack();
+        if (itemStack == null) return;
+
+        BiomeColor type = null;
+        try {
+            type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
+        } catch (NullPointerException | IllegalArgumentException ignored) {}
+
+        if (type != null) {
+            var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
+            if (biomeColor == null) return;
+            var potionColor = Color.fromARGB(biomeColor.getAlpha(), biomeColor.getRed(), biomeColor.getGreen(), biomeColor.getBlue());
+            var meta = itemStack.getItemMeta();
+            switch (meta) {
+                case LeatherArmorMeta armor -> armor.setColor(potionColor);
+                case PotionMeta potion -> potion.setColor(potionColor);
+                case MapMeta map -> map.setColor(potionColor);
+                case null, default -> {}
+            }
+            itemStack.setItemMeta(meta);
+        }
+        display.setItemStack(itemStack);
+    }
+
+    @Override
+    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
+        if (dataType == DataType.ENTITY) return List.of();
+        return NexoItems.itemNames()
+                .stream()
+                .map(i -> new Identifier("nexo", i))
+                .filter(dataType.asPredicate(this))
+                .toList();
+    }
+
+    @Override
+    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
+        if (dataType == DataType.ENTITY) return false;
+        return "nexo".equalsIgnoreCase(id.namespace());
+    }
+}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -24,6 +24,7 @@ import com.google.gson.stream.JsonReader;
 import com.google.gson.stream.JsonToken;
 import com.google.gson.stream.JsonWriter;
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.scripting.environment.PackEnvironment;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
@@ -33,18 +34,23 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.mantle.flag.MantleFlagAdapter;
+import com.volmit.iris.util.mantle.flag.MantleFlag;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
+import com.volmit.iris.util.reflect.KeyedType;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Data;
+import org.jetbrains.annotations.Nullable;
 
 import java.io.File;
 import java.io.FileReader;
 import java.io.IOException;
-import java.util.Objects;
+import java.nio.file.Files;
-import java.util.function.Function;
+import java.nio.file.Path;
+import java.util.*;
 
 @Data
 public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
@@ -52,6 +58,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     private final File dataFolder;
     private final int id;
     private boolean closed = false;
+    private PackEnvironment environment;
     private ResourceLoader<IrisBiome> biomeLoader;
     private ResourceLoader<IrisLootTable> lootLoader;
     private ResourceLoader<IrisRegion> regionLoader;
@@ -91,6 +98,10 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         return dataLoaders.computeIfAbsent(dataFolder, IrisData::new);
     }
 
+    public static Optional<IrisData> getLoaded(File dataFolder) {
+        return Optional.ofNullable(dataLoaders.get(dataFolder));
+    }
+
     public static void dereference() {
         dataLoaders.v().forEach(IrisData::cleanupEngine);
     }
@@ -110,92 +121,100 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         Iris.warn("  " + rl.getResourceTypeName() + " @ /" + rl.getFolderName() + ": Cache=" + rl.getLoadCache().getSize() + " Folders=" + rl.getFolders().size());
     }
 
-    public static IrisObject loadAnyObject(String key) {
+    public static IrisObject loadAnyObject(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getObjectLoader().load(key, false));
+        return loadAny(IrisObject.class, key, nearest);
     }
 
-    public static IrisMatterObject loadAnyMatter(String key) {
+    public static IrisMatterObject loadAnyMatter(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getMatterLoader().load(key, false));
+        return loadAny(IrisMatterObject.class, key, nearest);
     }
 
-    public static IrisBiome loadAnyBiome(String key) {
+    public static IrisBiome loadAnyBiome(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getBiomeLoader().load(key, false));
+        return loadAny(IrisBiome.class, key, nearest);
     }
 
-    public static IrisExpression loadAnyExpression(String key) {
+    public static IrisExpression loadAnyExpression(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getExpressionLoader().load(key, false));
+        return loadAny(IrisExpression.class, key, nearest);
     }
 
-    public static IrisMod loadAnyMod(String key) {
+    public static IrisMod loadAnyMod(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getModLoader().load(key, false));
+        return loadAny(IrisMod.class, key, nearest);
     }
 
-    public static IrisJigsawPiece loadAnyJigsawPiece(String key) {
+    public static IrisJigsawPiece loadAnyJigsawPiece(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getJigsawPieceLoader().load(key, false));
+        return loadAny(IrisJigsawPiece.class, key, nearest);
     }
 
-    public static IrisJigsawPool loadAnyJigsawPool(String key) {
+    public static IrisJigsawPool loadAnyJigsawPool(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getJigsawPoolLoader().load(key, false));
+        return loadAny(IrisJigsawPool.class, key, nearest);
     }
 
-    public static IrisEntity loadAnyEntity(String key) {
+    public static IrisEntity loadAnyEntity(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getEntityLoader().load(key, false));
+        return loadAny(IrisEntity.class, key, nearest);
     }
 
-    public static IrisLootTable loadAnyLootTable(String key) {
+    public static IrisLootTable loadAnyLootTable(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getLootLoader().load(key, false));
+        return loadAny(IrisLootTable.class, key, nearest);
     }
 
-    public static IrisBlockData loadAnyBlock(String key) {
+    public static IrisBlockData loadAnyBlock(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getBlockLoader().load(key, false));
+        return loadAny(IrisBlockData.class, key, nearest);
     }
 
-    public static IrisSpawner loadAnySpaner(String key) {
+    public static IrisSpawner loadAnySpaner(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getSpawnerLoader().load(key, false));
+        return loadAny(IrisSpawner.class, key, nearest);
     }
 
-    public static IrisScript loadAnyScript(String key) {
+    public static IrisScript loadAnyScript(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getScriptLoader().load(key, false));
+        return loadAny(IrisScript.class, key, nearest);
     }
 
-    public static IrisRavine loadAnyRavine(String key) {
+    public static IrisRavine loadAnyRavine(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getRavineLoader().load(key, false));
+        return loadAny(IrisRavine.class, key, nearest);
     }
 
-    public static IrisRegion loadAnyRegion(String key) {
+    public static IrisRegion loadAnyRegion(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getRegionLoader().load(key, false));
+        return loadAny(IrisRegion.class, key, nearest);
     }
 
-    public static IrisMarker loadAnyMarker(String key) {
+    public static IrisMarker loadAnyMarker(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getMarkerLoader().load(key, false));
+        return loadAny(IrisMarker.class, key, nearest);
     }
 
-    public static IrisCave loadAnyCave(String key) {
+    public static IrisCave loadAnyCave(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getCaveLoader().load(key, false));
+        return loadAny(IrisCave.class, key, nearest);
     }
 
-    public static IrisImage loadAnyImage(String key) {
+    public static IrisImage loadAnyImage(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getImageLoader().load(key, false));
+        return loadAny(IrisImage.class, key, nearest);
     }
 
-    public static IrisDimension loadAnyDimension(String key) {
+    public static IrisDimension loadAnyDimension(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getDimensionLoader().load(key, false));
+        return loadAny(IrisDimension.class, key, nearest);
     }
 
-    public static IrisJigsawStructure loadAnyJigsawStructure(String key) {
+    public static IrisJigsawStructure loadAnyJigsawStructure(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getJigsawStructureLoader().load(key, false));
+        return loadAny(IrisJigsawStructure.class, key, nearest);
     }
 
-    public static IrisGenerator loadAnyGenerator(String key) {
+    public static IrisGenerator loadAnyGenerator(String key, @Nullable IrisData nearest) {
-        return loadAny(key, (dm) -> dm.getGeneratorLoader().load(key, false));
+        return loadAny(IrisGenerator.class, key, nearest);
     }
 
-    public static <T extends IrisRegistrant> T loadAny(String key, Function<IrisData, T> v) {
+    public static <T extends IrisRegistrant> T loadAny(Class<T> type, String key, @Nullable IrisData nearest) {
         try {
+            if (nearest != null) {
+                T t = nearest.load(type, key, false);
+                if (t != null) {
+                    return t;
+                }
+            }
+
             for (File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
                 if (i.isDirectory()) {
                     IrisData dm = get(i);
-                    T t = v.apply(dm);
+                    if (dm == nearest) continue;
+                    T t = dm.load(type, key, false);
 
                     if (t != null) {
                         return t;
@@ -210,6 +229,17 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         return null;
     }
 
+    public <T extends IrisRegistrant> T load(Class<T> type, String key, boolean warn) {
+        var loader = getLoader(type);
+        if (loader == null) return null;
+        return loader.load(key, warn);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T extends IrisRegistrant> ResourceLoader<T> getLoader(Class<T> type) {
+        return (ResourceLoader<T>) loaders.get(type);
+    }
+
     public ResourceLoader<?> getTypedLoaderFor(File f) {
         String[] k = f.getPath().split("\\Q" + File.separator + "\\E");
 
@@ -249,12 +279,20 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                 }
             }
 
-            if (engine != null && t.getPreprocessors().isNotEmpty()) {
+            if (engine == null) return;
+            var global = engine.getDimension().getPreProcessors(t.getFolderName());
+            var local = t.getPreprocessors();
+            if ((global != null && global.isNotEmpty()) || local.isNotEmpty()) {
                 synchronized (this) {
-                    engine.getExecution().getAPI().setPreprocessorObject(t);
+                    if (global != null) {
+                        for (String i : global) {
+                            engine.getExecution().preprocessObject(i, t);
+                            Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
+                        }
+                    }
 
-                    for (String i : t.getPreprocessors()) {
+                    for (String i : local) {
-                        engine.getExecution().execute(i);
+                        engine.getExecution().preprocessObject(i, t);
                         Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
                     }
                 }
@@ -268,6 +306,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     public void close() {
         closed = true;
         dump();
+        dataLoaders.remove(dataFolder);
     }
 
     public IrisData copy() {
@@ -299,6 +338,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
             return r;
         } catch (Throwable e) {
+            Iris.reportError(e);
             e.printStackTrace();
             Iris.error("Failed to create loader! " + registrant.getCanonicalName());
         }
@@ -307,12 +347,14 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     }
 
     public synchronized void hotloaded() {
+        closed = false;
         possibleSnippets = new KMap<>();
         builder = new GsonBuilder()
                 .addDeserializationExclusionStrategy(this)
                 .addSerializationExclusionStrategy(this)
                 .setLenient()
                 .registerTypeAdapterFactory(this)
+                .registerTypeAdapter(MantleFlag.class, new MantleFlagAdapter())
                 .setPrettyPrinting();
         loaders.clear();
         File packs = dataFolder;
@@ -337,7 +379,18 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         this.imageLoader = registerLoader(IrisImage.class);
         this.scriptLoader = registerLoader(IrisScript.class);
         this.matterObjectLoader = registerLoader(IrisMatterObject.class);
+        this.environment = PackEnvironment.create(this);
+        builder.registerTypeAdapterFactory(KeyedType::createTypeAdapter);
+
         gson = builder.create();
+        dimensionLoader.streamAll()
+                .map(IrisDimension::getDataScripts)
+                .flatMap(KList::stream)
+                .forEach(environment::execute);
+
+        if (engine != null) {
+            engine.hotload();
+        }
     }
 
     public void dump() {
@@ -350,6 +403,34 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         for (ResourceLoader<?> i : loaders.values()) {
             i.clearList();
         }
+        possibleSnippets.clear();
+    }
+
+    public Set<Class<?>> resolveSnippets() {
+        var result = new HashSet<Class<?>>();
+        var processed = new HashSet<Class<?>>();
+        var excluder = gson.excluder();
+
+        var queue = new LinkedList<Class<?>>(loaders.keySet());
+        while (!queue.isEmpty()) {
+            var type = queue.poll();
+            if (excluder.excludeClass(type, false) || !processed.add(type))
+                continue;
+            if (type.isAnnotationPresent(Snippet.class))
+                result.add(type);
+
+            try {
+                for (var field : type.getDeclaredFields()) {
+                    if (excluder.excludeField(field, false))
+                        continue;
+
+                    queue.add(field.getType());
+                }
+            } catch (Throwable ignored) {
+            }
+        }
+
+        return result;
     }
 
     public String toLoadKey(File f) {
@@ -398,6 +479,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         }
 
         String snippetType = typeToken.getRawType().getDeclaredAnnotation(Snippet.class).value();
+        String snippedBase = "snippet/" + snippetType + "/";
 
         return new TypeAdapter<>() {
             @Override
@@ -411,13 +493,14 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
 
                 if (reader.peek().equals(JsonToken.STRING)) {
                     String r = reader.nextString();
+                    if (!r.startsWith("snippet/"))
+                        return null;
+                    if (!r.startsWith(snippedBase))
+                        r = snippedBase + r.substring(8);
 
-                    if (r.startsWith("snippet/" + snippetType + "/")) {
                     File f = new File(getDataFolder(), r + ".json");
-
                     if (f.exists()) {
-                            try {
+                        try (JsonReader snippetReader = new JsonReader(new FileReader(f))){
-                                JsonReader snippetReader = new JsonReader(new FileReader(f));
                             return adapter.read(snippetReader);
                         } catch (Throwable e) {
                             Iris.error("Couldn't read snippet " + r + " in " + reader.getPath() + " (" + e.getMessage() + ")");
@@ -425,7 +508,6 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                     } else {
                         Iris.error("Couldn't find snippet " + r + " in " + reader.getPath());
                     }
-                    }
 
                     return null;
                 }
@@ -434,6 +516,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
                     return adapter.read(reader);
                 } catch (Throwable e) {
                     Iris.error("Failed to read " + typeToken.getRawType().getCanonicalName() + "... faking objects a little to load the file at least.");
+                    Iris.reportError(e);
                     try {
                         return (T) typeToken.getRawType().getConstructor().newInstance();
                     } catch (Throwable ignored) {
@@ -450,11 +533,20 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
             KList<String> l = new KList<>();
 
             File snippetFolder = new File(getDataFolder(), "snippet/" + f);
+            if (!snippetFolder.exists()) return l;
 
-            if (snippetFolder.exists() && snippetFolder.isDirectory()) {
+            String absPath = snippetFolder.getAbsolutePath();
-                for (File i : snippetFolder.listFiles()) {
+            try (var stream = Files.walk(snippetFolder.toPath())) {
-                    l.add("snippet/" + f + "/" + i.getName().split("\\Q.\\E")[0]);
+                stream.filter(Files::isRegularFile)
-                }
+                        .map(Path::toAbsolutePath)
+                        .map(Path::toString)
+                        .filter(s -> s.endsWith(".json"))
+                        .map(s -> s.substring(absPath.length() + 1))
+                        .map(s -> s.replace("\\", "/"))
+                        .map(s -> s.split("\\Q.\\E")[0])
+                        .forEach(s -> l.add("snippet/" + s));
+            } catch (Throwable e) {
+                e.printStackTrace();
             }
 
             return l;
@@ -466,7 +558,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     }
 
     public void savePrefetch(Engine engine) {
-        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+        BurstExecutor b = MultiBurst.ioBurst.burst(loaders.size());
 
         for (ResourceLoader<?> i : loaders.values()) {
             b.queue(() -> {
@@ -483,7 +575,7 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
     }
 
     public void loadPrefetch(Engine engine) {
-        BurstExecutor b = MultiBurst.burst.burst(loaders.size());
+        BurstExecutor b = MultiBurst.ioBurst.burst(loaders.size());
 
         for (ResourceLoader<?> i : loaders.values()) {
             b.queue(() -> {

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -28,17 +28,19 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.json.JSONObject;
 import com.volmit.iris.util.plugin.VolmitSender;
 import lombok.Data;
+import lombok.EqualsAndHashCode;
 
 import java.awt.*;
 import java.io.File;
 
 @Data
 public abstract class IrisRegistrant {
-    @Desc("Preprocess this object in-memory when it's loaded, run scripts using the variable 'Iris.getPreprocessorObject()' and modify properties about this object before it's used.")
+    @Desc("Preprocess this object in-memory when it's loaded, run scripts using the variable 'object' and modify properties about this object before it's used.\nFile extension: .proc.kts")
     @RegistryListResource(IrisScript.class)
     @ArrayType(min = 1, type = String.class)
     private KList<String> preprocessors = new KList<>();
 
+    @EqualsAndHashCode.Exclude
     private transient IrisData loader;
 
     private transient String loadKey;

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -23,6 +23,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.project.SchemaBuilder;
 import com.volmit.iris.core.service.PreservationSVC;
+import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.MeteredCache;
 import com.volmit.iris.util.collection.KList;
@@ -44,9 +45,10 @@ import lombok.EqualsAndHashCode;
 import lombok.ToString;
 
 import java.io.*;
+import java.util.Arrays;
+import java.util.HashSet;
 import java.util.Locale;
 import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
@@ -59,7 +61,7 @@ import java.util.zip.GZIPOutputStream;
 public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public static final AtomicDouble tlt = new AtomicDouble(0);
     private static final int CACHE_SIZE = 100000;
-    protected final AtomicReference<KList<File>> folderCache;
+    protected final AtomicCache<KList<File>> folderCache;
     protected KSet<String> firstAccess;
     protected File root;
     protected String folderName;
@@ -75,7 +77,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public ResourceLoader(File root, IrisData manager, String folderName, String resourceTypeName, Class<? extends T> objectClass) {
         this.manager = manager;
         firstAccess = new KSet<>();
-        folderCache = new AtomicReference<>();
+        folderCache = new AtomicCache<>();
         sec = new ChronoLatch(5000);
         loads = new AtomicInteger();
         this.objectClass = objectClass;
@@ -169,7 +171,6 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
             return possibleKeys;
         }
 
-        KSet<String> m = new KSet<>();
         KList<File> files = getFolders();
 
         if (files == null) {
@@ -177,6 +178,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
             return possibleKeys;
         }
 
+        HashSet<String> m = new HashSet<>();
         for (File i : files) {
             for (File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
                 m.add(i.toURI().relativize(j.toURI()).getPath().replaceAll("\\Q.json\\E", ""));
@@ -215,6 +217,10 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         return j;
     }
 
+    public Stream<T> streamAll() {
+        return streamAll(Arrays.stream(getPossibleKeys()));
+    }
+
     public Stream<T> streamAll(Stream<String> s) {
         return s.map(this::load);
     }
@@ -235,13 +241,15 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
 
     public KList<T> loadAllParallel(KList<String> s) {
         KList<T> m = new KList<>();
-        BurstExecutor burst = MultiBurst.burst.burst(s.size());
+        BurstExecutor burst = MultiBurst.ioBurst.burst(s.size());
 
         for (String i : s) {
             burst.queue(() -> {
                 T t = load(i);
+                if (t == null)
+                    return;
 
-                if (t != null) {
+                synchronized (m) {
                     m.add(t);
                 }
             });
@@ -312,7 +320,8 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
             return null;
         }
 
-        firstAccess.add(name);
+        var set = firstAccess;
+        if (set != null) firstAccess.add(name);
         return loadCache.get(name);
     }
 
@@ -335,21 +344,24 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         }
 
         din.close();
-        file.deleteOnExit();
         Iris.info("Loading " + s.size() + " prefetch " + getFolderName());
+        firstAccess = null;
         loadAllParallel(s);
     }
 
     public void saveFirstAccess(Engine engine) throws IOException {
+        if (firstAccess == null) return;
         String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
         File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
         file.getParentFile().mkdirs();
         FileOutputStream fos = new FileOutputStream(file);
         GZIPOutputStream gzo = new CustomOutputStream(fos, 9);
         DataOutputStream dos = new DataOutputStream(gzo);
-        dos.writeInt(firstAccess.size());
+        var set = firstAccess;
+        firstAccess = null;
+        dos.writeInt(set.size());
 
-        for (String i : firstAccess) {
+        for (String i : set) {
             dos.writeUTF(i);
         }
 
@@ -358,8 +370,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public KList<File> getFolders() {
-        synchronized (folderCache) {
+        return folderCache.aquire(() -> {
-            if (folderCache.get() == null) {
             KList<File> fc = new KList<>();
 
             File[] files = root.listFiles();
@@ -375,12 +386,8 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
                     }
                 }
             }
-
+            return fc;
-                folderCache.set(fc);
+        });
-            }
-        }
-
-        return folderCache.get();
     }
 
     public KList<File> getFolders(String rc) {
@@ -400,7 +407,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     public void clearCache() {
         possibleKeys = null;
         loadCache.invalidate();
-        folderCache.set(null);
+        folderCache.reset();
     }
 
     public File fileFor(T b) {
@@ -426,7 +433,7 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
     }
 
     public void clearList() {
-        folderCache.set(null);
+        folderCache.reset();
         possibleKeys = null;
     }
 

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -82,8 +82,8 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     private Set<String> getKeysInDirectory(File directory) {
         Set<String> keys = new HashSet<>();
         for (File file : directory.listFiles()) {
-            if (file.isFile() && file.getName().endsWith(".js")) {
+            if (file.isFile() && file.getName().endsWith(".kts")) {
-                keys.add(file.getName().replaceAll("\\Q.js\\E", ""));
+                keys.add(file.getName().replaceAll("\\Q.kts\\E", ""));
             } else if (file.isDirectory()) {
                 keys.addAll(getKeysInDirectory(file));
             }
@@ -127,12 +127,12 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     public File findFile(String name) {
         for (File i : getFolders(name)) {
             for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                if (j.isFile() && j.getName().endsWith(".kts") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return j;
                 }
             }
 
-            File file = new File(i, name + ".js");
+            File file = new File(i, name + ".kts");
 
             if (file.exists()) {
                 return file;
@@ -147,12 +147,12 @@ public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
     private IrisScript loadRaw(String name) {
         for (File i : getFolders(name)) {
             for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".js") && j.getName().split("\\Q.\\E")[0].equals(name)) {
+                if (j.isFile() && j.getName().endsWith(".kts") && j.getName().split("\\Q.\\E")[0].equals(name)) {
                     return loadFile(j, name);
                 }
             }
 
-            File file = new File(i, name + ".js");
+            File file = new File(i, name + ".kts");
 
             if (file.exists()) {
                 return loadFile(file, name);

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,48 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.core.pregenerator.PregenListener;
-import com.volmit.iris.server.node.IrisSession;
-import com.volmit.iris.server.packet.work.ChunkPacket;
-import com.volmit.iris.util.documentation.ChunkCoordinates;
-import com.volmit.iris.util.documentation.RegionCoordinates;
-import com.volmit.iris.util.parallel.MultiBurst;
-
-import java.io.Closeable;
-import java.util.concurrent.CompletableFuture;
-
-public interface IHeadless extends Closeable {
-
-    void setSession(IrisSession session);
-
-    int getLoadedChunks();
-
-    @ChunkCoordinates
-    boolean exists(int x, int z);
-
-    @RegionCoordinates
-    CompletableFuture<Void> generateRegion(MultiBurst burst, int x, int z, int maxConcurrent, PregenListener listener);
-
-    @ChunkCoordinates
-    void generateChunk(int x, int z);
-
-    @ChunkCoordinates
-    void addChunk(ChunkPacket packet);
-}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -23,17 +23,33 @@ import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import org.bukkit.Bukkit;
 
-import java.util.Map;
+import java.util.List;
 
 public class INMS {
-    private static final Map<String, String> REVISION = Map.of(
+    private static final Version CURRENT = Boolean.getBoolean("iris.no-version-limit") ?
-            "1.20.5", "v1_20_R4",
+            new Version(Integer.MAX_VALUE, Integer.MAX_VALUE, null) :
-            "1.20.6", "v1_20_R4",
+            new Version(21, 10, null);
-            "1.21", "v1_21_R1",
+
-            "1.21.1", "v1_21_R1"
+    private static final List<Version> REVISION = List.of(
+            new Version(21, 9, "v1_21_R6"),
+            new Version(21, 6, "v1_21_R5"),
+            new Version(21, 5, "v1_21_R4"),
+            new Version(21, 4, "v1_21_R3"),
+            new Version(21, 2, "v1_21_R2"),
+            new Version(21, 0, "v1_21_R1"),
+            new Version(20, 5, "v1_20_R4")
     );
+
+    private static final List<Version> PACKS = List.of(
+            new Version(21, 5, "31100"),
+            new Version(21, 4, "31020"),
+            new Version(21, 2, "31000"),
+            new Version(20, 1, "3910")
+    );
+
     //@done
     private static final INMSBinding binding = bind();
+    public static final String OVERWORLD_TAG = getTag(PACKS, "3910");
 
     public static INMSBinding get() {
         return binding;
@@ -47,7 +63,7 @@ public class INMS {
         try {
             String name = Bukkit.getServer().getClass().getCanonicalName();
             if (name.equals("org.bukkit.craftbukkit.CraftServer")) {
-                return REVISION.getOrDefault(Bukkit.getServer().getBukkitVersion().split("-")[0], "BUKKIT");
+                return getTag(REVISION, "BUKKIT");
             } else {
                 return name.split("\\Q.\\E")[3];
             }
@@ -65,7 +81,7 @@ public class INMS {
         Iris.info("Locating NMS Binding for " + code);
 
         try {
-            Class<?> clazz = Class.forName("com.volmit.iris.core.nms." + code + ".NMSBinding");
+            Class<?> clazz = Class.forName("com.volmit.iris.core.nms."+code+".NMSBinding");
             try {
                 Object b = clazz.getConstructor().newInstance();
                 if (b instanceof INMSBinding binding) {
@@ -76,9 +92,7 @@ public class INMS {
                 Iris.reportError(e);
                 e.printStackTrace();
             }
-        } catch (ClassNotFoundException |
+        } catch (ClassNotFoundException|NoClassDefFoundError 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.");
@@ -86,4 +100,29 @@ public class INMS {
 
         return new NMSBinding1X();
     }
+
+    private static String getTag(List<Version> versions, String def) {
+        var version = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.", 3);
+        int major = 0;
+        int minor = 0;
+
+        if (version.length > 2) {
+            major = Integer.parseInt(version[1]);
+            minor = Integer.parseInt(version[2]);
+        } else if (version.length == 2) {
+            major = Integer.parseInt(version[1]);
+        }
+        if (CURRENT.major < major || CURRENT.minor < minor) {
+            return versions.getFirst().tag;
+        }
+
+        for (var p : versions) {
+            if (p.major > major || p.minor > minor)
+                continue;
+            return p.tag;
+        }
+        return def;
+    }
+
+    private record Version(int major, int minor, String tag) {}
 }

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -18,12 +18,15 @@
 
 package com.volmit.iris.core.nms;
 
+import com.volmit.iris.core.link.Identifier;
+import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.IPackRepository;
+import com.volmit.iris.core.nms.container.BlockProperty;
+import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.core.nms.container.StructurePlacement;
 import com.volmit.iris.core.nms.datapack.DataVersion;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.mantle.Mantle;
@@ -33,19 +36,14 @@ import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
 import org.bukkit.*;
 import org.bukkit.block.Biome;
-import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
-import java.io.File;
 import java.awt.Color;
-import java.util.ArrayList;
+import java.util.List;
-import java.util.Collection;
 
 public interface INMSBinding {
     boolean hasTile(Material material);
@@ -97,6 +95,9 @@ public interface INMSBinding {
     MCABiomeContainer newBiomeContainer(int min, int max);
 
     default World createWorld(WorldCreator c) {
+        if (c.generator() instanceof PlatformChunkGenerator gen
+                && missingDimensionTypes(gen.getTarget().getDimension().getDimensionTypeKey()))
+            throw new IllegalStateException("Missing dimension types to create world");
         return c.createWorld();
     }
 
@@ -118,11 +119,6 @@ public interface INMSBinding {
 
     Vector3d getBoundingbox(org.bukkit.entity.EntityType entity);
     
-    default String getMobCategory(EntityType entityType) {
-        // todo: Update to other versions!
-        return null;
-    }
-
     Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason);
 
     Color getBiomeColor(Location location, BiomeColor type);
@@ -131,30 +127,21 @@ public interface INMSBinding {
         return DataVersion.V1192;
     }
 
-    boolean registerDimension(String name, IrisDimension dimension);
-
-    boolean registerBiome(String dimensionId, IrisBiomeCustom biome, boolean replace);
-
-    boolean dumpRegistry(File... folders);
-
-    void injectBukkit();
-
-    default IHeadless createHeadless(Engine engine) {
-        throw new IllegalStateException("Headless mode not supported");
-    }
-
     default int getSpawnChunkCount(World world) {
         return 441;
     }
 
-    IPackRepository getPackRepository();
-
     KList<String> getStructureKeys();
 
-    default void reconnectAll() {
+    boolean missingDimensionTypes(String... keys);
-        new ArrayList<>(Bukkit.getOnlinePlayers())
+
-                .forEach(this::reconnect);
+    default boolean injectBukkit() {
+        return true;
     }
 
-    void reconnect(Player player);
+    KMap<Material, List<BlockProperty>> getBlockProperties();
+
+    void placeStructures(Chunk chunk);
+
+    KMap<Identifier, StructurePlacement> collectStructures();
 }

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

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

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

@@ -1,21 +1,3 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.container;
 
 public enum BiomeColor {

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

@@ -1,21 +1,3 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.container;
 
 import lombok.AllArgsConstructor;

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

@@ -0,0 +1,154 @@
+package com.volmit.iris.core.nms.container;
+
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.*;
+import java.util.function.Function;
+
+public class BlockProperty {
+    private static final Set<Class<?>> NATIVES = Set.of(Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class, Boolean.class, String.class);
+    private final String name;
+    private final Class<?> type;
+
+    private final Object defaultValue;
+    private final Set<Object> values;
+    private final Function<Object, String> nameFunction;
+    private final Function<Object, Object> jsonFunction;
+
+    public  <T extends Comparable<T>> BlockProperty(
+            String name,
+            Class<T> type,
+            T defaultValue,
+            Collection<T> values,
+            Function<T, String> nameFunction
+    ) {
+        this.name = name;
+        this.type = type;
+        this.defaultValue = defaultValue;
+        this.values = Collections.unmodifiableSet(new TreeSet<>(values));
+        this.nameFunction = (Function<Object, String>) (Object) nameFunction;
+        jsonFunction = NATIVES.contains(type) ? Function.identity() : this.nameFunction::apply;
+    }
+
+    public static <T extends Enum<T>> BlockProperty ofEnum(Class<T> type, String name, T defaultValue) {
+        return new BlockProperty(
+                name,
+                type,
+                defaultValue,
+                Arrays.asList(type.getEnumConstants()),
+                val -> val == null ? "null" : val.name()
+        );
+    }
+
+    public static BlockProperty ofFloat(String name, float defaultValue, float min, float max, boolean exclusiveMin, boolean exclusiveMax) {
+        return new BoundedDouble(
+                name,
+                defaultValue,
+                min,
+                max,
+                exclusiveMin,
+                exclusiveMax,
+                (f) -> String.format("%.2f", f)
+        );
+    }
+
+    public static BlockProperty ofBoolean(String name, boolean defaultValue) {
+        return new BlockProperty(
+                name,
+                Boolean.class,
+                defaultValue,
+                List.of(true, false),
+                (b) -> b ? "true" : "false"
+        );
+    }
+
+    @Override
+    public @NotNull String toString() {
+        return name + "=" + nameFunction.apply(defaultValue) + " [" + String.join(",", names()) + "]";
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public String defaultValue() {
+        return nameFunction.apply(defaultValue);
+    }
+
+    public List<String> names() {
+        return values.stream().map(nameFunction).toList();
+    }
+
+    public Object defaultValueAsJson() {
+        return jsonFunction.apply(defaultValue);
+    }
+
+    public JSONArray valuesAsJson() {
+        return new JSONArray(values.stream().map(jsonFunction).toList());
+    }
+
+    public JSONObject buildJson() {
+        var json = new JSONObject();
+        json.put("type", jsonType());
+        json.put("default", defaultValueAsJson());
+        if (!values.isEmpty()) json.put("enum", valuesAsJson());
+        return json;
+    }
+
+    public String jsonType() {
+        if (type == Boolean.class)
+            return "boolean";
+        if (type == Byte.class || type == Short.class || type == Integer.class || type == Long.class)
+            return "integer";
+        if (type == Float.class || type == Double.class)
+            return "number";
+        return "string";
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (obj == this) return true;
+        if (obj == null || obj.getClass() != this.getClass()) return false;
+        var that = (BlockProperty) obj;
+        return Objects.equals(this.name, that.name) &&
+                Objects.equals(this.values, that.values) &&
+                Objects.equals(this.type, that.type);
+    }
+
+    @Override
+    public int hashCode() {
+        return Objects.hash(name, values, type);
+    }
+
+    private static class BoundedDouble extends BlockProperty {
+        private final double min, max;
+        private final boolean exclusiveMin, exclusiveMax;
+
+        public BoundedDouble(
+                String name,
+                double defaultValue,
+                double min,
+                double max,
+                boolean exclusiveMin,
+                boolean exclusiveMax,
+                Function<Double, String> nameFunction
+        ) {
+            super(name, Double.class, defaultValue, List.of(), nameFunction);
+            this.min = min;
+            this.max = max;
+            this.exclusiveMin = exclusiveMin;
+            this.exclusiveMax = exclusiveMax;
+        }
+
+        @Override
+        public JSONObject buildJson() {
+            return super.buildJson()
+                    .put("minimum", min)
+                    .put("maximum", max)
+                    .put("exclusiveMinimum", exclusiveMin)
+                    .put("exclusiveMaximum", exclusiveMax);
+        }
+    }
+}

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

@@ -1,39 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.container;
-
-import java.util.Collection;
-
-public interface IPackRepository {
-    void reload();
-
-    void reloadWorldData();
-
-    void setSelected(Collection<String> packs);
-
-    boolean addPack(String packId);
-
-    boolean removePack(String packId);
-
-    Collection<String> getAvailableIds();
-
-    Collection<String> getSelectedIds();
-
-    boolean isAvailable(String packId);
-}

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

@@ -1,21 +1,3 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.container;
 
 import lombok.AllArgsConstructor;

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

@@ -0,0 +1,77 @@
+package com.volmit.iris.core.nms.container;
+
+import com.google.gson.JsonObject;
+import com.volmit.iris.engine.object.IrisJigsawStructurePlacement.SpreadType;
+import lombok.*;
+import lombok.experimental.Accessors;
+import lombok.experimental.SuperBuilder;
+import org.apache.commons.math3.fraction.Fraction;
+
+import java.util.List;
+
+@Data
+@SuperBuilder
+@Accessors(fluent = true, chain = true)
+public abstract class StructurePlacement {
+    private final int salt;
+    private final float frequency;
+    private final List<Structure> structures;
+
+    public abstract JsonObject toJson(String structure);
+
+    protected JsonObject createBase(String structure) {
+        JsonObject object = new JsonObject();
+        object.addProperty("structure", structure);
+        object.addProperty("salt", salt);
+        return object;
+    }
+
+    public int frequencyToSpacing() {
+        var frac = new Fraction(Math.max(Math.min(frequency, 1), 0.000000001f));
+        return (int) Math.round(Math.sqrt((double) frac.getDenominator() / frac.getNumerator()));
+    }
+
+    @Getter
+    @Accessors(chain = true, fluent = true)
+    @EqualsAndHashCode(callSuper = true)
+    @SuperBuilder
+    public static class RandomSpread extends StructurePlacement {
+        private final int spacing;
+        private final int separation;
+        private final SpreadType spreadType;
+
+        @Override
+        public JsonObject toJson(String structure) {
+            JsonObject object = createBase(structure);
+            object.addProperty("spacing", Math.max(spacing, frequencyToSpacing()));
+            object.addProperty("separation", separation);
+            object.addProperty("spreadType", spreadType.name());
+            return object;
+        }
+    }
+
+    @Getter
+    @EqualsAndHashCode(callSuper = true)
+    @SuperBuilder
+    public static class ConcentricRings extends StructurePlacement {
+        private final int distance;
+        private final int spread;
+        private final int count;
+
+        @Override
+        public JsonObject toJson(String structure) {
+            return null;
+        }
+    }
+
+    public record Structure(
+            int weight,
+            String key,
+            List<String> tags
+    ) {
+
+        public boolean isValid() {
+            return weight > 0 && key != null;
+        }
+    }
+}

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

@@ -1,26 +1,9 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.datapack;
 
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
 import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
+import com.volmit.iris.core.nms.datapack.v1213.DataFixerV1213;
 import com.volmit.iris.util.collection.KMap;
 import lombok.AccessLevel;
 import lombok.Getter;
@@ -30,8 +13,10 @@ import java.util.function.Supplier;
 //https://minecraft.wiki/w/Pack_format
 @Getter
 public enum DataVersion {
+    UNSUPPORTED("0.0.0", 0, () -> null),
     V1192("1.19.2", 10, DataFixerV1192::new),
-    V1205("1.20.6", 41, DataFixerV1206::new);
+    V1205("1.20.6", 41, DataFixerV1206::new),
+    V1213("1.21.3", 57, DataFixerV1213::new);
     private static final KMap<DataVersion, IDataFixer> cache = new KMap<>();
     @Getter(AccessLevel.NONE)
     private final Supplier<IDataFixer> constructor;
@@ -44,6 +29,10 @@ public enum DataVersion {
         this.version = version;
     }
 
+    public IDataFixer get() {
+        return cache.computeIfAbsent(this, k -> constructor.get());
+    }
+
     public static IDataFixer getDefault() {
         return INMS.get().getDataVersion().get();
     }
@@ -51,8 +40,4 @@ public enum DataVersion {
     public static DataVersion getLatest() {
         return values()[values().length - 1];
     }
-
-    public IDataFixer get() {
-        return cache.computeIfAbsent(this, k -> constructor.get());
-    }
 }

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

@@ -1,29 +1,31 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.datapack;
 
 import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisDimensionTypeOptions;
 import com.volmit.iris.util.json.JSONObject;
+import org.jetbrains.annotations.Nullable;
 
 public interface IDataFixer {
+    default JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        return json;
+    }
 
-    JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json);
+    JSONObject resolve(Dimension dimension, @Nullable IrisDimensionTypeOptions options);
 
-    JSONObject fixDimension(JSONObject json);
+    void fixDimension(Dimension dimension, JSONObject json);
+
+    default JSONObject createDimension(Dimension base, int minY, int height, int logicalHeight, @Nullable IrisDimensionTypeOptions options) {
+        JSONObject obj = resolve(base, options);
+        obj.put("min_y", minY);
+        obj.put("height", height);
+        obj.put("logical_height", logicalHeight);
+        fixDimension(base, obj);
+        return obj;
+    }
+
+    enum Dimension {
+        OVERWORLD,
+        NETHER,
+        END
+    }
 }

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

@@ -1,36 +1,104 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.datapack.v1192;
 
 import com.volmit.iris.core.nms.datapack.IDataFixer;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.engine.object.IrisDimensionTypeOptions;
 import com.volmit.iris.util.json.JSONObject;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Map;
+
+import static com.volmit.iris.engine.object.IrisDimensionTypeOptions.TriState.*;
 
 public class DataFixerV1192 implements IDataFixer {
+    private static final Map<Dimension, IrisDimensionTypeOptions> OPTIONS = Map.of(
+            Dimension.OVERWORLD, new IrisDimensionTypeOptions(
+                    FALSE,
+                    TRUE,
+                    FALSE,
+                    FALSE,
+                    TRUE,
+                    TRUE,
+                    TRUE,
+                    FALSE,
+                    1d,
+                    0f,
+                    null,
+                    192,
+                    0),
+            Dimension.NETHER, new IrisDimensionTypeOptions(
+                    TRUE,
+                    FALSE,
+                    TRUE,
+                    TRUE,
+                    FALSE,
+                    FALSE,
+                    FALSE,
+                    TRUE,
+                    8d,
+                    0.1f,
+                    18000L,
+                    null,
+                    15),
+            Dimension.END, new IrisDimensionTypeOptions(
+                    FALSE,
+                    FALSE,
+                    FALSE,
+                    FALSE,
+                    FALSE,
+                    TRUE,
+                    FALSE,
+                    FALSE,
+                    1d,
+                    0f,
+                    6000L,
+                    null,
+                    0)
+    );
+
+    private static final Map<Dimension, String> DIMENSIONS = Map.of(
+            Dimension.OVERWORLD, """
+            {
+              "effects": "minecraft:overworld",
+              "infiniburn": "#minecraft:infiniburn_overworld",
+              "monster_spawn_light_level": {
+                "type": "minecraft:uniform",
+                "value": {
+                  "max_inclusive": 7,
+                  "min_inclusive": 0
+                }
+              }
+            }""",
+            Dimension.NETHER, """
+            {
+              "effects": "minecraft:the_nether",
+              "infiniburn": "#minecraft:infiniburn_nether",
+              "monster_spawn_light_level": 7,
+            }""",
+            Dimension.END, """
+            {
+              "effects": "minecraft:the_end",
+              "infiniburn": "#minecraft:infiniburn_end",
+              "monster_spawn_light_level": {
+                "type": "minecraft:uniform",
+                "value": {
+                  "max_inclusive": 7,
+                  "min_inclusive": 0
+                }
+              }
+            }"""
+    );
 
     @Override
-    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+    public JSONObject resolve(Dimension dimension, @Nullable IrisDimensionTypeOptions options) {
-        return json;
+        return options == null ? OPTIONS.get(dimension).toJson() : options.resolve(OPTIONS.get(dimension)).toJson();
     }
 
     @Override
-    public JSONObject fixDimension(JSONObject json) {
+    public void fixDimension(Dimension dimension, JSONObject json) {
-        return json;
+        var missing = new JSONObject(DIMENSIONS.get(dimension));
+        for (String key : missing.keySet()) {
+            if (json.has(key)) continue;
+            json.put(key, missing.get(key));
+        }
     }
 }

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

@@ -1,24 +1,6 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.datapack.v1206;
 
-import com.volmit.iris.core.nms.datapack.IDataFixer;
+import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
 import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
@@ -28,12 +10,14 @@ import com.volmit.iris.util.json.JSONObject;
 
 import java.util.Locale;
 
-public class DataFixerV1206 implements IDataFixer {
+public class DataFixerV1206 extends DataFixerV1192 {
     @Override
     public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
         int spawnRarity = biome.getSpawnRarity();
         if (spawnRarity > 0) {
-            json.put("creature_spawn_probability", Math.min(spawnRarity / 20d, 0.9999999));
+            json.put("creature_spawn_probability", Math.min(spawnRarity/20d, 0.9999999));
+        } else {
+            json.remove("creature_spawn_probability");
         }
 
         var spawns = biome.getSpawns();
@@ -44,10 +28,10 @@ public class DataFixerV1206 implements IDataFixer {
             for (IrisBiomeCustomSpawn i : spawns) {
                 JSONArray g = groups.computeIfAbsent(i.getGroup(), (k) -> new JSONArray());
                 JSONObject o = new JSONObject();
-                o.put("type", "minecraft:" + i.getType().name().toLowerCase());
+                o.put("type", i.getType().getKey());
                 o.put("weight", i.getWeight());
-                o.put("minCount", Math.min(i.getMinCount() / 20d, 0));
+                o.put("minCount", i.getMinCount());
-                o.put("maxCount", Math.min(i.getMaxCount() / 20d, 0.9999999));
+                o.put("maxCount", i.getMaxCount());
                 g.put(o);
             }
 
@@ -61,12 +45,12 @@ public class DataFixerV1206 implements IDataFixer {
     }
 
     @Override
-    public JSONObject fixDimension(JSONObject json) {
+    public void fixDimension(Dimension dimension, JSONObject json) {
+        super.fixDimension(dimension, json);
         if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
-            return json;
+            return;
         var value = (JSONObject) lightLevel.remove("value");
         lightLevel.put("max_inclusive", value.get("max_inclusive"));
         lightLevel.put("min_inclusive", value.get("min_inclusive"));
-        return json;
     }
 }

core/src/main/java/com/volmit/iris/core/nms/datapack/v1213/DataFixerV1213.java

@@ -0,0 +1,16 @@
+package com.volmit.iris.core.nms.datapack.v1213;
+
+import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
+import com.volmit.iris.engine.object.IrisBiomeCustom;
+import com.volmit.iris.util.json.JSONArray;
+import com.volmit.iris.util.json.JSONObject;
+
+public class DataFixerV1213 extends DataFixerV1206 {
+
+    @Override
+    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
+        json = super.fixCustomBiome(biome, json);
+        json.put("carvers", new JSONArray());
+        return json;
+    }
+}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -18,41 +18,34 @@
 
 package com.volmit.iris.core.nms.v1X;
 
-import com.google.common.base.Preconditions;
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.link.Identifier;
 import com.volmit.iris.core.nms.INMSBinding;
 import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockPos;
+import com.volmit.iris.core.nms.container.BlockProperty;
-import com.volmit.iris.core.nms.container.IPackRepository;
+import com.volmit.iris.core.nms.datapack.DataVersion;
+import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.core.nms.container.StructurePlacement;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
-import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.Vector3d;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
-import net.bytebuddy.ByteBuddy;
-import net.bytebuddy.asm.Advice;
-import net.bytebuddy.dynamic.loading.ClassReloadingStrategy;
-import net.bytebuddy.matcher.ElementMatchers;
 import org.bukkit.*;
-import org.bukkit.WorldCreator;
 import org.bukkit.block.Biome;
-import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
-import org.bukkit.entity.Player;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
 import java.awt.Color;
-import java.io.File;
+import java.util.List;
+import java.util.stream.StreamSupport;
 
 public class NMSBinding1X implements INMSBinding {
     private static final boolean supportsCustomHeight = testCustomHeight();
@@ -117,21 +110,6 @@ public class NMSBinding1X implements INMSBinding {
         return location.getWorld().spawnEntity(location, type);
     }
 
-    @Override
-    public boolean registerDimension(String name, IrisDimension dimension) {
-        return false;
-    }
-
-    @Override
-    public boolean registerBiome(String dimensionId, IrisBiomeCustom biome, boolean replace) {
-        return false;
-    }
-
-    @Override
-    public boolean dumpRegistry(File... folders) {
-        return false;
-    }
-
     @Override
     public Color getBiomeColor(Location location, BiomeColor type) {
         return Color.GREEN;
@@ -139,7 +117,7 @@ public class NMSBinding1X implements INMSBinding {
 
     @Override
     public KList<String> getStructureKeys() {
-        var list = Registry.STRUCTURE.stream()
+        var list = StreamSupport.stream(Registry.STRUCTURE.spliterator(), false)
                 .map(Structure::getKey)
                 .map(NamespacedKey::toString)
                 .toList();
@@ -147,8 +125,27 @@ public class NMSBinding1X implements INMSBinding {
     }
 
     @Override
-    public void reconnect(Player player) {
+    public boolean missingDimensionTypes(String... keys) {
+        return false;
+    }
 
+    @Override
+    public KMap<Material, List<BlockProperty>> getBlockProperties() {
+        KMap<Material, List<BlockProperty>> map = new KMap<>();
+        for (Material m : Material.values()) {
+            if (m.isBlock()) map.put(m, List.of());
+        }
+        return map;
+    }
+
+    @Override
+    public void placeStructures(Chunk chunk) {
+
+    }
+
+    @Override
+    public KMap<Identifier, StructurePlacement> collectStructures() {
+        return new KMap<>();
     }
 
     @Override
@@ -235,6 +232,11 @@ public class NMSBinding1X implements INMSBinding {
         return true;
     }
 
+    @Override
+    public DataVersion getDataVersion() {
+        return DataVersion.UNSUPPORTED;
+    }
+
     @Override
     public int getBiomeId(Biome biome) {
         return biome.ordinal();
@@ -274,44 +276,4 @@ public class NMSBinding1X implements INMSBinding {
         Iris.error("Cannot use the global data palette! Iris is incapable of using MCA generation on this version of minecraft!");
         return null;
     }
-
-    public void injectBukkit() {
-        try {
-            Iris.info("Injecting Bukkit");
-            new ByteBuddy()
-                    .redefine(WorldCreator.class)
-                    .visit(Advice.to(WorldCreatorAdvice.class).on(ElementMatchers.isConstructor().and(ElementMatchers.takesArguments(String.class))))
-                    .make()
-                    .load(WorldCreator.class.getClassLoader(), ClassReloadingStrategy.fromInstalledAgent());
-            Iris.info("Injected Bukkit Successfully!");
-        } catch (Exception e) {
-            Iris.info(C.RED + "Failed to Inject Bukkit!");
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-
-    }
-
-    @Override
-    public IPackRepository getPackRepository() {
-        return new PackRepository1X();
-    }
-
-    private static class WorldCreatorAdvice {
-        @Advice.OnMethodEnter
-        static void enter(@Advice.Argument(0) String name) {
-            File isIrisWorld = new File(name, "iris");
-            boolean isFromIris = false;
-            StackTraceElement[] stackTrace = Thread.currentThread().getStackTrace();
-            for (StackTraceElement stack : stackTrace) {
-                if (stack.getClassName().contains("Iris")) {
-                    isFromIris = true;
-                    break;
-                }
-            }
-            if (!isFromIris) {
-                Preconditions.checkArgument(!isIrisWorld.exists(), "Only Iris can load Iris Worlds!");
-            }
-        }
-    }
 }

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

@@ -1,63 +0,0 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.v1X;
-
-import com.volmit.iris.core.nms.container.IPackRepository;
-
-import java.util.Collection;
-import java.util.List;
-
-class PackRepository1X implements IPackRepository {
-    @Override
-    public void reload() {
-    }
-
-    @Override
-    public void reloadWorldData() {
-    }
-
-    @Override
-    public void setSelected(Collection<String> packs) {
-    }
-
-    @Override
-    public boolean addPack(String packId) {
-        return false;
-    }
-
-    @Override
-    public boolean removePack(String packId) {
-        return false;
-    }
-
-    @Override
-    public Collection<String> getAvailableIds() {
-        return List.of();
-    }
-
-    @Override
-    public Collection<String> getSelectedIds() {
-        return List.of();
-    }
-
-    @Override
-    public boolean isAvailable(String packId) {
-        return false;
-    }
-}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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

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

@@ -1,92 +1,67 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.pregenerator;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.service.PreservationSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.mantle.flag.MantleFlag;
 import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RollingSequence;
-import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.plugin.chunk.TicketHolder;
+import com.volmit.iris.util.profile.LoadBalancer;
 import com.volmit.iris.util.scheduling.J;
 import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
 import java.io.File;
-import java.util.ArrayList;
+
 import java.util.concurrent.*;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
 public class ChunkUpdater {
-    private final RollingSequence chunksPerSecond;
+    private static final String REGION_PATH = "region" + File.separator + "r.";
-    private final AtomicInteger worldheightsize;
+    private final AtomicBoolean paused = new AtomicBoolean();
-    private final AtomicInteger worldwidthsize;
+    private final AtomicBoolean cancelled = new AtomicBoolean();
-    private final AtomicInteger totalChunks;
+    private final TicketHolder holder;
-    private final AtomicInteger totalMaxChunks;
+    private final RollingSequence chunksPerSecond = new RollingSequence(5);
-    private final AtomicInteger totalMcaregions;
+    private final AtomicInteger totalMaxChunks = new AtomicInteger();
-    private final AtomicInteger position;
+    private final AtomicInteger chunksProcessed = new AtomicInteger();
-    private final Object pauseLock;
+    private final AtomicInteger chunksProcessedLast = new AtomicInteger();
+    private final AtomicInteger chunksUpdated = new AtomicInteger();
+    private final AtomicBoolean serverEmpty = new AtomicBoolean(true);
+    private final AtomicLong lastCpsTime = new AtomicLong(M.ms());
+    private final int maxConcurrency = IrisSettings.get().getUpdater().getMaxConcurrency();
+    private final int coreLimit = (int) Math.max(Runtime.getRuntime().availableProcessors() * IrisSettings.get().getUpdater().getThreadMultiplier(), 1);
+    private final Semaphore semaphore = new Semaphore(maxConcurrency);
+    private final LoadBalancer loadBalancer = new LoadBalancer(semaphore, maxConcurrency, IrisSettings.get().getUpdater().emptyMsRange);
+    private final AtomicLong startTime = new AtomicLong();
+    private final Dimensions dimensions;
+    private final PregenTask task;
+    private final ExecutorService chunkExecutor = IrisSettings.get().getUpdater().isNativeThreads() ? Executors.newFixedThreadPool(coreLimit) : Executors.newVirtualThreadPerTaskExecutor();
+    private final ScheduledExecutorService scheduler  = Executors.newScheduledThreadPool(1);
+    private final CountDownLatch latch;
     private final Engine engine;
     private final World world;
-    private AtomicBoolean paused;
-    private AtomicBoolean cancelled;
-    private KMap<Chunk, Long> lastUse;
-    private AtomicInteger chunksProcessed;
-    private AtomicInteger chunksUpdated;
-    private AtomicLong startTime;
-    private ExecutorService executor;
-    private ExecutorService chunkExecutor;
-    private ScheduledExecutorService scheduler;
-    private CompletableFuture future;
-    private CountDownLatch latch;
 
     public ChunkUpdater(World world) {
         this.engine = IrisToolbelt.access(world).getEngine();
-        this.chunksPerSecond = new RollingSequence(5);
         this.world = world;
-        this.lastUse = new KMap();
+        this.holder = Iris.tickets.getHolder(world);
-        this.worldheightsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 1));
+        this.dimensions = calculateWorldDimensions(new File(world.getWorldFolder(), "region"));
-        this.worldwidthsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 0));
+        this.task = dimensions.task();
-        int m = Math.max(worldheightsize.get(), worldwidthsize.get());
+        this.totalMaxChunks.set(dimensions.count * 1024);
-        this.executor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
-        this.chunkExecutor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
-        this.scheduler = Executors.newScheduledThreadPool(1);
-        this.future = new CompletableFuture<>();
-        this.startTime = new AtomicLong();
-        this.worldheightsize.set(m);
-        this.worldwidthsize.set(m);
-        this.totalMaxChunks = new AtomicInteger((worldheightsize.get() / 16) * (worldwidthsize.get() / 16));
-        this.chunksProcessed = new AtomicInteger();
-        this.chunksUpdated = new AtomicInteger();
-        this.position = new AtomicInteger(0);
         this.latch = new CountDownLatch(totalMaxChunks.get());
-        this.paused = new AtomicBoolean(false);
+    }
-        this.pauseLock = new Object();
+
-        this.cancelled = new AtomicBoolean(false);
+    public String getName() {
-        this.totalChunks = new AtomicInteger(0);
+        return world.getName();
-        this.totalMcaregions = new AtomicInteger(0);
     }
 
     public int getChunks() {
@@ -114,7 +89,6 @@ public class ChunkUpdater {
         cancelled.set(true);
     }
 
-
     private void update() {
         Iris.info("Updating..");
         try {
@@ -123,50 +97,36 @@ public class ChunkUpdater {
                 try {
                     if (!paused.get()) {
                         long eta = computeETA();
-                        long elapsedSeconds = (System.currentTimeMillis() - startTime.get()) / 3000;
                         int processed = chunksProcessed.get();
-                        double cps = elapsedSeconds > 0 ? processed / (double) elapsedSeconds : 0;
+                        double last = processed - chunksProcessedLast.getAndSet(processed);
+                        double cps = last / ((M.ms() - lastCpsTime.getAndSet(M.ms())) / 1000d);
                         chunksPerSecond.put(cps);
-                        double percentage = ((double) chunksProcessed.get() / (double) totalMaxChunks.get()) * 100;
+                        double percentage = ((double) processed / (double) totalMaxChunks.get()) * 100;
                         if (!cancelled.get()) {
                             Iris.info("Updated: " + Form.f(processed) + " of " + Form.f(totalMaxChunks.get()) + " (%.0f%%) " + Form.f(chunksPerSecond.getAverage()) + "/s, ETA: " + Form.duration(eta,
                                     2), percentage);
                         }
                     }
                 } catch (Exception e) {
+                    Iris.reportError(e);
                     e.printStackTrace();
                 }
             }, 0, 3, TimeUnit.SECONDS);
+            scheduler.scheduleAtFixedRate(() -> {
+                boolean empty = Bukkit.getOnlinePlayers().isEmpty();
+                if (serverEmpty.getAndSet(empty) == empty)
+                    return;
+                loadBalancer.setRange(empty ? IrisSettings.get().getUpdater().emptyMsRange : IrisSettings.get().getUpdater().defaultMsRange);
+            }, 0, 10, TimeUnit.SECONDS);
 
-            CompletableFuture.runAsync(() -> {
+            var t = new Thread(() -> {
-                for (int i = 0; i < totalMaxChunks.get(); i++) {
+                run();
-                    if (paused.get()) {
-                        synchronized (pauseLock) {
-                            try {
-                                pauseLock.wait();
-                            } catch (InterruptedException e) {
-                                Iris.error("Interrupted while waiting for executor: ");
-                                e.printStackTrace();
-                                break;
-                            }
-                        }
-                    }
-                    executor.submit(() -> {
-                        if (!cancelled.get()) {
-                            processNextChunk();
-                        }
-                        latch.countDown();
-                    });
-                }
-            }).thenRun(() -> {
-                try {
-                    latch.await();
                 close();
-                } catch (Exception e) {
+            }, "Iris Chunk Updater - " + world.getName());
-                    Thread.currentThread().interrupt();
+            t.setPriority(Thread.MAX_PRIORITY);
-                }
+            t.start();
-            });
 
+            Iris.service(PreservationSVC.class).register(t);
         } catch (Exception e) {
             e.printStackTrace();
         }
@@ -174,14 +134,14 @@ public class ChunkUpdater {
 
     public void close() {
         try {
-            unloadAndSaveAllChunks();
+            loadBalancer.close();
-            executor.shutdown();
+            semaphore.acquire(256);
-            executor.awaitTermination(5, TimeUnit.SECONDS);
+
             chunkExecutor.shutdown();
             chunkExecutor.awaitTermination(5, TimeUnit.SECONDS);
             scheduler.shutdownNow();
-        } catch (Exception ignored) {
+            unloadAndSaveAllChunks();
-        }
+        } catch (Exception ignored) {}
         if (cancelled.get()) {
             Iris.info("Updated: " + Form.f(chunksUpdated.get()) + " Chunks");
             Iris.info("Irritated: " + Form.f(chunksProcessed.get()) + " of " + Form.f(totalMaxChunks.get()));
@@ -192,18 +152,68 @@ public class ChunkUpdater {
         }
     }
 
-    private void processNextChunk() {
+    private void run() {
-        int pos = position.getAndIncrement();
+        task.iterateRegions((rX, rZ) -> {
-        int[] coords = getChunk(pos);
+            if (cancelled.get())
-        if (loadChunksIfGenerated(coords[0], coords[1])) {
+                return;
-            Chunk c = world.getChunkAt(coords[0], coords[1]);
+
-            engine.updateChunk(c);
+            while (paused.get()) {
-            chunksUpdated.incrementAndGet();
+                J.sleep(50);
             }
+
+            if (rX < dimensions.min.getX() ||
+                    rX > dimensions.max.getX() ||
+                    rZ < dimensions.min.getZ() ||
+                    rZ > dimensions.max.getZ() ||
+                    !new File(world.getWorldFolder(), REGION_PATH + rX + "." + rZ + ".mca").exists()
+            ) return;
+
+            task.iterateChunks(rX, rZ, (x, z) -> {
+                while (paused.get() && !cancelled.get()) {
+                    J.sleep(50);
+                }
+
+                try {
+                    semaphore.acquire();
+                } catch (InterruptedException ignored) {
+                    return;
+                }
+                chunkExecutor.submit(() -> {
+                    try {
+                        if (!cancelled.get())
+                            processChunk(x, z);
+                    } finally {
+                        latch.countDown();
+                        semaphore.release();
+                    }
+                });
+            });
+        });
+    }
+
+    private void processChunk(int x, int z) {
+        if (!loadChunksIfGenerated(x, z)) {
             chunksProcessed.getAndIncrement();
+            return;
+        }
+
+        var mc = engine.getMantle().getMantle().getChunk(x, z).use();
+        try {
+            Chunk c = world.getChunkAt(x, z);
+            engine.updateChunk(c);
+
+            removeTickets(x, z);
+        } finally {
+            chunksUpdated.incrementAndGet();
+            chunksProcessed.getAndIncrement();
+            mc.release();
+        }
     }
 
     private boolean loadChunksIfGenerated(int x, int z) {
+        if (engine.getMantle().getMantle().hasFlag(x, z, MantleFlag.ETCHED))
+            return false;
+
         for (int dx = -1; dx <= 1; dx++) {
             for (int dz = -1; dz <= 1; dz++) {
                 if (!PaperLib.isChunkGenerated(world, x + dx, z + dz)) {
@@ -213,45 +223,41 @@ public class ChunkUpdater {
         }
 
         AtomicBoolean generated = new AtomicBoolean(true);
-        KList<Future<?>> futures = new KList<>(9);
+        CountDownLatch latch = new CountDownLatch(9);
         for (int dx = -1; dx <= 1; dx++) {
             for (int dz = -1; dz <= 1; dz++) {
                 int xx = x + dx;
                 int zz = z + dz;
-                futures.add(chunkExecutor.submit(() -> {
+                PaperLib.getChunkAtAsync(world, xx, zz, false, true)
-                    Chunk c;
+                        .thenAccept(chunk -> {
-                    try {
+                            if (chunk == null || !chunk.isGenerated()) {
-                        c = PaperLib.getChunkAtAsync(world, xx, zz, false).get();
+                                latch.countDown();
-                    } catch (InterruptedException | ExecutionException e) {
                                 generated.set(false);
                                 return;
                             }
-                    if (!c.isLoaded()) {
+                            holder.addTicket(chunk);
-                        CountDownLatch latch = new CountDownLatch(1);
-                        J.s(() -> {
-                            c.load(false);
                             latch.countDown();
                         });
+            }
+        }
+
         try {
             latch.await();
-                        } catch (InterruptedException ignored) {
+        } catch (InterruptedException e) {
+            Iris.info("Interrupted while waiting for chunks to load");
+        }
+
+        if (generated.get()) return true;
+        removeTickets(x, z);
+        return false;
+    }
+
+    private void removeTickets(int x, int z) {
+        for (int xx = -1; xx <= 1; xx++) {
+            for (int zz = -1; zz <= 1; zz++) {
+                holder.removeTicket(x + xx, z + zz);
             }
         }
-                    if (!c.isGenerated()) {
-                        generated.set(false);
-                    }
-                    lastUse.put(c, M.ms());
-                }));
-            }
-        }
-        while (!futures.isEmpty()) {
-            futures.removeIf(Future::isDone);
-            try {
-                Thread.sleep(50);
-            } catch (InterruptedException ignored) {
-            }
-        }
-        return generated.get();
     }
 
     private void unloadAndSaveAllChunks() {
@@ -262,16 +268,10 @@ public class ChunkUpdater {
                     return;
                 }
 
-                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
-                    Long lastUseTime = lastUse.get(i);
-                    if (lastUseTime != null && M.ms() - lastUseTime >= 5000) {
-                        i.unload();
-                        lastUse.remove(i);
-                    }
-                }
                 world.save();
             }).get();
         } catch (Throwable e) {
+            Iris.reportError(e);
             e.printStackTrace();
         }
     }
@@ -285,7 +285,7 @@ public class ChunkUpdater {
         );
     }
 
-    private int calculateWorldDimensions(File regionDir, Integer o) {
+    private Dimensions calculateWorldDimensions(File regionDir) {
         File[] files = regionDir.listFiles((dir, name) -> name.endsWith(".mca"));
 
         int minX = Integer.MAX_VALUE;
@@ -298,40 +298,23 @@ public class ChunkUpdater {
             int x = Integer.parseInt(parts[1]);
             int z = Integer.parseInt(parts[2]);
 
-            if (x < minX) minX = x;
+            minX = Math.min(minX, x);
-            if (x > maxX) maxX = x;
+            maxX = Math.max(maxX, x);
-            if (z < minZ) minZ = z;
+            minZ = Math.min(minZ, z);
-            if (z > maxZ) maxZ = z;
+            maxZ = Math.max(maxZ, z);
+        }
+        int oX = minX + ((maxX - minX) / 2);
+        int oZ = minZ + ((maxZ - minZ) / 2);
+
+        int height = maxX - minX + 1;
+        int width = maxZ - minZ + 1;
+
+        return new Dimensions(new Position2(minX, minZ), new Position2(maxX, maxZ), height * width, PregenTask.builder()
+                .radiusZ((int) Math.ceil(width / 2d * 512))
+                .radiusX((int) Math.ceil(height / 2d * 512))
+                .center(new Position2(oX, oZ))
+                .build());
     }
 
-        int height = (maxX - minX + 1) * 32 * 16;
+    private record Dimensions(Position2 min, Position2 max, int count, PregenTask task) { }
-        int width = (maxZ - minZ + 1) * 32 * 16;
-
-        if (o == 1) {
-            return height;
-        }
-        if (o == 0) {
-            return width;
-        }
-        return 0;
-    }
-
-    private int[] getChunk(int position) {
-        int p = -1;
-        AtomicInteger xx = new AtomicInteger();
-        AtomicInteger zz = new AtomicInteger();
-        Spiraler s = new Spiraler(worldheightsize.get() * 2, worldwidthsize.get() * 2, (x, z) -> {
-            xx.set(x);
-            zz.set(z);
-        });
-
-        while (s.hasNext() && p++ < position) {
-            s.next();
-        }
-        int[] coords = new int[2];
-        coords[0] = xx.get();
-        coords[1] = zz.get();
-
-        return coords;
-    }
 }

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

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

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

@@ -1,82 +0,0 @@
-package com.volmit.iris.core.pregenerator;
-
-public final class EmptyListener implements PregenListener {
-    public static final PregenListener INSTANCE = new EmptyListener();
-
-    private EmptyListener() {}
-
-    @Override
-    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
-
-    }
-
-    @Override
-    public void onChunkGenerating(int x, int z) {
-
-    }
-
-    @Override
-    public void onChunkGenerated(int x, int z) {
-
-    }
-
-    @Override
-    public void onRegionGenerated(int x, int z) {
-
-    }
-
-    @Override
-    public void onRegionGenerating(int x, int z) {
-
-    }
-
-    @Override
-    public void onChunkCleaned(int x, int z) {
-
-    }
-
-    @Override
-    public void onRegionSkipped(int x, int z) {
-
-    }
-
-    @Override
-    public void onNetworkStarted(int x, int z) {
-
-    }
-
-    @Override
-    public void onNetworkFailed(int x, int z) {
-
-    }
-
-    @Override
-    public void onNetworkReclaim(int revert) {
-
-    }
-
-    @Override
-    public void onNetworkGeneratedChunk(int x, int z) {
-
-    }
-
-    @Override
-    public void onNetworkDownloaded(int x, int z) {
-
-    }
-
-    @Override
-    public void onClose() {
-
-    }
-
-    @Override
-    public void onSaving() {
-
-    }
-
-    @Override
-    public void onChunkExistsInRegionGen(int x, int z) {
-
-    }
-}

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -18,11 +18,8 @@
 
 package com.volmit.iris.core.pregenerator;
 
-import com.google.gson.Gson;
-import com.google.gson.reflect.TypeToken;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
-import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.format.C;
@@ -31,60 +28,51 @@ import com.volmit.iris.util.mantle.Mantle;
 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.nbt.mca.Chunk;
-import com.volmit.iris.util.nbt.mca.MCAFile;
-import com.volmit.iris.util.nbt.mca.MCAUtil;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.Looper;
-import org.bukkit.World;
+import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
 
-import java.io.*;
-import java.lang.reflect.Type;
-import java.util.HashSet;
-import java.util.Set;
-import java.util.concurrent.ConcurrentHashMap;
 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 java.util.regex.Matcher;
-import java.util.regex.Pattern;
 
 
 public class IrisPregenerator {
-    private static AtomicInteger generated;
+    private static final double INVALID = 9223372036854775807d;
-    private static AtomicInteger totalChunks;
-    private final String saveFile = "regions.json";
     private final PregenTask task;
     private final PregeneratorMethod generator;
     private final PregenListener listener;
     private final Looper ticker;
     private final AtomicBoolean paused;
     private final AtomicBoolean shutdown;
+    private final RollingSequence cachedPerSecond;
     private final RollingSequence chunksPerSecond;
     private final RollingSequence chunksPerMinute;
     private final RollingSequence regionsPerMinute;
     private final KList<Integer> chunksPerSecondHistory;
-    private final AtomicInteger generatedLast;
+    private final AtomicLong generated;
-    private final AtomicInteger generatedLastMinute;
+    private final AtomicLong generatedLast;
+    private final AtomicLong generatedLastMinute;
+    private final AtomicLong cached;
+    private final AtomicLong cachedLast;
+    private final AtomicLong cachedLastMinute;
+    private final AtomicLong totalChunks;
     private final AtomicLong startTime;
     private final ChronoLatch minuteLatch;
     private final AtomicReference<String> currentGeneratorMethod;
+    private final KSet<Position2> generatedRegions;
     private final KSet<Position2> retry;
     private final KSet<Position2> net;
     private final ChronoLatch cl;
     private final ChronoLatch saveLatch = new ChronoLatch(30000);
-    private Set<Position2> generatedRegions;
+    private final IrisPackBenchmarking benchmarking;
 
     public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
-        generatedRegions = ConcurrentHashMap.newKeySet();
+        benchmarking = IrisPackBenchmarking.getInstance();
         this.listener = listenify(listener);
         cl = new ChronoLatch(5000);
+        generatedRegions = new KSet<>();
         this.shutdown = new AtomicBoolean(false);
         this.paused = new AtomicBoolean(false);
         this.task = task;
@@ -93,50 +81,71 @@ public class IrisPregenerator {
         net = new KSet<>();
         currentGeneratorMethod = new AtomicReference<>("Void");
         minuteLatch = new ChronoLatch(60000, false);
+        cachedPerSecond = new RollingSequence(5);
         chunksPerSecond = new RollingSequence(10);
         chunksPerMinute = new RollingSequence(10);
         regionsPerMinute = new RollingSequence(10);
         chunksPerSecondHistory = new KList<>();
-        generated = new AtomicInteger(0);
+        generated = new AtomicLong(0);
-        generatedLast = new AtomicInteger(0);
+        generatedLast = new AtomicLong(0);
-        generatedLastMinute = new AtomicInteger(0);
+        generatedLastMinute = new AtomicLong(0);
-        totalChunks = new AtomicInteger(0);
+        cached = new AtomicLong();
-        if (!IrisPackBenchmarking.benchmarkInProgress) {
+        cachedLast = new AtomicLong(0);
-            loadCompletedRegions();
+        cachedLastMinute = new AtomicLong(0);
-            IrisToolbelt.access(generator.getWorld()).getEngine().saveEngineData();
+        totalChunks = new AtomicLong(0);
-        }
+        task.iterateAllChunks((_a, _b) -> totalChunks.incrementAndGet());
-        task.iterateRegions((_a, _b) -> totalChunks.addAndGet(1024));
         startTime = new AtomicLong(M.ms());
         ticker = new Looper() {
             @Override
             protected long loop() {
                 long eta = computeETA();
-                int secondGenerated = generated.get() - generatedLast.get();
+
+                long secondCached = cached.get() - cachedLast.get();
+                cachedLast.set(cached.get());
+                cachedPerSecond.put(secondCached);
+
+                long secondGenerated = generated.get() - generatedLast.get() - secondCached;
                 generatedLast.set(generated.get());
+                if (secondCached == 0 || secondGenerated != 0) {
                     chunksPerSecond.put(secondGenerated);
-                chunksPerSecondHistory.add(secondGenerated);
+                    chunksPerSecondHistory.add((int) secondGenerated);
+                }
 
                 if (minuteLatch.flip()) {
-                    int minuteGenerated = generated.get() - generatedLastMinute.get();
+                    long minuteCached = cached.get() - cachedLastMinute.get();
+                    cachedLastMinute.set(cached.get());
+
+                    long minuteGenerated = generated.get() - generatedLastMinute.get() - minuteCached;
                     generatedLastMinute.set(generated.get());
+                    if (minuteCached == 0 || minuteGenerated != 0) {
                         chunksPerMinute.put(minuteGenerated);
                         regionsPerMinute.put((double) minuteGenerated / 1024D);
                     }
-
-                listener.onTick(chunksPerSecond.getAverage(), chunksPerMinute.getAverage(),
-                        regionsPerMinute.getAverage(),
-                        (double) generated.get() / (double) totalChunks.get(),
-                        generated.get(), totalChunks.get(),
-                        totalChunks.get() - generated.get(),
-                        eta, M.ms() - startTime.get(), currentGeneratorMethod.get());
-
-                if (cl.flip() && !paused.get()) {
-                    double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
-                    if (!IrisPackBenchmarking.benchmarkInProgress) {
-                        Iris.info("Pregen: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
-                    } else {
-                        Iris.info("Benchmarking: " + Form.f(generated.get()) + " of " + Form.f(totalChunks.get()) + " (%.0f%%) " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration(eta, 2), percentage);
                 }
+                boolean cached = cachedPerSecond.getAverage() != 0;
+
+                listener.onTick(
+                        cached ? cachedPerSecond.getAverage() : chunksPerSecond.getAverage(),
+                        chunksPerMinute.getAverage(),
+                        regionsPerMinute.getAverage(),
+                        (double) generated.get() / (double) totalChunks.get(), generated.get(),
+                        totalChunks.get(),
+                        totalChunks.get() - generated.get(), eta, M.ms() - startTime.get(), currentGeneratorMethod.get(),
+                        cached);
+
+                if (cl.flip()) {
+                    double percentage = ((double) generated.get() / (double) totalChunks.get()) * 100;
+
+                    Iris.info("%s: %s of %s (%.0f%%), %s/s ETA: %s",
+                            benchmarking != null ? "Benchmarking" : "Pregen",
+                            Form.f(generated.get()),
+                            Form.f(totalChunks.get()),
+                            percentage,
+                            cached ?
+                                    "Cached " + Form.f((int) cachedPerSecond.getAverage()) :
+                                    Form.f((int) chunksPerSecond.getAverage()),
+                            Form.duration(eta, 2)
+                    );
                 }
                 return 1000;
             }
@@ -144,18 +153,12 @@ public class IrisPregenerator {
     }
 
     private long computeETA() {
-        long currentTime = M.ms();
+        double d = (long) (generated.get() > 1024 ? // Generated chunks exceed 1/8th of total?
-        long elapsedTime = currentTime - startTime.get();
+                // If yes, use smooth function (which gets more accurate over time since its less sensitive to outliers)
-        int generatedChunks = generated.get();
+                ((totalChunks.get() - generated.get()) * ((double) (M.ms() - startTime.get()) / (double) generated.get())) :
-        int remainingChunks = totalChunks.get() - generatedChunks;
+                // 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);
-        if (generatedChunks <= 12_000) {
+        return Double.isFinite(d) && d != INVALID ? (long) d : 0;
-            // quick
-            return (long) (remainingChunks * ((double) elapsedTime / generatedChunks));
-        } else {
-            //smooth
-            return (long) (remainingChunks / chunksPerSecond.getAverage() * 1000);
-        }
     }
 
 
@@ -167,19 +170,15 @@ public class IrisPregenerator {
         init();
         ticker.start();
         checkRegions();
+        var p = PrecisionStopwatch.start();
         task.iterateRegions((x, z) -> visitRegion(x, z, true));
         task.iterateRegions((x, z) -> visitRegion(x, z, false));
+        Iris.info("Pregen took " + Form.duration((long) p.getMilliseconds()));
         shutdown();
-        if (!IrisPackBenchmarking.benchmarkInProgress) {
+        if (benchmarking == null) {
             Iris.info(C.IRIS + "Pregen stopped.");
-            // todo: optimizer just takes too long.
-//            if (totalChunks.get() == generated.get() && task.isOptimizer()) {
-//                Iris.info("Starting World Optimizer..");
-//                ChunkUpdater updater = new ChunkUpdater(generator.getWorld());
-//                updater.start();
-//            }
         } else {
-            IrisPackBenchmarking.getInstance().finishedBenchmark(chunksPerSecondHistory);
+            benchmarking.finishedBenchmark(chunksPerSecondHistory);
         }
     }
 
@@ -197,50 +196,12 @@ public class IrisPregenerator {
         generator.close();
         ticker.interrupt();
         listener.onClose();
-        saveCompletedRegions();
         Mantle mantle = getMantle();
         if (mantle != null) {
             mantle.trim(0, 0);
         }
     }
 
-    private void getGeneratedRegions() {
-        World world = generator.getWorld();
-        File[] region = new File(world.getWorldFolder(), "region").listFiles();
-        BurstExecutor b = MultiBurst.burst.burst(region.length);
-        b.setMulticore(true);
-        b.queue(() -> {
-            for (File file : region) {
-                try {
-                    String regex = "r\\.(\\d+)\\.(-?\\d+)\\.mca";
-                    Pattern pattern = Pattern.compile(regex);
-                    Matcher matcher = pattern.matcher(file.getName());
-                    if (!matcher.find()) continue;
-                    int x = Integer.parseInt(matcher.group(1));
-                    int z = Integer.parseInt(matcher.group(2));
-                    Position2 pos = new Position2(x, z);
-                    generatedRegions.add(pos);
-
-                    MCAFile mca = MCAUtil.read(file, 0);
-
-                    boolean notFull = false;
-                    for (int i = 0; i < 1024; i++) {
-                        Chunk chunk = mca.getChunk(i);
-                        if (chunk == null) {
-                            generatedRegions.remove(pos);
-                            notFull = true;
-                            break;
-                        }
-                    }
-                    Iris.info("Completed MCA region: " + file.getName());
-                } catch (Exception e) {
-                    e.printStackTrace();
-                }
-            }
-        });
-        b.complete();
-    }
-
     private void visitRegion(int x, int z, boolean regions) {
         while (paused.get() && !shutdown.get()) {
             J.sleep(50);
@@ -254,10 +215,6 @@ public class IrisPregenerator {
         Position2 pos = new Position2(x, z);
 
         if (generatedRegions.contains(pos)) {
-            if (regions) {
-                listener.onRegionGenerated(x, z);
-                generated.addAndGet(1024);
-            }
             return;
         }
 
@@ -270,7 +227,7 @@ public class IrisPregenerator {
         } else if (!regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
-            PregenTask.iterateRegion(x, z, (xx, zz) -> {
+            task.iterateChunks(x, z, (xx, zz) -> {
                 while (paused.get() && !shutdown.get()) {
                     J.sleep(50);
                 }
@@ -300,39 +257,6 @@ public class IrisPregenerator {
         generator.supportsRegions(x, z, listener);
     }
 
-    public void saveCompletedRegions() {
-        if (IrisPackBenchmarking.benchmarkInProgress) return;
-        Gson gson = new Gson();
-        try (Writer writer = new FileWriter(generator.getWorld().getWorldFolder().getPath() + "/" + saveFile)) {
-            gson.toJson(new HashSet<>(generatedRegions), writer);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public void loadCompletedRegions() {
-        if (task.isResetCache()) {
-            File test = new File(generator.getWorld().getWorldFolder().getPath() + "/" + saveFile);
-            if (!test.delete()) {
-                Iris.info(C.RED + "Failed to reset region cache ");
-            }
-        }
-        Gson gson = new Gson();
-        try (Reader reader = new FileReader(generator.getWorld().getWorldFolder().getPath() + "/" + saveFile)) {
-            Type setType = new TypeToken<HashSet<Position2>>() {
-            }.getType();
-            Set<Position2> loadedSet = gson.fromJson(reader, setType);
-            if (loadedSet != null) {
-                generatedRegions.clear();
-                generatedRegions.addAll(loadedSet);
-            }
-        } catch (FileNotFoundException e) {
-            // all fine
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
     public void pause() {
         paused.set(true);
     }
@@ -344,8 +268,8 @@ public class IrisPregenerator {
     private PregenListener listenify(PregenListener listener) {
         return new PregenListener() {
             @Override
-            public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method) {
+            public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached) {
-                listener.onTick(chunksPerSecond, chunksPerMinute, regionsPerMinute, percent, generated, totalChunks, chunksRemaining, eta, elapsed, method);
+                listener.onTick(chunksPerSecond, chunksPerMinute, regionsPerMinute, percent, generated, totalChunks, chunksRemaining, eta, elapsed, method, cached);
             }
 
             @Override
@@ -354,15 +278,14 @@ public class IrisPregenerator {
             }
 
             @Override
-            public void onChunkGenerated(int x, int z) {
+            public void onChunkGenerated(int x, int z, boolean c) {
-                listener.onChunkGenerated(x, z);
+                listener.onChunkGenerated(x, z, c);
                 generated.addAndGet(1);
+                if (c) cached.addAndGet(1);
             }
 
             @Override
             public void onRegionGenerated(int x, int z) {
-                generatedRegions.add(new Position2(x, z));
-                saveCompletedRegions();
                 listener.onRegionGenerated(x, z);
             }
 

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

@@ -1,21 +1,3 @@
-/*
- *  Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 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.pregenerator;
 
 import com.google.gson.Gson;
@@ -30,7 +12,6 @@ import com.volmit.iris.util.math.Spiraler;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import io.papermc.lib.PaperLib;
-import lombok.Builder;
 import lombok.Data;
 import lombok.Getter;
 import org.bukkit.Bukkit;
@@ -42,31 +23,32 @@ import org.bukkit.scheduler.BukkitRunnable;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.HashMap;
-import java.util.Map;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
 
+import java.util.HashMap;
+import java.util.Map;
+
 public class LazyPregenerator extends Thread implements Listener {
-    private static final Map<String, LazyPregenJob> jobs = new HashMap<>();
     @Getter
     private static LazyPregenerator instance;
-    private static AtomicInteger lazyGeneratedChunks;
     private final LazyPregenJob job;
     private final File destination;
     private final int maxPosition;
+    private World world;
     private final long rate;
     private final ChronoLatch latch;
+    private static AtomicInteger lazyGeneratedChunks;
     private final AtomicInteger generatedLast;
     private final AtomicInteger lazyTotalChunks;
     private final AtomicLong startTime;
     private final RollingSequence chunksPerSecond;
     private final RollingSequence chunksPerMinute;
-    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
-    private World world;
+    private static final Map<String, LazyPregenJob> jobs = new HashMap<>();
 
     public LazyPregenerator(LazyPregenJob job, File destination) {
         this.job = job;
@@ -105,26 +87,6 @@ public class LazyPregenerator extends Thread implements Listener {
         }
     }
 
-    public static void setPausedLazy(World world) {
-        LazyPregenJob job = jobs.get(world.getName());
-        if (isPausedLazy(world)) {
-            job.paused = false;
-        } else {
-            job.paused = true;
-        }
-
-        if (job.paused) {
-            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
-        } else {
-            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
-        }
-    }
-
-    public static boolean isPausedLazy(World world) {
-        LazyPregenJob job = jobs.get(world.getName());
-        return job != null && job.isPaused();
-    }
-
     @EventHandler
     public void on(WorldUnloadEvent e) {
         if (e.getWorld().equals(world)) {
@@ -183,6 +145,8 @@ public class LazyPregenerator extends Thread implements Listener {
         // todo broken
     }
 
+    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
+
     private void tickGenerate(Position2 chunk) {
         executorService.submit(() -> {
             CountDownLatch latch = new CountDownLatch(1);
@@ -201,8 +165,7 @@ public class LazyPregenerator extends Thread implements Listener {
             }
             try {
                 latch.await();
-            } catch (InterruptedException ignored) {
+            } catch (InterruptedException ignored) {}
-            }
             lazyGeneratedChunks.addAndGet(1);
         });
     }
@@ -238,6 +201,26 @@ public class LazyPregenerator extends Thread implements Listener {
         });
     }
 
+    public static void setPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        if (isPausedLazy(world)){
+            job.paused = false;
+        } else {
+            job.paused = true;
+        }
+
+        if ( job.paused) {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Paused");
+        } else {
+            Iris.info(C.BLUE + "LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
+        }
+    }
+
+    public static boolean isPausedLazy(World world) {
+        LazyPregenJob job = jobs.get(world.getName());
+        return job != null && job.isPaused();
+    }
+
     public void shutdownInstance(World world) throws IOException {
         Iris.info("LazyGen: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
         LazyPregenJob job = jobs.get(world.getName());
@@ -258,7 +241,7 @@ public class LazyPregenerator extends Thread implements Listener {
             new BukkitRunnable() {
                 @Override
                 public void run() {
-                    while (lazyFile.exists()) {
+                    while (lazyFile.exists()){
                         lazyFile.delete();
                         J.sleep(1000);
                     }
@@ -280,23 +263,23 @@ public class LazyPregenerator extends Thread implements Listener {
     }
 
     @Data
-    @Builder
+    @lombok.Builder
     public static class LazyPregenJob {
-        @Builder.Default
-        boolean silent = false;
-        @Builder.Default
-        boolean paused = false;
         private String world;
-        @Builder.Default
+        @lombok.Builder.Default
         private int healingPosition = 0;
-        @Builder.Default
+        @lombok.Builder.Default
         private boolean healing = false;
-        @Builder.Default
+        @lombok.Builder.Default
         private int chunksPerMinute = 32;
-        @Builder.Default
+        @lombok.Builder.Default
         private int radiusBlocks = 5000;
-        @Builder.Default
+        @lombok.Builder.Default
         private int position = 0;
+        @lombok.Builder.Default
+        boolean silent = false;
+        @lombok.Builder.Default
+        boolean paused = false;
     }
 }
 

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -19,11 +19,15 @@
 package com.volmit.iris.core.pregenerator;
 
 public interface PregenListener {
-    void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, int generated, int totalChunks, int chunksRemaining, long eta, long elapsed, String method);
+    void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached);
 
     void onChunkGenerating(int x, int z);
 
-    void onChunkGenerated(int x, int z);
+    default void onChunkGenerated(int x, int z) {
+        onChunkGenerated(x, z, false);
+    }
+
+    void onChunkGenerated(int x, int z, boolean cached);
 
     void onRegionGenerated(int x, int z);
 

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -23,8 +23,6 @@ import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.Spiraled;
 import com.volmit.iris.util.math.Spiraler;
-import lombok.AccessLevel;
-import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 
@@ -32,23 +30,28 @@ import java.util.Comparator;
 
 @Builder
 @Data
-@AllArgsConstructor(access = AccessLevel.PROTECTED)
 public class PregenTask {
     private static final Position2 ZERO = new Position2(0, 0);
-    private static final KList<Position2> ORDER_CENTER = computeChunkOrder();
     private static final KMap<Position2, KList<Position2>> ORDERS = new KMap<>();
 
+    @Builder.Default
+    private final boolean gui = false;
+    @Builder.Default
+    private final Position2 center = new Position2(0, 0);
+    @Builder.Default
+    private final int radiusX = 1;
+    @Builder.Default
+    private final int radiusZ = 1;
 
-    @Builder.Default
+    private final Bounds bounds = new Bounds();
-    private boolean resetCache = false;
+
-    @Builder.Default
+    protected PregenTask(boolean gui, Position2 center, int radiusX, int radiusZ) {
-    private boolean gui = false;
+        this.gui = gui;
-    @Builder.Default
+        this.center = new ProxiedPos(center);
-    private Position2 center = new Position2(0, 0);
+        this.radiusX = radiusX;
-    @Builder.Default
+        this.radiusZ = radiusZ;
-    private int width = 1;
+        bounds.update();
-    @Builder.Default
+    }
-    private int height = 1;
 
     public static void iterateRegion(int xr, int zr, Spiraled s, Position2 pull) {
         for (Position2 i : ORDERS.computeIfAbsent(pull, PregenTask::computeOrder)) {
@@ -76,29 +79,72 @@ public class PregenTask {
         return p;
     }
 
-    private static KList<Position2> computeChunkOrder() {
-        Position2 center = new Position2(15, 15);
-        KList<Position2> p = new KList<>();
-        new Spiraler(33, 33, (x, z) -> {
-            int xx = x + 15;
-            int zz = z + 15;
-            if (xx < 0 || xx > 31 || zz < 0 || zz > 31) {
-                return;
-            }
-
-            p.add(new Position2(xx, zz));
-        }).drain();
-        p.sort(Comparator.comparing((i) -> i.distance(center)));
-        return p;
-    }
-
     public void iterateRegions(Spiraled s) {
-        new Spiraler(getWidth() * 2, getHeight() * 2, s)
+        var bound = bounds.region();
-                .setOffset(center.getX(), center.getZ()).drain();
+        new Spiraler(bound.sizeX, bound.sizeZ, ((x, z) -> {
+            if (bound.check(x, z)) s.on(x, z);
+        })).setOffset(center.getX() >> 9, center.getZ() >> 9).drain();
+    }
+
+    public void iterateChunks(int rX, int rZ, Spiraled s) {
+        var bound = bounds.chunk();
+        iterateRegion(rX, rZ, ((x, z) -> {
+            if (bound.check(x, z)) s.on(x, z);
+        }));
     }
 
     public void iterateAllChunks(Spiraled s) {
-        new Spiraler(getWidth() * 2, getHeight() * 2, (x, z) -> iterateRegion(x, z, s))
+        iterateRegions(((rX, rZ) -> iterateChunks(rX, rZ, s)));
-                .setOffset(center.getX(), center.getZ()).drain();
+    }
+
+    private class Bounds {
+        private Bound chunk = null;
+        private Bound region = null;
+
+        public void update() {
+            int maxX = center.getX() + radiusX;
+            int maxZ = center.getZ() + radiusZ;
+            int minX = center.getX() - radiusX;
+            int minZ = center.getZ() - radiusZ;
+
+            chunk = new Bound(minX >> 4, minZ >> 4, Math.ceilDiv(maxX, 16), Math.ceilDiv(maxZ, 16));
+            region = new Bound(minX >> 9, minZ >> 9, Math.ceilDiv(maxX, 512), Math.ceilDiv(maxZ, 512));
+        }
+
+        public Bound chunk() {
+            if (chunk == null) update();
+            return chunk;
+        }
+
+        public Bound region() {
+            if (region == null) update();
+            return region;
+        }
+    }
+
+    private record Bound(int minX, int maxX, int minZ, int maxZ, int sizeX, int sizeZ) {
+        private Bound(int minX, int minZ, int maxX, int maxZ) {
+            this(minX, maxX, minZ, maxZ, maxZ - minZ + 1, maxZ - minZ + 1);
+        }
+
+        boolean check(int x, int z) {
+            return x >= minX && x <= maxX && z >= minZ && z <= maxZ;
+        }
+    }
+
+    private static class ProxiedPos extends Position2 {
+        public ProxiedPos(Position2 p) {
+            super(p.getX(), p.getZ());
+        }
+
+        @Override
+        public void setX(int x) {
+            throw new IllegalStateException("This Position2 may not be modified");
+        }
+
+        @Override
+        public void setZ(int z) {
+            throw new IllegalStateException("This Position2 may not be modified");
+        }
     }
 }

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

@@ -1,6 +1,6 @@
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
- *  Copyright (c) 2024 Arcane Arts (Volmit Software)
+ * 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
@@ -19,7 +19,6 @@
 package com.volmit.iris.core.pregenerator;
 
 import com.volmit.iris.util.mantle.Mantle;
-import org.bukkit.World;
 
 /**
  * Represents something that is capable of generating in chunks or regions, or both
@@ -78,6 +77,4 @@ public interface PregeneratorMethod {
     void generateChunk(int x, int z, PregenListener listener);
 
     Mantle getMantle();
-
-    World getWorld();
 }