v+ , and the other v+ lol

Merge pull request #1094 from RePixelatedMC/master
Update README.md
2026-01-04 15:41:30 +00:00 · 2024-04-29 15:45:41 -04:00 · 2024-04-27 12:42:50 +02:00 · 2024-04-27 12:41:29 +02:00 · 2024-04-26 18:06:37 +02:00 · 2024-04-23 12:29:19 +02:00
24 changed files with 1226 additions and 197 deletions
--- a/README.md
+++ b/README.md
@@ -69,7 +69,6 @@ IrisAccess access=IrisToolbelt.createWorld() // If you like builders...
  .name("myWorld") // The world name
  .dimension("terrifyinghands")
  .seed(69133742) // The world seed
-  .headless(true)  // Headless make gen go fast
  .pregen(PregenTask // Define a pregen job to run
  .builder()
    .center(new Position2(0,0)) // REGION coords (1 region = 32x32 chunks)
--- a/build.gradle
+++ b/build.gradle
@@ -25,7 +25,7 @@ plugins {
    id "de.undercouch.download" version "5.0.1"
 }

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

 // ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
@@ -37,7 +37,7 @@ registerCustomOutputTask('Coco', 'D://mcsm/plugins')
 registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
 registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
 registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
-registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.4 - Iris Development/plugins')
+registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.4 - Development/plugins')
 // ========================== UNIX ==============================
 registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
 registerCustomOutputTaskUnix('PsychoLT', '/Volumes/PRO-G40/Minecraft/MinecraftDevelopment/Server/plugins')
@@ -237,6 +237,8 @@ allprojects {
        implementation "net.kyori:adventure-text-minimessage:4.13.1"
        implementation 'net.kyori:adventure-platform-bukkit:4.3.2'
        implementation 'net.kyori:adventure-api:4.13.1'
+        //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'

        // Dynamically Loaded
--- a/core/src/main/java/com/volmit/iris/Iris.java
+++ b/core/src/main/java/com/volmit/iris/Iris.java
@@ -739,7 +739,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() {
@@ -806,9 +806,6 @@ public class Iris extends VolmitPlugin implements Listener {
        } else {
            splash = splashstable;
        }
-        OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
-        String osArch = osBean.getArch();
-        String osName = osBean.getName();

        if (!passedserversoftware) {
            Iris.info("Server type & version: " + C.RED + Bukkit.getVersion());
@@ -821,35 +818,9 @@ public class Iris extends VolmitPlugin implements Listener {
                Iris.info(C.YELLOW + "Purpur is recommended to use with iris.");
            }
        }
-        Iris.info("Server OS: " + osName + " (" + osArch + ")");
-
-        try {
-            if (warningmode){
-                Iris.info("Server Cpu: " + C.GOLD + getCPUModel());
-            } else {
-            if(unstablemode){
-                Iris.info("Server Cpu: " + C.DARK_RED + getCPUModel());
-            } else {
-                if (getCPUModel().contains("Intel")) {
-                    Iris.info("Server Cpu: " + C.BLUE + getCPUModel());
-                }
-                if (getCPUModel().contains("Ryzen")) {
-                    Iris.info("Server Cpu: " + C.RED + getCPUModel());
-                }
-                if (!getCPUModel().contains("Ryzen") && !getCPUModel().contains("Intel")) {
-                    Iris.info("Server Cpu: " + C.GRAY + getCPUModel());
-                }
-            }
-            }
-        } catch (Exception e){
-            Iris.info("Server Cpu: " + C.DARK_RED + "Failed");
-        }
-
-        Iris.info("Process Threads: " +  Runtime.getRuntime().availableProcessors());
-        Iris.info("Process Memory: " + getHardware.getProcessMemory() + " MB");
-        Iris.info("Free DiskSpace: " + Form.ofSize(freeSpace.getFreeSpace(), 1024));
        if (getHardware.getProcessMemory() < 5999) {
            Iris.warn("6GB+ Ram is recommended");
+            Iris.warn("Process Memory: " + getHardware.getProcessMemory() + " MB");
        }
        Iris.info("Bukkit version: " + Bukkit.getBukkitVersion());
        Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
--- a/core/src/main/java/com/volmit/iris/core/IrisSettings.java
+++ b/core/src/main/java/com/volmit/iris/core/IrisSettings.java
@@ -177,7 +177,6 @@ public class IrisSettings {
    public static class IrisSettingsGenerator {
        public String defaultWorldType = "overworld";
        public int maxBiomeChildDepth = 4;
-       // public boolean forceConvertTo320Height = false;
        public boolean preventLeafDecay = true;
    }

--- a/core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java
@@ -22,6 +22,7 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.nms.INMS;
 import com.volmit.iris.core.nms.v1X.NMSBinding1X;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.IrisEngineSVC;
 import com.volmit.iris.core.tools.IrisPackBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
@@ -40,7 +41,10 @@ import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.io.IO;
 import com.volmit.iris.util.mantle.TectonicPlate;
+import com.volmit.iris.util.math.Spiraler;
 import com.volmit.iris.util.math.Vector3d;
+import com.volmit.iris.util.nbt.mca.MCAFile;
+import com.volmit.iris.util.nbt.mca.MCAUtil;
 import com.volmit.iris.util.plugin.VolmitSender;
 import io.lumine.mythic.bukkit.adapters.BukkitEntity;
 import net.jpountz.lz4.LZ4BlockInputStream;
@@ -61,6 +65,7 @@ import java.net.NetworkInterface;
 import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.zip.GZIPInputStream;
 import java.util.zip.GZIPOutputStream;

@@ -150,9 +155,29 @@ public class CommandDeveloper implements DecreeExecutor {

    }

+    @Decree(description = "Test")
+    public void updater(
+            @Param(description = "Updater for chunks")
+            World world
+    ) {
+        Iris.info("test");
+        ChunkUpdater updater = new ChunkUpdater(world);
+        updater.start();
+
+
+    }
+
    @Decree(description = "test")
-    public void test() throws NoSuchFieldException, IllegalAccessException {
-        IrisEngineSVC.instance.engineStatus();
+    public void mca (
+            @Param(description = "String") String world) {
+        try {
+            File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
+            for (File mca : McaFiles) {
+                MCAFile MCARegion = MCAUtil.read(mca);
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }

    }

--- a/core/src/main/java/com/volmit/iris/core/commands/CommandIris.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandIris.java
@@ -21,6 +21,7 @@ package com.volmit.iris.core.commands;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
 import com.volmit.iris.core.service.StudioSVC;
 import com.volmit.iris.core.tools.IrisBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
@@ -30,12 +31,14 @@ import com.volmit.iris.core.safeguard.UtilsSFG;
 import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
 import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
 import com.volmit.iris.util.decree.specialhandlers.NullablePlayerHandler;
 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;
@@ -75,9 +78,9 @@ public class CommandIris implements DecreeExecutor {
    private CommandWhat what;
    private CommandEdit edit;
    private CommandFind find;
+    private CommandSupport support;
    private CommandDeveloper developer;
    public static boolean worldCreation = false;
-    String WorldToLoad;
    String WorldEngine;
    String worldNameToCheck = "YourWorldName";
    VolmitSender sender = Iris.getSender();
@@ -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.");
@@ -216,41 +222,41 @@ public class CommandIris implements DecreeExecutor {
        Iris.service(StudioSVC.class).open(sender(), 1337, "overworld");
    }

-    @Decree(description = "Check if iris has access to that specific world")
-    public void hasAccess(
-            @Param(description = "The world to access", aliases = {"world"})
-            World world
-    ) {
-        Engine engine = IrisToolbelt.access(world).getEngine();
-        if (engine != null) {
-            sender().sendMessage("Access granted successfully.");
-        } else {
-            sender().sendMessage(C.RED + "Failed to grant access.");
-        }
-    }
+    @Decree(description = "Check access of all worlds.", aliases = {"accesslist"})
+    public void worlds() {
+        KList<World> IrisWorlds = new KList<>();
+        KList<World> BukkitWorlds = new KList<>();

-    @Decree(description = "All Iris Worlds on the server.", aliases = {"worlds"})
-    public void irisworlds() {
-        List<World> IrisWorlds = new ArrayList<>();
-        for (World world : Bukkit.getWorlds()) {
+        for (World w : Bukkit.getServer().getWorlds()) {
            try {
-                if (IrisToolbelt.access(world).getEngine() != null) {
-                    IrisWorlds.add(world);
+                Engine engine = IrisToolbelt.access(w).getEngine();
+                if (engine != null) {
+                    IrisWorlds.add(w);
                }
            } catch (Exception e) {
-                // no
+                BukkitWorlds.add(w);
            }
        }
+
        if (sender().isPlayer()) {
-            sender.sendMessage(C.IRIS + "Iris Worlds:");
-            for (World world : IrisWorlds) {
-                sender.sendMessage(C.GREEN + "- " + world.getName());
+            sender().sendMessage(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                sender().sendMessage(C.IRIS + "- " +IrisWorld.getName());
+            }
+            sender().sendMessage(C.GOLD + "Bukkit Worlds: ");
+            for (World BukkitWorld : BukkitWorlds.copy()) {
+                sender().sendMessage(C.GRAY + "- " +BukkitWorld.getName());
            }
        } else {
-            Iris.info(C.IRIS + "Iris Worlds:");
-            for (World world : IrisWorlds) {
-                sender.sendMessage(C.GREEN + "- " + world.getName());
+            Iris.info(C.BLUE + "Iris Worlds: ");
+            for (World IrisWorld : IrisWorlds.copy()) {
+                Iris.info(C.IRIS + "- " +IrisWorld.getName());
            }
+            Iris.info(C.GOLD + "Bukkit Worlds: ");
+            for (World BukkitWorld : BukkitWorlds.copy()) {
+                Iris.info(C.GRAY + "- " +BukkitWorld.getName());
+            }
+            
        }
    }

@@ -314,6 +320,24 @@ public class CommandIris implements DecreeExecutor {
        return dir.delete();
    }

+    @Decree(description = "Updates all chunk in the specified world")
+    public void updater(
+            @Param(description = "World to update chunks at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        ChunkUpdater updater = new ChunkUpdater(world);
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + " Total chunks: " + Form.f(updater.getChunks()));
+        }
+        updater.start();
+    }
+
    @Decree(description = "Set aura spins")
    public void aura(
            @Param(description = "The h color value", defaultValue = "-20")
@@ -473,7 +497,7 @@ public class CommandIris implements DecreeExecutor {
            sender().sendMessage(C.YELLOW + world + " Doesnt exist on the server.");
            return;
        }
-        WorldToLoad = world;
+
        File BUKKIT_YML = new File("bukkit.yml");
        String pathtodim = world + File.separator +"iris"+File.separator +"pack"+File.separator +"dimensions"+File.separator;
        File directory = new File(Bukkit.getWorldContainer(), pathtodim);
@@ -509,9 +533,10 @@ public class CommandIris implements DecreeExecutor {
            } catch (IOException e) {
                Iris.error("Failed to update bukkit.yml!");
                e.printStackTrace();
+                return;
            }
        }
-        checkForBukkitWorlds();
+        checkForBukkitWorlds(world);
        sender().sendMessage(C.GREEN + world + " loaded successfully.");
    }
    @Decree(description = "Evacuate an iris world", origin = DecreeOrigin.PLAYER, sync = true)
@@ -532,7 +557,7 @@ public class CommandIris implements DecreeExecutor {
        File worldDirectory = new File(worldContainer, worldName);
        return worldDirectory.exists() && worldDirectory.isDirectory();
    }
-    private void checkForBukkitWorlds() {
+    private void checkForBukkitWorlds(String world) {
        FileConfiguration fc = new YamlConfiguration();
        try {
            fc.load(new File("bukkit.yml"));
@@ -541,9 +566,9 @@ public class CommandIris implements DecreeExecutor {
                return;
            }

-            List<String> worldsToLoad = Collections.singletonList(WorldToLoad);
+            List<String> worldsToLoad = Collections.singletonList(world);

-            for (String s : section.getKeys(false)) {
+             for (String s : section.getKeys(false)) {
                if (!worldsToLoad.contains(s)) {
                    continue;
                }
@@ -622,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);
    }
 }
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandStudio.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandStudio.java
@@ -85,7 +85,7 @@ import java.util.function.Supplier;
 public class CommandStudio implements DecreeExecutor {
    private CommandFind find;
    private CommandEdit edit;
-    private CommandDeepSearch deepSearch;
+    //private CommandDeepSearch deepSearch;

    public static String hrf(Duration duration) {
        return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandSupport.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandSupport.java
@@ -0,0 +1,82 @@
+/*
+ * 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.service.IrisEngineSVC;
+import com.volmit.iris.core.tools.IrisPackBenchmarking;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.engine.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();
+        }
+    }
+
+
+}
+
+
--- a/core/src/main/java/com/volmit/iris/core/commands/CommandUpdater.java
+++ b/core/src/main/java/com/volmit/iris/core/commands/CommandUpdater.java
@@ -0,0 +1,107 @@
+/*
+ * 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 org.bukkit.World;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.pregenerator.ChunkUpdater;
+import com.volmit.iris.core.tools.IrisToolbelt;
+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;
+
+@Decree(name = "Updater", origin = DecreeOrigin.BOTH, description = "Iris World Updater")
+public class CommandUpdater implements DecreeExecutor {
+    private ChunkUpdater chunkUpdater;
+
+    @Decree(description = "Updates all chunk in the specified world")
+    public void start(
+            @Param(description = "World to update chunks at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        chunkUpdater = new ChunkUpdater(world);
+        if (sender().isPlayer()) {
+            sender().sendMessage(C.GREEN + "Updating " + world.getName()  + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
+        } else {
+            Iris.info(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
+        }
+        chunkUpdater.start();
+    }
+
+    @Decree(description = "Pause the updater")
+    public void pause(
+            @Param(description = "World to pause the Updater at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        if (chunkUpdater == null) {
+            sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
+            return;
+        }
+        boolean status = chunkUpdater.pause();
+        if (sender().isPlayer()) {
+            if (status) {
+                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+            } else {
+                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+            }
+        } else {
+            if (status) {
+                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + world.getName());
+            } else {
+                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + world.getName());
+            }
+        }
+    }
+
+    @Decree(description = "Stops the updater")
+    public void stop(
+            @Param(description = "World to stop the Updater at")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.GOLD + "This is not an Iris world");
+            return;
+        }
+        if (chunkUpdater == null) {
+            sender().sendMessage(C.GOLD + "You cant stop something that doesnt exist?");
+            return;
+        }
+        if (sender().isPlayer()) {
+            sender().sendMessage("Stopping Updater for: " + C.GRAY + world.getName());
+        } else {
+            Iris.info("Stopping Updater for: " + C.GRAY + world.getName());
+        }
+        chunkUpdater.stop();
+    }
+
+}
+
+
--- a/core/src/main/java/com/volmit/iris/core/gui/components/IrisRenderer.java
+++ b/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 {
--- a/core/src/main/java/com/volmit/iris/core/pregenerator/ChunkUpdater.java
+++ b/core/src/main/java/com/volmit/iris/core/pregenerator/ChunkUpdater.java
@@ -0,0 +1,318 @@
+package com.volmit.iris.core.pregenerator;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.collection.KMap;
+import com.volmit.iris.util.format.Form;
+import com.volmit.iris.util.math.M;
+import com.volmit.iris.util.math.RollingSequence;
+import com.volmit.iris.util.math.Spiraler;
+import com.volmit.iris.util.scheduling.J;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Chunk;
+import org.bukkit.World;
+
+import java.io.File;
+
+import java.util.ArrayList;
+import java.util.concurrent.*;
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
+
+public class ChunkUpdater {
+    private AtomicBoolean paused;
+    private AtomicBoolean cancelled;
+    private KMap<Chunk, Long> lastUse;
+    private final RollingSequence chunksPerSecond;
+    private final AtomicInteger worldheightsize;
+    private final AtomicInteger worldwidthsize;
+    private final AtomicInteger totalChunks;
+    private final AtomicInteger totalMaxChunks;
+    private final AtomicInteger totalMcaregions;
+    private final AtomicInteger position;
+    private AtomicInteger chunksProcessed;
+    private AtomicInteger chunksUpdated;
+    private AtomicLong startTime;
+    private ExecutorService executor;
+    private ExecutorService chunkExecutor;
+    private ScheduledExecutorService scheduler;
+    private CompletableFuture future;
+    private  CountDownLatch latch;
+    private final Object pauseLock;
+    private final Engine engine;
+    private final World world;
+
+    public ChunkUpdater(World world) {
+        this.engine = IrisToolbelt.access(world).getEngine();
+        this.chunksPerSecond = new RollingSequence(5);
+        this.world = world;
+        this.lastUse = new KMap();
+        this.worldheightsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 1));
+        this.worldwidthsize = new AtomicInteger(calculateWorldDimensions(new File(world.getWorldFolder(), "region"), 0));
+        int m = Math.max(worldheightsize.get(), worldwidthsize.get());
+        this.executor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
+        this.chunkExecutor = Executors.newFixedThreadPool(Math.max(Runtime.getRuntime().availableProcessors() / 3, 1));
+        this.scheduler = Executors.newScheduledThreadPool(1);
+        this.future = new CompletableFuture<>();
+        this.startTime = new AtomicLong();
+        this.worldheightsize.set(m);
+        this.worldwidthsize.set(m);
+        this.totalMaxChunks = new AtomicInteger((worldheightsize.get() / 16) * (worldwidthsize.get() / 16));
+        this.chunksProcessed = new AtomicInteger();
+        this.chunksUpdated = new AtomicInteger();
+        this.position = new AtomicInteger(0);
+        this.latch = new CountDownLatch(totalMaxChunks.get());
+        this.paused = new AtomicBoolean(false);
+        this.pauseLock = new Object();
+        this.cancelled = new AtomicBoolean(false);
+        this.totalChunks = new AtomicInteger(0);
+        this.totalMcaregions = new AtomicInteger(0);
+    }
+
+    public int getChunks() {
+        return totalMaxChunks.get();
+    }
+
+    public void start() {
+        unloadAndSaveAllChunks();
+        update();
+    }
+
+    public boolean pause() {
+        unloadAndSaveAllChunks();
+        if (paused.get()) {
+            paused.set(false);
+            return false;
+        } else {
+            paused.set(true);
+            return true;
+        }
+    }
+
+    public void stop() {
+        unloadAndSaveAllChunks();
+        cancelled.set(true);
+    }
+
+
+    private void update() {
+        Iris.info("Updating..");
+        try {
+            startTime.set(System.currentTimeMillis());
+            scheduler.scheduleAtFixedRate(() -> {
+                try {
+                    if (!paused.get()) {
+                        long eta = computeETA();
+                        long elapsedSeconds = (System.currentTimeMillis() - startTime.get()) / 1000;
+                        int processed = chunksProcessed.get();
+                        double cps = elapsedSeconds > 0 ? processed / (double) elapsedSeconds : 0;
+                        chunksPerSecond.put(cps);
+                        double percentage = ((double) chunksProcessed.get() / (double) totalMaxChunks.get()) * 100;
+                        if (!cancelled.get()) {
+                            Iris.info("Updated: " + Form.f(processed) + " of " + Form.f(totalMaxChunks.get()) + " (%.0f%%) " + Form.f(chunksPerSecond.getAverage()) + "/s, ETA: " + Form.duration(eta,
+                                    2), percentage);
+                        }
+                    }
+                } catch (Exception e) {
+                    e.printStackTrace();
+                }
+            }, 0, 3, TimeUnit.SECONDS);
+
+            CompletableFuture.runAsync(() -> {
+                for (int i = 0; i < totalMaxChunks.get(); i++) {
+                    if (paused.get()) {
+                        synchronized (pauseLock) {
+                            try {
+                                pauseLock.wait();
+                            } catch (InterruptedException e) {
+                                Iris.error("Interrupted while waiting for executor: ");
+                                e.printStackTrace();
+                                break;
+                            }
+                        }
+                    }
+                    executor.submit(() -> {
+                        if (!cancelled.get()) {
+                            processNextChunk();   
+                        }
+                        latch.countDown();
+                    });
+                }
+            }).thenRun(() -> {
+                try {
+                    latch.await();
+                    close();
+                } catch (Exception e) {
+                    Thread.currentThread().interrupt();
+                }
+            });
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void close() {
+        try {
+            unloadAndSaveAllChunks();
+            executor.shutdown();
+            executor.awaitTermination(5, TimeUnit.SECONDS);
+            chunkExecutor.shutdown();
+            chunkExecutor.awaitTermination(5, TimeUnit.SECONDS);
+            scheduler.shutdownNow();
+        } catch (Exception ignored) {
+        }
+        if (cancelled.get()) {
+            Iris.info("Updated: " + Form.f(chunksUpdated.get()) + " Chunks");
+            Iris.info("Irritated: " + Form.f(chunksProcessed.get()) + " of " + Form.f(totalMaxChunks.get()));
+            Iris.info("Stopped updater.");
+        } else {
+            Iris.info("Processed: " + Form.f(chunksProcessed.get()) + " Chunks");
+            Iris.info("Finished Updating: " + Form.f(chunksUpdated.get()) + " Chunks");
+        }
+    }
+
+    private void processNextChunk() {
+        int pos = position.getAndIncrement();
+        int[] coords = getChunk(pos);
+        if (loadChunksIfGenerated(coords[0], coords[1])) {
+            Chunk c = world.getChunkAt(coords[0], coords[1]);
+            engine.updateChunk(c);
+            chunksUpdated.incrementAndGet();
+        }
+        chunksProcessed.getAndIncrement();
+    }
+
+    private boolean loadChunksIfGenerated(int x, int z) {
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                if (!PaperLib.isChunkGenerated(world, x + dx, z + dz)) {
+                    return false;
+                }
+            }
+        }
+
+        AtomicBoolean generated = new AtomicBoolean(true);
+        KList<Future<?>> futures = new KList<>(9);
+        for (int dx = -1; dx <= 1; dx++) {
+            for (int dz = -1; dz <= 1; dz++) {
+                int xx = x + dx;
+                int zz = z + dz;
+                futures.add(chunkExecutor.submit(() -> {
+                    Chunk c;
+                    try {
+                        c = PaperLib.getChunkAtAsync(world, xx, zz, false).get();
+                    } catch (InterruptedException | ExecutionException e) {
+                        generated.set(false);
+                        return;
+                    }
+                    if (!c.isLoaded()) {
+                        CountDownLatch latch = new CountDownLatch(1);
+                        J.s(() -> {
+                            c.load(false);
+                            latch.countDown();
+                        });
+                        try {
+                            latch.await();
+                        } catch (InterruptedException ignored) {}
+                    }
+                    if (!c.isGenerated()) {
+                        generated.set(false);
+                    }
+                    lastUse.put(c, M.ms());
+                }));
+            }
+        }
+        while (!futures.isEmpty()) {
+            futures.removeIf(Future::isDone);
+            try {
+                Thread.sleep(50);
+            } catch (InterruptedException ignored) {}
+        }
+        return generated.get();
+    }
+
+    private void unloadAndSaveAllChunks() {
+        try {
+            J.sfut(() -> {
+                if (world == null) {
+                    Iris.warn("World was null somehow...");
+                    return;
+                }
+
+                for (Chunk i : new ArrayList<>(lastUse.keySet())) {
+                    Long lastUseTime = lastUse.get(i);
+                    if (lastUseTime != null && M.ms() - lastUseTime >= 5000) {
+                        i.unload();
+                        lastUse.remove(i);
+                    }
+                }
+                world.save();
+            }).get();
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+
+    private long computeETA() {
+        return (long) (totalMaxChunks.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)
+                ((totalMaxChunks.get() - chunksProcessed.get()) * ((double) (M.ms() - startTime.get()) / (double) chunksProcessed.get())) :
+                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
+                ((totalMaxChunks.get() - chunksProcessed.get()) / chunksPerSecond.getAverage()) * 1000
+        );
+    }
+
+    public int calculateWorldDimensions(File regionDir, Integer o) {
+        File[] files = regionDir.listFiles((dir, name) -> name.endsWith(".mca"));
+
+        int minX = Integer.MAX_VALUE;
+        int maxX = Integer.MIN_VALUE;
+        int minZ = Integer.MAX_VALUE;
+        int maxZ = Integer.MIN_VALUE;
+
+        for (File file : files) {
+            String[] parts = file.getName().split("\\.");
+            int x = Integer.parseInt(parts[1]);
+            int z = Integer.parseInt(parts[2]);
+
+            if (x < minX) minX = x;
+            if (x > maxX) maxX = x;
+            if (z < minZ) minZ = z;
+            if (z > maxZ) maxZ = z;
+        }
+
+        int height = (maxX - minX + 1) * 32 * 16;
+        int width = (maxZ - minZ + 1) * 32 * 16;
+
+        if (o == 1) {
+            return height;
+        }
+        if (o == 0) {
+            return width;
+        }
+        return 0;
+    }
+
+    public int[] getChunk(int position) {
+        int p = -1;
+        AtomicInteger xx = new AtomicInteger();
+        AtomicInteger zz = new AtomicInteger();
+        Spiraler s = new Spiraler(worldheightsize.get() * 2, worldwidthsize.get() * 2, (x, z) -> {
+            xx.set(x);
+            zz.set(z);
+        });
+
+        while (s.hasNext() && p++ < position) {
+            s.next();
+        }
+        int[] coords = new int[2];
+        coords[0] = xx.get();
+        coords[1] = zz.get();
+
+        return coords;
+    }
+}
--- a/core/src/main/java/com/volmit/iris/core/service/IrisEngineSVC.java
+++ b/core/src/main/java/com/volmit/iris/core/service/IrisEngineSVC.java
@@ -78,6 +78,9 @@ public class IrisEngineSVC implements IrisService {
            t = t - 200;
        }
        this.setup();
+        this.TrimLogic();
+        this.UnloadLogic();
+
        trimAlive.begin();
        unloadAlive.begin();
        trimActiveAlive.begin();
@@ -85,8 +88,8 @@ public class IrisEngineSVC implements IrisService {

        updateTicker.start();
        cacheTicker.start();
-        trimTicker.start();
-        unloadTicker.start();
+        //trimTicker.start();
+        //unloadTicker.start();
        instance = this;

    }
@@ -104,10 +107,6 @@ public class IrisEngineSVC implements IrisService {
        return tectonicLimit.get();
    }

-    public void EngineReport() {
-        Iris.info(C.RED + "CRITICAL ENGINE FAILURE! The Tectonic Trim subsystem has not responded for: " + Form.duration(trimAlive.getMillis()) + ".");
-    }
-
    @EventHandler
    public void onWorldUnload(WorldUnloadEvent event) {
        updateWorlds();
@@ -179,9 +178,9 @@ public class IrisEngineSVC implements IrisService {
                    }
                    if (!isServerShuttingDown && isServerLoaded) {
                        if (!trimTicker.isAlive()) {
-                            Iris.info(C.IRIS + "TrimTicker found dead! Booting it up!");
+                            Iris.info(C.RED + "TrimTicker found dead! Booting it up!");
                            try {
-                                trimTicker.start();
+                                TrimLogic();
                            } catch (Exception e) {
                                Iris.error("What happened?");
                                e.printStackTrace();
@@ -189,9 +188,9 @@ public class IrisEngineSVC implements IrisService {
                        }

                        if (!unloadTicker.isAlive()) {
-                            Iris.info(C.IRIS + "UnloadTicker found dead! Booting it up!");
+                            Iris.info(C.RED + "UnloadTicker found dead! Booting it up!");
                            try {
-                                unloadTicker.start();
+                               UnloadLogic();
                            } catch (Exception e) {
                                Iris.error("What happened?");
                                e.printStackTrace();
@@ -205,63 +204,72 @@ public class IrisEngineSVC implements IrisService {
                return 1000;
            }
        };
+    }
+    public void TrimLogic() {
+        if (trimTicker == null || !trimTicker.isAlive()) {
+            trimTicker = new Looper() {
+                private final Supplier<Engine> supplier = createSupplier();

-        trimTicker = new Looper() {
-            private final Supplier<Engine> supplier = createSupplier();
-            @Override
-            protected long loop() {
-                long start = System.currentTimeMillis();
-                trimAlive.reset();
-                try {
-                    Engine engine = supplier.get();
-                    if (engine != null) {
-                        engine.getMantle().trim(tectonicLimit.get() / lastUse.size());
-                    }
-                } catch (Throwable e) {
-                    Iris.reportError(e);
-                    Iris.info(C.RED + "EngineSVC: Failed to trim. Please contact support!");
-                    e.printStackTrace();
-                    return -1;
-                }
-
-                int size = lastUse.size();
-                long time = (size > 0 ? 1000/size : 1000) - (System.currentTimeMillis() - start);
-                if (time <= 0)
-                    return 0;
-                return time;
-            }
-        };
-
-        unloadTicker = new Looper() {
-            private final Supplier<Engine> supplier = createSupplier();
-
-            @Override
-            protected long loop() {
-                long start = System.currentTimeMillis();
-                unloadAlive.reset();
-                try {
-                    Engine engine = supplier.get();
-                    if (engine != null) {
-                        long unloadStart = System.currentTimeMillis();
-                        int count = engine.getMantle().unloadTectonicPlate(tectonicLimit.get() / lastUse.size());
-                        if (count > 0) {
-                            Iris.debug(C.GOLD + "Unloaded " +  C.YELLOW + count + " TectonicPlates in " + C.RED + Form.duration(System.currentTimeMillis() - unloadStart, 2));
+                @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;
                    }
-                } 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;
-            }
-        };
+                    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() {
@@ -281,7 +289,8 @@ public class IrisEngineSVC implements IrisService {

                    if (generator != null) {
                        Engine engine = generator.getEngine();
-                        if (engine != null && !engine.isStudio()) {
+                        boolean closed = engine.getMantle().getData().isClosed();
+                        if (engine != null && !engine.isStudio() && !closed) {
                            lastUseLock.lock();
                            lastUse.put(world, System.currentTimeMillis());
                            lastUseLock.unlock();
--- a/core/src/main/java/com/volmit/iris/core/tools/IrisBenchmarking.java
+++ b/core/src/main/java/com/volmit/iris/core/tools/IrisBenchmarking.java
@@ -28,7 +28,6 @@ import java.io.InputStreamReader;

 import static com.google.common.math.LongMath.isPrime;
 import static com.volmit.iris.util.misc.getHardware.getCPUModel;
-import static com.volmit.iris.util.misc.getHardware.getDiskModel;
 public class IrisBenchmarking {
    static String ServerOS;
    static String filePath = "benchmark.dat";
@@ -180,12 +179,12 @@ public class IrisBenchmarking {
        Iris.info("- Data Compression: " + formatDouble(calculateDataCompression) + " MBytes/Sec");

        if (WindowsDiskSpeed) {
-            Iris.info("Disk Model: " + getDiskModel());
+            //Iris.info("Disk Model: " + getDiskModel());
            Iris.info(C.BLUE + "- Running with Windows System Assessment Tool");
            Iris.info("- Sequential 64.0 Write: " + C.BLUE + formatDouble(avgWriteSpeedMBps) + " Mbps");
            Iris.info("- Sequential 64.0 Read: " + C.BLUE + formatDouble(avgReadSpeedMBps) + " Mbps");
        } else {
-            Iris.info("Disk Model: " + getDiskModel());
+           // Iris.info("Disk Model: " + getDiskModel());
            Iris.info(C.GREEN + "- Running in Native Mode");
            Iris.info("- Average Write Speed: " + C.GREEN + formatDouble(avgWriteSpeedMBps) + " Mbps");
            Iris.info("- Average Read Speed: " + C.GREEN + formatDouble(avgReadSpeedMBps) + " Mbps");
--- a/core/src/main/java/com/volmit/iris/core/tools/IrisCreator.java
+++ b/core/src/main/java/com/volmit/iris/core/tools/IrisCreator.java
@@ -86,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);
@@ -112,13 +113,6 @@ public class IrisCreator {
     */

    public World create() throws IrisException {
-        if (unstablemode){
-            Iris.info(C.RED + "Your server is experiencing an incompatibility with the Iris plugin. Please rectify this problem to avoid further complications.");
-            Iris.info(C.RED + "----------------------------------------------------------------");
-            Iris.info(C.RED + "Operation ran: Loading Iris World..");
-            UtilsSFG.printIncompatibleWarnings();
-            Iris.info(C.RED + "----------------------------------------------------------------");
-        }
        if (Bukkit.isPrimaryThread()) {
            throw new IrisException("You cannot invoke create() on the main thread.");
        }
@@ -149,6 +143,7 @@ public class IrisCreator {
                .name(name)
                .seed(seed)
                .studio(studio)
+                .smartVanillaHeight(smartVanillaHeight)
                .create();
        ServerConfigurator.installDataPacks(false);

--- a/core/src/main/java/com/volmit/iris/core/tools/IrisWorldCreator.java
+++ b/core/src/main/java/com/volmit/iris/core/tools/IrisWorldCreator.java
@@ -32,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() {
@@ -63,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);

@@ -76,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)
--- a/core/src/main/java/com/volmit/iris/engine/IrisComplex.java
+++ b/core/src/main/java/com/volmit/iris/engine/IrisComplex.java
@@ -292,7 +292,7 @@ public class IrisComplex implements DataProvider {
                double b = 0;

                for (IrisGenerator gen : generators) {
-                    b += bx.getGenLinkMax(gen.getLoadKey());
+                    b += bx.getGenLinkMax(gen.getLoadKey(), engine);
                }

                return b;
@@ -311,7 +311,7 @@ public class IrisComplex implements DataProvider {
                double b = 0;

                for (IrisGenerator gen : generators) {
-                    b += bx.getGenLinkMin(gen.getLoadKey());
+                    b += bx.getGenLinkMin(gen.getLoadKey(), engine);
                }

                return b;
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisBiome.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisBiome.java
@@ -194,13 +194,14 @@ public class IrisBiome extends IrisRegistrant implements IRare {
        return getCustomDerivitives() != null && getCustomDerivitives().isNotEmpty();
    }

-    public double getGenLinkMax(String loadKey) {
+    public double getGenLinkMax(String loadKey, Engine engine) {
        Integer v = genCacheMax.aquire(() ->
        {
            KMap<String, Integer> l = new KMap<>();

            for (IrisBiomeGeneratorLink i : getGenerators()) {
-                l.put(i.getGenerator(), i.getMax());
+                l.put(i.getGenerator(), i.getMax(engine));
+
            }

            return l;
@@ -209,13 +210,13 @@ public class IrisBiome extends IrisRegistrant implements IRare {
        return v == null ? 0 : v;
    }

-    public double getGenLinkMin(String loadKey) {
+    public double getGenLinkMin(String loadKey, Engine engine) {
        Integer v = genCacheMin.aquire(() ->
        {
            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;
@@ -450,26 +451,26 @@ public class IrisBiome extends IrisRegistrant implements IRare {
        return real;
    }

-    public int getMaxHeight() {
+    public int getMaxHeight(Engine engine) {
        return maxHeight.aquire(() ->
        {
            int maxHeight = 0;

            for (IrisBiomeGeneratorLink i : getGenerators()) {
-                maxHeight += i.getMax();
+                maxHeight += i.getMax(engine);
            }

            return maxHeight;
        });
    }

-    public int getMaxWithObjectHeight(IrisData data) {
+    public int getMaxWithObjectHeight(IrisData data, Engine engine) {
        return maxWithObjectHeight.aquire(() ->
        {
            int maxHeight = 0;

            for (IrisBiomeGeneratorLink i : getGenerators()) {
-                maxHeight += i.getMax();
+                maxHeight += i.getMax(engine);
            }

            int gg = 0;
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisBiomeGeneratorLink.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisBiomeGeneratorLink.java
@@ -18,14 +18,13 @@

 package com.volmit.iris.engine.object;

-import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.Iris;
 import com.volmit.iris.engine.data.cache.AtomicCache;
+import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.annotations.*;
 import com.volmit.iris.util.data.DataProvider;
 import com.volmit.iris.util.interpolation.IrisInterpolation;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
+import lombok.*;
 import lombok.experimental.Accessors;

@Snippet("generator-layer")
@@ -40,22 +39,23 @@ public class IrisBiomeGeneratorLink {
    @RegistryListResource(IrisGenerator.class)
    @Desc("The generator id")
    private String generator = "default";
-    @DependsOn({"min", "max"})
+    @DependsOn({ "min", "max" })
    @Required
    @MinNumber(-2032) // TODO: WARNING HEIGHT
    @MaxNumber(2032) // TODO: WARNING HEIGHT
    @Desc("The min block value (value + fluidHeight)")
+    @Getter(AccessLevel.NONE)
    private int min = 0;
-    @DependsOn({"min", "max"})
+    @DependsOn({ "min", "max" })
    @Required
    @MinNumber(-2032) // TODO: WARNING HEIGHT
    @MaxNumber(2032) // TODO: WARNING HEIGHT
+    @Getter(AccessLevel.NONE)
    @Desc("The max block value (value + fluidHeight)")
    private int max = 0;

    public IrisGenerator getCachedGenerator(DataProvider g) {
-        return gen.aquire(() ->
-        {
+        return gen.aquire(() -> {
            IrisGenerator gen = g.getData().getGeneratorLoader().load(getGenerator());

            if (gen == null) {
@@ -66,21 +66,74 @@ public class IrisBiomeGeneratorLink {
        });
    }

+    private int[] getBiomeGeneratorsRaw(Engine engine) {
+        int max = engine.getDimension().getMinHeight();
+        int min = engine.getDimension().getMaxHeight();
+        for (IrisBiome biome : engine.getAllBiomes()) {
+            for (IrisBiomeGeneratorLink i : biome.getGenerators()) {
+                int biomeRawMax = i.getMaxRaw();
+                int biomeRawMin = i.getMinRaw();
+                if (max < biomeRawMax)
+                    max = biomeRawMax;
+                if (min > biomeRawMin)
+                    min = biomeRawMin;
+            }
+        }
+
+        return new int[] { min, max };
+    }
+
+    private int calculateHeight(Engine engine, int option) {
+        int dmx = engine.getDimension().getMaxHeight();
+        int dmn = engine.getDimension().getMinHeight();
+        int[] heights = getBiomeGeneratorsRaw(engine);
+        int gmx = heights[1];
+        int gmn = heights[0];
+
+        int mx = getMaxRaw();
+        int mn = getMinRaw();
+        if (engine.getDimension().isSmartVanillaHeight()) {
+            if (mx > 0)
+                mx = Math.min((int) (((float) mx / (float) gmx) * 300.0f), 300);
+            if (mx < 0)
+                mx = Math.min((int) (((float) mx / (float) gmn) * 300.0f), 56);
+
+            if (mn > 0)
+                mn = Math.min((int) (((float) mn / (float) gmx) * 300.0f), 300);
+            if (mn < 0)
+                mn = Math.min((int) (((float) mn / (float) gmn) * 300.0f), 56);
+        }
+
+        if (option == 1) {
+            return mx;
+        }
+        if (option == 0) {
+            return mn;
+        }
+        Iris.error("Fatal Generator error!");
+        return 0;
+    }
+
+    public int getMax(Engine engine) {
+        return calculateHeight(engine, 1);
+    }
+
+    public int getMin(Engine engine) {
+        return calculateHeight(engine, 0);
+    }
+
+    private int getMaxRaw() {
+        return max;
+    }
+
+    private int getMinRaw() {
+        return min;
+    }
+
    public double getHeight(DataProvider xg, double x, double z, long seed) {
        double g = getCachedGenerator(xg).getHeight(x, z, seed);
        g = g < 0 ? 0 : g;
        g = g > 1 ? 1 : g;
-//        if (IrisSettings.get().getGenerator().forceConvertTo320Height) {
-//           if (max > 320 || min > 320) {
-//                double scaleFactor = 320.0 / Math.max(max, min);
-//                min *= (int) scaleFactor;
-//                max *= (int) scaleFactor;
-//                if (min < 0) {
-//
-//                }
-//            }
-//        }
-        // todo This

        return IrisInterpolation.lerp(min, max, g);
    }
--- a/core/src/main/java/com/volmit/iris/engine/object/IrisDimension.java
+++ b/core/src/main/java/com/volmit/iris/engine/object/IrisDimension.java
@@ -19,6 +19,7 @@
 package com.volmit.iris.engine.object;

 import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
 import com.volmit.iris.engine.data.cache.AtomicCache;
@@ -210,6 +211,8 @@ public class IrisDimension extends IrisRegistrant {
    private IrisCarving carving = new IrisCarving();
    @Desc("Configuration of fluid bodies such as rivers & lakes")
    private IrisFluidBodies fluidBodies = new IrisFluidBodies();
+    @Desc("forceConvertTo320Height")
+    private Boolean forceConvertTo320Height = false;
    @Desc("The world environment")
    private Environment environment = Environment.NORMAL;
    @RegistryListResource(IrisRegion.class)
@@ -231,6 +234,8 @@ public class IrisDimension extends IrisRegistrant {
    private IrisRange dimensionHeightEnd = new IrisRange(-64, 320);
    @Desc("Define the min and max Y bounds of this dimension. Please keep in mind that Iris internally generates from 0 to (max - min). \n\nFor example at -64 to 320, Iris is internally generating to 0 to 384, then on outputting chunks, it shifts it down by the min height (64 blocks). The default is -64 to 320. \n\nThe fluid height is placed at (fluid height + min height). So a fluid height of 63 would actually show up in the world at 1.")
    private IrisRange dimensionHeightNether = new IrisRange(-64, 320);
+    @Desc("Enable smart vanilla height")
+    private boolean smartVanillaHeight = false;
    @RegistryListResource(IrisBiome.class)
    @Desc("Keep this either undefined or empty. Setting any biome name into this will force iris to only generate the specified biome. Great for testing.")
    private String focus = "";
--- a/core/src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java
+++ b/core/src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java
@@ -58,6 +58,8 @@ import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

 import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
 import java.lang.reflect.Field;
 import java.util.List;
 import java.util.Random;
@@ -82,6 +84,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
    private final AtomicBoolean setup;
    private final boolean studio;
    private final AtomicInteger a = new AtomicInteger(0);
+    private final boolean smartVanillaHeight;
    private Engine engine;
    private Looper hotloader;
    private StudioMode lastMode;
@@ -91,7 +94,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun

    private boolean initialized = false;

-    public BukkitChunkGenerator(IrisWorld world, boolean studio, File dataLocation, String dimensionKey) {
+    public BukkitChunkGenerator(IrisWorld world, boolean studio, File dataLocation, String dimensionKey, boolean smartVanillaHeight) {
        setup = new AtomicBoolean(false);
        studioGenerator = null;
        dummyBiomeProvider = new DummyBiomeProvider();
@@ -103,6 +106,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
        this.dataLocation = dataLocation;
        this.dimensionKey = dimensionKey;
        this.folder = new ReactiveFolder(dataLocation, (_a, _b, _c) -> hotload());
+        this.smartVanillaHeight = smartVanillaHeight;
        Bukkit.getServer().getPluginManager().registerEvents(this, Iris.instance);
    }

@@ -181,6 +185,14 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
                throw new RuntimeException("Missing Dimension: " + dimensionKey);
            }
        }
+        if (smartVanillaHeight) {
+            dimension.setSmartVanillaHeight(true);
+            try (FileWriter writer = new FileWriter(data.getDimensionLoader().fileFor(dimension))) {
+                writer.write(data.getGson().toJson(dimension));
+            } catch (IOException e) {
+                e.printStackTrace();
+            }
+        }

        lastMode = StudioMode.NORMAL;
        engine = new IrisEngine(new EngineTarget(world, dimension, data), studio);
--- a/core/src/main/java/com/volmit/iris/util/misc/Hastebin.java
+++ b/core/src/main/java/com/volmit/iris/util/misc/Hastebin.java
@@ -0,0 +1,135 @@
+package com.volmit.iris.util.misc;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.framework.Engine;
+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import net.md_5.bungee.api.chat.ClickEvent;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.command.CommandSender;
+import oshi.SystemInfo;
+
+import java.io.BufferedReader;
+import java.io.DataOutputStream;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.nio.file.Files;
+import java.util.List;
+
+public class Hastebin {
+
+    public static void enviornment(CommandSender sender) {
+        // Construct the server information
+        StringBuilder sb = new StringBuilder();
+        SystemInfo systemInfo = new SystemInfo();
+        KList<String> disks = new KList<>(getHardware.getDisk());
+        KList<String> interfaces = new KList<>(getHardware.getInterfaces());
+        KList<String> displays = new KList<>(getHardware.getEDID());
+        KList<String> sensors = new KList<>(getHardware.getSensors());
+        KList<String> gpus = new KList<>(getHardware.getGraphicsCards());
+        KList<String> powersources = new KList<>(getHardware.getPowerSources());
+
+        KList<World> IrisWorlds = new KList<>();
+        KList<World> BukkitWorlds = new KList<>();
+
+        for (World w : Bukkit.getServer().getWorlds()) {
+            try {
+                Engine engine = IrisToolbelt.access(w).getEngine();
+                if (engine != null) {
+                    IrisWorlds.add(w);
+                }
+            } catch (Exception e) {
+                BukkitWorlds.add(w);
+            }
+        }
+
+        sb.append(" -- == Iris Info == -- \n");
+        sb.append("Iris Version Version: ").append(Iris.instance.getDescription().getVersion()).append("\n");
+        sb.append("- Iris Worlds");
+        for (World w : IrisWorlds.copy()) {
+            sb.append(" - ").append(w.getName());
+        }
+        sb.append("- Bukkit Worlds");
+        for (World w : BukkitWorlds.copy()) {
+            sb.append(" - ").append(w.getName());
+        }
+        sb.append(" -- == Platform Overview == -- " + "\n");
+        sb.append("Server Type: ").append(Bukkit.getVersion()).append("\n");
+        sb.append("Server Uptime: ").append(Form.stampTime(systemInfo.getOperatingSystem().getSystemUptime())).append("\n");
+        sb.append("Version: ").append(Platform.getVersion()).append(" - Platform: ").append(Platform.getName()).append("\n");
+        sb.append("Java Vendor: ").append(Platform.ENVIRONMENT.getJavaVendor()).append(" - Java Version: ").append(Platform.ENVIRONMENT.getJavaVersion()).append("\n");
+        sb.append(" -- == Processor Overview == -- " + "\n");
+        sb.append("CPU Model: ").append(getHardware.getCPUModel());
+        sb.append("CPU Architecture: ").append(Platform.CPU.getArchitecture()).append(" Available Processors: ").append(Platform.CPU.getAvailableProcessors()).append("\n");
+        sb.append("CPU Load: ").append(Form.pc(Platform.CPU.getCPULoad())).append(" CPU Live Process Load: ").append(Form.pc(Platform.CPU.getLiveProcessCPULoad())).append("\n");
+        sb.append("-=" + " Graphics " + "=- " + "\n");
+        for (String gpu : gpus) {
+            sb.append(" ").append(gpu).append("\n");
+        }
+        sb.append(" -- == Memory Information == -- " + "\n");
+        sb.append("Physical Memory - Total: ").append(Form.memSize(Platform.MEMORY.PHYSICAL.getTotalMemory())).append(" Free: ").append(Form.memSize(Platform.MEMORY.PHYSICAL.getFreeMemory())).append(" Used: ").append(Form.memSize(Platform.MEMORY.PHYSICAL.getUsedMemory())).append("\n");
+        sb.append("Virtual Memory - Total: ").append(Form.memSize(Platform.MEMORY.VIRTUAL.getTotalMemory())).append(" Free: ").append(Form.memSize(Platform.MEMORY.VIRTUAL.getFreeMemory())).append(" Used: ").append(Form.memSize(Platform.MEMORY.VIRTUAL.getUsedMemory())).append("\n");
+        sb.append(" -- == Storage Information == -- " + "\n");
+        for (String disk : disks) {
+            sb.append(" ").append(sb.append(disk)).append("\n");
+        }
+        sb.append(" -- == Interface Information == -- "+ "\n" );
+        for (String inter : interfaces) {
+            sb.append(" ").append(inter).append("\n");
+        }
+        sb.append(" -- == Display Information == -- "+ "\n" );
+        for (String display : displays) {
+            sb.append(display).append("\n");
+        }
+        sb.append(" -- == Sensor Information == -- " + "\n");
+        for (String sensor : sensors) {
+            sb.append(" ").append(sensor).append("\n");
+        }
+        sb.append(" -- == Power Information == -- " + "\n");
+        for (String power : powersources) {
+            sb.append(" ").append(power).append("\n");
+        }
+
+        try {
+            String hastebinUrl = uploadToHastebin(sb.toString());
+
+            // Create the clickable message
+            TextComponent message = new TextComponent("[Link]");
+            TextComponent link = new TextComponent(hastebinUrl);
+            link.setClickEvent(new ClickEvent(ClickEvent.Action.OPEN_URL, hastebinUrl));
+            message.addExtra(link);
+
+            // Send the clickable message to the player
+            sender.spigot().sendMessage(message);
+        } catch (Exception e) {
+            sender.sendMessage(C.DARK_RED + "Failed to upload server information to Hastebin.");
+        }
+    }
+
+    private static String uploadToHastebin(String content) throws Exception {
+        URL url = new URL("https://paste.bytecode.ninja/documents");
+        HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+        conn.setRequestMethod("POST");
+        conn.setRequestProperty("Content-Type", "text/plain");
+        conn.setDoOutput(true);
+
+        DataOutputStream wr = new DataOutputStream(conn.getOutputStream());
+        wr.writeBytes(content);
+        wr.flush();
+        wr.close();
+
+        BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
+        String response = br.readLine();
+        br.close();
+
+        return "https://paste.bytecode.ninja/" + response.split("\"")[3];
+    }
+
+
+}
--- a/core/src/main/java/com/volmit/iris/util/misc/Platform.java
+++ b/core/src/main/java/com/volmit/iris/util/misc/Platform.java
@@ -0,0 +1,145 @@
+package com.volmit.iris.util.misc;
+
+import com.sun.management.OperatingSystemMXBean;
+
+import java.io.File;
+import java.lang.management.ManagementFactory;
+
+@SuppressWarnings("restriction")
+public class Platform {
+    public static String getVersion() {
+        return getSystem().getVersion();
+    }
+
+    public static String getName() {
+        return getSystem().getName();
+    }
+
+    private static OperatingSystemMXBean getSystem() {
+        return (OperatingSystemMXBean) ManagementFactory.getOperatingSystemMXBean();
+    }
+
+    public static class ENVIRONMENT {
+        public static boolean canRunBatch() {
+            return getSystem().getName().toLowerCase().contains("windows");
+        }
+
+        public static String getJavaHome() {
+            return System.getProperty("java.home");
+        }
+
+        public static String getJavaVendor() {
+            return System.getProperty("java.vendor");
+        }
+
+        public static String getJavaVersion() {
+            return System.getProperty("java.version");
+        }
+    }
+
+    public static class STORAGE {
+        public static long getAbsoluteTotalSpace() {
+            long t = 0;
+
+            for (File i : getRoots()) {
+                t += getTotalSpace(i);
+            }
+
+            return t;
+        }
+
+        public static long getTotalSpace() {
+            return getTotalSpace(new File("."));
+        }
+
+        public static long getTotalSpace(File root) {
+            return root.getTotalSpace();
+        }
+
+        public static long getAbsoluteFreeSpace() {
+            long t = 0;
+
+            for (File i : getRoots()) {
+                t += getFreeSpace(i);
+            }
+
+            return t;
+        }
+
+        public static long getFreeSpace() {
+            return getFreeSpace(new File("."));
+        }
+
+        public static long getFreeSpace(File root) {
+            return root.getFreeSpace();
+        }
+
+        public static long getUsedSpace() {
+            return getTotalSpace() - getFreeSpace();
+        }
+
+        public static long getUsedSpace(File root) {
+            return getTotalSpace(root) - getFreeSpace(root);
+        }
+
+        public static long getAbsoluteUsedSpace() {
+            return getAbsoluteTotalSpace() - getAbsoluteFreeSpace();
+        }
+
+        public static File[] getRoots() {
+            return File.listRoots();
+        }
+    }
+
+    public static class MEMORY {
+        public static class PHYSICAL {
+            public static long getTotalMemory() {
+                return getSystem().getTotalPhysicalMemorySize();
+            }
+
+            public static long getFreeMemory() {
+                return getSystem().getFreePhysicalMemorySize();
+            }
+
+            public static long getUsedMemory() {
+                return getTotalMemory() - getFreeMemory();
+            }
+        }
+
+        public static class VIRTUAL {
+            public static long getTotalMemory() {
+                return getSystem().getTotalSwapSpaceSize();
+            }
+
+            public static long getFreeMemory() {
+                return getSystem().getFreeSwapSpaceSize();
+            }
+
+            public static long getUsedMemory() {
+                return getTotalMemory() - getFreeMemory();
+            }
+
+            public static long getCommittedVirtualMemory() {
+                return getSystem().getCommittedVirtualMemorySize();
+            }
+        }
+    }
+
+    public static class CPU {
+        public static int getAvailableProcessors() {
+            return getSystem().getAvailableProcessors();
+        }
+
+        public static double getCPULoad() {
+            return getSystem().getSystemCpuLoad();
+        }
+
+        public static double getLiveProcessCPULoad() {
+            return getSystem().getProcessCpuLoad();
+        }
+
+        public static String getArchitecture() {
+            return getSystem().getArch();
+        }
+    }
+}
--- a/core/src/main/java/com/volmit/iris/util/misc/getHardware.java
+++ b/core/src/main/java/com/volmit/iris/util/misc/getHardware.java
@@ -1,11 +1,24 @@
 package com.volmit.iris.util.misc;

-import oshi.SystemInfo;
-import oshi.hardware.CentralProcessor;
-import oshi.hardware.HWDiskStore;
-import oshi.software.os.OperatingSystem;

+import com.volmit.iris.util.collection.KList;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.format.Form;
+import org.jetbrains.annotations.Nullable;
+import oshi.SystemInfo;
+import oshi.hardware.*;
+import oshi.software.os.FileSystem;
+import oshi.software.os.OSFileStore;
+import oshi.software.os.OperatingSystem;
+import oshi.util.EdidUtil;
+
+import java.net.InetAddress;
+import java.net.NetworkInterface;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Enumeration;
 import java.util.List;
+import java.util.stream.Collectors;

 public class getHardware {
    public static String getServerOS() {
@@ -44,14 +57,127 @@ public class getHardware {
        }
    }

-    public static String getDiskModel() {
-        SystemInfo systemInfo = new SystemInfo();
-        List<HWDiskStore> diskStores = systemInfo.getHardware().getDiskStores();
-        if (!diskStores.isEmpty()) {
-            HWDiskStore firstDisk = diskStores.get(0);
-            return firstDisk.getModel();
-        } else {
-            return "Unknown Disk Model";
+    public static KList<String> getSensors() {
+        try {
+            KList<String> temps = new KList<>();
+            SystemInfo systemInfo = new SystemInfo();
+            temps.add("CPU Temperature: " + systemInfo.getHardware().getSensors().getCpuTemperature());
+            temps.add("CPU Voltage: " + systemInfo.getHardware().getSensors().getCpuTemperature());
+            temps.add("Fan Speeds: " + Arrays.toString(systemInfo.getHardware().getSensors().getFanSpeeds()));
+            return temps.copy();
+        } catch (Exception e) {
+            e.printStackTrace();
        }
+        return null;
    }
-}
+
+    public static KList<String> getGraphicsCards() {
+        try {
+            KList<String> gpus = new KList<>();
+            SystemInfo systemInfo = new SystemInfo();
+            for (GraphicsCard gpu : systemInfo.getHardware().getGraphicsCards()) {
+                gpus.add(C.BLUE + "Gpu Model: " + C.GRAY + gpu.getName());
+                gpus.add("- vRam Size: " + C.GRAY + Form.memSize(gpu.getVRam()));
+                gpus.add("- Vendor: " + C.GRAY + gpu.getVendor());
+            }
+            return gpus.copy();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static KList<String> getDisk() {
+        try {
+            KList<String> systemDisks = new KList<>();
+            SystemInfo systemInfo = new SystemInfo();
+            List<HWDiskStore> diskStores = systemInfo.getHardware().getDiskStores();
+            OperatingSystem operatingSystem = systemInfo.getOperatingSystem();
+            List<OSFileStore> fileStores = operatingSystem.getFileSystem().getFileStores();
+
+            for (HWDiskStore disk : diskStores) {
+                systemDisks.add(C.BLUE + "Disk: " + disk.getName());
+                systemDisks.add("- Model: " + disk.getModel());
+                systemDisks.add("Partitions: " + disk.getPartitions());
+                for (OSFileStore partition : fileStores) {
+                    systemDisks.add(C.BLUE + "- Name: " + partition.getName());
+                    systemDisks.add(" - Description: " + partition.getDescription());
+                    systemDisks.add(" - Total Space: " + Form.memSize(partition.getTotalSpace()));
+                    systemDisks.add(" - Free Space: " + Form.memSize(partition.getFreeSpace()));
+                    systemDisks.add(" - Mount: " + partition.getMount());
+                    systemDisks.add(" - Label: " + partition.getLabel());
+                }
+                systemDisks.add(C.DARK_GRAY + "-=" + C.BLUE +" Since Boot " + C.DARK_GRAY + "=- ");
+                systemDisks.add("- Total Reads: " + Form.memSize(disk.getReadBytes()));
+                systemDisks.add("- Total Writes: " + Form.memSize(disk.getWriteBytes()));
+            }
+            if (systemDisks.isEmpty()) {
+                systemDisks.add("Failed to get disks.");
+            }
+            return systemDisks.copy();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static KList<String> getPowerSources() {
+        try {
+            KList<String> systemPowerSources = new KList<>();
+            SystemInfo systemInfo = new SystemInfo();
+            List<PowerSource> powerSources = systemInfo.getHardware().getPowerSources();
+            for (PowerSource powersource : powerSources) {
+                systemPowerSources.add(C.BLUE + "- Name: " + powersource.getName());
+                systemPowerSources.add("- RemainingCapacityPercent: " + powersource.getRemainingCapacityPercent());
+                systemPowerSources.add("- Power Usage Rate: " + powersource.getPowerUsageRate());
+                systemPowerSources.add("- Power OnLine: " + powersource.isPowerOnLine());
+                systemPowerSources.add("- Capacity Units: " + powersource.getCapacityUnits());
+                systemPowerSources.add("- Cycle Count: " + powersource.getCycleCount());
+            }
+            if (systemPowerSources.isEmpty()) {
+                systemPowerSources.add("No PowerSources.");
+            }
+            return systemPowerSources.copy();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static KList<String> getEDID() {
+        try {
+            KList<String> systemEDID = new KList<>();
+            SystemInfo systemInfo = new SystemInfo();
+            HardwareAbstractionLayer hardware = systemInfo.getHardware();
+            List<Display> displays = hardware.getDisplays();
+            for (Display display : displays) {
+                systemEDID.add("Display: " + display.getEdid());
+            }
+            if (!systemEDID.isEmpty()) {
+                systemEDID.add("No displays");
+            }
+            return systemEDID.copy();
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static KList<String> getInterfaces() {
+        try {
+            KList<String> interfaces = new KList<>();
+            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
+            for (NetworkInterface ni : Collections.list(networkInterfaces)) {
+                interfaces.add(C.BLUE + "Display Name: %s", ni.getDisplayName());
+                Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
+                for (InetAddress ia : Collections.list(inetAddresses)) {
+                    interfaces.add("IP: %s", ia.getHostAddress());
+                }
+                return interfaces.copy();
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}
--- a/core/src/main/java/com/volmit/iris/util/nbt/mca/Chunk.java
+++ b/core/src/main/java/com/volmit/iris/util/nbt/mca/Chunk.java
@@ -27,10 +27,12 @@ import com.volmit.iris.util.nbt.io.NamedTag;
 import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
 import com.volmit.iris.util.nbt.tag.CompoundTag;
 import com.volmit.iris.util.nbt.tag.ListTag;
+import org.bukkit.World;

 import java.io.*;

 import static com.volmit.iris.util.nbt.mca.LoadFlags.*;
+import static org.bukkit.Bukkit.getServer;

 public class Chunk {
    public static final int DEFAULT_DATA_VERSION = 2730;
@@ -39,6 +41,7 @@ public class Chunk {
    private int lastMCAUpdate;
    private CompoundTag data;
    private int dataVersion;
+    private int nativeIrisVersion;
    private long lastUpdate;
    private long inhabitedTime;
    private MCABiomeContainer biomes;
@@ -71,15 +74,21 @@ public class Chunk {
    }

    public static Chunk newChunk() {
+        World mainWorld = getServer().getWorlds().get(0);
        Chunk c = new Chunk(0);
        c.dataVersion = DEFAULT_DATA_VERSION;
        c.data = new CompoundTag();
-        c.biomes = INMS.get().newBiomeContainer(0, 256);
+        c.biomes = INMS.get().newBiomeContainer(mainWorld.getMinHeight(), mainWorld.getMaxHeight());
        c.data.put("Level", defaultLevel());
        c.status = "full";
        return c;
    }

+    public static void injectIrisData(Chunk c) {
+        World mainWorld = getServer().getWorlds().get(0);
+        c.data.put("Iris", nativeIrisVersion());
+    }
+
    private static CompoundTag defaultLevel() {
        CompoundTag level = new CompoundTag();
        level.putString("Status", "full");
@@ -87,19 +96,25 @@ public class Chunk {
        return level;
    }

+    private static CompoundTag nativeIrisVersion() {
+        CompoundTag level = new CompoundTag();
+        level.putString("Generator", "Iris " + Iris.instance.getDescription().getVersion());
+        return level;
+    }
+
    private void initReferences(long loadFlags) {
        if (data == null) {
            throw new NullPointerException("data cannot be null");
        }
-        CompoundTag level;
-        if ((level = data.getCompoundTag("Level")) == null) {
-            throw new IllegalArgumentException("data does not contain \"Level\" tag");
-        }
+
+        CompoundTag level = data;
+
+        World mainWorld = getServer().getWorlds().get(0);
        dataVersion = data.getInt("DataVersion");
        inhabitedTime = level.getLong("InhabitedTime");
        lastUpdate = level.getLong("LastUpdate");
        if ((loadFlags & BIOMES) != 0) {
-            biomes = INMS.get().newBiomeContainer(0, 256, level.getIntArray("Biomes"));
+            biomes = INMS.get().newBiomeContainer(mainWorld.getMinHeight(), mainWorld.getMaxHeight(), level.getIntArray("Biomes"));
        }
        if ((loadFlags & HEIGHTMAPS) != 0) {
            heightMaps = level.getCompoundTag("Heightmaps");
Author	SHA1	Message	Date
Brian Neumann-Fopiano	a3dcf031c9	v+ , and the other v+ lol	2024-04-29 15:45:41 -04:00
RePixelatedMC	468e7ef018	Merge pull request #1094 from RePixelatedMC/master Update README.md	2024-04-27 12:42:50 +02:00
RePixelatedMC	e3e4ecbc5c	Update README.md	2024-04-27 12:41:29 +02:00
RePixelatedMC	e7c9cad7f6	Merge pull request #1093 from RePixelatedMC/3.2.5 3.2.5	2024-04-26 18:06:37 +02:00
RePixelatedMC	178a462a4e	e	2024-04-23 12:29:19 +02:00
RePixelatedMC	8f4ae613f0	Merge branch '3.2.5' of https://github.com/RePixelatedMC/Iris into PixelatedDev # Conflicts: # core/src/main/java/com/volmit/iris/core/commands/CommandIris.java	2024-04-23 11:29:18 +02:00
RePixelatedMC	9e6963b6ce	A lot of improvements thanks to CrazyDev!	2024-04-23 11:24:53 +02:00
RePixelatedMC	2555cd23a0	Merge branch 'VolmitSoftware:master' into 3.2.6	2024-04-19 15:17:21 +02:00
RePixelatedMC	484fbeca7b	Merge branch '3.2.6' of https://github.com/RePixelatedMC/Iris into PixelatedDev # Conflicts: # core/src/main/java/com/volmit/iris/core/commands/CommandIris.java # core/src/main/java/com/volmit/iris/core/safeguard/ServerBootSFG.java	2024-04-19 15:16:46 +02:00
RePixelatedMC	9a45e0df10	/iris support report ( gives server info ) and cleaned the main splash screen and fixed /iris import saying its loaded successfully even if it didnt	2024-04-19 15:15:08 +02:00
RePixelatedMC	9175296fc6	rev2.0	2024-04-19 12:43:57 +02:00
RePixelatedMC	5a4a86aeba	- Iris Updater Updates chunks thats it/	2024-04-19 10:14:16 +02:00
Brian Neumann-Fopiano	768fa7beb5	v+	2024-04-19 02:47:02 -04:00
Brian Fopiano	8f019cd794	Merge pull request #1088 from RePixelatedMC/PixelatedDev 3.2.5 iris	2024-04-18 07:13:52 -04:00
RePixelatedMC	72ed312654	wops	2024-04-16 18:09:03 +02:00
RePixelatedMC	c7fe4723f7	Merge remote-tracking branch 'origin/master' into PixelatedDev	2024-04-16 17:18:51 +02:00
RePixelatedMC	bfbea83a4a	- Fixed NMS biome height. - Improved /iris load - Improved Vanilla height converter - Removed WorldCreation unstable message	2024-04-16 17:18:02 +02:00
RePixelatedMC	55c58fe896	Merge pull request #1087 from RePixelatedMC/PixelatedDev Should work	2024-04-16 16:34:12 +02:00
RePixelatedMC	72949e0950	Update IrisSettings.java	2024-04-16 16:32:52 +02:00
RePixelatedMC	7fb2a51a33	sync	2024-04-12 17:08:13 +02:00
RePixelatedMC	5b7c0b2bc3	Merge branch 'PixelatedDev' of https://github.com/RePixelatedMC/Iris into PixelatedDev # Conflicts: # core/src/main/java/com/volmit/iris/engine/object/IrisBiome.java # core/src/main/java/com/volmit/iris/engine/object/IrisBiomeGeneratorLink.java	2024-04-09 20:07:50 +02:00
RePixelatedMC	fc15175ff9	Improved?	2024-04-09 20:06:32 +02:00
RePixelatedMC	1eec3a09c1	now it should work	2024-04-09 18:05:27 +02:00
RePixelatedMC	60d349dd8b	test	2024-04-09 17:05:43 +02:00
RePixelatedMC	0c8d144ffb	Merge remote-tracking branch 'VolmitDev/smartHeight' into PixelatedDev	2024-04-09 17:04:45 +02:00
RePixelatedMC	b898f73a05	Fixed another potential mem leak Added the base of smart320height	2024-04-09 17:04:32 +02:00
CrazyDev22	c2b9b0ba0e	add smartVanillaHeight	2024-04-09 16:52:14 +02:00
RePixelatedMC	206a4e9057	Revert "sync laptop" This reverts commit `63b8a935ae`.	2024-04-06 17:07:14 +02:00
RePixelatedMC	83a0a7dd54	sync laptop	2024-04-06 17:06:06 +02:00
RePixelatedMC	63b8a935ae	sync laptop	2024-04-05 18:43:30 +02:00
RePixelatedMC	bad547356c	Disabled for now	2024-01-14 16:43:39 +01:00
RePixelatedMC	1740bb0021	whoop	2024-01-14 16:35:00 +01:00
RePixelatedMC	669ede5482	remove turbo for now	2024-01-14 10:18:41 +01:00