wee

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

README.md

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

build.gradle

@@ -1,5 +1,3 @@
-import xyz.jpenilla.runpaper.task.RunServer
-
 /*
  * Iris is a World Generator for Minecraft Bukkit Servers
  * Copyright (c) 2021 Arcane Arts (Volmit Software)
@@ -32,11 +30,9 @@ plugins {
     id 'java-library'
     id "io.github.goooler.shadow" version "8.1.7"
     id "de.undercouch.download" version "5.0.1"
-    id "xyz.jpenilla.run-paper" version "2.3.1"
 }
 
-
-version '3.6.6-1.20.1-1.21.4'
+version '3.4.3-1.19.2-1.21.1'
 
 // ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
 // ======================== WINDOWS =============================
@@ -47,8 +43,8 @@ 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')
+registerCustomOutputTask('Pixel', 'D://Iris Dimension Engine/1.20.4 - Development/plugins')
+registerCustomOutputTask('PixelFury', 'C://Users/RePixelatedMC/Iris/1.21 - Development-v3/plugins')
 // ========================== UNIX ==============================
 registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
 registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Developer/RemoteGit/Server/plugins')
@@ -56,48 +52,34 @@ registerCustomOutputTaskUnix('PixelMac', '/Users/test/Desktop/mcserver/plugins')
 registerCustomOutputTaskUnix('CrazyDev22LT', '/home/julian/Desktop/server/plugins')
 // ==============================================================
 
-def MIN_HEAP_SIZE = "2G"
-def MAX_HEAP_SIZE = "8G"
-//Valid values are: none, truecolor, indexed256, indexed16, indexed8
-def COLOR = "truecolor"
-
 def NMS_BINDINGS = Map.of(
-        "v1_21_R3", "1.21.4-R0.1-SNAPSHOT",
-        "v1_21_R2", "1.21.3-R0.1-SNAPSHOT",
         "v1_21_R1", "1.21.1-R0.1-SNAPSHOT",
         "v1_20_R4", "1.20.6-R0.1-SNAPSHOT",
         "v1_20_R3", "1.20.4-R0.1-SNAPSHOT",
         "v1_20_R2", "1.20.2-R0.1-SNAPSHOT",
         "v1_20_R1", "1.20.1-R0.1-SNAPSHOT",
+        "v1_19_R3", "1.19.4-R0.1-SNAPSHOT",
+        "v1_19_R2", "1.19.3-R0.1-SNAPSHOT",
+        "v1_19_R1", "1.19.2-R0.1-SNAPSHOT"
 )
-def JVM_VERSION = Map.<String, Integer>of()
-NMS_BINDINGS.forEach { key, value ->
-    project(":nms:$key") {
+def JVM_VERSION = Map.of(
+        "v1_21_R1", 21,
+        "v1_20_R4", 21,
+)
+NMS_BINDINGS.each { nms ->
+    project(":nms:${nms.key}") {
         apply plugin: 'java'
         apply plugin: 'com.volmit.nmstools'
 
         nmsTools {
-            it.jvm = JVM_VERSION.getOrDefault(key, 21)
-            it.version = value
+            it.jvm = JVM_VERSION.getOrDefault(nms.key, 17)
+            it.version = nms.value
         }
 
         dependencies {
             implementation project(":core")
         }
     }
-
-    tasks.register("runServer-$key", RunServer) {
-        group("servers")
-        minecraftVersion(value.split("-")[0])
-        minHeapSize(MIN_HEAP_SIZE)
-        maxHeapSize(MAX_HEAP_SIZE)
-        pluginJars(tasks.shadowJar.archiveFile)
-        javaLauncher = javaToolchains.launcherFor { it.languageVersion = JavaLanguageVersion.of(JVM_VERSION.getOrDefault(key, 21))}
-        runDirectory.convention(layout.buildDirectory.dir("run/$key"))
-        systemProperty("disable.watchdog", "")
-        systemProperty("net.kyori.ansi.colorLevel", COLOR)
-        systemProperty("com.mojang.eula.agree", true)
-    }
 }
 
 shadowJar {
@@ -111,7 +93,6 @@ shadowJar {
     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'
-    relocate 'org.bstats', 'com.volmit.util.metrics'
     archiveFileName.set("Iris-${project.version}.jar")
 }
 
@@ -139,22 +120,20 @@ allprojects {
         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.nexomc.com/snapshots/" }
-        maven { url "https://libraries.minecraft.net" }
+        maven { url "https://repo.oraxen.com/releases" }
     }
 
     dependencies {
         // Provided or Classpath
-        compileOnly 'org.projectlombok:lombok:1.18.36'
-        annotationProcessor 'org.projectlombok:lombok:1.18.36'
+        compileOnly 'org.projectlombok:lombok:1.18.24'
+        annotationProcessor 'org.projectlombok:lombok:1.18.24'
 
         // Shaded
-        implementation 'com.dfsek:paralithic:0.8.1'
+        implementation 'com.dfsek:Paralithic:0.4.0'
         implementation 'io.papermc:paperlib:1.0.5'
         implementation "net.kyori:adventure-text-minimessage:4.17.0"
         implementation 'net.kyori:adventure-platform-bukkit:4.3.4'
         implementation 'net.kyori:adventure-api:4.17.0'
-        implementation 'org.bstats:bstats-bukkit:3.1.0'
         //implementation 'org.bytedeco:javacpp:1.5.10'
         //implementation 'org.bytedeco:cuda-platform:12.3-8.9-1.5.10'
         compileOnly 'io.lumine:Mythic-Dist:5.2.1'
@@ -172,7 +151,6 @@ allprojects {
         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 'com.github.oshi:oshi-core:6.6.5'
     }
 
     /**
@@ -199,18 +177,18 @@ allprojects {
     }
 }
 
-if (JavaVersion.current().toString() != "21") {
+if (JavaVersion.current().toString() != "17") {
     System.err.println()
     System.err.println("=========================================================================================================")
-    System.err.println("You must run gradle on Java 21. You are using " + JavaVersion.current())
+    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 21")
-    System.err.println("2. Configure the bundled gradle to use Java 21 in settings")
+    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 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("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()

core/build.gradle

@@ -55,14 +55,14 @@ dependencies {
     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-io:commons-io:2.14.0'
     compileOnly 'commons-lang:commons-lang:2.6'
     compileOnly 'com.github.oshi:oshi-core:5.8.5'
     compileOnly 'org.lz4:lz4-java:1.8.0'
 
     // Third Party Integrations
     compileOnly 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
-    compileOnly 'com.nexomc:nexo:1.0.0-dev.38'
+    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'
@@ -71,9 +71,6 @@ dependencies {
     //implementation files('libs/CustomItems.jar')
 }
 
-java {
-    disableAutoTargetJvm()
-}
 
 /**
  * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.

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

@@ -32,17 +32,14 @@ import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import com.volmit.iris.core.pregenerator.LazyPregenerator;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.core.tools.IrisWorldCreator;
 import com.volmit.iris.engine.EnginePanic;
 import com.volmit.iris.engine.object.IrisCompat;
-import com.volmit.iris.engine.object.IrisContextInjector;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
 import com.volmit.iris.engine.platform.DummyChunkGenerator;
 import com.volmit.iris.core.safeguard.IrisSafeguard;
 import com.volmit.iris.core.safeguard.UtilsSFG;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.exceptions.IrisException;
@@ -58,6 +55,7 @@ import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.misc.getHardware;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.IrisService;
+import com.volmit.iris.util.plugin.Metrics;
 import com.volmit.iris.util.plugin.VolmitPlugin;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.reflect.ShadeFix;
@@ -65,13 +63,13 @@ import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.Queue;
 import com.volmit.iris.util.scheduling.ShurikenQueue;
 import io.papermc.lib.PaperLib;
+import lombok.Getter;
 import net.kyori.adventure.platform.bukkit.BukkitAudiences;
 import net.kyori.adventure.text.serializer.ComponentSerializer;
-import org.bstats.bukkit.Metrics;
-import org.bstats.charts.DrilldownPie;
-import org.bstats.charts.SimplePie;
-import org.bstats.charts.SingleLineChart;
-import org.bukkit.*;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.WorldCreator;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
@@ -79,30 +77,35 @@ 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.*;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
 import org.bukkit.generator.BiomeProvider;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.plugin.IllegalPluginAccessException;
 import org.bukkit.plugin.Plugin;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
-import oshi.SystemInfo;
 
 import java.io.*;
 import java.lang.annotation.Annotation;
-import java.math.RoundingMode;
+import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
+import java.lang.management.ThreadMXBean;
 import java.net.URL;
-import java.text.NumberFormat;
-import java.util.*;
+import java.util.Date;
+import java.util.Map;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
-import java.util.stream.Collectors;
 
 import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
 import static com.volmit.iris.core.safeguard.ServerBootSFG.passedserversoftware;
+import static com.volmit.iris.util.misc.getHardware.getCPUModel;
 
 @SuppressWarnings("CanBeFinal")
 public class Iris extends VolmitPlugin implements Listener {
+    public static final String OVERWORLD_TAG = "3800";
+
     private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
 
     public static Iris instance;
@@ -459,12 +462,9 @@ public class Iris extends VolmitPlugin implements Listener {
         initialize("com.volmit.iris.core.service").forEach((i) -> services.put((Class<? extends IrisService>) i.getClass(), (IrisService) i));
         INMS.get();
         IO.delete(new File("iris"));
-        compat = IrisCompat.configured(getDataFile("compat.json"));
-        ServerConfigurator.configure();
-        new IrisContextInjector();
         IrisSafeguard.IrisSafeguardSystem();
         getSender().setTag(getTag());
-        IrisSafeguard.earlySplash();
+        compat = IrisCompat.configured(getDataFile("compat.json"));
         linkMultiverseCore = new MultiverseCoreLink();
         linkMythicMobs = new MythicMobsLink();
         configWatcher = new FileWatcher(getDataFile("settings.json"));
@@ -513,16 +513,17 @@ public class Iris extends VolmitPlugin implements Listener {
                     continue;
                 }
 
-                if (Bukkit.getWorld(s) != null)
-                    continue;
+                Iris.info("2 World: %s | Generator: %s", s, generator);
 
-                Iris.info("Loading 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 + "...");
-                WorldCreator c = new WorldCreator(s)
+                new WorldCreator(s)
                         .generator(getDefaultWorldGenerator(s, generator))
-                        .environment(IrisData.loadAnyDimension(generator).getEnvironment());
-                INMS.get().createWorld(c);
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
                 Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
             }
         } catch (Throwable e) {
@@ -664,50 +665,7 @@ public class Iris extends VolmitPlugin implements Listener {
 
     private void bstats() {
         if (IrisSettings.get().getGeneral().isPluginMetrics()) {
-            J.s(() -> {
-                var metrics = new Metrics(Iris.instance, 24220);
-                metrics.addCustomChart(new SingleLineChart("custom_dimensions", () -> Bukkit.getWorlds()
-                        .stream()
-                        .filter(IrisToolbelt::isIrisWorld)
-                        .mapToInt(w -> 1)
-                        .sum()));
-
-                metrics.addCustomChart(new DrilldownPie("used_packs", () -> Bukkit.getWorlds().stream()
-                        .map(IrisToolbelt::access)
-                        .filter(Objects::nonNull)
-                        .map(PlatformChunkGenerator::getEngine)
-                        .collect(Collectors.toMap(engine -> engine.getDimension().getLoadKey(), engine -> {
-                            var hash32 = engine.getHash32().getNow(null);
-                            if (hash32 == null) return Map.of();
-                            int version = engine.getDimension().getVersion();
-                            String checksum = Long.toHexString(hash32);
-
-                            return Map.of("v" + version + " (" + checksum + ")", 1);
-                        }, (a, b) -> {
-                            Map<String, Integer> merged = new HashMap<>(a);
-                            b.forEach((k, v) -> merged.merge(k, v, Integer::sum));
-                            return merged;
-                        }))));
-
-
-                var info = new SystemInfo().getHardware();
-                var cpu = info.getProcessor().getProcessorIdentifier();
-                var mem = info.getMemory();
-                metrics.addCustomChart(new SimplePie("cpu_model", cpu::getName));
-
-                var nf = NumberFormat.getInstance(Locale.ENGLISH);
-                nf.setMinimumFractionDigits(0);
-                nf.setMaximumFractionDigits(2);
-                nf.setRoundingMode(RoundingMode.HALF_UP);
-
-                metrics.addCustomChart(new DrilldownPie("memory", () -> {
-                    double total = mem.getTotal() * 1E-9;
-                    double alloc = Math.min(total, Runtime.getRuntime().maxMemory() * 1E-9);
-                    return Map.of(nf.format(alloc), Map.of(nf.format(total), 1));
-                }));
-
-                postShutdown.add(metrics::shutdown);
-            });
+            J.s(() -> new Metrics(Iris.instance, 8757));
         }
     }
 
@@ -782,7 +740,7 @@ public class Iris extends VolmitPlugin implements Listener {
             service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
         }
 
-        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey(), false);
     }
 
     public void splash() {
@@ -854,6 +812,22 @@ public class Iris extends VolmitPlugin implements Listener {
             Iris.info("Server type & version: " + C.RED + Bukkit.getVersion());
         } else { Iris.info("Server type & version: " + Bukkit.getVersion()); }
         Iris.info("Java: " + getJava());
+        try {
+            if (getCPUModel().contains("Intel")) {
+                Iris.info("Server Cpu: " + C.BLUE + getCPUModel());
+            }
+            if (getCPUModel().contains("Ryzen")) {
+                Iris.info("Server Cpu: " + C.RED + getCPUModel());
+            }
+            if (!getCPUModel().contains("Ryzen") && !getCPUModel().contains("Intel")) {
+                Iris.info("Server Cpu: " + C.GRAY + getCPUModel());
+            }
+
+        } catch (Exception e){
+            Iris.info("Server Cpu: " + C.DARK_RED + "Failed");
+        }
+
+        Iris.info("Threads: " + C.GRAY + Runtime.getRuntime().availableProcessors());
         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..");

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

@@ -47,6 +47,8 @@ public class IrisSettings {
     private IrisSettingsUpdater updater = new IrisSettingsUpdater();
 
     public static int getThreadCount(int c) {
+        if (System.getProperty("os.name").toLowerCase().contains("win"))
+            return Runtime.getRuntime().availableProcessors();
         return switch (c) {
             case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
             case 0, 1, 2 -> 1;
@@ -135,6 +137,7 @@ public class IrisSettings {
     @Data
     public static class IrisSettingsConcurrency {
         public int parallelism = -1;
+        public boolean windowsFullPerformance = true;
     }
 
     @Data
@@ -181,7 +184,6 @@ public class IrisSettings {
         public boolean splashLogoStartup = true;
         public boolean useConsoleCustomColors = true;
         public boolean useCustomColorsIngame = true;
-        public boolean adjustVanillaHeight = false;
         public String forceMainWorld = "";
         public int spinh = -20;
         public int spins = 7;

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

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

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

@@ -1,134 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.DeepSearchPregenerator;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.data.Dimension;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Position2;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-
-@Decree(name = "DeepSearch", aliases = "search", description = "Pregenerate your Iris worlds!")
-public class CommandDeepSearch implements DecreeExecutor {
-    public String worldName;
-    @Decree(description = "DeepSearch a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center
-            ) {
-
-        worldName = world.getName();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File TurboFile = new File(worldDirectory, "DeepSearch.json");
-        if (TurboFile.exists()) {
-            if (DeepSearchPregenerator.getInstance() != null) {
-                sender().sendMessage(C.BLUE + "DeepSearch is already in progress");
-                Iris.info(C.YELLOW + "DeepSearch is already in progress");
-                return;
-            } else {
-                try {
-                    TurboFile.delete();
-                } catch (Exception e){
-                   Iris.error("Failed to delete the old instance file of DeepSearch!");
-                   return;
-                }
-            }
-        }
-
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-
-            DeepSearchPregenerator.DeepSearchJob DeepSearchJob = DeepSearchPregenerator.DeepSearchJob.builder()
-                    .world(world)
-                    .radiusBlocks(radius)
-                    .position(0)
-                    .build();
-
-            File SearchGenFile = new File(worldDirectory, "DeepSearch.json");
-            DeepSearchPregenerator pregenerator = new DeepSearchPregenerator(DeepSearchJob, SearchGenFile);
-            pregenerator.start();
-
-            String msg = C.GREEN + "DeepSearch started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active DeepSearch task", aliases = "x")
-    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
-        DeepSearchPregenerator DeepSearchInstance = DeepSearchPregenerator.getInstance();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File turboFile = new File(worldDirectory, "DeepSearch.json");
-
-        if (DeepSearchInstance != null) {
-            DeepSearchInstance.shutdownInstance(world);
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists() && turboFile.delete()) {
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists()) {
-            Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) {
-        if (TurboPregenerator.getInstance() != null) {
-            TurboPregenerator.setPausedTurbo(world);
-            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
-        } else {
-            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-            File TurboFile = new File(worldDirectory, "DeepSearch.json");
-            if (TurboFile.exists()){
-                TurboPregenerator.loadTurboGenerator(world.getName());
-                sender().sendMessage(C.YELLOW + "Started DeepSearch back up!");
-            } else {
-                sender().sendMessage(C.YELLOW + "No active DeepSearch tasks to pause/unpause.");
-            }
-
-        }
-    }
-}

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

@@ -21,19 +21,20 @@ package com.volmit.iris.core.commands;
 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.IrisWorldAnalytics;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.service.EngineStatusSVC;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.CountingDataInputStream;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.mantle.TectonicPlate;
 import com.volmit.iris.util.nbt.mca.MCAFile;
@@ -45,9 +46,7 @@ import net.jpountz.lz4.LZ4BlockOutputStream;
 import net.jpountz.lz4.LZ4FrameInputStream;
 import net.jpountz.lz4.LZ4FrameOutputStream;
 import org.apache.commons.lang.RandomStringUtils;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
+import org.bukkit.*;
 
 import java.io.*;
 import java.net.InetAddress;
@@ -61,25 +60,57 @@ 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;
 
     @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
     public void EngineStatus() {
-        var status = EngineStatusSVC.getStatus();
+        List<World> IrisWorlds = new ArrayList<>();
+        int TotalLoadedChunks = 0;
+        int TotalQueuedTectonicPlates = 0;
+        int TotalNotQueuedTectonicPlates = 0;
+        int TotalTectonicPlates = 0;
 
-        sender().sendMessage("-------------------------");
-        sender().sendMessage(C.DARK_PURPLE + "Engine Status");
-        sender().sendMessage(C.DARK_PURPLE + "Total Engines: " + C.LIGHT_PURPLE + status.engineCount());
-        sender().sendMessage(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + status.loadedChunks());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + status.tectonicLimit());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + status.tectonicPlates());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + status.activeTectonicPlates());
-        sender().sendMessage(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + status.queuedTectonicPlates());
-        sender().sendMessage(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.minTectonicUnloadDuration()));
-        sender().sendMessage(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(status.maxTectonicUnloadDuration()));
-        sender().sendMessage(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
-        sender().sendMessage("-------------------------");
+        long lowestUnloadDuration = 0;
+        long highestUnloadDuration = 0;
+
+        for (World world : Bukkit.getWorlds()) {
+            try {
+                if (IrisToolbelt.access(world).getEngine() != null) {
+                    IrisWorlds.add(world);
+                }
+            } catch (Exception e) {
+                // no
+            }
+        }
+
+        for (World world : IrisWorlds) {
+            Engine engine = IrisToolbelt.access(world).getEngine();
+            TotalQueuedTectonicPlates += (int) engine.getMantle().getToUnload();
+            TotalNotQueuedTectonicPlates += (int) engine.getMantle().getNotQueuedLoadedRegions();
+            TotalTectonicPlates += engine.getMantle().getLoadedRegionCount();
+            if (highestUnloadDuration <= (long) engine.getMantle().getTectonicDuration()) {
+                highestUnloadDuration = (long) engine.getMantle().getTectonicDuration();
+            }
+            if (lowestUnloadDuration >= (long) engine.getMantle().getTectonicDuration()) {
+                lowestUnloadDuration = (long) engine.getMantle().getTectonicDuration();
+            }
+            for (Chunk chunk : world.getLoadedChunks()) {
+                if (chunk.isLoaded()) {
+                    TotalLoadedChunks++;
+                }
+            }
+        }
+        Iris.info("-------------------------");
+        Iris.info(C.DARK_PURPLE + "Engine Status");
+        Iris.info(C.DARK_PURPLE + "Total Loaded Chunks: " + C.LIGHT_PURPLE + TotalLoadedChunks);
+        Iris.info(C.DARK_PURPLE + "Tectonic Limit: " + C.LIGHT_PURPLE + IrisEngineSVC.getTectonicLimit());
+        Iris.info(C.DARK_PURPLE + "Tectonic Total Plates: " + C.LIGHT_PURPLE + TotalTectonicPlates);
+        Iris.info(C.DARK_PURPLE + "Tectonic Active Plates: " + C.LIGHT_PURPLE + TotalNotQueuedTectonicPlates);
+        Iris.info(C.DARK_PURPLE + "Tectonic ToUnload: " + C.LIGHT_PURPLE + TotalQueuedTectonicPlates);
+        Iris.info(C.DARK_PURPLE + "Lowest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(lowestUnloadDuration));
+        Iris.info(C.DARK_PURPLE + "Highest Tectonic Unload Duration: " + C.LIGHT_PURPLE + Form.duration(highestUnloadDuration));
+        Iris.info(C.DARK_PURPLE + "Cache Size: " + C.LIGHT_PURPLE + Form.f(IrisData.cacheSize()));
+        Iris.info("-------------------------");
     }
 
     @Decree(description = "Test")
@@ -105,14 +136,23 @@ public class CommandDeveloper implements DecreeExecutor {
 
     @Decree(description = "Test")
     public void packBenchmark(
-            @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
-            IrisDimension dimension,
-            @Param(description = "Radius in regions", defaultValue = "2048")
-            int radius,
-            @Param(description = "Open GUI while benchmarking", defaultValue = "false")
-            boolean gui
+            @Param(description = "The pack to bench", aliases = {"pack"})
+            IrisDimension dimension
     ) {
-        new IrisPackBenchmarking(dimension, radius, gui);
+        Iris.info("test");
+        IrisPackBenchmarking benchmark = new IrisPackBenchmarking(dimension, 1);
+
+    }
+
+    @Decree(description = "gets wg height")
+    public void whatHeight() {
+        Iris.info("test");
+        sender().sendMessage("Height: " + player().getWorld().getHighestBlockAt(player().getLocation(), HeightMap.MOTION_BLOCKING).getY());
+    }
+
+    @Decree(description = "check", aliases = {"ck"} )
+    public void check() {
+        sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
     }
 
     @Decree(description = "Upgrade to another Minecraft version")
@@ -130,6 +170,7 @@ public class CommandDeveloper implements DecreeExecutor {
             File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
             for (File mca : McaFiles) {
                 MCAFile MCARegion = MCAUtil.read(mca);
+                int i = 0;
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -137,6 +178,19 @@ public class CommandDeveloper implements DecreeExecutor {
 
     }
 
+    @Decree(description = "test")
+    public void anl (
+            @Param(description = "String") String world) {
+        try {
+            IrisWorldAnalytics a = new IrisWorldAnalytics(world);
+            a.execute();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+
+    }
+
+
     @Decree(description = "UnloadChunks for good reasons.")
     public void unloadchunks() {
         List<World> IrisWorlds = new ArrayList<>();
@@ -217,7 +271,7 @@ public class CommandDeveloper implements DecreeExecutor {
             VolmitSender sender = sender();
             service.submit(() -> {
                 try {
-                    CountingDataInputStream raw = CountingDataInputStream.wrap(new FileInputStream(file));
+                    DataInputStream raw = new DataInputStream(new FileInputStream(file));
                     TectonicPlate plate = new TectonicPlate(height, raw);
                     raw.close();
 
@@ -236,7 +290,7 @@ public class CommandDeveloper implements DecreeExecutor {
                         if (size == 0)
                             size = tmp.length();
                         start = System.currentTimeMillis();
-                        CountingDataInputStream din = createInput(tmp, algorithm);
+                        DataInputStream din = createInput(tmp, algorithm);
                         new TectonicPlate(height, din);
                         din.close();
                         d2 += System.currentTimeMillis() - start;
@@ -256,10 +310,10 @@ public class CommandDeveloper implements DecreeExecutor {
         }
     }
 
-    private CountingDataInputStream createInput(File file, String algorithm) throws Throwable {
+    private DataInputStream createInput(File file, String algorithm) throws Throwable {
         FileInputStream in = new FileInputStream(file);
 
-        return CountingDataInputStream.wrap(switch (algorithm) {
+        return new DataInputStream(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/CommandIris.java

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

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

@@ -1,121 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.gui.PregeneratorJob;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Position2;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-
-@Decree(name = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
-public class CommandLazyPregen implements DecreeExecutor {
-    public String worldName;
-    @Decree(description = "Pregenerate a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center,
-            @Param(aliases = "maxcpm", description = "Limit the chunks per minute the pregen will generate", defaultValue = "999999999")
-            int cpm,
-            @Param(aliases = "silent", description = "Silent generation", defaultValue = "false")
-            boolean silent
-            ) {
-
-        worldName = world.getName();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File lazyFile = new File(worldDirectory, "lazygen.json");
-        if (lazyFile.exists()) {
-            sender().sendMessage(C.BLUE + "Lazy pregen is already in progress");
-            Iris.info(C.YELLOW + "Lazy pregen is already in progress");
-            return;
-        }
-
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-
-            LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
-                    .world(worldName)
-                    .healingPosition(0)
-                    .healing(false)
-                    .chunksPerMinute(cpm)
-                    .radiusBlocks(radius)
-                    .position(0)
-                    .silent(silent)
-                    .build();
-
-            File lazyGenFile = new File(worldDirectory, "lazygen.json");
-            LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, lazyGenFile);
-            pregenerator.start();
-
-            String msg = C.GREEN + "LazyPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active pregeneration task", aliases = "x")
-    public void stop(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) throws IOException {
-        if (LazyPregenerator.getInstance() != null) {
-            LazyPregenerator.getInstance().shutdownInstance(world);
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed lazygen instance for " + world.getName());
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) {
-        if (LazyPregenerator.getInstance() != null) {
-            LazyPregenerator.getInstance().setPausedLazy(world);
-            sender().sendMessage(C.GREEN + "Paused/unpaused Lazy Pregen, now: " + (LazyPregenerator.getInstance().isPausedLazy(world) ? "Paused" : "Running") + ".");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active Lazy Pregen tasks to pause/unpause.");
-
-        }
-    }
-}

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

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

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

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

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

@@ -26,6 +26,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.ConversionSVC;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisConverter;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.*;
@@ -54,6 +55,7 @@ import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
 import com.volmit.iris.util.plugin.VolmitSender;
+import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.O;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
@@ -62,6 +64,7 @@ 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;
 
@@ -76,6 +79,7 @@ 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.ExecutionException;
 import java.util.concurrent.Future;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -172,7 +176,7 @@ public class CommandStudio implements DecreeExecutor {
                     KList<Runnable> js = new KList<>();
                     BurstExecutor b = MultiBurst.burst.burst();
                     b.setMulticore(false);
-                    int rad = engine.getMantle().getRadius();
+                    int rad = engine.getMantle().getRealRadius();
                     for (int i = -(radius + rad); i <= radius + rad; i++) {
                         for (int j = -(radius + rad); j <= radius + rad; j++) {
                             engine.getMantle().getMantle().deleteChunk(i + cx.getX(), j + cx.getZ());

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

@@ -1,81 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.pregenerator.ChunkUpdater;
-import com.volmit.iris.core.tools.IrisPackBenchmarking;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.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.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.mantle.TectonicPlate;
-import com.volmit.iris.util.misc.Hastebin;
-import com.volmit.iris.util.misc.Platform;
-import com.volmit.iris.util.misc.getHardware;
-import com.volmit.iris.util.nbt.mca.MCAFile;
-import com.volmit.iris.util.nbt.mca.MCAUtil;
-import com.volmit.iris.util.plugin.VolmitSender;
-import net.jpountz.lz4.LZ4BlockInputStream;
-import net.jpountz.lz4.LZ4BlockOutputStream;
-import net.jpountz.lz4.LZ4FrameInputStream;
-import net.jpountz.lz4.LZ4FrameOutputStream;
-import org.apache.commons.lang.RandomStringUtils;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-import oshi.SystemInfo;
-
-import java.io.*;
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-@Decree(name = "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,131 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-
-@Decree(name = "turbopregen", aliases = "turbo", description = "Pregenerate your Iris worlds!")
-public class CommandTurboPregen implements DecreeExecutor {
-    public String worldName;
-    @Decree(description = "Pregenerate a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center
-            ) {
-
-        worldName = world.getName();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File TurboFile = new File(worldDirectory, "turbogen.json");
-        if (TurboFile.exists()) {
-            if (TurboPregenerator.getInstance() != null) {
-                sender().sendMessage(C.BLUE + "Turbo pregen is already in progress");
-                Iris.info(C.YELLOW + "Turbo pregen is already in progress");
-                return;
-            } else {
-                try {
-                    TurboFile.delete();
-                } catch (Exception e){
-                   Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-                   return;
-                }
-            }
-        }
-
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-
-            TurboPregenerator.TurboPregenJob pregenJob = TurboPregenerator.TurboPregenJob.builder()
-                    .world(worldName)
-                    .radiusBlocks(radius)
-                    .position(0)
-                    .build();
-
-            File TurboGenFile = new File(worldDirectory, "turbogen.json");
-            TurboPregenerator pregenerator = new TurboPregenerator(pregenJob, TurboGenFile);
-            pregenerator.start();
-
-            String msg = C.GREEN + "TurboPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active pregeneration task", aliases = "x")
-    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
-        TurboPregenerator turboPregenInstance = TurboPregenerator.getInstance();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File turboFile = new File(worldDirectory, "turbogen.json");
-
-        if (turboPregenInstance != null) {
-            turboPregenInstance.shutdownInstance(world);
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists() && turboFile.delete()) {
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists()) {
-            Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) {
-        if (TurboPregenerator.getInstance() != null) {
-            TurboPregenerator.setPausedTurbo(world);
-            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
-        } else {
-            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-            File TurboFile = new File(worldDirectory, "turbogen.json");
-            if (TurboFile.exists()){
-                TurboPregenerator.loadTurboGenerator(world.getName());
-                sender().sendMessage(C.YELLOW + "Started Turbo Pregen back up!");
-            } else {
-                sender().sendMessage(C.YELLOW + "No active Turbo Pregen tasks to pause/unpause.");
-            }
-
-        }
-    }
-}

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

@@ -275,8 +275,10 @@ public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, List
                         n = n > 1 ? 1 : n < 0 ? 0 : n;
 
                         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) (0.666f - n * 0.666f), 1f, (float) (1f - n * 0.8f)) : Color.getHSBColor(0f, 0f, (float) n);
+                            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) 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

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

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

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

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

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

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

@@ -9,7 +9,6 @@ import com.willfp.ecoitems.items.EcoItems;
 import org.bukkit.NamespacedKey;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 
@@ -34,27 +33,23 @@ public class EcoItemsDataProvider extends ExternalDataProvider {
         }
     }
 
-    @NotNull
     @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
         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 {
+    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();
     }
 
-    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         return new Identifier[0];
     }
 
-    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -71,7 +66,7 @@ public class EcoItemsDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+    public boolean isValidProvider(Identifier id, boolean isItem) {
         return id.namespace().equalsIgnoreCase("ecoitems") && isItem;
     }
 }

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

@@ -6,7 +6,6 @@ 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 org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 import java.util.Optional;
@@ -21,27 +20,23 @@ public class ExecutableItemsDataProvider extends ExternalDataProvider {
         Iris.info("Setting up ExecutableItems Link...");
     }
 
-    @NotNull
     @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
         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 {
+    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()));
     }
 
-    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         return new Identifier[0];
     }
 
-    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -58,7 +53,7 @@ public class ExecutableItemsDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(@NotNull Identifier key, boolean isItem) {
+    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

@@ -2,28 +2,22 @@ package com.volmit.iris.core.link;
 
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
 import lombok.Getter;
-import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.Plugin;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 import java.util.MissingResourceException;
 
-@Getter
 @RequiredArgsConstructor
 public abstract class ExternalDataProvider {
 
-    @NonNull
+    @Getter
     private final String pluginId;
 
-    @Nullable
     public Plugin getPlugin() {
         return Bukkit.getPluginManager().getPlugin(pluginId);
     }
@@ -34,60 +28,23 @@ public abstract class ExternalDataProvider {
 
     public abstract void init();
 
-    /**
-     * @see ExternalDataProvider#getBlockData(Identifier, KMap)
-     */
-    @NotNull
-    public BlockData getBlockData(@NotNull Identifier blockId) throws MissingResourceException {
+    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
         return getBlockData(blockId, new KMap<>());
     }
 
-    /**
-     * 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 abstract BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException;
+    public abstract BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException;
 
-    /**
-     * @see ExternalDataProvider#getItemStack(Identifier)
-     */
-    @NotNull
-    public ItemStack getItemStack(@NotNull Identifier itemId) throws MissingResourceException {
+    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
         return getItemStack(itemId, new KMap<>());
     }
 
-    /**
-     * This method returns a {@link ItemStack} corresponding to the itemID
-     * 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 abstract ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException;
+    public abstract ItemStack getItemStack(Identifier itemId, KMap<String, Object> customNbt) throws MissingResourceException;
 
-    /**
-     * 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 void processUpdate(Engine engine, Block block, Identifier blockId) {}
 
-    public abstract @NotNull Identifier[] getBlockTypes();
+    public abstract Identifier[] getBlockTypes();
 
-    public abstract @NotNull Identifier[] getItemTypes();
+    public abstract Identifier[] getItemTypes();
 
-    public abstract boolean isValidProvider(@NotNull Identifier id, boolean isItem);
+    public abstract boolean isValidProvider(Identifier id, boolean isItem);
 }

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

@@ -6,7 +6,7 @@ import com.volmit.iris.core.service.ExternalDataSVC;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.reflect.WrappedField;
 import com.volmit.iris.util.reflect.WrappedReturningMethod;
 import org.bukkit.Bukkit;
@@ -16,7 +16,6 @@ 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.Map;
 import java.util.MissingResourceException;
@@ -52,9 +51,8 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		}
 	}
 
-	@NotNull
 	@Override
-	public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+	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());
@@ -64,19 +62,18 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		BlockData blockData = Bukkit.createBlockData(material);
 		if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
 			leaves.setPersistent(true);
-		return new IrisCustomData(blockData, ExternalDataSVC.buildState(blockId, state));
+		return new IrisBlockData(blockData, ExternalDataSVC.buildState(blockId, state));
 	}
 
-	@NotNull
 	@Override
-	public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+	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(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+	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});
@@ -89,7 +86,6 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		}
 	}
 
-	@NotNull
 	@Override
 	public Identifier[] getBlockTypes() {
 		KList<Identifier> names = new KList<>();
@@ -105,7 +101,6 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 		return names.toArray(new Identifier[0]);
 	}
 
-	@NotNull
 	@Override
 	public Identifier[] getItemTypes() {
 		KList<Identifier> names = new KList<>();
@@ -122,7 +117,7 @@ public class HMCLeavesDataProvider extends ExternalDataProvider {
 	}
 
 	@Override
-	public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+	public boolean isValidProvider(Identifier id, boolean isItem) {
 		return (isItem ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
 	}
 

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

@@ -7,7 +7,6 @@ import dev.lone.itemsadder.api.CustomBlock;
 import dev.lone.itemsadder.api.CustomStack;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 
@@ -33,15 +32,13 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
         }
     }
 
-    @NotNull
     @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
         return CustomBlock.getBaseBlockData(blockId.toString());
     }
 
-    @NotNull
     @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+    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());
@@ -49,7 +46,6 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
         return stack.getItemStack();
     }
 
-    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         KList<Identifier> keys = new KList<>();
@@ -59,7 +55,6 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
         return keys.toArray(new Identifier[0]);
     }
 
-    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> keys = new KList<>();
@@ -70,7 +65,7 @@ public class ItemAdderDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+    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

@@ -11,7 +11,6 @@ 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.MissingResourceException;
 import java.util.concurrent.CompletableFuture;
@@ -28,9 +27,8 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         Iris.info("Setting up MMOItems Link...");
     }
 
-    @NotNull
     @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(Identifier blockId, KMap<String, String> state) throws MissingResourceException {
         int id = -1;
         try {
             id = Integer.parseInt(blockId.key());
@@ -40,9 +38,8 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         return block.getState().getBlockData();
     }
 
-    @NotNull
     @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
+    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());
@@ -85,7 +82,6 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         return item;
     }
 
-    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         KList<Identifier> names = new KList<>();
@@ -100,7 +96,6 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
         return names.toArray(new Identifier[0]);
     }
 
-    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -129,7 +124,7 @@ public class MMOItemsDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
+    public boolean isValidProvider(Identifier id, boolean isItem) {
         return isItem ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
     }
 

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

@@ -27,7 +27,7 @@ import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.math.RNG;
 import io.lumine.mythic.bukkit.BukkitAdapter;
 import io.lumine.mythic.bukkit.utils.serialize.Chroma;
@@ -40,7 +40,6 @@ import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.MissingResourceException;
 import java.util.Optional;
@@ -63,24 +62,22 @@ public class MythicCrucibleDataProvider extends ExternalDataProvider {
         }
     }
 
-    @NotNull
     @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
+    public BlockData getBlockData(Identifier blockId, 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 new IrisCustomData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
+            return new IrisBlockData(B.getAir(), ExternalDataSVC.buildState(blockId, state));
         } else if (blockItemContext != null) {
             return blockItemContext.getBlockData();
         }
         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 {
+    public ItemStack getItemStack(Identifier itemId, 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()))
@@ -88,7 +85,6 @@ public class MythicCrucibleDataProvider extends ExternalDataProvider {
                 .generateItemStack(1));
     }
 
-    @NotNull
     @Override
     public Identifier[] getBlockTypes() {
         KList<Identifier> names = new KList<>();
@@ -105,7 +101,6 @@ public class MythicCrucibleDataProvider extends ExternalDataProvider {
         return names.toArray(new Identifier[0]);
     }
 
-    @NotNull
     @Override
     public Identifier[] getItemTypes() {
         KList<Identifier> names = new KList<>();
@@ -122,7 +117,7 @@ public class MythicCrucibleDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
+    public void processUpdate(Engine engine, Block block, Identifier blockId) {
         var pair = ExternalDataSVC.parseState(blockId);
         var state = pair.getB();
         blockId = pair.getA();
@@ -165,7 +160,7 @@ public class MythicCrucibleDataProvider extends ExternalDataProvider {
     }
 
     @Override
-    public boolean isValidProvider(@NotNull Identifier key, boolean isItem) {
+    public boolean isValidProvider(Identifier key, boolean isItem) {
         return key.namespace().equalsIgnoreCase("crucible");
     }
 }

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

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

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

@@ -1,164 +0,0 @@
-package com.volmit.iris.core.link;
-
-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.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.KMap;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.math.RNG;
-import org.bukkit.Color;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.entity.ItemDisplay;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.PotionMeta;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Arrays;
-import java.util.MissingResourceException;
-import java.util.concurrent.atomic.AtomicBoolean;
-
-public class NexoDataProvider extends ExternalDataProvider {
-    private final AtomicBoolean failed = new AtomicBoolean(false);
-
-    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 new IrisCustomData(data, blockState);
-        } else if (NexoFurniture.isFurniture(blockId.key())) {
-            return new IrisCustomData(B.getAir(), blockState);
-        }
-
-        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 {
-        ItemBuilder builder = NexoItems.itemFromId(itemId.key());
-        if (builder == null) {
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        }
-        return builder.build();
-    }
-
-    @Override
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
-        var pair = ExternalDataSVC.parseState(blockId);
-        var state = pair.getB();
-        blockId = pair.getA();
-
-        if (NexoBlocks.isCustomBlock(blockId.key())) {
-            NexoBlocks.place(blockId.key(), block.getLocation());
-            return;
-        }
-
-        if (!NexoFurniture.isFurniture(blockId.key()))
-            return;
-
-        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;
-        }
-        ItemDisplay display = NexoFurniture.place(blockId.key(), block.getLocation(), yaw, face);
-        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());
-            if (itemStack.getItemMeta() instanceof PotionMeta meta) {
-                meta.setColor(potionColor);
-                itemStack.setItemMeta(meta);
-            }
-        }
-        display.setItemStack(itemStack);
-    }
-
-    @NotNull
-    @Override
-    public Identifier[] getBlockTypes() {
-        return NexoItems.itemNames().stream()
-                .map(i -> new Identifier("nexo", i))
-                .filter(i -> {
-                    try {
-                        return getBlockData(i) != null;
-                    } catch (MissingResourceException e) {
-                        return false;
-                    }
-                })
-                .toArray(Identifier[]::new);
-    }
-
-    @NotNull
-    @Override
-    public Identifier[] getItemTypes() {
-        return NexoItems.itemNames().stream()
-                .map(i -> new Identifier("nexo", i))
-                .filter(i -> {
-                    try {
-                        return getItemStack(i) != null;
-                    } catch (MissingResourceException e) {
-                        return false;
-                    }
-                })
-                .toArray(Identifier[]::new);
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, boolean isItem) {
-        return "nexo".equalsIgnoreCase(id.namespace());
-    }
-
-    @Override
-    public boolean isReady() {
-        return super.isReady() && !failed.get();
-    }
-}

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

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

@@ -36,7 +36,6 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.reflect.OldEnum;
 import com.volmit.iris.util.scheduling.ChronoLatch;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Data;
@@ -338,15 +337,6 @@ public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
         this.imageLoader = registerLoader(IrisImage.class);
         this.scriptLoader = registerLoader(IrisScript.class);
         this.matterObjectLoader = registerLoader(IrisMatterObject.class);
-        if (OldEnum.exists()) {
-            builder.registerTypeAdapterFactory(new TypeAdapterFactory() {
-                @Override
-                public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> type) {
-                    return (TypeAdapter<T>) OldEnum.create(type.getRawType());
-                }
-            });
-        }
-
         gson = builder.create();
     }
 
@@ -444,7 +434,6 @@ 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) {

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

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

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

@@ -0,0 +1,15 @@
+package com.volmit.iris.core.nms;
+
+import org.bukkit.Chunk;
+import org.bukkit.World;
+import org.bukkit.event.Listener;
+import org.bukkit.generator.ChunkGenerator;
+
+public interface IMemoryWorld extends Listener, AutoCloseable {
+
+    World getBukkit();
+
+    Chunk getChunk(int x, int z);
+
+    ChunkGenerator.ChunkData getChunkData(int x, int z);
+}

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

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

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

@@ -18,7 +18,7 @@
 
 package com.volmit.iris.core.nms;
 
-import com.volmit.iris.core.nms.container.AutoClosing;
+import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.container.BiomeColor;
 import com.volmit.iris.core.nms.datapack.DataVersion;
 import com.volmit.iris.engine.framework.Engine;
@@ -31,13 +31,18 @@ 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.block.data.BlockData;
+import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.entity.CreatureSpawnEvent;
 import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
+import java.awt.*;
 import java.awt.Color;
+import java.io.IOException;
 
 public interface INMSBinding {
     boolean hasTile(Material material);
@@ -89,17 +94,15 @@ public interface INMSBinding {
     MCABiomeContainer newBiomeContainer(int min, int max);
 
     default World createWorld(WorldCreator c) {
-        if (missingDimensionTypes(true, true, true))
-            throw new IllegalStateException("Missing dimenstion types to create world");
-
-        try (var ignored = injectLevelStems()) {
-            ignored.storeContext();
-            return c.createWorld();
-        }
+        return c.createWorld();
     }
 
     int countCustomBiomes();
 
+    default boolean setBlock(World world, int x, int y, int z, BlockData data, int flag, int updateDepth) {
+        throw new UnsupportedOperationException();
+    }
+
     void forceBiomeInto(int x, int y, int z, Object somethingVeryDirty, ChunkGenerator.BiomeGrid chunk);
 
     default boolean supportsDataPacks() {
@@ -130,13 +133,19 @@ public interface INMSBinding {
 
     KList<String> getStructureKeys();
 
-    AutoClosing injectLevelStems();
-
-    default AutoClosing injectUncached(boolean overworld, boolean nether, boolean end) {
+    default BlockData getBlockData(CompoundTag tag) {
+        Iris.error("Unsupported version!");
         return null;
+    };
+
+    default IMemoryWorld createMemoryWorld(WorldCreator creator) throws IOException {
+        return createMemoryWorld(switch (creator.environment()) {
+            case NORMAL -> NamespacedKey.minecraft("overworld");
+            case NETHER -> NamespacedKey.minecraft("the_nether");
+            case THE_END -> NamespacedKey.minecraft("the_end");
+            default -> throw new IllegalArgumentException("Illegal dimension (" + creator.environment() + ")");
+        }, creator);
     }
 
-    boolean missingDimensionTypes(boolean overworld, boolean nether, boolean end);
-
-    void removeCustomDimensions(World world);
+    IMemoryWorld createMemoryWorld(NamespacedKey levelType, WorldCreator creator) throws IOException;
 }

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

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

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

@@ -3,7 +3,6 @@ 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;
@@ -14,8 +13,7 @@ import java.util.function.Supplier;
 @Getter
 public enum DataVersion {
     V1192("1.19.2", 10, DataFixerV1192::new),
-    V1205("1.20.6", 41, DataFixerV1206::new),
-    V1213("1.21.3", 57, DataFixerV1213::new);
+    V1205("1.20.6", 41, DataFixerV1206::new);
     private static final KMap<DataVersion, IDataFixer> cache = new KMap<>();
     @Getter(AccessLevel.NONE)
     private final Supplier<IDataFixer> constructor;

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

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

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

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

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

@@ -1,6 +1,6 @@
 package com.volmit.iris.core.nms.datapack.v1206;
 
-import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
+import com.volmit.iris.core.nms.datapack.IDataFixer;
 import com.volmit.iris.engine.object.IrisBiomeCustom;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
 import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
@@ -10,14 +10,12 @@ import com.volmit.iris.util.json.JSONObject;
 
 import java.util.Locale;
 
-public class DataFixerV1206 extends DataFixerV1192 {
+public class DataFixerV1206 implements IDataFixer {
     @Override
     public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
         int spawnRarity = biome.getSpawnRarity();
         if (spawnRarity > 0) {
             json.put("creature_spawn_probability", Math.min(spawnRarity/20d, 0.9999999));
-        } else {
-            json.remove("creature_spawn_probability");
         }
 
         var spawns = biome.getSpawns();
@@ -28,10 +26,10 @@ public class DataFixerV1206 extends DataFixerV1192 {
             for (IrisBiomeCustomSpawn i : spawns) {
                 JSONArray g = groups.computeIfAbsent(i.getGroup(), (k) -> new JSONArray());
                 JSONObject o = new JSONObject();
-                o.put("type", i.getType().getKey());
+                o.put("type", "minecraft:" + i.getType().name().toLowerCase());
                 o.put("weight", i.getWeight());
-                o.put("minCount", i.getMinCount());
-                o.put("maxCount", i.getMaxCount());
+                o.put("minCount", Math.min(i.getMinCount()/20d, 0));
+                o.put("maxCount", Math.min(i.getMaxCount()/20d, 0.9999999));
                 g.put(o);
             }
 
@@ -45,8 +43,7 @@ public class DataFixerV1206 extends DataFixerV1192 {
     }
 
     @Override
-    public JSONObject rawDimension(Dimension dimension) {
-        JSONObject json = super.rawDimension(dimension);
+    public JSONObject fixDimension(JSONObject json) {
         if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
             return json;
         var value = (JSONObject) lightLevel.remove("value");

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

@@ -1,16 +0,0 @@
-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

@@ -19,10 +19,10 @@
 package com.volmit.iris.core.nms.v1X;
 
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.IMemoryWorld;
 import com.volmit.iris.core.nms.INMSBinding;
-import com.volmit.iris.core.nms.container.AutoClosing;
 import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
@@ -33,6 +33,8 @@ 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.block.data.BlockData;
+import org.bukkit.entity.Dolphin;
 import org.bukkit.entity.Entity;
 import org.bukkit.entity.EntityType;
 import org.bukkit.event.entity.CreatureSpawnEvent;
@@ -40,8 +42,9 @@ import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.generator.structure.Structure;
 import org.bukkit.inventory.ItemStack;
 
+import java.awt.*;
 import java.awt.Color;
-import java.util.stream.StreamSupport;
+import java.io.IOException;
 
 public class NMSBinding1X implements INMSBinding {
     private static final boolean supportsCustomHeight = testCustomHeight();
@@ -113,7 +116,7 @@ public class NMSBinding1X implements INMSBinding {
 
     @Override
     public KList<String> getStructureKeys() {
-        var list = StreamSupport.stream(Registry.STRUCTURE.spliterator(), false)
+        var list = Registry.STRUCTURE.stream()
                 .map(Structure::getKey)
                 .map(NamespacedKey::toString)
                 .toList();
@@ -121,23 +124,8 @@ public class NMSBinding1X implements INMSBinding {
     }
 
     @Override
-    public AutoClosing injectLevelStems() {
-        return new AutoClosing(() -> {});
-    }
-
-    @Override
-    public AutoClosing injectUncached(boolean overworld, boolean nether, boolean end) {
-        return injectLevelStems();
-    }
-
-    @Override
-    public boolean missingDimensionTypes(boolean overworld, boolean nether, boolean end) {
-        return false;
-    }
-
-    @Override
-    public void removeCustomDimensions(World world) {
-
+    public IMemoryWorld createMemoryWorld(NamespacedKey levelType, WorldCreator creator) throws IOException {
+        throw new IOException("Unsupported version!");
     }
 
     @Override

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

@@ -165,11 +165,8 @@ public class ChunkUpdater {
             if (rX < dimensions.min.getX() || rX > dimensions.max.getX() || rZ < dimensions.min.getZ() || rZ > dimensions.max.getZ()) {
                 return;
             }
-            if (!new File(world.getWorldFolder(), "region" + File.separator + rX + "." + rZ + ".mca").exists()) {
-                return;
-            }
 
-            task.iterateChunks(rX, rZ, (x, z) -> {
+            PregenTask.iterateRegion(rX, rZ, (x, z) -> {
                 while (paused.get() && !cancelled.get()) {
                     J.sleep(50);
                 }
@@ -239,8 +236,7 @@ public class ChunkUpdater {
                         try {
                             c = PaperLib.getChunkAtAsync(world, xx, zz, false, true)
                                     .thenApply(chunk -> {
-                                        if (chunk != null)
-                                            chunk.addPluginChunkTicket(Iris.instance);
+                                        chunk.addPluginChunkTicket(Iris.instance);
                                         return chunk;
                                     }).get();
                         } catch (InterruptedException | ExecutionException e) {
@@ -248,17 +244,12 @@ public class ChunkUpdater {
                             return;
                         }
 
-                        if (c == null) {
-                            generated.set(false);
-                            return;
-                        }
-
                         if (!c.isLoaded()) {
                             var future = J.sfut(() -> c.load(false));
                             if (future != null) future.join();
                         }
 
-                        if (!PaperLib.isChunkGenerated(c.getWorld(), xx, zz))
+                        if (!c.isGenerated())
                             generated.set(false);
 
                         var pair = lastUse.computeIfAbsent(Cache.key(c), k -> new Pair<>(0L, new AtomicInteger(-1)));
@@ -351,8 +342,8 @@ public class ChunkUpdater {
         int width = maxZ - minZ + 1;
 
         return new Dimensions(new Position2(minX, minZ), new Position2(maxX, maxZ), height * width, PregenTask.builder()
-                .radiusZ((int) Math.ceil(width / 2d * 512))
-                .radiusX((int) Math.ceil(height / 2d * 512))
+                .width((int) Math.ceil(width / 2d))
+                .height((int) Math.ceil(height / 2d))
                 .center(new Position2(oX, oZ))
                 .build());
     }

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

@@ -1,274 +0,0 @@
-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/IrisPregenerator.java

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

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

@@ -12,6 +12,7 @@ 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;
@@ -263,22 +264,22 @@ public class LazyPregenerator extends Thread implements Listener {
     }
 
     @Data
-    @lombok.Builder
+    @Builder
     public static class LazyPregenJob {
         private String world;
-        @lombok.Builder.Default
+        @Builder.Default
         private int healingPosition = 0;
-        @lombok.Builder.Default
+        @Builder.Default
         private boolean healing = false;
-        @lombok.Builder.Default
+        @Builder.Default
         private int chunksPerMinute = 32;
-        @lombok.Builder.Default
+        @Builder.Default
         private int radiusBlocks = 5000;
-        @lombok.Builder.Default
+        @Builder.Default
         private int position = 0;
-        @lombok.Builder.Default
+        @Builder.Default
         boolean silent = false;
-        @lombok.Builder.Default
+        @Builder.Default
         boolean paused = false;
     }
 }

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

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

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

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

@@ -22,6 +22,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.pregenerator.PregenListener;
 import com.volmit.iris.core.pregenerator.PregeneratorMethod;
 import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.M;
@@ -33,12 +34,12 @@ import org.bukkit.World;
 
 import java.util.ArrayList;
 import java.util.Map;
-import java.util.concurrent.Semaphore;
+import java.util.concurrent.Future;
 
 public class AsyncPregenMethod implements PregeneratorMethod {
     private final World world;
     private final MultiBurst burst;
-    private final Semaphore semaphore;
+    private final KList<Future<?>> future;
     private final Map<Chunk, Long> lastUse;
 
     public AsyncPregenMethod(World world, int threads) {
@@ -48,7 +49,7 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
         this.world = world;
         burst = new MultiBurst("Iris Async Pregen", Thread.MIN_PRIORITY);
-        semaphore = new Semaphore(256);
+        future = new KList<>(256);
         this.lastUse = new KMap<>();
     }
 
@@ -62,7 +63,7 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
                 for (Chunk i : new ArrayList<>(lastUse.keySet())) {
                     Long lastUseTime = lastUse.get(i);
-                    if (!i.isLoaded() || (lastUseTime != null && M.ms() - lastUseTime >= 10000)) {
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 10000) {
                         i.unload();
                         lastUse.remove(i);
                     }
@@ -84,8 +85,37 @@ public class AsyncPregenMethod implements PregeneratorMethod {
         } catch (InterruptedException ignored) {
         } catch (Throwable e) {
             e.printStackTrace();
-        } finally {
-            semaphore.release();
+        }
+    }
+
+    private void waitForChunksPartial(int maxWaiting) {
+        while (future.size() > maxWaiting) {
+            try {
+                Future<?> i = future.remove(0);
+
+                if (i == null) {
+                    continue;
+                }
+
+                i.get();
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
+    private void waitForChunks() {
+        for (Future<?> i : future.copy()) {
+            if (i == null) {
+                continue;
+            }
+
+            try {
+                i.get();
+                future.remove(i);
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
         }
     }
 
@@ -101,13 +131,14 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void close() {
-        semaphore.acquireUninterruptibly(256);
+        waitForChunks();
         unloadAndSaveAllChunks();
         burst.close();
     }
 
     @Override
     public void save() {
+        waitForChunksPartial(256);
         unloadAndSaveAllChunks();
     }
 
@@ -124,12 +155,10 @@ public class AsyncPregenMethod implements PregeneratorMethod {
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
         listener.onChunkGenerating(x, z);
-        try {
-            semaphore.acquire();
-        } catch (InterruptedException e) {
-            return;
+        if (future.size() > 256) {
+            waitForChunksPartial(256);
         }
-        burst.complete(() -> completeChunk(x, z, listener));
+        future.add(burst.complete(() -> completeChunk(x, z, listener)));
     }
 
     @Override

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

@@ -22,23 +22,21 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.core.loader.ResourceLoader;
+import com.volmit.iris.engine.framework.ListFunction;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.json.JSONArray;
 import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.reflect.OldEnum;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.potion.PotionEffectType;
-import org.jetbrains.annotations.NotNull;
 
 import java.awt.*;
 import java.lang.reflect.Field;
 import java.lang.reflect.Modifier;
 import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 import java.util.stream.Collectors;
 
 public class SchemaBuilder {
@@ -46,6 +44,7 @@ public class SchemaBuilder {
     private static final String SYMBOL_TYPE__N = "";
     private static final JSONArray POTION_TYPES = getPotionTypes();
     private static final JSONArray ENCHANT_TYPES = getEnchantTypes();
+    private static final JSONArray ITEM_TYPES = new JSONArray(B.getItemTypes());
     private static final JSONArray FONT_TYPES = new JSONArray(GraphicsEnvironment.getLocalGraphicsEnvironment().getAvailableFontFamilyNames());
     private final KMap<String, JSONObject> definitions;
     private final Class<?> root;
@@ -263,7 +262,7 @@ public class SchemaBuilder {
 
                     if (!definitions.containsKey(key)) {
                         JSONObject j = new JSONObject();
-                        j.put("enum", B.getItemTypes());
+                        j.put("enum", ITEM_TYPES);
                         definitions.put(key, j);
                     }
 
@@ -343,9 +342,38 @@ public class SchemaBuilder {
                     description.add(SYMBOL_TYPE__N + "  Must be a valid Potion Effect Type (use ctrl+space for auto complete!)");
 
                 } else if (k.getType().isEnum()) {
-                    fancyType = addEnum(k.getType(), prop, description, k.getType().getEnumConstants(), o -> ((Enum<?>) o).name());
-                } else if (OldEnum.isOldEnum(k.getType())) {
-                    fancyType = addEnum(k.getType(), prop, description, OldEnum.values(k.getType()), OldEnum::name);
+                    fancyType = k.getType().getSimpleName().replaceAll("\\QIris\\E", "");
+                    JSONArray a = new JSONArray();
+                    boolean advanced = k.getType().isAnnotationPresent(Desc.class);
+                    for (Object gg : k.getType().getEnumConstants()) {
+                        if (advanced) {
+                            try {
+                                JSONObject j = new JSONObject();
+                                String name = ((Enum<?>) gg).name();
+                                j.put("const", name);
+                                Desc dd = k.getType().getField(name).getAnnotation(Desc.class);
+                                j.put("description", dd == null ? ("No Description for " + name) : dd.value());
+                                a.put(j);
+                            } catch (Throwable e) {
+                                Iris.reportError(e);
+                                e.printStackTrace();
+                            }
+                        } else {
+                            a.put(((Enum<?>) gg).name());
+                        }
+                    }
+
+                    String key = (advanced ? "oneof-" : "") + "enum-" + k.getType().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
+
+                    if (!definitions.containsKey(key)) {
+                        JSONObject j = new JSONObject();
+                        j.put(advanced ? "oneOf" : "enum", a);
+                        definitions.put(key, j);
+                    }
+
+                    prop.put("$ref", "#/definitions/" + key);
+                    description.add(SYMBOL_TYPE__N + "  Must be a valid " + k.getType().getSimpleName().replaceAll("\\QIris\\E", "") + " (use ctrl+space for auto complete!)");
+
                 }
             }
             case "object" -> {
@@ -369,6 +397,10 @@ public class SchemaBuilder {
                             description.add(SYMBOL_LIMIT__N + " Requires at least " + t.min() + " entries.");
                         }
                     }
+                    if (t.max() > 0) {
+                        prop.put("maxItems", t.max());
+                        description.add(SYMBOL_LIMIT__N + " Maximum allowed entries are " + t.max() + ".");
+                    }
 
                     String arrayType = getType(t.type());
 
@@ -440,7 +472,7 @@ public class SchemaBuilder {
 
                                 if (!definitions.containsKey(key)) {
                                     JSONObject j = new JSONObject();
-                                    j.put("enum", B.getItemTypes());
+                                    j.put("enum", ITEM_TYPES);
                                     definitions.put(key, j);
                                 }
 
@@ -491,9 +523,39 @@ public class SchemaBuilder {
                                 prop.put("items", items);
                                 description.add(SYMBOL_TYPE__N + "  Must be a valid Potion Effect Type (use ctrl+space for auto complete!)");
                             } else if (t.type().isEnum()) {
-                                fancyType = addEnumList(prop, description, t, t.type().getEnumConstants(), o -> ((Enum<?>) o).name());
-                            } else if (OldEnum.isOldEnum(t.type())) {
-                                fancyType = addEnumList(prop, description, t, OldEnum.values(t.type()), OldEnum::name);
+                                fancyType = "List of " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + "s";
+                                JSONArray a = new JSONArray();
+                                boolean advanced = t.type().isAnnotationPresent(Desc.class);
+                                for (Object gg : t.type().getEnumConstants()) {
+                                    if (advanced) {
+                                        try {
+                                            JSONObject j = new JSONObject();
+                                            String name = ((Enum<?>) gg).name();
+                                            j.put("const", name);
+                                            Desc dd = t.type().getField(name).getAnnotation(Desc.class);
+                                            j.put("description", dd == null ? ("No Description for " + name) : dd.value());
+                                            a.put(j);
+                                        } catch (Throwable e) {
+                                            Iris.reportError(e);
+                                            e.printStackTrace();
+                                        }
+                                    } else {
+                                        a.put(((Enum<?>) gg).name());
+                                    }
+                                }
+
+                                String key = (advanced ? "oneof-" : "") + "enum-" + t.type().getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
+
+                                if (!definitions.containsKey(key)) {
+                                    JSONObject j = new JSONObject();
+                                    j.put(advanced ? "oneOf" : "enum", a);
+                                    definitions.put(key, j);
+                                }
+
+                                JSONObject items = new JSONObject();
+                                items.put("$ref", "#/definitions/" + key);
+                                prop.put("items", items);
+                                description.add(SYMBOL_TYPE__N + "  Must be a valid " + t.type().getSimpleName().replaceAll("\\QIris\\E", "") + " (use ctrl+space for auto complete!)");
                             }
                         }
                     }
@@ -526,7 +588,7 @@ public class SchemaBuilder {
                 if (value instanceof List) {
                     d.add("    ");
                     d.add("* Default Value is an empty list");
-                } else if (!cl.isPrimitive() && !(value instanceof Number) && !(value instanceof String) && !(cl.isEnum()) && !OldEnum.isOldEnum(cl)) {
+                } else if (!cl.isPrimitive() && !(value instanceof Number) && !(value instanceof String) && !(cl.isEnum())) {
                     d.add("    ");
                     d.add("* Default Value is a default object (create this object to see default properties)");
                 } else {
@@ -572,50 +634,6 @@ public class SchemaBuilder {
         return prop;
     }
 
-    @NotNull
-    private String addEnumList(JSONObject prop, KList<String> description, ArrayType t, Object[] values, Function<Object, String> function) {
-        JSONObject items = new JSONObject();
-        var s = addEnum(t.type(), items, description, values, function);
-        prop.put("items", items);
-
-        return "List of " + s + "s";
-    }
-
-    @NotNull
-    private String addEnum(Class<?> type, JSONObject prop, KList<String> description, Object[] values, Function<Object, String> function) {
-        JSONArray a = new JSONArray();
-        boolean advanced = type.isAnnotationPresent(Desc.class);
-        for (Object gg : values) {
-            if (advanced) {
-                try {
-                    JSONObject j = new JSONObject();
-                    String name = function.apply(gg);
-                    j.put("const", name);
-                    Desc dd = type.getField(name).getAnnotation(Desc.class);
-                    j.put("description", dd == null ? ("No Description for " + name) : dd.value());
-                    a.put(j);
-                } catch (Throwable e) {
-                    Iris.reportError(e);
-                    e.printStackTrace();
-                }
-            } else {
-                a.put(function.apply(gg));
-            }
-        }
-
-        String key = (advanced ? "oneof-" : "") + "enum-" + type.getCanonicalName().replaceAll("\\Q.\\E", "-").toLowerCase();
-
-        if (!definitions.containsKey(key)) {
-            JSONObject j = new JSONObject();
-            j.put(advanced ? "oneOf" : "enum", a);
-            definitions.put(key, j);
-        }
-
-        prop.put("$ref", "#/definitions/" + key);
-        description.add(SYMBOL_TYPE__N + "  Must be a valid " + type.getSimpleName().replaceAll("\\QIris\\E", "") + " (use ctrl+space for auto complete!)");
-        return type.getSimpleName().replaceAll("\\QIris\\E", "");
-    }
-
     private String getType(Class<?> c) {
         if (c.equals(int.class) || c.equals(Integer.class) || c.equals(long.class) || c.equals(Long.class)) {
             return "integer";
@@ -629,7 +647,7 @@ public class SchemaBuilder {
             return "boolean";
         }
 
-        if (c.equals(String.class) || c.isEnum() || OldEnum.isOldEnum(c) || c.equals(Enchantment.class) || c.equals(PotionEffectType.class)) {
+        if (c.equals(String.class) || c.isEnum() || c.equals(Enchantment.class) || c.equals(PotionEffectType.class)) {
             return "string";
         }
 

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

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

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

@@ -3,7 +3,6 @@ package com.volmit.iris.core.safeguard;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import com.volmit.iris.engine.object.IrisContextInjector;
 import org.bukkit.Bukkit;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.PluginManager;
@@ -21,16 +20,16 @@ import java.util.Map;
 import java.util.StringJoiner;
 
 import static com.volmit.iris.Iris.getJavaVersion;
+import static com.volmit.iris.Iris.instance;
 import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
 
 public class ServerBootSFG {
     public static final Map<String, Boolean> incompatibilities = new HashMap<>();
-    public static boolean isCorrectJDK = true;
+    public static boolean isJDK17 = true;
     public static boolean hasEnoughDiskSpace = true;
     public static boolean isJRE = false;
     public static boolean hasPrivileges = true;
     public static boolean unsuportedversion = false;
-    public static boolean missingDimensionTypes = false;
     protected static boolean safeguardPassed;
     public static boolean passedserversoftware = true;
     protected static int count;
@@ -88,8 +87,8 @@ public class ServerBootSFG {
             severityHigh++;
         }
 
-        if (!List.of(21).contains(getJavaVersion())) {
-            isCorrectJDK = false;
+        if (!List.of(17, 21).contains(getJavaVersion())) {
+            isJDK17 = false;
             joiner.add("Unsupported Java version");
             severityMedium++;
         }
@@ -112,12 +111,6 @@ public class ServerBootSFG {
             severityMedium++;
         }
 
-        if (IrisContextInjector.isMissingDimensionTypes()) {
-            missingDimensionTypes = true;
-            joiner.add("Missing Dimension Types");
-            severityHigh++;
-        }
-
         allIncompatibilities = joiner.toString();
 
         safeguardPassed = (severityHigh == 0 && severityMedium == 0 && severityLow == 0);

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

@@ -37,12 +37,7 @@ public class UtilsSFG {
             }
             if (ServerBootSFG.unsuportedversion) {
                 Iris.safeguard(C.RED + "Server Version");
-                Iris.safeguard(C.RED + "- Iris only supports 1.20.1 > 1.21.4");
-            }
-            if (ServerBootSFG.missingDimensionTypes) {
-                Iris.safeguard(C.RED + "Dimension Types");
-                Iris.safeguard(C.RED + "- Required Iris dimension types were not loaded.");
-                Iris.safeguard(C.RED + "- If this still happens after a restart please contact support.");
+                Iris.safeguard(C.RED + "- Iris only supports 1.19.2 > 1.21.1");
             }
             if (!ServerBootSFG.passedserversoftware) {
                 Iris.safeguard(C.YELLOW + "Unsupported Server Software");
@@ -56,13 +51,13 @@ public class UtilsSFG {
                 Iris.safeguard(C.YELLOW + "Insufficient Disk Space");
                 Iris.safeguard(C.YELLOW + "- The server has insufficient Free DiskSpace to run iris required 3GB+.");
             }
-            if (!ServerBootSFG.isCorrectJDK) {
+            if (!ServerBootSFG.isJDK17) {
                 Iris.safeguard(C.YELLOW + "Unsupported java version");
-                Iris.safeguard(C.YELLOW + "- Please consider using JDK 21 Instead of JDK " + Iris.getJavaVersion());
+                Iris.safeguard(C.YELLOW + "- Please consider using JDK 17 (or 21 for 1.20.6) Instead of JDK " + Iris.getJavaVersion());
             }
             if (ServerBootSFG.isJRE) {
                 Iris.safeguard(C.YELLOW + "Unsupported Server JDK");
-                Iris.safeguard(C.YELLOW + "- Please consider using JDK 21 Instead of JRE " + Iris.getJavaVersion());
+                Iris.safeguard(C.YELLOW + "- Please consider using JDK 17 (or 21 for 1.20.6) Instead of JRE " + Iris.getJavaVersion());
             }
         }
     }

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

@@ -40,7 +40,6 @@ import org.bukkit.event.player.PlayerChangedWorldEvent;
 import org.bukkit.event.player.PlayerJoinEvent;
 
 import java.util.List;
-import java.util.concurrent.CopyOnWriteArrayList;
 
 public class BoardSVC implements IrisService, BoardProvider {
     private final KMap<Player, PlayerBoard> boards = new KMap<>();
@@ -105,11 +104,11 @@ public class BoardSVC implements IrisService, BoardProvider {
     @Data
     public static class PlayerBoard {
         private final Player player;
-        private final CopyOnWriteArrayList<String> lines;
+        private final KList<String> lines;
 
         public PlayerBoard(Player player) {
             this.player = player;
-            this.lines = new CopyOnWriteArrayList<>();
+            this.lines = new KList<>();
             update();
         }
 
@@ -126,32 +125,19 @@ public class BoardSVC implements IrisService, BoardProvider {
                 int y = player.getLocation().getBlockY() - player.getWorld().getMinHeight();
                 int z = player.getLocation().getBlockZ();
 
-                if(IrisSettings.get().getGeneral().debug){
-                    lines.add("&7&m                   ");
-                    lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
-                    lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
-                    lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
-                    lines.add(C.LIGHT_PURPLE + "Carving" + C.GRAY + ": " + engine.getMantle().isCarved(x,y,z));
-                    lines.add("&7&m                   ");
-                    lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
-                    lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
-                    lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
-                    lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
-                    lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
-                    lines.add("&7&m                   ");
-                } else {
-                    lines.add("&7&m                   ");
-                    lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
-                    lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
-                    lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
-                    lines.add("&7&m                   ");
-                    lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
-                    lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
-                    lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
-                    lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
-                    lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
-                    lines.add("&7&m                   ");
-                }
+
+                lines.add("&7&m                   ");
+                lines.add(C.GREEN + "Speed" + C.GRAY + ":  " + Form.f(engine.getGeneratedPerSecond(), 0) + "/s " + Form.duration(1000D / engine.getGeneratedPerSecond(), 0));
+                lines.add(C.AQUA + "Cache" + C.GRAY + ": " + Form.f(IrisData.cacheSize()));
+                lines.add(C.AQUA + "Mantle" + C.GRAY + ": " + engine.getMantle().getLoadedRegionCount());
+                lines.add("&7&m                   ");
+                lines.add(C.AQUA + "Region" + C.GRAY + ": " + engine.getRegion(x, z).getName());
+                lines.add(C.AQUA + "Biome" + C.GRAY + ":  " + engine.getBiomeOrMantle(x, y, z).getName());
+                lines.add(C.AQUA + "Height" + C.GRAY + ": " + Math.round(engine.getHeight(x, z)));
+                lines.add(C.AQUA + "Slope" + C.GRAY + ":  " + Form.f(engine.getComplex().getSlopeStream().get(x, z), 2));
+                lines.add(C.AQUA + "BUD/s" + C.GRAY + ": " + Form.f(engine.getBlockUpdatesPerSecond()));
+                lines.add("&7&m                   ");
+
             }
         }
     }

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

@@ -20,9 +20,12 @@ package com.volmit.iris.core.service;
 
 import com.google.gson.Gson;
 import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.INMS;
+import com.volmit.iris.core.nms.v1X.NMSBinding1X;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.function.Consumer2;
 import com.volmit.iris.util.io.Converter;
@@ -37,13 +40,16 @@ import com.volmit.iris.util.nbt.tag.ListTag;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
+import org.apache.commons.io.FileUtils;
 import org.bukkit.Material;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.type.Jigsaw;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Objects;
 import java.util.concurrent.atomic.AtomicInteger;
+import java.util.stream.Collectors;
 
 public class ConversionSVC implements IrisService {
     private KList<Converter> converters;
@@ -122,7 +128,7 @@ public class ConversionSVC implements IrisService {
                     @SuppressWarnings("unchecked") ListTag<CompoundTag> paletteList = (ListTag<CompoundTag>) compound.getListTag("palette");
                     for (int i = 0; i < paletteList.size(); i++) {
                         CompoundTag cp = paletteList.get(i);
-                        palette.add(NBTWorld.getBlockData(cp));
+                        palette.add(INMS.get().getBlockData(cp));
                     }
                     IrisJigsawPiece piece = new IrisJigsawPiece();
                     IrisObject object = new IrisObject(w, h, d);
@@ -135,20 +141,37 @@ public class ConversionSVC implements IrisService {
                         int z = pos.get(2).asInt();
                         BlockData bd = palette.get(cp.getInt("state")).clone();
 
+                        piece.setObject(in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0]);
                         if (bd.getMaterial().equals(Material.JIGSAW) && cp.containsKey("nbt")) {
-                            piece.setObject(in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0]);
+                            //.setObject(in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0]);
                             IrisPosition spos = new IrisPosition(object.getSigned(x, y, z));
                             CompoundTag nbt = cp.getCompoundTag("nbt");
                             CompoundTag finalState = new CompoundTag();
                             finalState.putString("Name", nbt.getString("final_state"));
                             BlockData jd = bd.clone();
-                            bd = NBTWorld.getBlockData(finalState);
+                            bd = INMS.get().getBlockData(finalState);
                             String joint = nbt.getString("joint");
                             String pool = nbt.getString("pool");
                             String poolId = toPoolName(pool);
                             String name = nbt.getString("name");
                             String target = nbt.getString("target");
-                            pools.computeIfAbsent(poolId, (k) -> new IrisJigsawPool());
+                            pools.computeIfAbsent(poolId, (k) -> {
+                                IrisJigsawPool irisPool = new IrisJigsawPool();
+
+                                String basePath = in.toURI().relativize(folder.toURI()).getPath();
+                                File baseFolder = new File(in.toURI().relativize(folder.toURI()).toString());
+                                String[] paths = FileUtils.listFiles(folder, null, true)
+                                        .stream()
+                                        .map(path -> path.getPath().replaceAll("\\.nbt$", "")).toArray(String[]::new);
+
+                                KList<String> poolList = new KList<>();
+                                for (int ii = 0; ii < Objects.requireNonNull(paths).length; ii++) {
+                                    String lastSegment = paths[ii].substring(paths[ii].lastIndexOf("\\") + 1);
+                                    poolList.add(basePath + lastSegment);
+                                }
+                                irisPool.setPieces(poolList);
+                                return irisPool;
+                            });
                             IrisJigsawPieceConnector connector = new IrisJigsawPieceConnector();
                             connector.setName(name);
                             connector.setTargetName(target);
@@ -169,10 +192,14 @@ public class ConversionSVC implements IrisService {
                         }
                     }
 
+                    if (piece.getObject().isBlank() || piece.getObject().isEmpty()) {
+                        Iris.info(C.RED + "Failed Setting object with path: " + in.toURI().relativize(folder.toURI()).getPath() + file.getName().split("\\Q.\\E")[0]);
+                    }
                     jpool.getPieces().addIfMissing(id);
                     object.write(new File(destObjects, file.getName().split("\\Q.\\E")[0] + ".iob"));
                     IO.writeAll(new File(destPieces, file.getName().split("\\Q.\\E")[0] + ".json"), new JSONObject(new Gson().toJson(piece)).toString(4));
-                    Iris.info("[Jigsaw]: (" + Form.pc((double) at.get() / (double) total.get(), 0) + ") Exported Piece: " + id);
+                    Iris.info("[Jigsaw]: (" + Form.pc((double) at.get() / (double) total.get(), 0).replace("%", "%%") + ") Exported Piece: " + id);
+
                 }
             } catch (Throwable e) {
                 e.printStackTrace();

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

@@ -26,7 +26,6 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.plugin.IrisService;
 import lombok.Data;
-import lombok.NonNull;
 import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;
@@ -47,9 +46,9 @@ public class ExternalDataSVC implements IrisService {
         Iris.info("Loading ExternalDataProvider...");
         Bukkit.getPluginManager().registerEvents(this, Iris.instance);
 
-        providers.add(new NexoDataProvider());
-        if (Bukkit.getPluginManager().getPlugin("Nexo") != null) {
-            Iris.info("Nexo found, loading NexoDataProvider...");
+        providers.add(new OraxenDataProvider());
+        if (Bukkit.getPluginManager().getPlugin("Oraxen") != null) {
+            Iris.info("Oraxen found, loading OraxenDataProvider...");
         }
         providers.add(new MythicCrucibleDataProvider());
         if (Bukkit.getPluginManager().getPlugin("MythicCrucible") != null) {
@@ -100,18 +99,6 @@ public class ExternalDataSVC implements IrisService {
         }
     }
 
-    public void registerProvider(@NonNull ExternalDataProvider provider) {
-        String plugin = provider.getPluginId();
-        if (providers.stream().map(ExternalDataProvider::getPluginId).anyMatch(plugin::equals))
-            throw new IllegalArgumentException("A provider with the same plugin id already exists.");
-
-        providers.add(provider);
-        if (provider.isReady()) {
-            activeProviders.add(provider);
-            provider.init();
-        }
-    }
-
     public Optional<BlockData> getBlockData(final Identifier key) {
         var pair = parseState(key);
         Identifier mod = pair.getA();

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

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

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

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

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

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

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

@@ -30,12 +30,15 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.matter.Matter;
 import com.volmit.iris.util.matter.WorldMatter;
+import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.plugin.VolmitSender;
 import com.volmit.iris.util.scheduling.J;
+import com.volmit.iris.util.scheduling.S;
 import com.volmit.iris.util.scheduling.SR;
 import com.volmit.iris.util.scheduling.jobs.Job;
 import org.bukkit.*;
+import org.bukkit.block.Block;
 import org.bukkit.enchantments.Enchantment;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -53,11 +56,11 @@ import java.awt.Color;
 import java.util.ArrayList;
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
-
-import static com.volmit.iris.util.data.registry.Particles.CRIT_MAGIC;
-import static com.volmit.iris.util.data.registry.Particles.REDSTONE;
+import java.util.concurrent.atomic.AtomicInteger;
 
 public class WandSVC implements IrisService {
+    private static final Particle CRIT_MAGIC = E.getOrDefault(Particle.class, "CRIT_MAGIC", "CRIT");
+    private static final Particle REDSTONE = E.getOrDefault(Particle.class,  "REDSTONE", "DUST");
     private static final int MS_PER_TICK = Integer.parseInt(System.getProperty("iris.ms_per_tick", "30"));
 
     private static ItemStack dust;
@@ -73,7 +76,7 @@ public class WandSVC implements IrisService {
      * @param p The wand player
      * @return The new object
      */
-    public static IrisObject createSchematic(Player p, boolean legacy) {
+    public static IrisObject createSchematic(Player p) {
         if (!isHoldingWand(p)) {
             return null;
         }
@@ -129,7 +132,7 @@ public class WandSVC implements IrisService {
                                         continue;
 
                                     BlockVector bv = b.getLocation().subtract(c.getLowerNE().toVector()).toVector().toBlockVector();
-                                    s.setUnsigned(bv.getBlockX(), bv.getBlockY(), bv.getBlockZ(), b, legacy);
+                                    s.setUnsigned(bv.getBlockX(), bv.getBlockY(), bv.getBlockZ(), b);
                                 } finally {
                                     i++;
                                 }

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

@@ -2,8 +2,12 @@ package com.volmit.iris.core.tools;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.engine.object.*;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.function.Consumer2;
+import com.volmit.iris.util.misc.E;
 import com.volmit.iris.util.nbt.io.NBTUtil;
 import com.volmit.iris.util.nbt.io.NamedTag;
 import com.volmit.iris.util.nbt.tag.*;
@@ -30,6 +34,10 @@ import java.util.concurrent.Executors;
 import java.util.concurrent.atomic.AtomicInteger;
 
 public class IrisConverter {
+    /**
+     * Converts all schematics in the convert folder
+     * @param sender
+     */
     public static void convertSchematics(VolmitSender sender) {
         File folder = Iris.instance.getDataFolder("convert");
 
@@ -132,6 +140,62 @@ public class IrisConverter {
         });
     }
 
+//    /**
+//     *
+//     * @param sender
+//     */
+//    public static void convertJigsawStructure(File in, File out, VolmitSender sender) {
+//        File dataFolder = Iris.instance.getDataFolder("convert");
+//        try {
+//            KMap<String, IrisJigsawPool> pools = new KMap<>();
+//            KList<File> roots = new KList<>();
+//            AtomicInteger total = new AtomicInteger(0);
+//            AtomicInteger at = new AtomicInteger(0);
+//            File destPools = new File(out.getAbsolutePath() + "/jigsaw-pools");
+//            destPools.mkdirs();
+//            findAllNBT(in, (folder, file) -> {
+//                total.getAndIncrement();
+//                if (roots.addIfMissing(folder)) {
+//                    String b = in.toURI().relativize(folder.toURI()).getPath();
+//                    if (b.startsWith("/")) {
+//                        b = b.substring(1);
+//                    }
+//
+//                    if (b.endsWith("/")) {
+//                        b = b.substring(0, b.length() - 1);
+//                    }
+//
+//                    pools.put(b, new IrisJigsawPool());
+//                }
+//            });
+//
+//        } catch (Exception e) {
+//            Iris.error(C.RED + "Failed to convert: " + in.getPath());
+//            e.printStackTrace();
+//        }
+//
+//
+//
+//    }
+
+    private static void findAllNBT(File path, Consumer2<File, File> inFile) {
+        if (path == null) {
+            return;
+        }
+
+        if (path.isFile() && path.getName().endsWith(".nbt")) {
+            inFile.accept(path.getParentFile(), path);
+            return;
+        }
+        for (File i : path.listFiles()) {
+            if (i.isDirectory()) {
+                findAllNBT(i, inFile);
+            } else if (i.isFile() && i.getName().endsWith(".nbt")) {
+                inFile.accept(path, i);
+            }
+        }
+    }
+
 }
 
 

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

@@ -22,11 +22,12 @@ import com.google.common.util.concurrent.AtomicDouble;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.ServerConfigurator;
-import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.pregenerator.PregenTask;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.platform.PlatformChunkGenerator;
+import com.volmit.iris.core.safeguard.UtilsSFG;
 import com.volmit.iris.util.exceptions.IrisException;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
@@ -45,6 +46,7 @@ import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Supplier;
+import static com.volmit.iris.core.safeguard.IrisSafeguard.unstablemode;
 
 /**
  * Makes it a lot easier to setup an engine, world, studio or whatever
@@ -84,6 +86,7 @@ public class IrisCreator {
      * Benchmark mode
      */
     private boolean benchmark = false;
+    private boolean smartVanillaHeight = false;
 
     public static boolean removeFromBukkitYml(String name) throws IOException {
         YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
@@ -123,11 +126,14 @@ public class IrisCreator {
         if (sender == null)
             sender = Iris.getSender();
 
-        if (!studio() || benchmark) {
+        if (!studio()) {
+            Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(Bukkit.getWorldContainer(), name()));
+        }
+        if (benchmark) {
             Iris.service(StudioSVC.class).installIntoWorld(sender, d.getLoadKey(), new File(Bukkit.getWorldContainer(), name()));
         }
 
-        PlatformChunkGenerator access;
+        PlatformChunkGenerator access = null;
         AtomicReference<World> world = new AtomicReference<>();
         AtomicDouble pp = new AtomicDouble(0);
         O<Boolean> done = new O<>();
@@ -137,6 +143,7 @@ public class IrisCreator {
                 .name(name)
                 .seed(seed)
                 .studio(studio)
+                .smartVanillaHeight(smartVanillaHeight)
                 .create();
         ServerConfigurator.installDataPacks(false);
 
@@ -171,7 +178,7 @@ public class IrisCreator {
 
         try {
             J.sfut(() -> {
-                world.set(INMS.get().createWorld(wc));
+                world.set(wc.createWorld());
             }).get();
         } catch (Throwable e) {
             e.printStackTrace();

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

@@ -9,6 +9,8 @@ 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.Form;
+import com.volmit.iris.util.math.Position2;
+
 import com.volmit.iris.util.scheduling.J;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Getter;
@@ -25,44 +27,44 @@ import java.nio.file.attribute.BasicFileAttributes;
 import java.time.Clock;
 import java.time.LocalDateTime;
 import java.util.Collections;
+import java.util.concurrent.*;
 
 
 public class IrisPackBenchmarking {
     @Getter
     public static IrisPackBenchmarking instance;
-    public static boolean benchmarkInProgress = false;
-    private final PrecisionStopwatch stopwatch = new PrecisionStopwatch();
-    private final IrisDimension dimension;
-    private final int radius;
-    private final boolean gui;
+     public static boolean benchmarkInProgress = false;
+     private IrisDimension IrisDimension;
+     private int radius;
+     private boolean finished = false;
+    PrecisionStopwatch stopwatch;
 
-    public IrisPackBenchmarking(IrisDimension dimension, int radius, boolean gui) {
+    public IrisPackBenchmarking(IrisDimension dimension, int r) {
         instance = this;
-        this.dimension = dimension;
-        this.radius = radius;
-        this.gui = gui;
+        this.IrisDimension = dimension;
+        this.radius = r;
         runBenchmark();
     }
 
     private void runBenchmark() {
-        Thread.ofVirtual()
-                .name("PackBenchmarking")
-                .start(() -> {
-                    Iris.info("Setting up benchmark environment ");
-                    benchmarkInProgress = true;
-                    File file = new File("benchmark");
-                    if (file.exists()) {
-                        deleteDirectory(file.toPath());
-                    }
-                    createBenchmark();
-                    while (!IrisToolbelt.isIrisWorld(Bukkit.getWorld("benchmark"))) {
-                        J.sleep(1000);
-                        Iris.debug("Iris PackBenchmark: Waiting...");
-                    }
-                    Iris.info("Starting Benchmark!");
-                    stopwatch.begin();
-                    startBenchmark();
-                });
+        this.stopwatch = new PrecisionStopwatch();
+        ExecutorService service = Executors.newSingleThreadExecutor();
+        service.submit(() -> {
+            Iris.info("Setting up benchmark environment ");
+            benchmarkInProgress = true;
+            File file = new File("benchmark");
+            if (file.exists()) {
+                deleteDirectory(file.toPath());
+            }
+            createBenchmark();
+            while (!IrisToolbelt.isIrisWorld(Bukkit.getWorld("benchmark"))) {
+                J.sleep(1000);
+                Iris.debug("Iris PackBenchmark: Waiting...");
+            }
+            Iris.info("Starting Benchmark!");
+            stopwatch.begin();
+            startBenchmark();
+        });
 
     }
 
@@ -86,14 +88,14 @@ public class IrisPackBenchmarking {
             File profilers = new File("plugins" + File.separator + "Iris" + File.separator + "packbenchmarks");
             profilers.mkdir();
 
-            File results = new File(profilers, dimension.getName() + " " + LocalDateTime.now(Clock.systemDefaultZone()).toString().replace(':', '-') + ".txt");
-            results.getParentFile().mkdirs();
+            File results = new File("plugins " + File.separator + "Iris", IrisDimension.getName() + LocalDateTime.now(Clock.systemDefaultZone()) + ".txt");
+            results.createNewFile();
             KMap<String, Double> metrics = engine.getMetrics().pull();
             try (FileWriter writer = new FileWriter(results)) {
                 writer.write("-----------------\n");
                 writer.write("Results:\n");
-                writer.write("Dimension: " + dimension.getName() + "\n");
-                writer.write("- Date of Benchmark: " + LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
+                writer.write("Dimension: " + IrisDimension.getName() + "\n");
+                writer.write("- Date of Benchmark: " +  LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
                 writer.write("\n");
                 writer.write("Metrics");
                 for (String m : metrics.k()) {
@@ -101,7 +103,7 @@ public class IrisPackBenchmarking {
                     writer.write("- " + m + ": " + i);
                 }
                 writer.write("- " + metrics);
-                writer.write("Benchmark: " + LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
+                writer.write("Benchmark: " +  LocalDateTime.now(Clock.systemDefaultZone()) + "\n");
                 writer.write("- Total time: " + time + "\n");
                 writer.write("- Average CPS: " + calculateAverage(cps) + "\n");
                 writer.write("  - Median CPS: " + calculateMedian(cps) + "\n");
@@ -114,24 +116,17 @@ public class IrisPackBenchmarking {
                 e.printStackTrace();
             }
 
-            J.s(() -> {
-                var world = Bukkit.getWorld("benchmark");
-                if (world == null) return;
-                IrisToolbelt.evacuate(world);
-                Bukkit.unloadWorld(world, true);
-            });
-
+            Bukkit.getServer().unloadWorld("benchmark", true);
             stopwatch.end();
         } catch (Exception e) {
             Iris.error("Something has gone wrong!");
             e.printStackTrace();
         }
     }
-
-    private void createBenchmark() {
+     private void createBenchmark(){
         try {
             IrisToolbelt.createWorld()
-                    .dimension(dimension.getLoadKey())
+                    .dimension(IrisDimension.getName())
                     .name("benchmark")
                     .seed(1337)
                     .studio(false)
@@ -142,14 +137,17 @@ public class IrisPackBenchmarking {
         }
     }
 
-    private void startBenchmark() {
-        IrisToolbelt.pregenerate(PregenTask
-                .builder()
-                .gui(gui)
-                .radiusX(radius)
-                .radiusZ(radius)
-                .build(), Bukkit.getWorld("benchmark")
-        );
+     private void startBenchmark(){
+        int x = 0;
+        int z = 0;
+            IrisToolbelt.pregenerate(PregenTask
+                    .builder()
+                    .gui(false)
+                    .center(new Position2(x, z))
+                    .width(5)
+                    .height(5)
+                    .build(), Bukkit.getWorld("benchmark")
+            );
     }
 
     private double calculateAverage(KList<Integer> list) {
@@ -181,7 +179,7 @@ public class IrisPackBenchmarking {
 
     private boolean deleteDirectory(Path dir) {
         try {
-            Files.walkFileTree(dir, new SimpleFileVisitor<>() {
+            Files.walkFileTree(dir, new SimpleFileVisitor<Path>() {
                 @Override
                 public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                     Files.delete(file);

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

@@ -0,0 +1,111 @@
+package com.volmit.iris.core.tools;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RollingSequence;
+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.Looper;
+
+import java.io.File;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+import java.util.function.Supplier;
+
+public class IrisWorldAnalytics {
+    private final ChronoLatch latch;
+    private final String world;
+    private final AtomicInteger totalChunks;
+    private final AtomicInteger processed;
+    private final RollingSequence chunksPerSecond;
+    private final AtomicLong startTime;
+    private final Looper ticker;
+
+    public IrisWorldAnalytics(String world) {
+        this.world = world;
+
+        totalChunks = new AtomicInteger();
+        processed = new AtomicInteger(0);
+        latch = new ChronoLatch(3000);
+        chunksPerSecond = new RollingSequence(3000);
+        startTime = new AtomicLong(M.ms());
+        index();
+        ticker = new Looper() {
+            @Override
+            protected long loop() {
+
+
+
+                return 1000;
+            }
+        };
+
+    }
+
+    public void execute() {
+        Iris.info("Starting world analyser..");
+        long startTime = System.currentTimeMillis();
+
+    }
+
+    private long computeETA() {
+        return (long) (totalChunks.get() > 1024 ? // Generated chunks exceed 1/8th of total?
+                // If yes, use smooth function (which gets more accurate over time since its less sensitive to outliers)
+                ((totalChunks.get() - processed.get()) * ((double) (M.ms() - startTime.get()) / (double) processed.get())) :
+                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
+                ((totalChunks.get() - processed.get()) / chunksPerSecond.getAverage()) * 1000
+        );
+    }
+
+    private void index() {
+        try {
+            AtomicInteger chunks = new AtomicInteger();
+            AtomicInteger pr = new AtomicInteger();
+            AtomicInteger pl = new AtomicInteger(0);
+            RollingSequence rps = new RollingSequence(5);
+            ChronoLatch cl = new ChronoLatch(3000);
+            File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
+            Supplier<Long> eta = () -> (long) ((McaFiles.length - pr.get()) / rps.getAverage()) * 1000;
+            ScheduledFuture<?> sc = Executors.newSingleThreadScheduledExecutor().scheduleAtFixedRate(() -> {
+                int sp = pr.get() - pl.get();
+                pl.set(pr.get());
+                rps.put(sp);
+                if (cl.flip()) {
+                    double pc = ((double) pr.get() / (double) McaFiles.length) * 100;
+                    Iris.info("Indexing: " + Form.f(pr.get()) + " of " + Form.f(McaFiles.length) + " (%.0f%%) " + Form.f((int) rps.getAverage()) + "/s  ETA: " + Form.duration(eta.get(), 2), pc);
+                }
+            }, 3,1, TimeUnit.SECONDS);
+            BurstExecutor b = MultiBurst.burst.burst(McaFiles.length);
+            for (File mca : McaFiles) {
+                b.queue(() -> {
+                    try {
+                        MCAFile region = MCAUtil.read(mca, 0);
+                        var array = region.getChunks();
+                        for (int i = 0; i < array.length(); i++) {
+                            if (array.get(i) != null) {
+                                chunks.incrementAndGet();
+                            }
+                        }
+                        pr.incrementAndGet();
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                });
+            }
+            b.complete();
+            sc.cancel(true);
+            totalChunks.set(chunks.get());
+            Iris.info("Indexing completed!");
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+}

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

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

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

@@ -0,0 +1,73 @@
+package com.volmit.iris.core.tools;
+
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.math.Position2;
+import com.volmit.iris.util.math.Spiraler;
+import org.bukkit.Chunk;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+
+public class IrisWorldMerger {
+    private Engine engine;
+    private World world;
+    private World selectedWorld;
+
+    /**
+     * @param world  > The selected world to get the caves from
+     * @param engine > The engine of the iris world
+     */
+    public IrisWorldMerger(Engine engine, World world) {
+        this.engine = engine;
+        this.world = this.engine.getWorld().realWorld();
+        this.selectedWorld = world;
+    }
+
+    /**
+     * Merges caves from a selected chunk into the corresponding chunk in the outcome world.
+     *
+     * @param selectedChunk The chunk from the selected world.
+     * @param targetChunk   The corresponding chunk in the outcome world.
+     */
+    private void mergeCavesInChunk(Chunk selectedChunk, Chunk targetChunk) {
+        int baseX = selectedChunk.getX() << 4;
+        int baseZ = selectedChunk.getZ() << 4;
+
+        for (int x = 0; x < 16; x++) {
+            int worldX = baseX + x;
+            for (int z = 0; z < 16; z++) {
+                int worldZ = baseZ + z;
+                int surfaceY = engine.getHeight(worldX, worldZ);
+                for (int y = 0; y <= surfaceY; y++) {
+                    Block selectedBlock = selectedChunk.getBlock(x, y, z);
+                    if (selectedBlock.getType() == Material.AIR) {
+                        Block targetBlock = targetChunk.getBlock(x, y, z);
+                        targetBlock.setType(Material.AIR);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * Irritates (merges) caves in a spiral pattern around the specified center chunk coordinates.
+     *
+     * @param centerX The X coordinate of the center chunk.
+     * @param centerZ The Z coordinate of the center chunk.
+     * @param radius  The radius (in chunks) to merge caves around.
+     */
+    public void irritateSpiral(int centerX, int centerZ, int radius) {
+        Spiraler spiraler = new Spiraler(radius * 2, radius * 2, (x, z) -> {
+            int chunkX = centerX + x;
+            int chunkZ = centerZ + z;
+            Chunk selectedChunk = selectedWorld.getChunkAt(chunkX, chunkZ);
+            Chunk targetChunk = world.getChunkAt(chunkX, chunkZ);
+            mergeCavesInChunk(selectedChunk, targetChunk);
+        });
+
+        // Execute the spiral iteration
+        while (spiraler.hasNext()) {
+            spiraler.next(); // The spiraler itself runs the callback defined in its constructor
+        }
+    }
+}

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

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

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

@@ -29,7 +29,6 @@ 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.util.data.DataProvider;
-import com.volmit.iris.util.interpolation.IrisInterpolation.NoiseKey;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.noise.CNG;
@@ -293,11 +292,9 @@ public class IrisComplex implements DataProvider {
             return 0;
         }
 
-        KMap<NoiseKey, IrisBiome> cache = new KMap<>();
         double hi = interpolator.interpolate(x, z, (xx, zz) -> {
             try {
                 IrisBiome bx = baseBiomeStream.get(xx, zz);
-                cache.put(new NoiseKey(xx, zz), bx);
                 double b = 0;
 
                 for (IrisGenerator gen : generators) {
@@ -316,11 +313,7 @@ public class IrisComplex implements DataProvider {
 
         double lo = interpolator.interpolate(x, z, (xx, zz) -> {
             try {
-                IrisBiome bx = cache.get(new NoiseKey(xx, zz));
-                if (bx == null) {
-                    bx = baseBiomeStream.get(xx, zz);
-                    cache.put(new NoiseKey(xx, zz), bx);
-                }
+                IrisBiome bx = baseBiomeStream.get(xx, zz);
                 double b = 0;
 
                 for (IrisGenerator gen : generators) {

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

@@ -24,7 +24,8 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.ServerConfigurator;
 import com.volmit.iris.core.events.IrisEngineHotloadEvent;
 import com.volmit.iris.core.gui.PregeneratorJob;
-import com.volmit.iris.core.loader.ResourceLoader;
+import com.volmit.iris.core.nms.IMemoryWorld;
+import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.core.project.IrisProject;
@@ -43,7 +44,6 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.io.JarScanner;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.M;
 import com.volmit.iris.util.math.RNG;
@@ -54,20 +54,21 @@ import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import lombok.ToString;
+import org.apache.commons.lang3.function.Failable;
 import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.WorldCreator;
 import org.bukkit.block.Biome;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.command.CommandSender;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
 
 import java.io.File;
 import java.io.IOException;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.util.Collections;
 import java.util.HashSet;
-import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -76,8 +77,6 @@ import java.util.concurrent.atomic.AtomicLong;
 @EqualsAndHashCode(exclude = "context")
 @ToString(exclude = "context")
 public class IrisEngine implements Engine {
-    private static final Map<Class<? extends IrisEngineService>, Constructor<? extends IrisEngineService>> SERVICES = scanServices();
-    private final KMap<Class<? extends IrisEngineService>, IrisEngineService> services;
     private final AtomicInteger bud;
     private final AtomicInteger buds;
     private final AtomicInteger generated;
@@ -97,11 +96,12 @@ public class IrisEngine implements Engine {
     private final AtomicBoolean cleaning;
     private final ChronoLatch cleanLatch;
     private final SeedManager seedManager;
-    private CompletableFuture<Long> hash32;
     private EngineMode mode;
     private EngineEffects effects;
     private EngineExecutionEnvironment execution;
     private EngineWorldManager worldManager;
+    private IMemoryWorld memoryWorld;
+    private IrisMerger merger;
     private volatile int parallelism;
     private volatile int minHeight;
     private boolean failing;
@@ -118,7 +118,6 @@ public class IrisEngine implements Engine {
         getEngineData();
         verifySeed();
         this.seedManager = new SeedManager(target.getWorld().getRawWorldSeed());
-        services = new KMap<>();
         bud = new AtomicInteger(0);
         buds = new AtomicInteger(0);
         metrics = new EngineMetrics(32);
@@ -134,6 +133,9 @@ public class IrisEngine implements Engine {
         context = new IrisContext(this);
         cleaning = new AtomicBoolean(false);
         context.touch();
+        merger = getDimension().getMerger();
+        merger.loadWorld(this);
+        updateMemoryWorld();
         getData().setEngine(this);
         getData().loadPrefetch(this);
         Iris.info("Initializing Engine: " + target.getWorld().name() + "/" + target.getDimension().getLoadKey() + " (" + target.getDimension().getDimensionHeight() + " height) Seed: " + getSeedManager().getSeed());
@@ -145,26 +147,6 @@ public class IrisEngine implements Engine {
         Iris.debug("Engine Initialized " + getCacheID());
     }
 
-    @SuppressWarnings("unchecked")
-    private static Map<Class<? extends IrisEngineService>, Constructor<? extends IrisEngineService>> scanServices() {
-        JarScanner js = new JarScanner(Iris.instance.getJarFile(), "com.volmit.iris.engine.service");
-        J.attempt(js::scan);
-        KMap<Class<? extends IrisEngineService>, Constructor<? extends IrisEngineService>> map = new KMap<>();
-        js.getClasses()
-                .stream()
-                .filter(IrisEngineService.class::isAssignableFrom)
-                .map(c -> (Class<? extends IrisEngineService>) c)
-                .forEach(c -> {
-                    try {
-                        map.put(c, c.getConstructor(Engine.class));
-                    } catch (NoSuchMethodException e) {
-                        Iris.warn("Failed to load service " + c.getName() + " due to missing constructor");
-                    }
-                });
-
-        return Collections.unmodifiableMap(map);
-    }
-
     private void verifySeed() {
         if (getEngineData().getSeed() != null && getEngineData().getSeed() != target.getWorld().getRawWorldSeed()) {
             target.getWorld().setRawWorldSeed(getEngineData().getSeed());
@@ -189,8 +171,6 @@ public class IrisEngine implements Engine {
         execution.close();
         effects.close();
         mode.close();
-        services.values().forEach(s -> s.onDisable(true));
-        services.values().forEach(Iris.instance::unregisterListener);
 
         J.a(() -> new IrisProject(getData().getDataFolder()).updateWorkspace());
     }
@@ -199,39 +179,12 @@ public class IrisEngine implements Engine {
         try {
             Iris.debug("Setup Engine " + getCacheID());
             cacheId = RNG.r.nextInt();
-            boolean hotload = true;
-            if (services.isEmpty()) {
-                SERVICES.forEach((s, c) -> {
-                    try {
-                        services.put(s, c.newInstance(this));
-                    } catch (InstantiationException | IllegalAccessException |
-                             InvocationTargetException e) {
-                        Iris.error("Failed to create service " + s.getName());
-                        e.printStackTrace();
-                    }
-                });
-                hotload = false;
-            }
-            for (var service : services.values()) {
-                service.onEnable(hotload);
-                Iris.instance.registerListener(service);
-            }
-
             worldManager = new IrisWorldManager(this);
             complex = new IrisComplex(this);
             execution = new IrisExecutionEnvironment(this);
             effects = new IrisEngineEffects(this);
-            hash32 = new CompletableFuture<>();
             setupMode();
             J.a(this::computeBiomeMaxes);
-            J.a(() -> {
-                File[] roots = getData().getLoaders()
-                        .values()
-                        .stream()
-                        .map(ResourceLoader::getRoot)
-                        .toArray(File[]::new);
-                hash32.complete(IO.hashRecursive(roots));
-            });
         } catch (Throwable e) {
             Iris.error("FAILED TO SETUP ENGINE!");
             e.printStackTrace();
@@ -248,6 +201,34 @@ public class IrisEngine implements Engine {
         mode = getDimension().getMode().getType().create(this);
     }
 
+    private void updateMemoryWorld() {
+        try {
+            if(!merger.isUseMemoryWorld() || merger.getGenerator().isEmpty())
+                return;
+            merger = getDimension().getMerger();
+            if (!getDimension().isEnableExperimentalMerger()) return;
+            if (getMerger().getGenerator().isBlank()) return;
+            NamespacedKey dk = NamespacedKey.minecraft("memory_current_creator");
+            PersistentDataContainer per;
+            if (memoryWorld != null) {
+                per = memoryWorld.getBukkit().getPersistentDataContainer();
+                if (Objects.equals(per.get(dk, PersistentDataType.STRING), getMerger().getGenerator()))
+                    return;
+                if (memoryWorld != null)
+                    memoryWorld.close();
+            }
+            memoryWorld = getMerger().isDatapackMode() ? Failable.get(() ->
+                    getMerger().getGenerator() == null ?
+                            INMS.get().createMemoryWorld(new WorldCreator("memoryworld").seed(getSeedManager().getSeed())) :
+                            INMS.get().createMemoryWorld(NamespacedKey.minecraft(getMerger().getGenerator()), new WorldCreator("memoryworld").seed(getSeedManager().getSeed()))
+            ) : null; // todo: experimental
+            per = memoryWorld.getBukkit().getPersistentDataContainer();
+            per.set(dk, PersistentDataType.STRING, getMerger().getGenerator());
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
     @Override
     public void generateMatter(int x, int z, boolean multicore, ChunkContext context) {
         getMantle().generateMatter(x, z, multicore, context);
@@ -297,6 +278,7 @@ public class IrisEngine implements Engine {
         getData().clearLists();
         getTarget().setDimension(getData().getDimensionLoader().load(getDimension().getLoadKey()));
         prehotload();
+        updateMemoryWorld();
         setupEngine();
         J.a(() -> {
             synchronized (ServerConfigurator.class) {
@@ -466,7 +448,6 @@ public class IrisEngine implements Engine {
         PregeneratorJob.shutdownInstance();
         closed = true;
         J.car(art);
-        services.values().forEach(s -> s.onDisable(false));
         getWorldManager().close();
         getTarget().close();
         saveEngineData();

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

@@ -18,7 +18,7 @@
 
 package com.volmit.iris.engine;
 
-import com.volmit.iris.core.nms.container.Pair;
+import com.volmit.iris.Iris;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.mantle.EngineMantle;
@@ -27,13 +27,23 @@ import com.volmit.iris.engine.mantle.components.MantleCarvingComponent;
 import com.volmit.iris.engine.mantle.components.MantleFluidBodyComponent;
 import com.volmit.iris.engine.mantle.components.MantleJigsawComponent;
 import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
+import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.collection.KSet;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.mantle.Mantle;
-import lombok.*;
+import com.volmit.iris.util.parallel.BurstExecutor;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.bukkit.util.BlockVector;
 
 import java.io.File;
-import java.util.stream.Collectors;
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
 
 @Data
 @EqualsAndHashCode(exclude = "engine")
@@ -41,9 +51,8 @@ import java.util.stream.Collectors;
 public class IrisEngineMantle implements EngineMantle {
     private final Engine engine;
     private final Mantle mantle;
-    @Getter(AccessLevel.NONE)
-    private final KMap<Integer, KList<MantleComponent>> components;
-    private final AtomicCache<KList<Pair<KList<MantleComponent>, Integer>>> componentsCache = new AtomicCache<>();
+    private final KList<MantleComponent> components;
+    private final int radius;
     private final AtomicCache<Integer> radCache = new AtomicCache<>();
     private final MantleObjectComponent object;
     private final MantleJigsawComponent jigsaw;
@@ -51,7 +60,8 @@ public class IrisEngineMantle implements EngineMantle {
     public IrisEngineMantle(Engine engine) {
         this.engine = engine;
         this.mantle = new Mantle(new File(engine.getWorld().worldFolder(), "mantle"), engine.getTarget().getHeight());
-        components = new KMap<>();
+        radius = radCache.aquire(this::computeParallaxSize);
+        components = new KList<>();
         registerComponent(new MantleCarvingComponent(this));
         registerComponent(new MantleFluidBodyComponent(this));
         jigsaw = new MantleJigsawComponent(this);
@@ -60,49 +70,9 @@ public class IrisEngineMantle implements EngineMantle {
         registerComponent(object);
     }
 
-    @Override
-    public int getRadius() {
-        if (components.isEmpty()) return 0;
-        return getComponents().getFirst().getB();
-    }
-
-    @Override
-    public int getRealRadius() {
-        if (components.isEmpty()) return 0;
-        return getComponents().getLast().getB();
-    }
-
-    @Override
-    public KList<Pair<KList<MantleComponent>, Integer>> getComponents() {
-        return componentsCache.aquire(() -> {
-            var list = components.keySet()
-                    .stream()
-                    .sorted()
-                    .map(components::get)
-                    .map(components -> {
-                        int radius = components.stream()
-                                .mapToInt(MantleComponent::getRadius)
-                                .max()
-                                .orElse(0);
-                        return new Pair<>(components, radius);
-                    })
-                    .collect(Collectors.toCollection(KList::new));
-
-
-            int radius = 0;
-            for (var pair : list.reversed()) {
-                radius += pair.getB();
-                pair.setB(Math.ceilDiv(radius, 16));
-            }
-
-            return list;
-        });
-    }
-
     @Override
     public void registerComponent(MantleComponent c) {
-        components.computeIfAbsent(c.getPriority(), k -> new KList<>()).add(c);
-        componentsCache.reset();
+        components.add(c);
     }
 
     @Override
@@ -114,4 +84,243 @@ public class IrisEngineMantle implements EngineMantle {
     public MantleObjectComponent getObjectComponent() {
         return object;
     }
+
+    private KList<IrisRegion> getAllRegions() {
+        KList<IrisRegion> r = new KList<>();
+
+        for (String i : getEngine().getDimension().getRegions()) {
+            r.add(getEngine().getData().getRegionLoader().load(i));
+        }
+
+        return r;
+    }
+
+    private KList<IrisBiome> getAllBiomes() {
+        KList<IrisBiome> r = new KList<>();
+
+        for (IrisRegion i : getAllRegions()) {
+            r.addAll(i.getAllBiomes(getEngine()));
+        }
+
+        return r;
+    }
+
+    private void warn(String ob, BlockVector bv) {
+        if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
+            Iris.warn("Object " + ob + " has a large size (" + bv + ") and may increase memory usage!");
+        }
+    }
+
+    private void warnScaled(String ob, BlockVector bv, double ms) {
+        if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
+            Iris.warn("Object " + ob + " has a large size (" + bv + ") and may increase memory usage! (Object scaled up to " + Form.pc(ms, 2) + ")");
+        }
+    }
+
+    private int computeParallaxSize() {
+        Iris.verbose("Calculating the Parallax Size in Parallel");
+        AtomicInteger xg = new AtomicInteger(0);
+        AtomicInteger zg = new AtomicInteger();
+        xg.set(0);
+        zg.set(0);
+        int jig = 0;
+        KSet<String> objects = new KSet<>();
+        KMap<IrisObjectScale, KList<String>> scalars = new KMap<>();
+        int x = xg.get();
+        int z = zg.get();
+
+        if (getEngine().getDimension().isUseMantle()) {
+            KList<IrisRegion> r = getAllRegions();
+            KList<IrisBiome> b = getAllBiomes();
+
+            for (IrisBiome i : b) {
+                for (IrisObjectPlacement j : i.getObjects()) {
+                    if (j.getScale().canScaleBeyond()) {
+                        scalars.put(j.getScale(), j.getPlace());
+                    } else {
+                        objects.addAll(j.getPlace());
+                    }
+                }
+
+                for (IrisJigsawStructurePlacement j : i.getJigsawStructures()) {
+                    jig = Math.max(jig, getData().getJigsawStructureLoader().load(j.getStructure()).getMaxDimension());
+                }
+            }
+
+            for (IrisRegion i : r) {
+                for (IrisObjectPlacement j : i.getObjects()) {
+                    if (j.getScale().canScaleBeyond()) {
+                        scalars.put(j.getScale(), j.getPlace());
+                    } else {
+                        objects.addAll(j.getPlace());
+                    }
+                }
+
+                for (IrisJigsawStructurePlacement j : i.getJigsawStructures()) {
+                    jig = Math.max(jig, getData().getJigsawStructureLoader().load(j.getStructure()).getMaxDimension());
+                }
+            }
+
+            for (IrisJigsawStructurePlacement j : getEngine().getDimension().getJigsawStructures()) {
+                jig = Math.max(jig, getData().getJigsawStructureLoader().load(j.getStructure()).getMaxDimension());
+            }
+
+            if (getEngine().getDimension().getStronghold() != null) {
+                try {
+                    jig = Math.max(jig, getData().getJigsawStructureLoader().load(getEngine().getDimension().getStronghold()).getMaxDimension());
+                } catch (Throwable e) {
+                    Iris.reportError(e);
+                    e.printStackTrace();
+                }
+            }
+
+            Iris.verbose("Checking sizes for " + Form.f(objects.size()) + " referenced objects.");
+            BurstExecutor e = getEngine().getTarget().getBurster().burst(objects.size());
+            KMap<String, BlockVector> sizeCache = new KMap<>();
+            for (String i : objects) {
+                e.queue(() -> {
+                    try {
+                        BlockVector bv = sizeCache.computeIfAbsent(i, (k) -> {
+                            try {
+                                return IrisObject.sampleSize(getData().getObjectLoader().findFile(i));
+                            } catch (IOException ex) {
+                                Iris.reportError(ex);
+                                ex.printStackTrace();
+                            }
+
+                            return null;
+                        });
+
+                        if (bv == null) {
+                            throw new RuntimeException();
+                        }
+
+                        warn(i, bv);
+
+                        synchronized (xg) {
+                            xg.getAndSet(Math.max(bv.getBlockX(), xg.get()));
+                        }
+
+                        synchronized (zg) {
+                            zg.getAndSet(Math.max(bv.getBlockZ(), zg.get()));
+                        }
+                    } catch (Throwable ed) {
+                        Iris.reportError(ed);
+
+                    }
+                });
+            }
+
+            for (Map.Entry<IrisObjectScale, KList<String>> entry : scalars.entrySet()) {
+                double ms = entry.getKey().getMaximumScale();
+                for (String j : entry.getValue()) {
+                    e.queue(() -> {
+                        try {
+                            BlockVector bv = sizeCache.computeIfAbsent(j, (k) -> {
+                                try {
+                                    return IrisObject.sampleSize(getData().getObjectLoader().findFile(j));
+                                } catch (IOException ioException) {
+                                    Iris.reportError(ioException);
+                                    ioException.printStackTrace();
+                                }
+
+                                return null;
+                            });
+
+                            if (bv == null) {
+                                throw new RuntimeException();
+                            }
+
+                            warnScaled(j, bv, ms);
+
+                            synchronized (xg) {
+                                xg.getAndSet((int) Math.max(Math.ceil(bv.getBlockX() * ms), xg.get()));
+                            }
+
+                            synchronized (zg) {
+                                zg.getAndSet((int) Math.max(Math.ceil(bv.getBlockZ() * ms), zg.get()));
+                            }
+                        } catch (Throwable ee) {
+                            Iris.reportError(ee);
+
+                        }
+                    });
+                }
+            }
+
+            e.complete();
+
+            x = xg.get();
+            z = zg.get();
+
+            for (IrisDepositGenerator i : getEngine().getDimension().getDeposits()) {
+                int max = i.getMaxDimension();
+                x = Math.max(max, x);
+                z = Math.max(max, z);
+            }
+
+            for (IrisRegion v : r) {
+                for (IrisDepositGenerator i : v.getDeposits()) {
+                    int max = i.getMaxDimension();
+                    x = Math.max(max, x);
+                    z = Math.max(max, z);
+                }
+            }
+
+            for (IrisBiome v : b) {
+                for (IrisDepositGenerator i : v.getDeposits()) {
+                    int max = i.getMaxDimension();
+                    x = Math.max(max, x);
+                    z = Math.max(max, z);
+                }
+            }
+        } else {
+            return 0;
+        }
+
+        x = Math.max(z, x);
+        int u = x;
+        int c = Math.max(computeCarvingRange(), computeBodyRange());
+        x = Math.max(jig, x);
+        x = Math.max(x, c);
+        x = (Math.max(x, 16) + 16) >> 4;
+        x = x % 2 == 0 ? x + 1 : x;
+        Iris.info("Mantle Size: " + x + " Chunks");
+        Iris.info("  Object Mantle Size: " + u + " (" + ((Math.max(u, 16) + 16) >> 4) + ")");
+        Iris.info("  Jigsaw Mantle Size: " + jig + " (" + ((Math.max(jig, 16) + 16) >> 4) + ")");
+        Iris.info("  Carving Mantle Size: " + c + " (" + ((Math.max(c, 16) + 16) >> 4) + ")");
+        return x;
+    }
+
+    private int computeBodyRange() {
+        int m = 0;
+
+        m = Math.max(m, getDimension().getFluidBodies().getMaxRange(getData()));
+
+        for (IrisRegion i : getDimension().getAllRegions(getEngine())) {
+            m = Math.max(m, i.getFluidBodies().getMaxRange(getData()));
+        }
+
+        for (IrisBiome i : getDimension().getAllBiomes(getEngine())) {
+            m = Math.max(m, i.getFluidBodies().getMaxRange(getData()));
+        }
+
+        return m;
+    }
+
+    private int computeCarvingRange() {
+        int m = 0;
+
+        m = Math.max(m, getDimension().getCarving().getMaxRange(getData()));
+
+        for (IrisRegion i : getDimension().getAllRegions(getEngine())) {
+            m = Math.max(m, i.getCarving().getMaxRange(getData()));
+        }
+
+        for (IrisBiome i : getDimension().getAllBiomes(getEngine())) {
+            m = Math.max(m, i.getCarving().getMaxRange(getData()));
+        }
+
+        return m;
+    }
 }

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

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

core/src/main/java/com/volmit/iris/engine/actuator/IrisTerrainNormalActuator.java

@@ -18,6 +18,7 @@
 
 package com.volmit.iris.engine.actuator;
 
+import com.volmit.iris.core.nms.IMemoryWorld;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineAssignedActuator;
 import com.volmit.iris.engine.object.IrisBiome;
@@ -29,15 +30,18 @@ import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.scheduling.PrecisionStopwatch;
 import lombok.Getter;
-import org.bukkit.Material;
+import org.bukkit.*;
 import org.bukkit.block.data.BlockData;
 
 public class IrisTerrainNormalActuator extends EngineAssignedActuator<BlockData> {
     private static final BlockData AIR = Material.AIR.createBlockData();
     private static final BlockData BEDROCK = Material.BEDROCK.createBlockData();
+    private static final BlockData DEEPSLATE = Material.DEEPSLATE.createBlockData();
     private static final BlockData LAVA = Material.LAVA.createBlockData();
     private static final BlockData GLASS = Material.GLASS.createBlockData();
     private static final BlockData CAVE_AIR = Material.CAVE_AIR.createBlockData();
+    private static final BlockData FILLER = Material.STONE.createBlockData();
+    private IMemoryWorld memoryWorld;
     @Getter
     private final RNG rng;
     @Getter
@@ -51,15 +55,21 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<BlockData>
     @BlockCoordinates
     @Override
     public void onActuate(int x, int z, Hunk<BlockData> h, boolean multicore, ChunkContext context) {
-        PrecisionStopwatch p = PrecisionStopwatch.start();
+        try {
+            PrecisionStopwatch p = PrecisionStopwatch.start();
 
-        for (int xf = 0; xf < h.getWidth(); xf++) {
-            terrainSliver(x, z, xf, h, context);
+            for (int xf = 0; xf < h.getWidth(); xf++) {
+                terrainSliver(x, z, xf, h, context);
+            }
+
+            getEngine().getMetrics().getTerrain().put(p.getMilliseconds());
+        } catch (Exception e) {
+            e.printStackTrace();
+            //Iris.error("Fatal Error!", e);
         }
-
-        getEngine().getMetrics().getTerrain().put(p.getMilliseconds());
     }
 
+
     private int fluidOrHeight(int height) {
         return Math.max(getDimension().getFluidHeight(), height);
     }
@@ -138,6 +148,11 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<BlockData>
                         continue;
                     }
 
+                    if (getDimension().isEnableExperimentalMerger()) {
+                        h.set(xf, i, zf, FILLER);
+                        continue;
+                    }
+
                     BlockData ore = biome.generateOres(realX, i, realZ, rng, getData());
                     ore = ore == null ? region.generateOres(realX, i, realZ, rng, getData()) : ore;
                     ore = ore == null ? getDimension().generateOres(realX, i, realZ, rng, getData()) : ore;
@@ -145,7 +160,11 @@ public class IrisTerrainNormalActuator extends EngineAssignedActuator<BlockData>
                     if (ore != null) {
                         h.set(xf, i, zf, ore);
                     } else {
-                        h.set(xf, i, zf, context.getRock().get(xf, zf));
+                        if (getDimension().isDeepslateLayer() && i < 64) {
+                            h.set(xf, i, zf, DEEPSLATE);
+                        } else {
+                            h.set(xf, i, zf, context.getRock().get(xf, zf));
+                        }
                     }
                 }
             }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -20,12 +20,12 @@ package com.volmit.iris.engine.framework;
 
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.events.IrisLootEvent;
 import com.volmit.iris.core.gui.components.RenderType;
 import com.volmit.iris.core.gui.components.Renderer;
 import com.volmit.iris.core.link.Identifier;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
+import com.volmit.iris.core.nms.IMemoryWorld;
 import com.volmit.iris.core.nms.container.BlockPos;
 import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.core.pregenerator.ChunkUpdater;
@@ -42,7 +42,7 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.data.DataProvider;
-import com.volmit.iris.util.data.IrisCustomData;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.format.C;
@@ -76,11 +76,11 @@ import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.InventoryHolder;
 import org.bukkit.inventory.ItemStack;
 
+import java.awt.*;
 import java.awt.Color;
 import java.util.Arrays;
 import java.util.Set;
 import java.util.UUID;
-import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.Semaphore;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -112,6 +112,10 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
 
     EngineExecutionEnvironment getExecution();
 
+    IMemoryWorld getMemoryWorld();
+
+    IrisMerger getMerger();
+
     double getMaxBiomeObjectDensity();
 
     double getMaxBiomeDecoratorDensity();
@@ -259,8 +263,10 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         if (B.isUpdatable(data)) {
             getMantle().updateBlock(x, y, z);
         }
-        if (data instanceof IrisCustomData) {
-            getMantle().getMantle().flag(x >> 4, z >> 4, MantleFlag.CUSTOM, true);
+        if (data instanceof IrisBlockData d) {
+            getMantle().getMantle().set(x, y, z, d.getCustom());
+        } else {
+            getMantle().getMantle().remove(x, y, z, Identifier.class);
         }
     }
 
@@ -467,10 +473,7 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
     }
 
     @Override
-    default void injectTables(KList<IrisLootTable> list, IrisLootReference r, boolean fallback) {
-        if (r.getMode().equals(IrisLootMode.FALLBACK) && !fallback)
-            return;
-
+    default void injectTables(KList<IrisLootTable> list, IrisLootReference r) {
         if (r.getMode().equals(IrisLootMode.CLEAR) || r.getMode().equals(IrisLootMode.REPLACE)) {
             list.clear();
         }
@@ -505,11 +508,10 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
         IrisBiome biomeUnder = ry < he ? getComplex().getCaveBiomeStream().get(rx, rz) : biomeSurface;
 
         double multiplier = 1D * getDimension().getLoot().getMultiplier() * region.getLoot().getMultiplier() * biomeSurface.getLoot().getMultiplier() * biomeUnder.getLoot().getMultiplier();
-        boolean fallback = tables.isEmpty();
-        injectTables(tables, getDimension().getLoot(), fallback);
-        injectTables(tables, region.getLoot(), fallback);
-        injectTables(tables, biomeSurface.getLoot(), fallback);
-        injectTables(tables, biomeUnder.getLoot(), fallback);
+        injectTables(tables, getDimension().getLoot());
+        injectTables(tables, region.getLoot());
+        injectTables(tables, biomeSurface.getLoot());
+        injectTables(tables, biomeUnder.getLoot());
 
         if (tables.isNotEmpty()) {
             int target = (int) Math.round(tables.size() * multiplier);
@@ -530,15 +532,15 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
     default void addItems(boolean debug, Inventory inv, RNG rng, KList<IrisLootTable> tables, InventorySlotType slot, World world, int x, int y, int z, int mgf) {
         KList<ItemStack> items = new KList<>();
 
+        int b = 4;
         for (IrisLootTable i : tables) {
             if (i == null)
                 continue;
+            b++;
             items.addAll(i.getLoot(debug, rng, slot, world, x, y, z));
         }
-        if (IrisLootEvent.callLootEvent(items, inv, world, x, y, z))
-            return;
 
-        if (PaperLib.isPaper() && getWorld().hasRealWorld()) {
+        if (PaperLib.isPaper() && getWorld().hasRealWorld()) { 
             PaperLib.getChunkAtAsync(getWorld().realWorld(), x >> 4, z >> 4).thenAccept((c) -> {
                 Runnable r = () -> {
                     for (ItemStack i : items) {
@@ -610,8 +612,6 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
 
     int getGenerated();
 
-    CompletableFuture<Long> getHash32();
-
     default <T> IrisPosition lookForStreamResult(T find, ProceduralStream<T> stream, Function2<T, T, Boolean> matcher, long timeout) {
         AtomicInteger checked = new AtomicInteger();
         AtomicLong time = new AtomicLong(M.ms());

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

@@ -1,13 +1,14 @@
-package com.volmit.iris.core.events;
+package com.volmit.iris.engine.framework;
 
-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 com.volmit.iris.util.math.RNG;
 import lombok.Getter;
-import org.bukkit.*;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.event.Event;
 import org.bukkit.event.HandlerList;
@@ -18,38 +19,28 @@ 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 org.bukkit.loot.LootTables;
 
+import javax.annotation.Nullable;
+import java.util.ArrayList;
 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;
+    private final Mode mode; // New field to represent the mode
+
+    // Define the different modes for the event
+    public enum Mode {
+        NORMAL,
+        BUKKIT_LOOT
+    }
 
     /**
      * Constructor for IrisLootEvent with mode selection.
@@ -64,6 +55,42 @@ public class IrisLootEvent extends Event {
         this.block = block;
         this.slot = slot;
         this.tables = tables;
+        this.mode = Mode.BUKKIT_LOOT;
+
+        if (this.mode == Mode.BUKKIT_LOOT) {
+            triggerBukkitLootEvent();
+        }
+    }
+
+    /**
+     * 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.
+     */
+    private Inventory triggerBukkitLootEvent() {
+        if (block.getState() instanceof InventoryHolder holder) {
+            Inventory inventory = holder.getInventory();
+            inventory.clear();
+
+            List<ItemStack> loot = new ArrayList<>();
+            RNG rng = new RNG();
+            int x = block.getX(), y = block.getY(), z = block.getZ();
+
+            for (IrisLootTable table : tables)
+                loot.addAll(table.getLoot(false, rng, slot, block.getWorld(), x, y, z));
+
+            LootContext context = new LootContext.Builder(block.getLocation()).build();
+
+            LootTable lootTable = LootTables.EMPTY.getLootTable(); // todo: Correct structure
+
+            LootGenerateEvent bukkitEvent = new LootGenerateEvent(engine.getWorld().realWorld(), null, holder, lootTable, context, loot, true); // todo: Use the iris loottable
+            Bukkit.getServer().getPluginManager().callEvent(bukkitEvent);
+
+            if (!bukkitEvent.isCancelled())
+                inventory.setContents(bukkitEvent.getLoot().toArray(new ItemStack[0]));
+            return inventory;
+        }
+        return null;
     }
 
     @Override
@@ -79,35 +106,4 @@ public class IrisLootEvent extends Event {
     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/engine/framework/ListFunction.java

@@ -1,10 +1,8 @@
 package com.volmit.iris.engine.framework;
 
-import com.volmit.iris.core.loader.IrisData;
-
 import java.util.function.Function;
 
-public interface ListFunction<R> extends Function<IrisData, R> {
+public interface ListFunction<T, R> extends Function<T, R> {
     String key();
     String fancyName();
 }

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

@@ -30,7 +30,7 @@ import org.bukkit.inventory.Inventory;
 public interface LootProvider {
     void scramble(Inventory inventory, RNG rng);
 
-    void injectTables(KList<IrisLootTable> list, IrisLootReference r, boolean fallback);
+    void injectTables(KList<IrisLootTable> list, IrisLootReference r);
 
     KList<IrisLootTable> getLootTables(RNG rng, Block b);
 

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

@@ -5,7 +5,7 @@ import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.tools.IrisToolbelt;
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.core.events.IrisLootEvent;
+import com.volmit.iris.engine.framework.IrisLootEvent;
 import com.volmit.iris.engine.mantle.EngineMantle;
 import com.volmit.iris.engine.object.IObjectPlacer;
 import com.volmit.iris.engine.object.InventorySlotType;
@@ -13,7 +13,6 @@ import com.volmit.iris.engine.object.IrisLootTable;
 import com.volmit.iris.engine.object.TileData;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.math.RNG;
 import lombok.EqualsAndHashCode;
 import lombok.Getter;
@@ -21,7 +20,10 @@ import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.World;
 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.Inventory;
 import org.bukkit.inventory.InventoryHolder;
 
 @Getter
@@ -63,6 +65,8 @@ public class WorldObjectPlacer implements IObjectPlacer {
             RNG rx = new RNG(Cache.key(x, z));
             KList<IrisLootTable> tables = engine.getLootTables(rx, block);
 
+            Inventory inventory = null;
+
             try {
                 Bukkit.getPluginManager().callEvent(new IrisLootEvent(engine, block, slot, tables));
 
@@ -79,11 +83,7 @@ public class WorldObjectPlacer implements IObjectPlacer {
             }
         }
 
-
-        if (d instanceof IrisCustomData data) {
-            block.setBlockData(data.getBase());
-            Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
-        } else block.setBlockData(d);
+        block.setBlockData(d);
     }
 
     @Override

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

@@ -25,10 +25,12 @@ import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.placer.WorldObjectPlacer;
 import com.volmit.iris.engine.object.*;
 import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.matter.slices.container.JigsawPieceContainer;
+import com.volmit.iris.util.matter.slices.container.JigsawStructureContainer;
 import com.volmit.iris.util.matter.slices.container.JigsawStructuresContainer;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Data;
@@ -60,7 +62,7 @@ public class PlannedStructure {
         this.structure = structure;
         this.position = position;
         this.rng = rng;
-        this.forcePlace = forcePlace || structure.isForcePlace();
+        this.forcePlace = forcePlace;
         this.data = structure.getLoader();
         generateStartPiece();
 
@@ -150,10 +152,15 @@ public class PlannedStructure {
 
         int id = rng.i(0, Integer.MAX_VALUE);
         JigsawPieceContainer container = JigsawPieceContainer.toContainer(i.getPiece());
+        JigsawStructureContainer structureContainer = JigsawStructureContainer.toContainer(structure);
         i.setRealPositions(xx, height, zz, placer);
         return v.place(xx, height, zz, placer, options, rng, (b, data) -> {
             e.set(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id);
             e.set(b.getX(), b.getY(), b.getZ(), container);
+            e.set(b.getX(), b.getY(), b.getZ(), structureContainer);
+            if (data instanceof IrisBlockData d) {
+                e.set(b.getX(), b.getY(), b.getZ(), d.getCustom());
+            }
         }, null, getData().getEngine() != null ? getData() : eng.getData()) != -1;
     }
 

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

@@ -20,10 +20,10 @@ package com.volmit.iris.engine.mantle;
 
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.container.Pair;
 import com.volmit.iris.engine.IrisComplex;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineTarget;
+import com.volmit.iris.engine.framework.SeedManager;
 import com.volmit.iris.engine.mantle.components.MantleJigsawComponent;
 import com.volmit.iris.engine.mantle.components.MantleObjectComponent;
 import com.volmit.iris.engine.object.IObjectPlacer;
@@ -34,7 +34,6 @@ import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.context.IrisContext;
 import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.hunk.Hunk;
@@ -45,6 +44,7 @@ import com.volmit.iris.util.matter.*;
 import com.volmit.iris.util.matter.slices.UpdateMatter;
 import com.volmit.iris.util.parallel.BurstExecutor;
 import com.volmit.iris.util.parallel.MultiBurst;
+import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 
 import java.util.concurrent.TimeUnit;
@@ -59,9 +59,7 @@ public interface EngineMantle extends IObjectPlacer {
 
     int getRadius();
 
-    int getRealRadius();
-
-    KList<Pair<KList<MantleComponent>, Integer>> getComponents();
+    KList<MantleComponent> getComponents();
 
     void registerComponent(MantleComponent c);
 
@@ -105,10 +103,7 @@ public interface EngineMantle extends IObjectPlacer {
 
     @Override
     default void set(int x, int y, int z, BlockData d) {
-        if (d instanceof IrisCustomData data) {
-            getMantle().set(x, y, z, data.getBase());
-            getMantle().set(x, y, z, data.getCustom());
-        } else getMantle().set(x, y, z, d == null ? AIR : d);
+        getMantle().set(x, y, z, d == null ? AIR : d);
     }
 
     @Override
@@ -192,37 +187,39 @@ public interface EngineMantle extends IObjectPlacer {
         return getEngine().burst();
     }
 
+    default int getRealRadius() {
+        return (int) Math.ceil(getRadius() / 2D);
+    }
+
+
     @ChunkCoordinates
     default void generateMatter(int x, int z, boolean multicore, ChunkContext context) {
-        if (!getEngine().getDimension().isUseMantle()) {
-            return;
-        }
-
-        try (MantleWriter writer = getMantle().write(this, x, z, getRadius() * 2)) {
-            var iterator = getComponents().iterator();
-            while (iterator.hasNext()) {
-                var pair = iterator.next();
-                int radius = pair.getB();
-                boolean last = !iterator.hasNext();
-                BurstExecutor burst = burst().burst(radius * 2 + 1);
-                burst.setMulticore(multicore);
-
-                for (int i = -radius; i <= radius; i++) {
-                    for (int j = -radius; j <= radius; j++) {
-                        int xx = x + i;
-                        int zz = z + j;
-                        MantleChunk mc = getMantle().getChunk(xx, zz);
-
-                        burst.queue(() -> {
-                            IrisContext.touch(getEngine().getContext());
-                            pair.getA().forEach(k -> generateMantleComponent(writer, xx, zz, k, mc, context));
-                            if (last) mc.flag(MantleFlag.PLANNED, true);
-                        });
-                    }
-                }
-
-                burst.complete();
+        synchronized (this) {
+            if (!getEngine().getDimension().isUseMantle()) {
+                return;
             }
+
+            int s = getRealRadius();
+            BurstExecutor burst = burst().burst(multicore);
+            MantleWriter writer = getMantle().write(this, x, z, s * 2);
+            for (int i = -s; i <= s; i++) {
+                for (int j = -s; j <= s; j++) {
+                    int xx = i + x;
+                    int zz = j + z;
+                    burst.queue(() -> {
+                        IrisContext.touch(getEngine().getContext());
+                        getMantle().raiseFlag(xx, zz, MantleFlag.PLANNED, () -> {
+                            MantleChunk mc = getMantle().getChunk(xx, zz);
+
+                            for (MantleComponent k : getComponents()) {
+                                generateMantleComponent(writer, xx, zz, k, mc, context);
+                            }
+                        });
+                    });
+                }
+            }
+
+            burst.complete();
         }
     }
 

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

@@ -29,5 +29,4 @@ import lombok.ToString;
 public abstract class IrisMantleComponent implements MantleComponent {
     private final EngineMantle engineMantle;
     private final MantleFlag flag;
-    private final int priority;
 }

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

@@ -26,12 +26,11 @@ import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.parallel.BurstExecutor;
-import org.jetbrains.annotations.NotNull;
 
-public interface MantleComponent extends Comparable<MantleComponent> {
-    int getPriority();
-
-    int getRadius();
+public interface MantleComponent {
+    default int getRadius() {
+        return getEngineMantle().getRealRadius();
+    }
 
     default IrisData getData() {
         return getEngineMantle().getData();
@@ -63,9 +62,4 @@ public interface MantleComponent extends Comparable<MantleComponent> {
 
     @ChunkCoordinates
     void generateLayer(MantleWriter writer, int x, int z, ChunkContext context);
-
-    @Override
-    default int compareTo(@NotNull MantleComponent o) {
-        return Integer.compare(getPriority(), o.getPriority());
-    }
 }

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

@@ -29,13 +29,13 @@ import com.volmit.iris.engine.object.IrisPosition;
 import com.volmit.iris.engine.object.TileData;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.IrisCustomData;
 import com.volmit.iris.util.function.Function3;
 import com.volmit.iris.util.mantle.Mantle;
 import com.volmit.iris.util.mantle.MantleChunk;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.matter.Matter;
 import lombok.Data;
+import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.util.Vector;
 
@@ -44,7 +44,7 @@ import java.util.List;
 import java.util.Set;
 
 @Data
-public class MantleWriter implements IObjectPlacer, AutoCloseable {
+public class MantleWriter implements IObjectPlacer {
     private final EngineMantle engineMantle;
     private final Mantle mantle;
     private final KMap<Long, MantleChunk> cachedChunks;
@@ -62,7 +62,7 @@ public class MantleWriter implements IObjectPlacer, AutoCloseable {
 
         for (int i = -radius; i <= radius; i++) {
             for (int j = -radius; j <= radius; j++) {
-                cachedChunks.put(Cache.key(i + x, j + z), mantle.getChunk(i + x, j + z).use());
+                cachedChunks.put(Cache.key(i + x, j + z), mantle.getChunk(i + x, j + z));
             }
         }
     }
@@ -167,10 +167,7 @@ public class MantleWriter implements IObjectPlacer, AutoCloseable {
 
     @Override
     public void set(int x, int y, int z, BlockData d) {
-        if (d instanceof IrisCustomData data) {
-            setData(x, y, z, data.getBase());
-            setData(x, y, z, data.getCustom());
-        } else setData(x, y, z, d);
+        setData(x, y, z, d);
     }
 
     @Override
@@ -636,12 +633,4 @@ public class MantleWriter implements IObjectPlacer, AutoCloseable {
         return cx >= this.x - radius && cx <= this.x + radius
                 && cz >= this.z - radius && cz <= this.z + radius;
     }
-
-    @Override
-    public void close() {
-        cachedChunks.values().removeIf(c -> {
-            c.release();
-            return true;
-        });
-    }
 }

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

@@ -29,14 +29,10 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.RNG;
-import lombok.Getter;
 
-@Getter
 public class MantleCarvingComponent extends IrisMantleComponent {
-    private final int radius = computeRadius();
-
     public MantleCarvingComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.CARVED, 0);
+        super(engineMantle, MantleFlag.CARVED);
     }
 
     @Override
@@ -60,21 +56,4 @@ public class MantleCarvingComponent extends IrisMantleComponent {
     private void carve(IrisCarving carving, MantleWriter writer, RNG rng, int cx, int cz) {
         carving.doCarving(writer, rng, getEngineMantle().getEngine(), cx << 4, -1, cz << 4);
     }
-
-    private int computeRadius() {
-        var dimension = getDimension();
-        int max = 0;
-
-        max = Math.max(max, dimension.getCarving().getMaxRange(getData()));
-
-        for (var i : dimension.getAllRegions(this::getData)) {
-            max = Math.max(max, i.getCarving().getMaxRange(getData()));
-        }
-
-        for (var i : dimension.getAllBiomes(this::getData)) {
-            max = Math.max(max, i.getCarving().getMaxRange(getData()));
-        }
-
-        return max;
-    }
 }

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

@@ -29,14 +29,10 @@ import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.RNG;
-import lombok.Getter;
 
-@Getter
 public class MantleFluidBodyComponent extends IrisMantleComponent {
-    private final int radius = computeRadius();
-
     public MantleFluidBodyComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.FLUID_BODIES, 0);
+        super(engineMantle, MantleFlag.FLUID_BODIES);
     }
 
     @Override
@@ -60,20 +56,4 @@ public class MantleFluidBodyComponent extends IrisMantleComponent {
     private void generate(IrisFluidBodies bodies, MantleWriter writer, RNG rng, int cx, int cz) {
         bodies.generate(writer, rng, getEngineMantle().getEngine(), cx << 4, -1, cz << 4);
     }
-
-    private int computeRadius() {
-        int max = 0;
-
-        max = Math.max(max, getDimension().getFluidBodies().getMaxRange(getData()));
-
-        for (IrisRegion i : getDimension().getAllRegions(this::getData)) {
-            max = Math.max(max, i.getFluidBodies().getMaxRange(getData()));
-        }
-
-        for (IrisBiome i : getDimension().getAllBiomes(this::getData)) {
-            max = Math.max(max, i.getFluidBodies().getMaxRange(getData()));
-        }
-
-        return max;
-    }
 }

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

@@ -34,18 +34,15 @@ import com.volmit.iris.util.math.Position2;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.matter.slices.container.JigsawStructuresContainer;
 import com.volmit.iris.util.noise.CNG;
-import lombok.Getter;
 import org.jetbrains.annotations.Nullable;
 
 import java.util.List;
 
 public class MantleJigsawComponent extends IrisMantleComponent {
-    @Getter
-    private final int radius = computeRadius();
     private final CNG cng;
 
     public MantleJigsawComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.JIGSAW, 1);
+        super(engineMantle, MantleFlag.JIGSAW);
         cng = NoiseStyle.STATIC.create(new RNG(jigsaw()));
     }
 
@@ -90,10 +87,8 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     private boolean placeStructures(MantleWriter writer, long seed, int x, int z, KList<IrisJigsawStructurePlacement> structures,
             KSet<Position2> cachedRegions, KMap<String, KSet<Position2>> cache, KMap<Position2, Double> distanceCache) {
         IrisJigsawStructurePlacement i = pick(structures, seed, x, z);
-        try {
-            if (i == null || checkMinDistances(i.collectMinDistances(), x, z, cachedRegions, cache, distanceCache))
-                return false;
-        } catch (Throwable ignored) {}
+        if (i == null || checkMinDistances(i.collectMinDistances(), x, z, cachedRegions, cache, distanceCache))
+            return false;
         RNG rng = new RNG(seed);
         IrisPosition position = new IrisPosition((x << 4) + rng.nextInt(15), 0, (z << 4) + rng.nextInt(15));
         IrisJigsawStructure structure = getData().getJigsawStructureLoader().load(i.getStructure());
@@ -161,7 +156,7 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     @ChunkCoordinates
     private IrisJigsawStructurePlacement pick(List<IrisJigsawStructurePlacement> structures, long seed, int x, int z) {
         return IRare.pick(structures.stream()
-                .filter(p -> p.shouldPlace(getData(), getDimension().getJigsawStructureDivisor(), jigsaw(), x, z))
+                .filter(p -> p.shouldPlace(getDimension().getJigsawStructureDivisor(), jigsaw(), x, z))
                 .toList(), new RNG(seed).nextDouble());
     }
 
@@ -173,29 +168,4 @@ public class MantleJigsawComponent extends IrisMantleComponent {
     private long jigsaw() {
         return getEngineMantle().getEngine().getSeedManager().getJigsaw();
     }
-
-    private int computeRadius() {
-        var dimension = getDimension();
-
-        KSet<String> structures = new KSet<>();
-        for (var placement : dimension.getJigsawStructures()) {
-            structures.add(placement.getStructure());
-        }
-        for (var region : dimension.getAllRegions(this::getData)) {
-            for (var placement : region.getJigsawStructures()) {
-                structures.add(placement.getStructure());
-            }
-        }
-        for (var biome : dimension.getAllBiomes(this::getData)) {
-            for (var placement : biome.getJigsawStructures()) {
-                structures.add(placement.getStructure());
-            }
-        }
-
-        int max = 0;
-        for (var structure : structures) {
-            max = Math.max(max, getData().getJigsawStructureLoader().load(structure).getMaxDimension());
-        }
-        return max;
-    }
 }

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

@@ -24,34 +24,23 @@ import com.volmit.iris.engine.mantle.EngineMantle;
 import com.volmit.iris.engine.mantle.IrisMantleComponent;
 import com.volmit.iris.engine.mantle.MantleWriter;
 import com.volmit.iris.engine.object.*;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.collection.KSet;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.data.B;
+import com.volmit.iris.util.data.IrisBlockData;
 import com.volmit.iris.util.documentation.BlockCoordinates;
 import com.volmit.iris.util.documentation.ChunkCoordinates;
-import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.mantle.MantleFlag;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.matter.MatterStructurePOI;
 import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.noise.NoiseType;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import lombok.Getter;
-import org.bukkit.util.BlockVector;
 
-import java.io.IOException;
-import java.util.Map;
 import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
 
-@Getter
 public class MantleObjectComponent extends IrisMantleComponent {
-    private final int radius = computeRadius();
-
     public MantleObjectComponent(EngineMantle engineMantle) {
-        super(engineMantle, MantleFlag.OBJECT, 1);
+        super(engineMantle, MantleFlag.OBJECT);
     }
 
     @Override
@@ -115,6 +104,9 @@ public class MantleObjectComponent extends IrisMantleComponent {
                 if (objectPlacement.isDolphinTarget() && objectPlacement.isUnderwater() && B.isStorageChest(data)) {
                     writer.setData(b.getX(), b.getY(), b.getZ(), MatterStructurePOI.BURIED_TREASURE);
                 }
+                if (data instanceof IrisBlockData d) {
+                    writer.setData(b.getX(), b.getY(), b.getZ(), d.getCustom());
+                }
             }, null, getData());
         }
     }
@@ -154,112 +146,4 @@ public class MantleObjectComponent extends IrisMantleComponent {
 
         return v;
     }
-
-    private int computeRadius() {
-        var dimension = getDimension();
-
-        AtomicInteger xg = new AtomicInteger();
-        AtomicInteger zg = new AtomicInteger();
-
-        KSet<String> objects = new KSet<>();
-        KMap<IrisObjectScale, KList<String>> scalars = new KMap<>();
-        for (var region : dimension.getAllRegions(this::getData)) {
-            for (var j : region.getObjects()) {
-                if (j.getScale().canScaleBeyond()) {
-                    scalars.put(j.getScale(), j.getPlace());
-                } else {
-                    objects.addAll(j.getPlace());
-                }
-            }
-        }
-        for (var biome : dimension.getAllBiomes(this::getData)) {
-            for (var j : biome.getObjects()) {
-                if (j.getScale().canScaleBeyond()) {
-                    scalars.put(j.getScale(), j.getPlace());
-                } else {
-                    objects.addAll(j.getPlace());
-                }
-            }
-        }
-
-        BurstExecutor e = getEngineMantle().getTarget().getBurster().burst(objects.size());
-        KMap<String, BlockVector> sizeCache = new KMap<>();
-        for (String i : objects) {
-            e.queue(() -> {
-                try {
-                    BlockVector bv = sizeCache.computeIfAbsent(i, (k) -> {
-                        try {
-                            return IrisObject.sampleSize(getData().getObjectLoader().findFile(i));
-                        } catch (IOException ex) {
-                            Iris.reportError(ex);
-                            ex.printStackTrace();
-                        }
-
-                        return null;
-                    });
-
-                    if (bv == null) {
-                        throw new RuntimeException();
-                    }
-
-                    if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
-                        Iris.warn("Object " + i + " has a large size (" + bv + ") and may increase memory usage!");
-                    }
-
-                    synchronized (xg) {
-                        xg.getAndSet(Math.max(bv.getBlockX(), xg.get()));
-                    }
-
-                    synchronized (zg) {
-                        zg.getAndSet(Math.max(bv.getBlockZ(), zg.get()));
-                    }
-                } catch (Throwable ed) {
-                    Iris.reportError(ed);
-
-                }
-            });
-        }
-
-        for (Map.Entry<IrisObjectScale, KList<String>> entry : scalars.entrySet()) {
-            double ms = entry.getKey().getMaximumScale();
-            for (String j : entry.getValue()) {
-                e.queue(() -> {
-                    try {
-                        BlockVector bv = sizeCache.computeIfAbsent(j, (k) -> {
-                            try {
-                                return IrisObject.sampleSize(getData().getObjectLoader().findFile(j));
-                            } catch (IOException ioException) {
-                                Iris.reportError(ioException);
-                                ioException.printStackTrace();
-                            }
-
-                            return null;
-                        });
-
-                        if (bv == null) {
-                            throw new RuntimeException();
-                        }
-
-                        if (Math.max(bv.getBlockX(), bv.getBlockZ()) > 128) {
-                            Iris.warn("Object " + j + " has a large size (" + bv + ") and may increase memory usage! (Object scaled up to " + Form.pc(ms, 2) + ")");
-                        }
-
-                        synchronized (xg) {
-                            xg.getAndSet((int) Math.max(Math.ceil(bv.getBlockX() * ms), xg.get()));
-                        }
-
-                        synchronized (zg) {
-                            zg.getAndSet((int) Math.max(Math.ceil(bv.getBlockZ() * ms), zg.get()));
-                        }
-                    } catch (Throwable ee) {
-                        Iris.reportError(ee);
-
-                    }
-                });
-            }
-        }
-
-        e.complete();
-        return Math.max(xg.get(), zg.get());
-    }
 }

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

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

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

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

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

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

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

@@ -20,7 +20,10 @@ package com.volmit.iris.engine.modifier;
 
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineAssignedModifier;
-import com.volmit.iris.engine.object.*;
+import com.volmit.iris.engine.object.IrisBiome;
+import com.volmit.iris.engine.object.IrisDepositGenerator;
+import com.volmit.iris.engine.object.IrisObject;
+import com.volmit.iris.engine.object.IrisRegion;
 import com.volmit.iris.util.context.ChunkContext;
 import com.volmit.iris.util.data.B;
 import com.volmit.iris.util.data.HeightMap;
@@ -42,26 +45,30 @@ public class IrisDepositModifier extends EngineAssignedModifier<BlockData> {
     @Override
     public void onModify(int x, int z, Hunk<BlockData> output, boolean multicore, ChunkContext context) {
         PrecisionStopwatch p = PrecisionStopwatch.start();
-        generateDeposits(output, Math.floorDiv(x, 16), Math.floorDiv(z, 16), multicore, context);
+        generateDeposits(rng, output, Math.floorDiv(x, 16), Math.floorDiv(z, 16), multicore, context);
         getEngine().getMetrics().getDeposit().put(p.getMilliseconds());
     }
 
-    public void generateDeposits(Hunk<BlockData> terrain, int x, int z, boolean multicore, ChunkContext context) {
+    public void generateDeposits(RNG rx, Hunk<BlockData> terrain, int x, int z, boolean multicore, ChunkContext context) {
+        RNG ro = rx.nextParallelRNG(x * x).nextParallelRNG(z * z);
         IrisRegion region = context.getRegion().get(7, 7);
         IrisBiome biome = context.getBiome().get(7, 7);
         BurstExecutor burst = burst().burst(multicore);
 
-        long seed = x * 341873128712L + z * 132897987541L;
         for (IrisDepositGenerator k : getDimension().getDeposits()) {
-            burst.queue(() -> generate(k, terrain, rng.nextParallelRNG(seed), x, z, false, context));
+            burst.queue(() -> generate(k, terrain, ro, x, z, false, context));
         }
 
         for (IrisDepositGenerator k : region.getDeposits()) {
-            burst.queue(() -> generate(k, terrain, rng.nextParallelRNG(seed), x, z, false, context));
+            for (int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++) {
+                burst.queue(() -> generate(k, terrain, ro, x, z, false, context));
+            }
         }
 
         for (IrisDepositGenerator k : biome.getDeposits()) {
-            burst.queue(() -> generate(k, terrain, rng.nextParallelRNG(seed), x, z, false, context));
+            for (int l = 0; l < ro.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++) {
+                burst.queue(() -> generate(k, terrain, ro, x, z, false, context));
+            }
         }
         burst.complete();
     }
@@ -71,48 +78,45 @@ public class IrisDepositModifier extends EngineAssignedModifier<BlockData> {
     }
 
     public void generate(IrisDepositGenerator k, Hunk<BlockData> data, RNG rng, int cx, int cz, boolean safe, HeightMap he, ChunkContext context) {
-        if (k.getSpawnChance() < rng.d())
-            return;
-
-        for (int l = 0; l < rng.i(k.getMinPerChunk(), k.getMaxPerChunk() + 1); l++) {
-            if (k.getPerClumpSpawnChance() < rng.d())
-                continue;
-
+        for (int l = 0; l < rng.i(k.getMinPerChunk(), k.getMaxPerChunk()); l++) {
             IrisObject clump = k.getClump(rng, getData());
 
-            int dim = clump.getW();
-            int min = dim / 2;
-            int max = (int) (16D - dim / 2D);
+            int af = (int) Math.floor(clump.getW() / 2D);
+            int bf = (int) Math.floor(16D - (clump.getW() / 2D));
 
-            if (min > max || min < 0 || max > 15) {
-                min = 6;
-                max = 9;
+            if (af > bf || af < 0 || bf > 15) {
+                af = 6;
+                bf = 9;
             }
 
-            int x = rng.i(min, max + 1);
-            int z = rng.i(min, max + 1);
+            af = Math.max(af - 1, 0);
+            int x = rng.i(af, bf);
+            int z = rng.i(af, bf);
             int height = (he != null ? he.getHeight((cx << 4) + x, (cz << 4) + z) : (int) (Math.round(
                     context.getHeight().get(x, z)
             ))) - 7;
 
-            if (height <= 0)
-                continue;
+            if (height <= 0) {
+                return;
+            }
 
-            int minY = Math.max(0, k.getMinHeight());
+            int i = Math.max(0, k.getMinHeight());
             // TODO: WARNING HEIGHT
-            int maxY = Math.min(height, Math.min(getEngine().getHeight(), k.getMaxHeight()));
+            int a = Math.min(height, Math.min(getEngine().getHeight(), k.getMaxHeight()));
 
-            if (minY >= maxY)
-                continue;
+            if (i >= a) {
+                return;
+            }
 
-            int y = rng.i(minY, maxY + 1);
+            int h = rng.i(i, a);
 
-            if (y > k.getMaxHeight() || y < k.getMinHeight() || y > height - 2)
-                continue;
+            if (h > k.getMaxHeight() || h < k.getMinHeight() || h > height - 2) {
+                return;
+            }
 
             for (BlockVector j : clump.getBlocks().keySet()) {
                 int nx = j.getBlockX() + x;
-                int ny = j.getBlockY() + y;
+                int ny = j.getBlockY() + h;
                 int nz = j.getBlockZ() + z;
 
                 if (ny > height || nx > 15 || nx < 0 || ny > getEngine().getHeight() || ny < 0 || nz < 0 || nz > 15) {

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

@@ -1,13 +0,0 @@
-package com.volmit.iris.engine.object;
-
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.util.collection.KList;
-import org.bukkit.block.data.BlockData;
-
-public interface IObjectLoot {
-    KList<IrisBlockData> getFilter();
-    KList<BlockData> getFilter(IrisData manager);
-    boolean isExact();
-    String getName();
-    int getWeight();
-}

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

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

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

@@ -37,10 +37,12 @@ public class IrisBiomeCustomSpawn {
     private EntityType type = EntityType.COW;
 
     @MinNumber(1)
+    @MaxNumber(20)
     @Desc("The min to spawn")
     private int minCount = 2;
 
     @MinNumber(1)
+    @MaxNumber(20)
     @Desc("The max to spawn")
     private int maxCount = 5;