v+

Merge pull request #1038 from RePixelatedMC/repixelatedmc
Repixelatedmc
2026-01-03 14:22:30 +00:00 · 2023-10-22 23:35:58 -04:00 · 2023-10-22 23:17:53 -04:00 · 2023-10-22 23:17:26 -04:00 · 2023-10-22 20:08:58 +02:00 · 2023-10-22 15:22:01 +02:00
19 changed files with 1404 additions and 105 deletions
--- a/build.gradle
+++ b/build.gradle
@@ -24,7 +24,7 @@ plugins {
    id "de.undercouch.download" version "5.0.1"
 }

-version '2.7.6-1.20.1'
+version '2.8.1-1.20.1'
 def nmsVersion = '1.20.1' //[NMS]
 def apiVersion = '1.20'
 def specialSourceVersion = '1.11.0' //[NMS]
@@ -40,6 +40,8 @@ registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/s
 registerCustomOutputTask('Coco', 'D://mcsm/plugins')
 registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
 registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19.4/plugins')
+registerCustomOutputTask('CrazyDev22', 'C://Users/Julian/Desktop/server/plugins')
+registerCustomOutputTask('Pixel', 'C://Users/repix/Iris Dimension Engine/1.20.1 - Iris Coding/plugins')
 // ========================== UNIX ==============================
 registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
 registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Desktop/REMOTES/RemoteMinecraft/plugins')
@@ -75,7 +77,8 @@ repositories {
        }
    }
    mavenCentral()
-    maven { url "https://arcanearts.jfrog.io/artifactory/archives" }
+    maven { url "https://repo.papermc.io/repository/maven-public/"}
+    maven { url "https://repo.codemc.org/repository/maven-public" }
    maven { url "https://mvn.lumine.io/repository/maven-public/" }
    maven { url "https://jitpack.io"}

@@ -137,7 +140,7 @@ dependencies {
    implementation 'com.ticxo.playeranimator:PlayerAnimator:R1.2.7'
    implementation 'com.github.oraxen:oraxen:1.158.0'
    implementation 'com.github.LoneDev6:api-itemsadder:3.4.1-r4'
-    implementation 'me.clip:placeholderapi:2.11.3'
+    implementation 'com.github.PlaceholderAPI:placeholderapi:2.11.3'
    //implementation files('libs/CustomItems.jar')

    // Shaded
--- a/listing.json
+++ b/listing.json
@@ -4,7 +4,7 @@
  "flat IrisDimensions/flat",
  "redstone IrisDimensions/redstone",
  "mars IrisDimensions/mars",
-  "example IrisDimensions/example"
+  "example IrisDimensions/example",
  "newhorizons IrisDimensions/newhorizons",
  "theend IrisDimensions/theend"
 ]
--- a/src/main/java/com/volmit/iris/Iris.java
+++ b/src/main/java/com/volmit/iris/Iris.java
@@ -38,6 +38,8 @@ import com.volmit.iris.engine.object.IrisDimension;
 import com.volmit.iris.engine.object.IrisWorld;
 import com.volmit.iris.engine.platform.BukkitChunkGenerator;
 import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.engine.safeguard.IrisSafeguard;
+import com.volmit.iris.engine.safeguard.ServerBoot;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.collection.KMap;
 import com.volmit.iris.util.exceptions.IrisException;
@@ -85,13 +87,18 @@ import org.jetbrains.annotations.Nullable;

 import java.io.*;
 import java.lang.annotation.Annotation;
+import java.lang.management.ManagementFactory;
+import java.lang.management.OperatingSystemMXBean;
 import java.net.URL;
 import java.util.Date;
 import java.util.Map;

+import static com.volmit.iris.engine.safeguard.IrisSafeguard.unstablemode;
+import static com.volmit.iris.engine.safeguard.ServerBoot.passedserversoftware;
+
@SuppressWarnings("CanBeFinal")
 public class Iris extends VolmitPlugin implements Listener {
-    public static final String OVERWORLD_TAG = "3620";
+    public static final String OVERWORLD_TAG = "3800";

    private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();

@@ -308,6 +315,9 @@ public class Iris extends VolmitPlugin implements Listener {
    public static void info(String format, Object... args) {
        msg(C.WHITE + String.format(format, args));
    }
+    public static void safeguard(String format, Object... args) {
+        msg(C.RESET + String.format(format, args));
+    }

    @SuppressWarnings("deprecation")
    public static void later(NastyRunnable object) {
@@ -455,6 +465,9 @@ public class Iris extends VolmitPlugin implements Listener {
            J.s(this::setupPapi);
            J.a(ServerConfigurator::configure, 20);
            splash();
+            ServerBoot.UnstableMode();
+            ServerBoot.SupportedServerSoftware();
+            ServerBoot.printincompatiblepluginWarnings();
            autoStartStudio();
            checkForBukkitWorlds();
            IrisToolbelt.retainMantleDataForSlice(String.class.getCanonicalName());
@@ -542,6 +555,7 @@ public class Iris extends VolmitPlugin implements Listener {
        enable();
        super.onEnable();
        Bukkit.getPluginManager().registerEvents(this, this);
+        IrisSafeguard.IrisSafeguardSystem();
        setupChecks();
    }

@@ -714,12 +728,10 @@ public class Iris extends VolmitPlugin implements Listener {
            return;
        }

-        // @NoArgsConstructor
        String padd = Form.repeat(" ", 8);
        String padd2 = Form.repeat(" ", 4);
-        String[] info = {"", "", "", "", "", padd2 + C.IRIS + " Iris", padd2 + C.GRAY + " by " + "<rainbow>Volmit Software", padd2 + C.GRAY + " v" + C.IRIS + getDescription().getVersion(),
-        };
-        String[] splash = {
+        String[] info = {"", "", "", "", "", padd2 + C.IRIS + " Iris", padd2 + C.GRAY + " by " + "<rainbow>Volmit Software", padd2 + C.GRAY + " v" + C.IRIS + getDescription().getVersion()};
+        String[] splashstable = {
                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.IRIS + "   .(((()))).                     ",
                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.IRIS + "  .((((((())))))).                  ",
@@ -732,8 +744,37 @@ public class Iris extends VolmitPlugin implements Listener {
                padd + C.GRAY + "" + C.IRIS + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
        };
-        //@done
-        Iris.info("Server type & version: " + Bukkit.getVersion());
+
+        String[] splashunstable = {
+                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
+                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.RED + "   .(((()))).                     ",
+                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.RED + "  .((((((())))))).                  ",
+                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.RED + "  ((((((((()))))))))               " + C.GRAY + " @",
+                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.RED + "    ((((((((-)))))))))              " + C.GRAY + " @@",
+                padd + C.GRAY + "@@@&&" + C.RED + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
+                padd + C.GRAY + "@@" + C.RED + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
+                padd + C.GRAY + "@" + C.RED + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
+                padd + C.GRAY + "" + C.RED + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
+                padd + C.GRAY + "" + C.RED + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
+                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
+        };
+        String[] splash = unstablemode ? splashunstable : splashstable; // Choose the appropriate splash array based on unstablemode
+
+
+        long maxMemory = Runtime.getRuntime().maxMemory() / (1024 * 1024);
+        OperatingSystemMXBean osBean = ManagementFactory.getOperatingSystemMXBean();
+        String osArch = osBean.getArch();
+        String osName = osBean.getName();
+
+        if (!passedserversoftware) {
+            Iris.info("Server type & version: " + C.RED + Bukkit.getVersion());
+        } else { Iris.info("Server type & version: " + Bukkit.getVersion()); }
+
+        Iris.info("Server OS: " + osName + " (" + osArch + ")");
+        Iris.info("Process Memory: " + maxMemory + " MB");
+        if (maxMemory < 5999) {
+            Iris.warn("6GB+ Ram is recommended");
+        }
        Iris.info("Bukkit version: " + Bukkit.getBukkitVersion());
        Iris.info("Java version: " + getJavaVersion());
        Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
--- a/src/main/java/com/volmit/iris/core/commands/CommandIris.java
+++ b/src/main/java/com/volmit/iris/core/commands/CommandIris.java
@@ -21,16 +21,19 @@ package com.volmit.iris.core.commands;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.IrisSettings;
 import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisBenchmarking;
 import com.volmit.iris.core.tools.IrisToolbelt;
 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.engine.safeguard.ServerBoot;
 import com.volmit.iris.util.collection.KList;
 import com.volmit.iris.util.decree.DecreeContext;
 import com.volmit.iris.util.decree.DecreeExecutor;
 import com.volmit.iris.util.decree.DecreeOrigin;
 import com.volmit.iris.util.decree.annotations.Decree;
 import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.decree.specialhandlers.NullablePlayerHandler;
 import com.volmit.iris.util.format.C;
 import com.volmit.iris.util.format.Form;
 import com.volmit.iris.util.parallel.BurstExecutor;
@@ -41,12 +44,16 @@ import com.volmit.iris.util.scheduling.jobs.QueueJob;
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitRunnable;

 import java.io.File;
-import java.io.IOException;
 import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;

+import static com.volmit.iris.core.tools.IrisBenchmarking.inProgress;
+import static com.volmit.iris.engine.safeguard.ServerBoot.multiverse;
+
@Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
 public class CommandIris implements DecreeExecutor {
    private CommandStudio studio;
@@ -57,6 +64,7 @@ public class CommandIris implements DecreeExecutor {
    private CommandWhat what;
    private CommandEdit edit;
    private CommandFind find;
+    private CommandWorldManager manager;

    @Decree(description = "Create a new world", aliases = {"+", "c"})
    public void create(
@@ -67,6 +75,14 @@ public class CommandIris implements DecreeExecutor {
            @Param(description = "The seed to generate the world with", defaultValue = "1337")
            long seed
    ) {
+        if (multiverse){
+            sender().sendMessage(C.RED + "Your server has an incompatibility that may corrupt all worlds on the server if not handled properly.");
+            sender().sendMessage(C.RED + "it is strongly advised for you to take action. see log for full detail");
+            Iris.safeguard(C.RED + "----------------------------------------------------------------");
+            Iris.safeguard(C.RED + "Command ran: /iris create");
+            ServerBoot.printincompatiblepluginWarnings();
+            Iris.safeguard(C.RED + "----------------------------------------------------------------");
+        }
        if (name.equals("iris")) {
            sender().sendMessage(C.RED + "You cannot use the world name \"iris\" for creating worlds as Iris uses this directory for studio worlds.");
            sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
@@ -96,41 +112,43 @@ public class CommandIris implements DecreeExecutor {
        sender().sendMessage(C.GREEN + "Successfully created your world!");
    }

-    @Decree(description = "Remove an Iris world", aliases = {"del", "rm"}, sync = true)
-    public void remove(
-            @Param(description = "The world to remove")
+    @Decree(description = "Teleport to another world", aliases = {"tp"}, sync = true)
+    public void teleport(
+            @Param(description = "World to teleport to")
            World world,
-            @Param(description = "Whether to also remove the folder (if set to false, just does not load the world)", defaultValue = "true")
-            boolean delete
+            @Param(description = "Player to teleport", defaultValue = "---", customHandler = NullablePlayerHandler.class)
+            Player player
    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+        if (player == null && sender().isPlayer())
+            player = sender().player();
+
+        final Player target = player;
+        if (target == null) {
+            sender().sendMessage(C.RED + "The specified player does not exist.");
            return;
        }
-        sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
-        try {
-            if (IrisToolbelt.removeWorld(world)) {
-                sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
-            } else {
-                sender().sendMessage(C.YELLOW + "Looks like the world was already removed from bukkit.yml");
+
+        new BukkitRunnable() {
+            @Override
+            public void run() {
+                target.teleport(world.getSpawnLocation());
+                new VolmitSender(target).sendMessage(C.GREEN + "You have been teleported to " + world.getName() + ".");
            }
-        } catch (IOException e) {
-            sender().sendMessage(C.RED + "Failed to save bukkit.yml because of " + e.getMessage());
-            e.printStackTrace();
-        }
-        IrisToolbelt.evacuate(world, "Deleting world");
-        Bukkit.unloadWorld(world, false);
-        if (delete && world.getWorldFolder().delete()) {
-            sender().sendMessage(C.GREEN + "Successfully removed world folder");
-        } else {
-            sender().sendMessage(C.RED + "Failed to remove world folder");
-        }
+        }.runTask(Iris.instance);
    }

    @Decree(description = "Print version information")
    public void version() {
        sender().sendMessage(C.GREEN + "Iris v" + Iris.instance.getDescription().getVersion() + " by Volmit Software");
    }
+    @Decree(description = "Benchmark your server", origin = DecreeOrigin.CONSOLE)
+    public void benchmark() throws InterruptedException {
+        if(!inProgress) {
+            IrisBenchmarking.runBenchmark();
+        } else {
+            Iris.info(C.RED + "Benchmark already is in progress.");
+        }
+    }

    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
    public void height() {
--- a/src/main/java/com/volmit/iris/core/commands/CommandObject.java
+++ b/src/main/java/com/volmit/iris/core/commands/CommandObject.java
@@ -341,7 +341,7 @@ public class CommandObject implements DecreeExecutor {
                }
            }
        } else {
-            sender().sendMessage("Placed " + object);
+            sender().sendMessage(C.IRIS + "Placed " + object);
        }
    }

@@ -413,7 +413,7 @@ public class CommandObject implements DecreeExecutor {
        ObjectSVC service = Iris.service(ObjectSVC.class);
        int actualReverts = Math.min(service.getUndos().size(), amount);
        service.revertChanges(actualReverts);
-        sender().sendMessage("Reverted " + actualReverts + " pastes!");
+        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE +" pastes!");
    }

    @Decree(description = "Gets an object wand and grabs the current WorldEdit selection.", aliases = "we", origin = DecreeOrigin.PLAYER, studio = true)
--- a/src/main/java/com/volmit/iris/core/commands/CommandWorldManager.java
+++ b/src/main/java/com/volmit/iris/core/commands/CommandWorldManager.java
@@ -0,0 +1,295 @@
+/*
+ * Iris is a World Generator for Minecraft Bukkit Servers
+ * Copyright (c) 2022 Arcane Arts (Volmit Software)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package com.volmit.iris.core.commands;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.IrisSettings;
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.service.StudioSVC;
+import com.volmit.iris.core.tools.IrisToolbelt;
+import com.volmit.iris.engine.object.IrisDimension;
+import com.volmit.iris.engine.object.IrisWorld;
+import com.volmit.iris.engine.platform.BukkitChunkGenerator;
+import com.volmit.iris.engine.platform.DummyChunkGenerator;
+import com.volmit.iris.util.decree.DecreeExecutor;
+import com.volmit.iris.util.decree.DecreeOrigin;
+import com.volmit.iris.util.decree.annotations.Decree;
+import com.volmit.iris.util.decree.annotations.Param;
+import com.volmit.iris.util.format.C;
+import com.volmit.iris.util.plugin.VolmitSender;
+import org.bukkit.Bukkit;
+import org.bukkit.Difficulty;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.FileConfiguration;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.generator.ChunkGenerator;
+
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.io.File;
+import java.io.IOException;
+import java.util.Collections;
+import java.util.List;
+
+import static com.volmit.iris.Iris.service;
+
+// Not done yet but works
+@Decree(name = "worldmanager", origin = DecreeOrigin.PLAYER, description = "Iris World Manager", aliases = {"manager"})
+public class CommandWorldManager implements DecreeExecutor {
+    public Difficulty difficulty = Difficulty.NORMAL;
+    String WorldToLoad;
+    String WorldEngine;
+    String worldNameToCheck = "YourWorldName";
+    VolmitSender sender = Iris.getSender();
+    @Decree(description = "Unload an Iris World", origin = DecreeOrigin.PLAYER, sync = true)
+    public void unloadWorld(
+            @Param(description = "The world to unload")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Unloading world: " + world.getName());
+        try {
+            IrisToolbelt.evacuate(world);
+            Bukkit.unloadWorld(world, false);
+            sender().sendMessage(C.GREEN + "World unloaded successfully.");
+        } catch (Exception e) {
+            sender().sendMessage(C.RED + "Failed to unload the world: " + e.getMessage());
+            e.printStackTrace();
+        }
+    }
+
+    @Decree(description = "Load an Iris World", origin = DecreeOrigin.PLAYER, sync = true, aliases = {"import"})
+    public void loadWorld(
+            @Param(description = "The name of the world to load")
+            String world
+    ) {
+        World worldloaded = Bukkit.getWorld(world);
+         worldNameToCheck = world;
+         boolean worldExists = doesWorldExist(worldNameToCheck);
+         WorldEngine = world;
+
+        if (!worldExists) {
+            sender().sendMessage(C.YELLOW + world + " Doesnt exist on the server.");
+            return;
+        }
+            WorldToLoad = world;
+            File BUKKIT_YML = new File("bukkit.yml");
+            String pathtodim = world + "\\iris\\pack\\dimensions\\";
+            File directory = new File(Bukkit.getWorldContainer(), pathtodim);
+
+            String dimension = null;
+            if (directory.exists() && directory.isDirectory()) {
+                File[] files = directory.listFiles();
+                if (files != null) {
+                    for (File file : files) {
+                        if (file.isFile()) {
+                            String fileName = file.getName();
+                            if (fileName.endsWith(".json")) {
+                                dimension = fileName.substring(0, fileName.length() - 5);
+                                sender().sendMessage(C.BLUE + "Generator: " + dimension);
+                            }
+                        }
+                    }
+                }
+            } else {
+                sender().sendMessage(C.GOLD + world + " is not an iris world.");
+                return;
+            }
+            sender().sendMessage(C.GREEN + "Loading world: " + world);
+
+            YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
+            String gen = "Iris:" + dimension;
+            ConfigurationSection section = yml.contains("worlds") ? yml.getConfigurationSection("worlds") : yml.createSection("worlds");
+            if (!section.contains(world)) {
+                section.createSection(world).set("generator", gen);
+                try {
+                    yml.save(BUKKIT_YML);
+                    Iris.info("Registered \"" + world + "\" in bukkit.yml");
+                } catch (IOException e) {
+                    Iris.error("Failed to update bukkit.yml!");
+                    e.printStackTrace();
+                }
+            }
+            checkForBukkitWorlds();
+            sender().sendMessage(C.GREEN + world + " loaded successfully.");
+    }
+    @Decree(description = "Evacuate an iris world", origin = DecreeOrigin.PLAYER, sync = true)
+    public void evacuate(
+            @Param(description = "Evacuate the world")
+            World world
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Evacuating world" + world.getName());
+        IrisToolbelt.evacuate(world);
+    }
+    @Decree(description = "Remove an Iris world", aliases = {"del", "rm", "delete"}, sync = true)
+    public void remove(
+            @Param(description = "The world to remove")
+            World world,
+            @Param(description = "Whether to also remove the folder (if set to false, just does not load the world)", defaultValue = "true")
+            boolean delete
+    ) {
+        if (!IrisToolbelt.isIrisWorld(world)) {
+            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
+            return;
+        }
+        sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
+        try {
+            if (IrisToolbelt.removeWorld(world)) {
+                sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
+            } else {
+                sender().sendMessage(C.YELLOW + "Looks like the world was already removed from bukkit.yml");
+            }
+        } catch (IOException e) {
+            sender().sendMessage(C.RED + "Failed to save bukkit.yml because of " + e.getMessage());
+            e.printStackTrace();
+        }
+        IrisToolbelt.evacuate(world, "Deleting world");
+        Bukkit.unloadWorld(world, false);
+        if (delete) {
+            if (deleteDirectory(world.getWorldFolder())) {
+                sender().sendMessage(C.GREEN + "Successfully removed world folder");
+            } else {
+                sender().sendMessage(C.RED + "Failed to remove world folder");
+            }
+        }
+
+    }
+    public static boolean deleteDirectory(File dir) {
+        if (dir.isDirectory()) {
+            File[] children = dir.listFiles();
+            for (int i = 0; i < children.length; i++) {
+                boolean success = deleteDirectory(children[i]);
+                if (!success) {
+                    return false;
+                }
+            }
+        }
+        return dir.delete();
+    }
+
+    boolean doesWorldExist(String worldName) {
+        File worldContainer = Bukkit.getWorldContainer();
+        File worldDirectory = new File(worldContainer, worldName);
+        return worldDirectory.exists() && worldDirectory.isDirectory();
+    }
+    private void checkForBukkitWorlds() {
+        FileConfiguration fc = new YamlConfiguration();
+        try {
+            fc.load(new File("bukkit.yml"));
+            ConfigurationSection section = fc.getConfigurationSection("worlds");
+            if (section == null) {
+                return;
+            }
+
+            List<String> worldsToLoad = Collections.singletonList(WorldToLoad);
+
+            for (String s : section.getKeys(false)) {
+                if (!worldsToLoad.contains(s)) {
+                    continue;
+                }
+                ConfigurationSection entry = section.getConfigurationSection(s);
+                if (!entry.contains("generator", true)) {
+                    continue;
+                }
+                String generator = entry.getString("generator");
+                if (generator.startsWith("Iris:")) {
+                    generator = generator.split("\\Q:\\E")[1];
+                } else if (generator.equalsIgnoreCase("Iris")) {
+                    generator = IrisSettings.get().getGenerator().getDefaultWorldType();
+                } else {
+                    continue;
+                }
+                Iris.info("2 World: %s | Generator: %s", s, generator);
+                if (Bukkit.getWorlds().stream().anyMatch(w -> w.getName().equals(s))) {
+                    continue;
+                }
+                Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
+                new WorldCreator(s)
+                        .generator(getDefaultWorldGenerator(s, generator))
+                        .environment(IrisData.loadAnyDimension(generator).getEnvironment())
+                        .createWorld();
+                Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
+            }
+        } catch (Throwable e) {
+            e.printStackTrace();
+        }
+    }
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
+        if (worldName.equals("test")) {
+            try {
+                throw new RuntimeException();
+            } catch (Throwable e) {
+                Iris.info(e.getStackTrace()[1].getClassName());
+                if (e.getStackTrace()[1].getClassName().contains("com.onarandombox.MultiverseCore")) {
+                    Iris.debug("MVC Test detected, Quick! Send them the dummy!");
+                    return new DummyChunkGenerator();
+                }
+            }
+        }
+        IrisDimension dim;
+        if (id == null || id.isEmpty()) {
+            dim = IrisData.loadAnyDimension(IrisSettings.get().getGenerator().getDefaultWorldType());
+        } else {
+            dim = IrisData.loadAnyDimension(id);
+        }
+        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
+
+        if (dim == null) {
+            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
+
+            service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, true);
+            dim = IrisData.loadAnyDimension(id);
+
+            if (dim == null) {
+                throw new RuntimeException("Can't find dimension " + id + "!");
+            } else {
+                Iris.info("Resolved missing dimension, proceeding with generation.");
+            }
+        }
+        Iris.debug("Assuming IrisDimension: " + dim.getName());
+        IrisWorld w = IrisWorld.builder()
+                .name(worldName)
+                .seed(1337)
+                .environment(dim.getEnvironment())
+                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
+                .minHeight(dim.getMinHeight())
+                .maxHeight(dim.getMaxHeight())
+                .build();
+        Iris.debug("Generator Config: " + w.toString());
+        File ff = new File(w.worldFolder(), "iris/pack");
+        if (!ff.exists() || ff.listFiles().length == 0) {
+            ff.mkdirs();
+            service(StudioSVC.class).installIntoWorld(sender, dim.getLoadKey(), ff.getParentFile());
+        }
+        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
+    }
+}
+
+
--- a/src/main/java/com/volmit/iris/core/service/ObjectSVC.java
+++ b/src/main/java/com/volmit/iris/core/service/ObjectSVC.java
@@ -18,9 +18,11 @@

 package com.volmit.iris.core.service;

+import com.volmit.iris.Iris;
 import com.volmit.iris.util.plugin.IrisService;
 import com.volmit.iris.util.scheduling.J;
 import lombok.Getter;
+import org.bukkit.Bukkit;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.BlockData;

@@ -68,19 +70,22 @@ public class ObjectSVC implements IrisService {
     * @param blocks The blocks to remove
     */
    private void revert(Map<Block, BlockData> blocks) {
-        int amount = 0;
        Iterator<Map.Entry<Block, BlockData>> it = blocks.entrySet().iterator();
-        while (it.hasNext()) {
-            Map.Entry<Block, BlockData> entry = it.next();
-            BlockData data = entry.getValue();
-            entry.getKey().setBlockData(data, false);
-            it.remove();
+        Bukkit.getScheduler().runTask(Iris.instance, () -> {
+            int amount = 0;
+            while (it.hasNext()) {
+                Map.Entry<Block, BlockData> entry = it.next();
+                BlockData data = entry.getValue();
+                entry.getKey().setBlockData(data, false);

-            amount++;
+                it.remove();

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

 import java.awt.*;
-import java.util.*;
-import java.util.List;
+import java.util.Arrays;
+import java.util.Set;
+import java.util.UUID;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicLong;
@@ -348,6 +346,7 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat

    @BlockCoordinates
    @Override
+
    default void update(int x, int y, int z, Chunk c, RNG rf) {
        Block block = c.getBlock(x, y, z);
        BlockData data = block.getBlockData();
@@ -364,8 +363,17 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
                KList<IrisLootTable> tables = getLootTables(rx, block);

                try {
+                    Bukkit.getPluginManager().callEvent(new IrisLootEvent(this, block, slot, tables));
+
+                    if (!tables.isEmpty()){
+                        Iris.debug("IrisLootEvent has been accessed");
+                    }
+
+                    if (tables.isEmpty())
+                        return;
                    InventoryHolder m = (InventoryHolder) block.getState();
                    addItems(false, m.getInventory(), rx, tables, slot, x, y, z, 15);
+
                } catch (Throwable e) {
                    Iris.reportError(e);
                }
@@ -761,6 +769,15 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
        String[] v = objectAt.split("\\Q@\\E");
        String object = v[0];
        int id = Integer.parseInt(v[1]);
+
+
+        JigsawPieceContainer container = getMantle().getMantle().get(x, y, z, JigsawPieceContainer.class);
+        if (container != null) {
+            IrisJigsawPiece piece = container.load(getData());
+            if (piece.getObject().equals(object))
+                return new PlacedObject(piece.getPlacementOptions(), getData().getObjectLoader().load(object), id, x, z);
+        }
+
        IrisRegion region = getRegion(x, z);

        for (IrisObjectPlacement i : region.getObjects()) {
@@ -777,55 +794,9 @@ public interface Engine extends DataProvider, Fallible, LootProvider, BlockUpdat
            }
        }

-        KList<String> pieces = new KList<>();
-        KList<String> pools = new KList<>();
-        int r = 2;
-        for (int xX = -r; xX <= r; xX++) {
-            for (int zZ = -r; zZ <= r; zZ++) {
-                IrisJigsawStructure structure = getStructureAt((x >> 4) + xX, (z >> 4) + zZ);
-                if (structure != null) {
-                    for (String pieceID : structure.getPieces()) {
-                        IrisJigsawPiece result = searchAllPieces(pieceID, object, pieces, pools);
-                        if (result != null) {
-                            pieces.clear();
-                            pools.clear();
-                            return new PlacedObject(result.getPlacementOptions(), getData().getObjectLoader().load(object), id, x, z);
-                        }
-                    }
-                }
-            }
-        }
-        pieces.clear();
-        pools.clear();
-
        return new PlacedObject(null, getData().getObjectLoader().load(object), id, x, z);
    }

-    private IrisJigsawPiece searchAllPieces(String pieceID, String target, KList<String> pieces, KList<String> pools) {
-        IrisJigsawPiece piece = getData().getJigsawPieceLoader().load(pieceID);
-        if (piece.getObject().equals(target))
-            return piece;
-
-        pieces.add(pieceID);
-        for (IrisJigsawPieceConnector connector : piece.getConnectors()) {
-            for (String poolID : connector.getPools()) {
-                if (pools.contains(poolID))
-                    continue;
-                pools.add(poolID);
-
-                for (String pieceId : getData().getJigsawPoolLoader().load(poolID).getPieces()) {
-                    if (pieces.contains(pieceId))
-                        continue;
-
-                    IrisJigsawPiece piece1 = searchAllPieces(pieceId, target, pieces, pools);
-                    if (piece1 != null)
-                        return piece1;
-                }
-            }
-        }
-        return null;
-    }
-
    int getCacheID();

    default IrisBiome getBiomeOrMantle(Location l) {
--- a/src/main/java/com/volmit/iris/engine/framework/IrisLootEvent.java
+++ b/src/main/java/com/volmit/iris/engine/framework/IrisLootEvent.java
@@ -0,0 +1,32 @@
+package com.volmit.iris.engine.framework;
+
+import com.volmit.iris.engine.object.InventorySlotType;
+import com.volmit.iris.engine.object.IrisLootTable;
+import com.volmit.iris.util.collection.KList;
+import lombok.Getter;
+import org.bukkit.block.Block;
+import org.bukkit.event.Event;
+import org.bukkit.event.HandlerList;
+
+@Getter
+public class IrisLootEvent extends Event {
+    private static final HandlerList handlers = new HandlerList();
+    private final Engine engine;
+    private final Block block;
+    private final InventorySlotType slot;
+    private final KList<IrisLootTable> tables;
+
+    public IrisLootEvent(Engine engine, Block block, InventorySlotType slot, KList<IrisLootTable> tables) {
+        this.engine = engine;
+        this.block = block;
+        this.slot = slot;
+        this.tables = tables;
+    }
+    @Override
+    public HandlerList getHandlers() {
+        return handlers;
+    }
+    public static HandlerList getHandlerList() {
+        return handlers;
+    }
+}
--- a/src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java
+++ b/src/main/java/com/volmit/iris/engine/jigsaw/PlannedStructure.java
@@ -23,13 +23,18 @@ import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.engine.data.cache.Cache;
 import com.volmit.iris.engine.framework.Engine;
+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.mantle.Mantle;
 import com.volmit.iris.util.math.RNG;
+import com.volmit.iris.util.matter.slices.JigsawPieceMatter;
+import com.volmit.iris.util.matter.slices.container.JigsawPieceContainer;
 import lombok.Data;
 import org.bukkit.Axis;
 import org.bukkit.World;
+import org.bukkit.block.TileState;
+import org.bukkit.block.data.BlockData;

@Data
 public class PlannedStructure {
@@ -70,7 +75,7 @@ public class PlannedStructure {
        }
    }

-    public void place(IObjectPlacer placer, Mantle e, Engine eng) {
+    public void place(MantleWriter placer, Mantle e, Engine eng) {
        IrisObjectPlacement options = new IrisObjectPlacement();
        options.getRotation().setEnabled(false);
        int startHeight = pieces.get(0).getPosition().getY();
@@ -80,7 +85,7 @@ public class PlannedStructure {
        }
    }

-    public void place(PlannedPiece i, int startHeight, IrisObjectPlacement o, IObjectPlacer placer, Mantle e, Engine eng) {
+    public void place(PlannedPiece i, int startHeight, IrisObjectPlacement o, MantleWriter placer, Mantle e, Engine eng) {
        IrisObjectPlacement options = o;

        if (i.getPiece().getPlacementOptions() != null) {
@@ -117,7 +122,70 @@ public class PlannedStructure {
        }

        int id = rng.i(0, Integer.MAX_VALUE);
-        vo.place(xx, height, zz, placer, options, rng, (b, data) -> e.set(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id), null, getData());
+        JigsawPieceContainer container = JigsawPieceContainer.toContainer(i.getPiece());
+        vo.place(xx, height, zz, new IObjectPlacer() {
+            @Override
+            public int getHighest(int x, int z, IrisData data) {
+                return placer.getHighest(x, z, data);
+            }
+
+            @Override
+            public int getHighest(int x, int z, IrisData data, boolean ignoreFluid) {
+                return placer.getHighest(x, z, data, ignoreFluid);
+            }
+
+            @Override
+            public void set(int x, int y, int z, BlockData d) {
+                placer.setData(x, y, z, container);
+                placer.set(x, y, z, d);
+            }
+
+            @Override
+            public BlockData get(int x, int y, int z) {
+                placer.setData(x, y, z, container);
+                return placer.get(x, y, z);
+            }
+
+            @Override
+            public boolean isPreventingDecay() {
+                return placer.isPreventingDecay();
+            }
+
+            @Override
+            public boolean isCarved(int x, int y, int z) {
+                return placer.isCarved(x, y, z);
+            }
+
+            @Override
+            public boolean isSolid(int x, int y, int z) {
+                return placer.isSolid(x, y, z);
+            }
+
+            @Override
+            public boolean isUnderwater(int x, int z) {
+                return placer.isUnderwater(x, z);
+            }
+
+            @Override
+            public int getFluidHeight() {
+                return placer.getFluidHeight();
+            }
+
+            @Override
+            public boolean isDebugSmartBore() {
+                return placer.isDebugSmartBore();
+            }
+
+            @Override
+            public void setTile(int xx, int yy, int zz, TileData<? extends TileState> tile) {
+                placer.setTile(xx, yy, zz, tile);
+            }
+
+            @Override
+            public Engine getEngine() {
+                return placer.getEngine();
+            }
+        }, options, rng, (b, data) -> e.set(b.getX(), b.getY(), b.getZ(), v.getLoadKey() + "@" + id), null, getData());
    }

    public void place(World world) {
--- a/src/main/java/com/volmit/iris/engine/object/IrisObject.java
+++ b/src/main/java/com/volmit/iris/engine/object/IrisObject.java
@@ -525,7 +525,7 @@ public class IrisObject extends IrisRegistrant {
                }
            }
            double newRotation = config.getRotation().getYAxis().getMin() + slopeRotationY;
-            config.getRotation().setYAxis(new IrisAxisRotationClamp(true, false, newRotation, newRotation, 360));
+            config.getRotation().setYAxis(new IrisAxisRotationClamp(true, false, newRotation, newRotation, 90));
            config.getRotation().setEnabled(true);
        }

--- a/src/main/java/com/volmit/iris/engine/safeguard/IrisSafeguard.java
+++ b/src/main/java/com/volmit/iris/engine/safeguard/IrisSafeguard.java
@@ -0,0 +1,13 @@
+package com.volmit.iris.engine.safeguard;
+
+import com.volmit.iris.Iris;
+
+public class IrisSafeguard {
+ // more planned and WIP
+    public static boolean unstablemode = false;
+    public static void IrisSafeguardSystem() {
+        Iris.info("Enabled Iris SafeGuard");
+        ServerBoot.BootCheck();
+    }
+}
+
--- a/src/main/java/com/volmit/iris/engine/safeguard/SafeguardUtils.java
+++ b/src/main/java/com/volmit/iris/engine/safeguard/SafeguardUtils.java
@@ -0,0 +1,6 @@
+package com.volmit.iris.engine.safeguard;
+public class SafeguardUtils {
+ public static void resetdatapacks(){
+
+ }
+}
--- a/src/main/java/com/volmit/iris/engine/safeguard/ServerBoot.java
+++ b/src/main/java/com/volmit/iris/engine/safeguard/ServerBoot.java
@@ -0,0 +1,114 @@
+package com.volmit.iris.engine.safeguard;
+
+import com.volmit.iris.Iris;
+import com.volmit.iris.core.nms.v20.NMSBinding1_20_1;
+import com.volmit.iris.util.format.C;
+import org.bukkit.Bukkit;
+import org.bukkit.plugin.Plugin;
+
+import static com.volmit.iris.Iris.instance;
+import static com.volmit.iris.engine.safeguard.IrisSafeguard.unstablemode;
+
+public class ServerBoot {
+    public static boolean multiverse = false;
+    public static boolean dynmap = false;
+    public static boolean terraform = false;
+    public static boolean stratos = false;
+    public static boolean correctversion = true;
+
+    protected static boolean safeguardPassed;
+    public static boolean passedserversoftware = true;
+    protected static byte count;
+
+    public static void BootCheck() {
+        Iris.info("Checking for possible conflicts..");
+        org.bukkit.plugin.PluginManager pluginManager = Bukkit.getPluginManager();
+        Plugin[] plugins = pluginManager.getPlugins();
+        if (!instance.getServer().getBukkitVersion().contains(NMSBinding1_20_1.NMS_VERSION)) {
+            unstablemode = true;
+            correctversion = false;
+        }
+
+        StringBuilder pluginList = new StringBuilder("Plugin list: ");
+        count = 0;
+
+        for (Plugin plugin : plugins) {
+            String pluginName = plugin.getName();
+            if (pluginName.equalsIgnoreCase("Multiverse-Core")) {
+                multiverse = true;
+                count++;
+            }
+            if (pluginName.equalsIgnoreCase("Dynmap")) {
+                dynmap = true;
+                count++;
+            }
+            if (pluginName.equalsIgnoreCase("TerraformGenerator")) {
+                terraform = true;
+                count++;
+            }
+            if (pluginName.equalsIgnoreCase("Stratos")) {
+                stratos = true;
+                count++;
+            }
+            pluginList.append(pluginName).append(", ");
+        }
+
+        if (
+        !instance.getServer().getVersion().contains("Purpur") &&
+        !instance.getServer().getVersion().contains("Paper") &&
+        !instance.getServer().getVersion().contains("Spigot") &&
+        !instance.getServer().getVersion().contains("Pufferfish") &&
+         !instance.getServer().getVersion().contains("Bukkit"))
+        {
+            unstablemode = true;
+            passedserversoftware = false;
+        }
+
+        safeguardPassed = (count == 0);
+        if(!safeguardPassed){
+            unstablemode = true;
+        }
+        if (unstablemode){
+            Iris.safeguard("Unstable mode has been activated.");
+        }
+        Iris.safeguard(pluginList.toString());
+
+    }
+    public static void UnstableMode(){
+        if (unstablemode) {
+            Iris.safeguard(C.DARK_RED + "Iris is running in Unstable Mode");
+        } else {
+            Iris.safeguard(C.BLUE + "Iris is running Stable");
+        }
+    }
+    public static void SupportedServerSoftware(){
+        if (!passedserversoftware) {
+            Iris.safeguard(C.DARK_RED + "Server is running unsupported server software");
+            Iris.safeguard(C.RED + "Supported: Purpur, Pufferfish, Paper, Spigot, Bukkit");
+        }
+    }
+    public static void printincompatiblepluginWarnings(){
+
+        if (safeguardPassed) {
+            Iris.safeguard(C.BLUE + "0 Conflicts found");
+        } else {
+            Iris.safeguard(C.DARK_RED + "" + count + " Conflicts found");
+            unstablemode = true;
+
+            if (multiverse) {
+                Iris.safeguard(C.RED + "Multiverse");
+                Iris.safeguard(C.RED + "- The plugin Multiverse is not compatible with the server.");
+                Iris.safeguard(C.RED + "- If you want to have a world manager, consider using PhantomWorlds or MyWorlds instead.");
+            }
+            if (dynmap) {
+                Iris.safeguard(C.RED + "Dynmap");
+                Iris.safeguard(C.RED + "- The plugin Dynmap is not compatible with the server.");
+                Iris.safeguard(C.RED + "- If you want to have a map plugin like Dynmap, consider Bluemap or LiveAtlas.");
+            }
+            if (terraform || stratos) {
+                Iris.safeguard(C.YELLOW + "Terraform Generator / Stratos");
+                Iris.safeguard(C.YELLOW + "- Iris is not compatible with other worldgen plugins.");
+            }
+        }
+    }
+}
--- a/src/main/java/com/volmit/iris/util/decree/specialhandlers/NullablePlayerHandler.java
+++ b/src/main/java/com/volmit/iris/util/decree/specialhandlers/NullablePlayerHandler.java
@@ -0,0 +1,13 @@
+package com.volmit.iris.util.decree.specialhandlers;
+
+import com.volmit.iris.util.decree.exceptions.DecreeParsingException;
+import com.volmit.iris.util.decree.handlers.PlayerHandler;
+import org.bukkit.entity.Player;
+
+public class NullablePlayerHandler extends PlayerHandler {
+
+    @Override
+    public Player parse(String in, boolean force) throws DecreeParsingException {
+        return getPossibilities(in).stream().filter((i) -> toString(i).equalsIgnoreCase(in)).findFirst().orElse(null);
+    }
+}
--- a/src/main/java/com/volmit/iris/util/matter/slices/JigsawPieceMatter.java
+++ b/src/main/java/com/volmit/iris/util/matter/slices/JigsawPieceMatter.java
@@ -0,0 +1,35 @@
+package com.volmit.iris.util.matter.slices;
+
+import com.volmit.iris.util.data.palette.Palette;
+import com.volmit.iris.util.matter.Sliced;
+import com.volmit.iris.util.matter.slices.container.JigsawPieceContainer;
+
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
+
+@Sliced
+public class JigsawPieceMatter extends RawMatter<JigsawPieceContainer> {
+    public JigsawPieceMatter() {
+        this(1,1,1);
+    }
+
+    public JigsawPieceMatter(int width, int height, int depth) {
+        super(width, height, depth, JigsawPieceContainer.class);
+    }
+
+    @Override
+    public Palette<JigsawPieceContainer> getGlobalPalette() {
+        return null;
+    }
+
+    @Override
+    public void writeNode(JigsawPieceContainer b, DataOutputStream dos) throws IOException {
+        dos.writeUTF(b.getLoadKey());
+    }
+
+    @Override
+    public JigsawPieceContainer readNode(DataInputStream din) throws IOException {
+        return new JigsawPieceContainer(din.readUTF());
+    }
+}
--- a/src/main/java/com/volmit/iris/util/matter/slices/container/JigsawPieceContainer.java
+++ b/src/main/java/com/volmit/iris/util/matter/slices/container/JigsawPieceContainer.java
@@ -0,0 +1,13 @@
+package com.volmit.iris.util.matter.slices.container;
+
+import com.volmit.iris.engine.object.IrisJigsawPiece;
+
+public class JigsawPieceContainer extends RegistrantContainer<IrisJigsawPiece> {
+    public JigsawPieceContainer(String loadKey) {
+        super(IrisJigsawPiece.class, loadKey);
+    }
+
+    public static JigsawPieceContainer toContainer(IrisJigsawPiece piece) {
+        return new JigsawPieceContainer(piece.getLoadKey());
+    }
+}
--- a/src/main/java/com/volmit/iris/util/matter/slices/container/RegistrantContainer.java
+++ b/src/main/java/com/volmit/iris/util/matter/slices/container/RegistrantContainer.java
@@ -0,0 +1,22 @@
+package com.volmit.iris.util.matter.slices.container;
+
+import com.volmit.iris.core.loader.IrisData;
+import com.volmit.iris.core.loader.IrisRegistrant;
+
+public abstract class RegistrantContainer<T extends IrisRegistrant> {
+    private final Class<T> type;
+    private final String loadKey;
+
+    public RegistrantContainer(Class<T> type, String loadKey) {
+        this.type = type;
+        this.loadKey = loadKey;
+    }
+
+    public T load(IrisData data) {
+        return (T) data.getLoaders().get(type).load(loadKey);
+    }
+
+    public String getLoadKey() {
+        return loadKey;
+    }
+}
Author	SHA1	Message	Date
Brian Neumann-Fopiano	3dff96152c	v+	2023-10-22 23:35:58 -04:00
Brian Fopiano	79e198d441	Merge pull request #1038 from RePixelatedMC/repixelatedmc Repixelatedmc	2023-10-22 23:17:53 -04:00
Brian Fopiano	e6cf33e262	Merge pull request #1040 from CrazyDev05/repo_fix Fix build.gradle Thanks	2023-10-22 23:17:26 -04:00
RePixelatedMC	f839ca674b	Remove / Delete Iris world actually works now lol	2023-10-22 20:08:58 +02:00
RePixelatedMC	f9427d1258	ROTATION FIX WHOHOO	2023-10-22 15:22:01 +02:00
RePixelatedMC	bd2cdc9bd0	idk some fix	2023-10-22 12:09:10 +02:00
RePixelatedMC	67352311de	WHooPs	2023-10-22 11:02:46 +02:00
RePixelatedMC	555a7682e1	fixes	2023-10-22 11:01:07 +02:00
RePixelatedMC	19d94489d7	Merge pull request #2 from RePixelatedMC/repixelated-DEV Repixelated dev	2023-10-22 10:58:00 +02:00
RePixelatedMC	0175cfa986	fixes	2023-10-22 10:54:12 +02:00
RePixelatedMC	1b0ff36d51	cleanup	2023-10-22 10:44:32 +02:00
RePixelatedMC	f5c499ab60	Fixes + cleanup	2023-10-22 10:40:40 +02:00
RePixelatedMC	81e3fd346a	Rewrote The update process and made it more manual	2023-10-22 10:13:18 +02:00
RePixelatedMC	3bca1f5304	Fixes?	2023-10-22 09:20:13 +02:00
RePixelatedMC	593e96a31a	added WindowsCPUSpeedTest	2023-10-22 08:47:33 +02:00
Julian Krings	169b783e4f	Fix build.gradle	2023-10-21 22:47:01 +02:00
RePixelatedMC	f129742a41	cleanup	2023-10-21 20:19:03 +02:00
RePixelatedMC	01016d1b14	modes?	2023-10-21 20:18:02 +02:00
RePixelatedMC	a883e43acb	eh	2023-10-21 15:26:24 +02:00
RePixelatedMC	e0d0657e7b	thx coco	2023-10-21 15:25:55 +02:00
RePixelatedMC	e4c27bd49c	thx coco	2023-10-08 14:10:44 +02:00
RePixelatedMC	7a31fd31eb	whoop	2023-10-08 14:01:28 +02:00
RePixelatedMC	4f0f2c3213	grammar fix 2	2023-10-08 14:00:57 +02:00
RePixelatedMC	d9889b06ad	grammar fix	2023-10-08 13:59:56 +02:00
RePixelatedMC	9f5cff4ab8	brr	2023-10-06 12:41:21 +02:00
RePixelatedMC	958543a171	brr	2023-10-06 12:31:34 +02:00
RePixelatedMC	b8e03f5e13	Merge remote-tracking branch 'origin/master'	2023-10-06 12:28:40 +02:00
Brian Neumann-Fopiano	e76218b39f	forgot the overworld , this is the V+	2023-10-06 12:13:36 +02:00
Brian Neumann-Fopiano	7d1a375bda	v+	2023-10-06 12:13:36 +02:00
CrazyDev22	dfaa80f1e4	Add Color Gradient	2023-10-06 12:13:36 +02:00
CrazyDev22	8939a903be	Add NullablePlayerHandler Add Teleport Command	2023-10-06 12:13:32 +02:00
CrazyDev22	d6f1ea78fa	Fix NullPointerException	2023-10-06 12:13:14 +02:00
CrazyDev22	f25c4c74be	Fix IrisJigsawPiece tectonic plate panic	2023-10-06 12:13:14 +02:00
BuildTools	1619df1ba3	remove debug info	2023-10-06 12:13:14 +02:00
BuildTools	566169cdbf	better fix for jigsaw loot	2023-10-06 12:13:13 +02:00
RePixelatedMC	ee3e631789	comment	2023-10-06 11:47:24 +02:00
RePixelatedMC	8202754988	remove world to worldmanager	2023-10-06 10:30:24 +02:00
RePixelatedMC	447d7596dc	added evacuate	2023-10-06 10:26:43 +02:00
RePixelatedMC	7c4568066f	IrisSafeguard Prototype idea WorldManager ( Not done WIP )	2023-10-06 10:14:33 +02:00
RePixelatedMC	46ee7a5983	IrisSafeguard Prototype idea	2023-10-04 14:12:53 +02:00
Brian Neumann-Fopiano	5a8ef99afa	forgot the overworld , this is the V+	2023-10-04 03:30:55 -04:00
Brian Neumann-Fopiano	571729cfe4	v+	2023-10-04 03:24:32 -04:00
Brian Fopiano	c1de316ed6	Merge pull request #1036 from CrazyDev05/teleport Add Teleport Command	2023-10-04 03:22:29 -04:00
Brian Fopiano	1e316acd64	Merge pull request #1037 from CrazyDev05/jigsaw_piece_mantle_panic_fix Fix IrisJigsawPiece tectonic plate panic	2023-10-04 03:21:43 -04:00
CrazyDev22	f89460538d	Fix NullPointerException	2023-10-03 14:20:40 +02:00
CrazyDev22	0bf0062c2c	Fix IrisJigsawPiece tectonic plate panic	2023-10-01 22:28:03 +02:00
CrazyDev22	540d1b5801	Add Color Gradient	2023-10-01 17:45:40 +02:00
CrazyDev22	8f0d1b7b7b	Add NullablePlayerHandler Add Teleport Command	2023-10-01 16:50:50 +02:00
Brian Fopiano	5061791dcf	Merge pull request #1034 from RePixelatedMC/master Fixed - /iris object undo / Added - IrisLootEvent	2023-09-27 08:15:06 -04:00
Brian Fopiano	ce98264552	Merge pull request #1033 from CrazyDev05/jigsaw_loot_fix_2 Better Jigsaw loot fix	2023-09-27 08:14:51 -04:00
RePixelatedMC	15e6750e11	Merge pull request #1 IrisLootEvent	2023-09-27 10:31:43 +02:00
RePixelatedMC	7a20421580	Added IrisLootEvent.java and some debugging to that	2023-09-27 10:15:11 +02:00
RePixelatedMC	f42f06226c	Optimized it thx coco	2023-09-25 15:12:45 +02:00
RePixelatedMC	cce3d74c52	Merge remote-tracking branch 'origin/master'	2023-09-25 15:03:41 +02:00
RePixelatedMC	7b9fb880f4	Also changed the color for the /iris o paste cmd	2023-09-25 15:02:33 +02:00
RePixelatedMC	2a9b0a54d9	Merge branch 'VolmitSoftware:master' into master	2023-09-25 14:37:08 +02:00
RePixelatedMC	373e9e9755	Fixed - /iris object undo also added some colors	2023-09-25 14:30:21 +02:00
BuildTools	4115dd5797	remove debug info	2023-09-18 13:48:19 +02:00
BuildTools	57bfd251dc	better fix for jigsaw loot	2023-09-18 13:45:03 +02:00
Brian Neumann-Fopiano	d324790f66	forgot the v+ lol	2023-09-17 15:54:08 -04:00