Refactored some Files

A bit of cleanup, not done tho
Minimal fixes for the plugin to work

build.gradle

@@ -18,7 +18,9 @@ repositories {
 }
 
 dependencies {
-compileOnly "org.spigotmc:spigot-api:1.21-R0.1-SNAPSHOT"
+    compileOnly "org.spigotmc:spigot-api:1.21.11-R0.1-SNAPSHOT"
+    implementation "org.luaj:luaj-jse:3.0.1"
+    implementation 'com.google.code.gson:gson:2.11.0'
 }
 
 def targetJavaVersion = 21

src/main/java/de/ventority/randomizedminigames/Minigames/BlockRandomizer.java

@@ -0,0 +1,110 @@
+package de.ventority.randomizedminigames.Minigames;
+
+import de.ventority.randomizedminigames.misc.Timer.Timer;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.*;
+
+public class BlockRandomizer implements MinigameBase {
+    private Timer timer;
+    private List<Player> contestants;
+    private HashMap<Player, HashMap<Material, Material>> drops = new HashMap<>();
+    private Player owner;
+
+    public BlockRandomizer(List<Player> players, Player owner) {
+        this.owner = owner;
+        this.contestants = players;
+        this.timer = new Timer(contestants, this, "");
+        for (Player p : contestants) drops.put(p, new HashMap<>());
+        timer.startCounter();
+    }
+
+    private Material getAndAddRandomMaterial(Player p, Block block) {
+        List<Material> validMaterials = Arrays.stream(Material.values())
+                .filter(Material::isItem)
+                .toList();
+        Material m = validMaterials.get(new Random().nextInt(validMaterials.size()));
+        if (!hasEyeOrEPandBlaze(p))
+            m = new Random().nextDouble() < 0.05 ? Material.ENDER_EYE : m;
+        drops.get(p).put(block.getType(), m);
+        return m;
+    }
+
+    private ItemStack getItems(Player p, Block block, int amount) {
+        Material material = drops.get(p).containsKey(block.getType()) ? drops.get(p).get(block.getType()) : getAndAddRandomMaterial(p, block);
+        return new ItemStack(material, amount);
+    }
+
+    private boolean hasEyeOrEPandBlaze(Player p) {
+        HashMap<Material, Material> map = drops.get(p);
+        return map.containsValue(Material.ENDER_EYE) || (map.containsValue(Material.ENDER_PEARL) && (map.containsValue(Material.BLAZE_POWDER) || map.containsValue(Material.BLAZE_ROD)));
+    }
+
+    @Override
+    public int getID() {
+        return 0;
+    }
+
+    @Override
+    public String getName() {
+        return "";
+    }
+
+    @Override
+    public void addPlayers(List<Player> players) {
+
+    }
+
+    @Override
+    public List<Player> getPlayers() {
+        return contestants;
+    }
+
+    @Override
+    public void killGame() {
+
+    }
+
+    @Override
+    public void stopGame() {
+
+    }
+
+    @Override
+    public Player getOwner() {
+        return owner;
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent e) {
+        if (contestants.contains(e.getPlayer())) {
+            e.setDropItems(false);
+            Collection<ItemStack> vanillaDrops = e.getBlock().getDrops(e.getPlayer().getItemInUse());
+            int totalAmount = vanillaDrops.stream()
+                    .mapToInt(ItemStack::getAmount)
+                    .sum();
+
+            e.getBlock().getWorld().dropItemNaturally(e.getBlock().getLocation(), getItems(e.getPlayer(), e.getBlock(), Math.max(totalAmount, 1)));
+        }
+    }
+
+    @EventHandler
+    public void onEntityDeath(EntityDeathEvent e) {
+        if (e.getEntity() instanceof EnderDragon) {
+            timer.pauseCounter();
+        }
+    }
+
+    @EventHandler
+    public void onPlayerDeath(PlayerDeathEvent e) {
+        timer.pauseCounter();
+    }
+}

src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattle.java

@@ -1,9 +1,10 @@
 package de.ventority.randomizedminigames.Minigames;
 
-import de.ventority.randomizedminigames.GUI.InGame.GamesScoreboardManager;
+import de.ventority.randomizedminigames.gui.InGame.GamesScoreboardManager;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.misc.Timer.Timer;
-import de.ventority.randomizedminigames.misc.PlayerBackup;
+import de.ventority.randomizedminigames.util.MinigameHandler;
-import de.ventority.randomizedminigames.misc.Settings;
+import de.ventority.randomizedminigames.util.PlayerBackupHandler;
+import de.ventority.randomizedminigames.util.Settings;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.GameMode;
@@ -14,13 +15,19 @@ import org.bukkit.boss.BossBar;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.inventory.CraftItemEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
-import de.ventority.randomizedminigames.misc.Timer;
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
 import java.util.*;
 
 public class ForceItemBattle implements MinigameBase, Listener {
@@ -30,51 +37,25 @@ public class ForceItemBattle implements MinigameBase, Listener {
     private final int id;
     private GamesScoreboardManager scoreboardManager;
     protected final List<Player> contestants;
-    private final HashMap<Player, PlayerBackup> backups;
+    private final PlayerBackupHandler backups;
     private final Player owner;
     protected Settings settings;
-    private Timer timer;
+    private final Timer timer;
-    private List<Player> disconnected = new ArrayList<>();
+    private final List<Player> disconnected = new ArrayList<>();
+    private final HashMap<Player, Integer> skips = new HashMap<>();
 
-    private final List<Material> SURVIVAL_ITEMS = Arrays.stream(Material.values())
+    private final List<Material> SURVIVAL_ITEMS = loadMaterials();
-            .filter(Material::isItem)
-            .filter(m -> {
-                String name = m.name();
-                return !name.contains("SPAWN_EGG") &&
-                        !name.contains("COMMAND") &&
-                        !name.contains("STRUCTURE") &&
-                        !name.contains("JIGSAW") &&
-                        !name.contains("DEBUG") &&
-                        !name.contains("BARRIER") &&
-                        !name.contains("KNOWLEDGE_BOOK") &&
-                        !name.contains("LIGHT") &&
-                        !name.contains("INFESTED") &&
-                        !name.contains("BEDROCK") &&
-                        !name.contains("VOID") &&
-                        !name.contains("REINFORCED_DEEPSLATE") &&
-                        !name.contains("END_PORTAL") &&
-                        !name.contains("END_GATEWAY") &&
-                        !name.contains("NETHER_PORTAL") &&
-                        !name.contains("POTTED_") &&
-                        !name.contains("MUSIC") &&
-                        !name.contains("AMETHYST_BUD") &&
-                        !name.contains("OXIDIZED") &&
-                        !name.contains("AMETHYST") &&
-                        !name.contains("PURPUR") &&
-                        !name.contains("EXPOSED");
-            })
-            .toList();
 
 
     public ForceItemBattle(List<Player> players, Player owner) {
         settings = MinigameHandler.getSettings(owner);
-        timer = new Timer(settings.timerStop, players, this, "");
+        timer = new Timer(players, this, "");
-
+        timer.setStopTime(settings.getTimeLimit());
         id = new Random().nextInt(1024);
         currentItems = new HashMap<>();
         currentScores = new HashMap<>();
         itemDisplays = new HashMap<>();
-        backups = new HashMap<>();
+        backups = new PlayerBackupHandler(players);
         contestants = players;
         this.owner = owner;
         if (MinigameHandler.getSettings(owner).getScoreboardStatus())
@@ -82,6 +63,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
         for (Player player : players) {
             currentItems.put(player, null);
             currentScores.put(player, 0);
+            skips.put(player, 3);
 
             BossBar bar = Bukkit.createBossBar("Null", BarColor.PURPLE, BarStyle.SOLID);
             bar.addPlayer(player);
@@ -89,7 +71,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
             itemDisplays.put(player, bar);
 
             updatePlayerItem(player, getRandomItem());
-            backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation(), player.getGameMode()));
             player.getInventory().clear();
 
             ItemStack skip = new ItemStack(Material.BARRIER, 3);
@@ -112,11 +93,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
         return "Force Item Battle";
     }
 
-    @Override
-    public ItemStack getSymbol() {
-        return new ItemStack(Material.DIAMOND_SWORD, 1);
-    }
-
     @Override
     public void addPlayers(List<Player> players) {
 
@@ -172,6 +148,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
                 player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
         }
     }
+
     public void stopGame() {
         Map.Entry<Player, Integer> bestEntry = currentScores.entrySet()
                 .stream()
@@ -180,10 +157,12 @@ public class ForceItemBattle implements MinigameBase, Listener {
         assert bestEntry != null;
         stopGame(bestEntry.getKey());
     }
+
     private void stopGame(Player winner) {
         showEndMessage(winner);
         timer.pauseCounter();
-        Timer t = new Timer(10, contestants, this, this::killGame, true, "Resetting game in: ");
+        Timer t = new Timer(contestants, this, this::killGame, "Resetting game in: ");
+        t.setStopTime(10);
         t.startCounter();
     }
 
@@ -202,9 +181,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
     }
 
     public void killGame() {
-        for (Player p : contestants) {
+        backups.restoreAll();
-            restorePlayer(p);
-        }
         for (Player p : itemDisplays.keySet()) {
             itemDisplays.get(p).setVisible(false);
             itemDisplays.get(p).removePlayer(p);
@@ -224,16 +201,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
         MinigameHandler.deleteGame(this);
     }
 
-    private void restorePlayer(Player p) {
-        PlayerBackup backup = backups.get(p);
-        p.teleport(backup.getLocation());
-        p.setExp(backup.getExp());
-        p.getInventory().clear();
-        p.getInventory().setContents(backup.getInventory());
-        p.getInventory().setArmorContents(backup.getArmor());
-        p.setGameMode(backup.getGamemode());
-    }
-
     public List<Player> getPlayers() {
         return contestants;
     }
@@ -242,12 +209,36 @@ public class ForceItemBattle implements MinigameBase, Listener {
         ItemStack curItem = currentItems.get(p);
         p.getInventory().addItem(curItem);
         checkItem(p, curItem);
+        skips.put(p, skips.get(p) - 1);
     }
 
     public Player getOwner() {
         return owner;
     }
 
+    private List<Material> loadMaterials() {
+        List<Material> mats = new ArrayList<>();
+
+        try (BufferedReader reader = new BufferedReader(new InputStreamReader(Objects.requireNonNull(getClass().getClassLoader().getResourceAsStream("obtainableItems.txt"))))) {
+
+            String line;
+            while ((line = reader.readLine()) != null) {
+                line = line.trim();
+                if (line.isEmpty()) continue;
+                Material mat = Material.getMaterial(line);
+                if (mat != null) {
+                    mats.add(mat);
+                } else {
+                    System.out.println("Unbekanntes Material: " + line);
+                }
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        return mats;
+    }
+
     @EventHandler
     public void onItemPickup(EntityPickupItemEvent e) {
         Player eventPlayer;
@@ -275,4 +266,42 @@ public class ForceItemBattle implements MinigameBase, Listener {
             removePlayer(e.getPlayer());
         }
     }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent e) {
+        if (disconnected.contains(e.getPlayer())) {
+
+        }
+    }
+    @EventHandler
+    public void onPlayerInteract(PlayerInteractEvent event) {
+        if (event.getAction() != Action.RIGHT_CLICK_AIR &&
+                event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
+        ItemStack item = event.getItem();
+        if (item == null || item.getType() != Material.BARRIER) return;
+        Player p = event.getPlayer();
+        try {
+            if (MinigameHandler.getMinigames().isEmpty()) return;
+            for (MinigameBase minigame : MinigameHandler.getMinigames()) {
+                if ((minigame instanceof ForceItemBattle) && contestants.contains(p) && skips.get(p) > 0) {
+                    ((ForceItemBattle) minigame).skipItem(p);
+                }
+            }
+        } catch (Exception ignored) {
+        }
+        p.sendMessage(ChatColor.GREEN + "Skipped Item.");
+        if (item.getAmount() > 1)
+            item.setAmount(item.getAmount() - 1);
+        else
+            p.getInventory().remove(item);
+        event.setCancelled(true);
+    }
+
+    @EventHandler
+    public void onPlayerRespawn(PlayerRespawnEvent e) {
+        if (contestants.contains(e.getPlayer())) {
+            ItemStack skip = new ItemStack(Material.BARRIER, skips.get(e.getPlayer()));
+            e.getPlayer().getInventory().addItem(skip);
+        }
+    }
 }

src/main/java/de/ventority/randomizedminigames/Minigames/ForceItemBattleTeams.java

@@ -1,5 +1,6 @@
 package de.ventority.randomizedminigames.Minigames;
 
+import de.ventority.randomizedminigames.util.Team;
 import net.md_5.bungee.api.ChatColor;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;

src/main/java/de/ventority/randomizedminigames/Minigames/Minigame.java

@@ -4,7 +4,10 @@ import org.bukkit.Material;
 
 public enum Minigame {
     ForceItemBattle(Material.DIAMOND_SWORD, "Force Item Battle", 0, "startForceItem"),
-    ForceItemBattleSameItems(Material.NETHERITE_SWORD, "Force Item Battle (Same Items)", 1, "startForceItemSameItem");
+    ForceItemBattleSameItems(Material.NETHERITE_SWORD, "Force Item Battle (Same Items)", 1, "startForceItemSameItem"),
+    BlockRandomizer(Material.DIAMOND_PICKAXE, "Block Randomizer", 2, "startBlockRandomizer"),
+    ForceItemBattleTeams(Material.GOLDEN_SWORD, "Force Item Battle Teams", 3, "startForceItemTeams"),
+    OnlyChests(Material.CHEST, "Only Chests", 4, "startOnlyChests"),;
     //ForceItemBattleTeams(Material.GOLDEN_SWORD, "Force Item Battle (Teams)", 2, "startForceItemTeams"),;
 
     final Material material;

src/main/java/de/ventority/randomizedminigames/Minigames/MinigameBase.java

@@ -9,7 +9,6 @@ import java.util.List;
 public interface MinigameBase extends Listener {
     int getID();
     String getName();
-    ItemStack getSymbol();
     void addPlayers(List<Player> players);
     List<Player> getPlayers();
     void killGame();

src/main/java/de/ventority/randomizedminigames/Minigames/OnlyChests.java

@@ -0,0 +1,80 @@
+package de.ventority.randomizedminigames.Minigames;
+
+import de.ventority.randomizedminigames.misc.Timer.Timer;
+import org.bukkit.Material;
+import org.bukkit.entity.EnderDragon;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.entity.EntityDeathEvent;
+
+import java.util.HashMap;
+import java.util.List;
+
+public class OnlyChests implements MinigameBase{
+    private Timer timer;
+    private List<Player> contestants;
+    private HashMap<Player, HashMap<Material, Material>> drops = new HashMap<>();
+    private Player owner;
+
+    public OnlyChests(List<Player> players, Player owner) {
+        this.owner = owner;
+        this.contestants = players;
+        this.timer = new Timer(contestants, this, "");
+        timer.startCounter();
+    }
+
+    @Override
+    public int getID() {
+        return 0;
+    }
+
+    @Override
+    public String getName() {
+        return "Only Chest Loot";
+    }
+
+    @Override
+    public void addPlayers(List<Player> players) {
+
+    }
+
+    @Override
+    public List<Player> getPlayers() {
+        return List.of();
+    }
+
+    @Override
+    public void killGame() {
+
+    }
+
+    @Override
+    public void stopGame() {
+
+    }
+
+    @Override
+    public Player getOwner() {
+        return null;
+    }
+
+    @EventHandler
+    public void onBlockBreak(BlockBreakEvent event) {
+        if (contestants.contains(event.getPlayer())) {
+            event.setDropItems(false);
+        }
+    }
+
+    @EventHandler
+    public void onMobKilled(EntityDeathEvent event) {
+        if (event.getEntity() instanceof EnderDragon) {
+            timer.pauseCounter();
+        }
+        if (event.getDamageSource().getCausingEntity() instanceof Player && contestants.contains((Player) event.getDamageSource().getCausingEntity()))
+            if (event.getEntity().getType() != EntityType.BLAZE) {
+                event.getDrops().clear();
+            }
+    }
+}

src/main/java/de/ventority/randomizedminigames/RandomizedMinigames.java

@@ -1,16 +1,8 @@
 package de.ventority.randomizedminigames;
 
-import de.ventority.randomizedminigames.GUI.GUIClickEvent;
+import de.ventority.randomizedminigames.gui.GUIClickEvent;
-import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
+import de.ventority.randomizedminigames.util.MinigameHandler;
-import de.ventority.randomizedminigames.Minigames.MinigameBase;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
-import org.bukkit.*;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.java.JavaPlugin;
 
 public final class RandomizedMinigames extends JavaPlugin implements Listener {
@@ -22,9 +14,6 @@ public final class RandomizedMinigames extends JavaPlugin implements Listener {
         getServer().getPluginManager().registerEvents(new GUIClickEvent(), this);
         getServer().getPluginManager().registerEvents(this, this);
         this.getCommand("minigames").setExecutor(new executeMinigame());
-        for (World world : Bukkit.getWorlds()) {
-            world.setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
-        }
     }
 
     @Override
@@ -36,27 +25,4 @@ public final class RandomizedMinigames extends JavaPlugin implements Listener {
         serverSettingsHandler.setPlugin(this);
     }
 
-    @EventHandler
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        if (event.getAction() != Action.RIGHT_CLICK_AIR &&
-                event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
-        ItemStack item = event.getItem();
-        if (item == null || item.getType() != Material.BARRIER) return;
-        Player p = event.getPlayer();
-        try {
-            if (MinigameHandler.getMinigames().isEmpty()) return;
-            for (MinigameBase minigame : MinigameHandler.getMinigames()) {
-                if ((minigame instanceof ForceItemBattle) && minigame.getPlayers().contains(p)) {
-                    ((ForceItemBattle) minigame).skipItem(p);
-                }
-            }
-        } catch (Exception ignored) {
-        }
-        p.sendMessage(ChatColor.GREEN + "Skipped Item.");
-        if (item.getAmount() > 1)
-            item.setAmount(item.getAmount() - 1);
-        else
-            p.getInventory().remove(item);
-        event.setCancelled(true);
-    }
 }

src/main/java/de/ventority/randomizedminigames/executeMinigame.java

@@ -1,7 +1,8 @@
 package de.ventority.randomizedminigames;
 
-import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
+import de.ventority.randomizedminigames.gui.windows.MinigamesDisplayWindow;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.MinigameHandler;
+import de.ventority.randomizedminigames.util.WorldUtils;
 import org.bukkit.command.*;
 import org.bukkit.entity.Player;
 
@@ -20,6 +21,13 @@ public class executeMinigame implements CommandExecutor {
             return true;
         }
 
+        if (args.length > 0 && args[0].equalsIgnoreCase("reset")) {
+            player.sendMessage("Resetting Server");
+            WorldUtils.resetDefaultWorlds();
+            MinigameHandler.killAll();
+            return true;
+        }
+
         if (MinigameHandler.getOccupiedPlayers().contains(player))
             return true;
 

src/main/java/de/ventority/randomizedminigames/gui/BaseWindow.java

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.GUI;
+package de.ventority.randomizedminigames.gui;
 
 import de.ventority.randomizedminigames.RandomizedMinigames;
 import net.md_5.bungee.api.ChatColor;

src/main/java/de/ventority/randomizedminigames/gui/GUIClickEvent.java

@@ -1,8 +1,8 @@
-package de.ventority.randomizedminigames.GUI;
+package de.ventority.randomizedminigames.gui;
 
-import de.ventority.randomizedminigames.GUI.handlers.MinigameSelectHandler;
+import de.ventority.randomizedminigames.gui.handlers.MinigameSelectHandler;
-import de.ventority.randomizedminigames.GUI.handlers.MinigameSetupHandler;
+import de.ventority.randomizedminigames.gui.handlers.MinigameSetupHandler;
-import de.ventority.randomizedminigames.GUI.handlers.SettingsHandler;
+import de.ventority.randomizedminigames.gui.handlers.SettingsHandler;
 import de.ventority.randomizedminigames.RandomizedMinigames;
 import org.bukkit.Material;
 import org.bukkit.NamespacedKey;

src/main/java/de/ventority/randomizedminigames/gui/GUICreator.java

@@ -0,0 +1,89 @@
+package de.ventority.randomizedminigames.gui;
+
+import com.google.gson.Gson;
+import de.ventority.randomizedminigames.util.MinigameHandler;
+import de.ventority.randomizedminigames.util.Settings;
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.nio.charset.StandardCharsets;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+
+public class GUICreator extends BaseWindow {
+    private final String path;
+
+    // DTOs als statische Klassen
+    private static class GUIItem {
+        int slot;
+        String material;
+        String name;
+        Map<String, String> nbt;
+    }
+    private static class GUIConfig {
+        String title;
+        int rows;
+        List<GUIItem> items;
+    }
+
+    public GUICreator(Player p, String path) {
+        super(p);
+        this.path = path;
+    }
+
+    @Override
+    protected void fillGUI() {
+        Settings playerSettings = MinigameHandler.getSettings(p);
+
+        Gson gson = new Gson();
+        GUIConfig config;
+
+        try (InputStream in = Objects.requireNonNull(
+                getClass().getClassLoader().getResourceAsStream(path),
+                "Resource not found: " + path
+        );
+             Reader reader = new InputStreamReader(in, StandardCharsets.UTF_8)) {
+
+            config = gson.fromJson(reader, GUIConfig.class);
+            if (config == null) {
+                throw new IllegalStateException("Parsed GUI config is null; is the file empty? Path: " + path);
+            }
+            if (config.items == null) {
+                throw new IllegalStateException("'items' is null in GUI config. Path: " + path);
+            }
+        } catch (Exception e) {
+            System.out.println("Error loading " + path + ". Check that the file is packaged under src/main/resources and not empty.");
+            return;
+        }
+
+        for (GUIItem guiItem : config.items) {
+            Material mat = Material.valueOf(guiItem.material.toUpperCase());
+            ItemStack item = new ItemStack(mat);
+
+            if (guiItem.nbt != null) {
+                for (Map.Entry<String, String> entry : guiItem.nbt.entrySet()) {
+                    addNBT(item, entry.getKey(), entry.getValue());
+                }
+            }
+
+            String displayName = guiItem.name
+                    .replace("%scoreboard%", playerSettings.getScoreboardStatus() ? ChatColor.GREEN + "On" : ChatColor.RED + "Off")
+                    .replace("%scoreboardState%", playerSettings.getScoreboardStatus() ? ChatColor.GREEN + "On" : ChatColor.RED + "Off")
+                    .replace("%timer%", playerSettings.isTimed ? ChatColor.GREEN + "On" : ChatColor.RED + "Off");
+
+            setItemName(item, displayName);
+
+            if (guiItem.slot == -1) {
+                addItemToGUI(item);
+            } else {
+                addItemToGUI(guiItem.slot, item);
+            }
+        }
+    }
+}

src/main/java/de/ventority/randomizedminigames/gui/InGame/BossBarCreator.java

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.GUI.InGame;
+package de.ventority.randomizedminigames.gui.InGame;
 
 import org.bukkit.Bukkit;
 import org.bukkit.boss.*;

src/main/java/de/ventority/randomizedminigames/gui/InGame/GamesScoreboardManager.java

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.GUI.InGame;
+package de.ventority.randomizedminigames.gui.InGame;
 
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/MinigameSetup.java

@@ -1,8 +1,8 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.MinigameHandler;
-import de.ventority.randomizedminigames.misc.Settings;
+import de.ventority.randomizedminigames.util.Settings;
 import net.md_5.bungee.api.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/PlayerSelection.java

@@ -1,8 +1,7 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.util.MinigameHandler;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
 import net.md_5.bungee.api.ChatColor;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/SetLimit.java

@@ -1,8 +1,7 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.util.MinigameHandler;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/SetTimeLimit.java

@@ -1,7 +1,7 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.MinigameHandler;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
@@ -52,7 +52,7 @@ public class SetTimeLimit extends BaseWindow {
         ItemStack display = new ItemStack(Material.PAPER);
         addNBT(display, "Type", "MinigameSetup");
         addNBT(display, "Action", "none");
-        setItemName(display, formattedTime(MinigameHandler.getSettings(p).timerStop));
+        setItemName(display, formattedTime(MinigameHandler.getSettings(p).getTimeLimit()));
         addItemToGUI(13, display);
 
         ItemStack back = new ItemStack(Material.ARROW);

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamCountSelection.java

@@ -1,7 +1,7 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.MinigameHandler;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamOverview.java

@@ -1,6 +1,6 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
 import org.bukkit.entity.Player;
 
 public class TeamOverview extends BaseWindow {

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamPlayerSelection.java

@@ -1,7 +1,7 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.MinigameHandler;
 import net.md_5.bungee.api.ChatColor;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -26,14 +26,15 @@ public class TeamPlayerSelection extends BaseWindow {
                 addItemToGUI(item);
             }
         }
-        final org.bukkit.ChatColor[] colors = new org.bukkit.ChatColor[]{org.bukkit.ChatColor.GREEN,
+        final ChatColor[] colors = new ChatColor[]{ChatColor.GREEN,
-                org.bukkit.ChatColor.RED, org.bukkit.ChatColor.BLUE, org.bukkit.ChatColor.DARK_PURPLE,
+                ChatColor.RED, ChatColor.BLUE, ChatColor.DARK_PURPLE,
-                org.bukkit.ChatColor.BLACK, org.bukkit.ChatColor.DARK_GREEN};
+                ChatColor.BLACK, ChatColor.DARK_GREEN};
         final Material[] material = new Material[]{Material.GREEN_WOOL, Material.RED_WOOL,
                 Material.BLUE_WOOL, Material.PURPLE_WOOL, Material.BLACK_WOOL, Material.GREEN_WOOL};
 
         ItemStack selectedTeam = new ItemStack(material[MinigameHandler.getSettings(p).getSelectedTeamIndex()], 1);
         setItemName(selectedTeam, colors[MinigameHandler.getSettings(p).getSelectedTeamIndex()] + "Team #" + (MinigameHandler.getSettings(p).getSelectedTeamIndex() + 1));
+        addNBT(selectedTeam, "Team", Integer.toString(MinigameHandler.getSettings(p).getSelectedTeamIndex()));
         addItemToGUI(4, selectedTeam);
 
         ItemStack back = new ItemStack(Material.ARROW);

src/main/java/de/ventority/randomizedminigames/gui/MinigameSetups/TeamSetupSelection.java

@@ -1,14 +1,12 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.MinigameSetups;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.MinigameHandler;
 import org.bukkit.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
 
-import java.util.HashMap;
-
 public class TeamSetupSelection extends BaseWindow {
     private final ChatColor[] colors = new ChatColor[]{ChatColor.GREEN, ChatColor.RED, ChatColor.BLUE, ChatColor.DARK_PURPLE, ChatColor.BLACK, ChatColor.DARK_GREEN};
     private final Material[] material = new Material[]{Material.GREEN_WOOL, Material.RED_WOOL, Material.BLUE_WOOL, Material.PURPLE_WOOL, Material.BLACK_WOOL, Material.GREEN_WOOL};
@@ -27,5 +25,6 @@ public class TeamSetupSelection extends BaseWindow {
             addNBT(item, "selectedTeam", Integer.toString(i));
             addItemToGUI(item);
         }
+
     }
 }

src/main/java/de/ventority/randomizedminigames/gui/SettingsWindow.java

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.GUI;
+package de.ventority.randomizedminigames.gui;
 
 import org.bukkit.Material;
 import org.bukkit.entity.Player;

src/main/java/de/ventority/randomizedminigames/gui/handlers/GUIHandler.java

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.GUI.handlers;
+package de.ventority.randomizedminigames.gui.handlers;
 
 import de.ventority.randomizedminigames.RandomizedMinigames;
 import org.bukkit.NamespacedKey;

src/main/java/de/ventority/randomizedminigames/gui/handlers/MinigameSelectHandler.java

@@ -1,10 +1,9 @@
-package de.ventority.randomizedminigames.GUI.handlers;
+package de.ventority.randomizedminigames.gui.handlers;
 
-import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
+import de.ventority.randomizedminigames.gui.MinigameSetups.MinigameSetup;
-import de.ventority.randomizedminigames.GUI.MinigameSetups.TeamCountSelection;
+import de.ventority.randomizedminigames.gui.MinigameSetups.TeamCountSelection;
-import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.util.MinigameHandler;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.Settings;
-import de.ventority.randomizedminigames.misc.Settings;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryClickEvent;
 
@@ -16,7 +15,7 @@ public class MinigameSelectHandler extends GUIHandler{
     @Override
     public void handle() {
         Settings settings = MinigameHandler.getSettings((Player) event.getWhoClicked());
-        if (action.equals("startForceItem") || action.equals("startForceItemSameItem")) {
+        if (action.equals("startForceItem") || action.equals("startForceItemSameItem") || action.equals("startBlockRandomizer") || action.equals("startOnlyChests")) {
             settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
             new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
         }

src/main/java/de/ventority/randomizedminigames/gui/handlers/MinigameSetupHandler.java

@@ -1,8 +1,9 @@
-package de.ventority.randomizedminigames.GUI.handlers;
+package de.ventority.randomizedminigames.gui.handlers;
 
-import de.ventority.randomizedminigames.GUI.MinigameSetups.*;
+import de.ventority.randomizedminigames.gui.MinigameSetups.*;
-import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.util.Team;
-import de.ventority.randomizedminigames.misc.Settings;
+import de.ventority.randomizedminigames.util.MinigameHandler;
+import de.ventority.randomizedminigames.util.Settings;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryClickEvent;
@@ -31,12 +32,12 @@ public class MinigameSetupHandler extends GUIHandler {
         }
 
         if (action.equals("subFromLimit")) {
-            playerSettings.subFromSelectedLimit();
+            playerSettings.subFromWinLimit();
             new SetLimit((Player)event.getWhoClicked()).buildWindow();
         }
 
         if (action.equals("addToLimit")) {
-            playerSettings.addToSelectedLimit();
+            playerSettings.addToWinLimit();
             new SetLimit((Player)event.getWhoClicked()).buildWindow();
         }
 
@@ -83,6 +84,16 @@ public class MinigameSetupHandler extends GUIHandler {
         }
 
         if (action.equals("clickedPlayerInTeams")) {
+            Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
+            int teamNumber = Integer.parseInt(getNBT(event.getClickedInventory().getItem(4), "Team"));
+            Team team = playerSettings.getTeam(teamNumber - 1);
+            if (playerSettings.getSelectedPlayers().contains(toWork)) {
+                team.removePlayer(toWork);
+                playerSettings.removePlayersFromSelection(toWork);
+            } else {
+                team.addPlayer(toWork);
+                playerSettings.addPlayersToSelection(toWork);
+            }
             return;
         }
 
@@ -92,12 +103,12 @@ public class MinigameSetupHandler extends GUIHandler {
 
         if (action.contains("FromTimeLimit") || action.contains("ToTimeLimit")) {
             switch (action) {
-                case "add30ToTimeLimit": playerSettings.timerStop = playerSettings.timerStop + 30*60; break;
+                case "add30ToTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() + 30*60); break;
-                case "add10ToTimeLimit": playerSettings.timerStop = playerSettings.timerStop + 10*60; break;
+                case "add10ToTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() + 10*60); break;
-                case "add1ToTimeLimit": playerSettings.timerStop = playerSettings.timerStop + 60; break;
+                case "add1ToTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() + 60); break;
-                case "sub30FromTimeLimit": playerSettings.timerStop = playerSettings.timerStop - 30*60; break;
+                case "sub30FromTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() - 30*60); break;
-                case "sub10FromTimeLimit": playerSettings.timerStop = playerSettings.timerStop - 10*60; break;
+                case "sub10FromTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() - 10*60); break;
-                case "sub1FromTimeLimit": playerSettings.timerStop = playerSettings.timerStop - 60; break;
+                case "sub1FromTimeLimit": playerSettings.setTimeLimit(playerSettings.getTimeLimit() - 60); break;
             }
             new SetTimeLimit((Player)event.getWhoClicked()).buildWindow();
         }

src/main/java/de/ventority/randomizedminigames/gui/handlers/SettingsHandler.java

@@ -1,6 +1,6 @@
-package de.ventority.randomizedminigames.GUI.handlers;
+package de.ventority.randomizedminigames.gui.handlers;
 
-import de.ventority.randomizedminigames.GUI.SettingsWindow;
+import de.ventority.randomizedminigames.gui.SettingsWindow;
 import org.bukkit.entity.Player;
 import org.bukkit.event.inventory.InventoryClickEvent;
 

src/main/java/de/ventority/randomizedminigames/gui/windows/MinigamesDisplayWindow.java

@@ -1,11 +1,9 @@
-package de.ventority.randomizedminigames.GUI.MinigameSetups;
+package de.ventority.randomizedminigames.gui.windows;
 
-import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.gui.BaseWindow;
 import de.ventority.randomizedminigames.Minigames.Minigame;
-import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
 
 public class MinigamesDisplayWindow extends BaseWindow {
 
@@ -23,16 +21,5 @@ public class MinigamesDisplayWindow extends BaseWindow {
             addNBT(item, "selectedMinigame", Integer.toString(minigame.getNumber()));
             addItemToGUI(item);
         }
-        //addSettings();
-    }
-
-    private void addSettings() {
-        ItemStack settings = new ItemStack(Material.REDSTONE, 1);
-        ItemMeta settingsMeta = settings.getItemMeta();
-        setItemName(settings, "Settings");
-        addNBT(settings, "Type", "Misc");
-        addNBT(settings, "Action", "selectSettings");
-        settings.setItemMeta(settingsMeta);
-        addItemToGUI(45, settings);
     }
 }

src/main/java/de/ventority/randomizedminigames/misc/ColorCycler.java

@@ -0,0 +1,4 @@
+package de.ventority.randomizedminigames.misc;
+
+public class ColorCycler {
+}

src/main/java/de/ventority/randomizedminigames/misc/ReconnectionHandler.java

@@ -0,0 +1,118 @@
+package de.ventority.randomizedminigames.misc;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+import com.google.gson.reflect.TypeToken;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.*;
+
+public class ReconnectionHandler {
+
+    private final File file;
+    private final Gson gson;
+
+    private Map<UUID, PlayerData> storedPlayers;
+
+    public ReconnectionHandler(File dataFolder, String fileName) {
+        if (!dataFolder.exists()) {
+            dataFolder.mkdirs();
+        }
+        this.file = new File(dataFolder, fileName);
+        this.gson = new GsonBuilder().setPrettyPrinting().create();
+        this.storedPlayers = new HashMap<>();
+        load();
+    }
+
+    public void addPlayer(UUID uuid, Inventory inventory) {
+        PlayerData data = new PlayerData(uuid, inventory);
+        storedPlayers.put(uuid, data);
+        save();
+    }
+
+    public void removePlayer(UUID uuid) {
+        storedPlayers.remove(uuid);
+        save();
+    }
+
+    public boolean containsPlayer(UUID uuid) {
+        return storedPlayers.containsKey(uuid);
+    }
+
+    public Inventory getInventory(UUID uuid) {
+        PlayerData data = storedPlayers.get(uuid);
+        return data != null ? data.toInventory() : null;
+    }
+
+    public Set<UUID> getPlayers() {
+        return storedPlayers.keySet();
+    }
+
+    public void load() {
+        if (!file.exists()) {
+            save();
+            return;
+        }
+
+        try (FileReader reader = new FileReader(file)) {
+            Type type = new TypeToken<Map<UUID, PlayerData>>(){}.getType();
+            Map<UUID, PlayerData> loaded = gson.fromJson(reader, type);
+            if (loaded != null) {
+                storedPlayers = loaded;
+            }
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public void save() {
+        try (FileWriter writer = new FileWriter(file)) {
+            gson.toJson(storedPlayers, writer);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static class PlayerData {
+        private UUID uuid;
+        private List<Map<String, Object>> inventory; // serialisiertes Inventar
+
+        public PlayerData(UUID uuid, Inventory inv) {
+            this.uuid = uuid;
+            this.inventory = new ArrayList<>();
+            for (ItemStack item : inv.getContents()) {
+                if (item != null) {
+                    this.inventory.add(item.serialize());
+                } else {
+                    this.inventory.add(null); // Slot leer
+                }
+            }
+        }
+
+        public UUID getUuid() {
+            return uuid;
+        }
+
+        public Inventory toInventory() {
+            Inventory inv = org.bukkit.Bukkit.createInventory(null, 54, "Stored Inventory");
+            ItemStack[] items = new ItemStack[inventory.size()];
+
+            for (int i = 0; i < inventory.size(); i++) {
+                Map<String, Object> data = inventory.get(i);
+                if (data != null) {
+                    items[i] = ItemStack.deserialize(data);
+                } else {
+                    items[i] = null;
+                }
+            }
+            inv.setContents(items);
+            return inv;
+        }
+    }
+}

src/main/java/de/ventority/randomizedminigames/misc/Timer.java

@@ -1,108 +0,0 @@
-package de.ventority.randomizedminigames.misc;
-
-import de.ventority.randomizedminigames.Minigames.MinigameBase;
-import de.ventority.randomizedminigames.RandomizedMinigames;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.chat.TextComponent;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitTask;
-
-import java.util.List;
-
-
-public class Timer {
-    private int counter = 0;
-    private BukkitTask counterTask;
-    private int maxValue = 10;
-    private List<Player> players;
-    private MinigameBase minigame;
-    private boolean isPaused = false;
-    private Runnable methodToCall;
-    private boolean isReversed = false;
-    private String outputText;
-
-    public Timer(int maxValue, List<Player> players, MinigameBase minigame, String text) {
-        this.maxValue = maxValue;
-        this.players = players;
-        this.minigame = minigame;
-        this.outputText = text;
-    }
-
-    public Timer(int maxValue, List<Player> players, MinigameBase minigame, Runnable method, String text) {
-        this.maxValue = maxValue;
-        this.players = players;
-        this.minigame = minigame;
-        this.methodToCall = method;
-        this.outputText = text;
-    }
-    public Timer(int maxValue, List<Player> players, MinigameBase minigame, Runnable method, boolean isReversed, String text) {
-        this.maxValue = maxValue;
-        this.players = players;
-        this.minigame = minigame;
-        this.methodToCall = method;
-        this.isReversed = isReversed;
-        this.outputText = text;
-    }
-
-    public void startCounter() {
-        if (counterTask != null && !counterTask.isCancelled()) {
-            return;
-        }
-
-        counter = 0;
-
-        counterTask = Bukkit.getScheduler().runTaskTimer(RandomizedMinigames.serverSettingsHandler.getPlugin(), () -> {
-            updatePlayers();
-            if (!isPaused) {
-                counter++;
-                if (counter >= maxValue && MinigameHandler.getSettings(minigame.getOwner()).isTimed) {
-                    if (methodToCall != null)
-                        methodToCall.run();
-                    else
-                        minigame.stopGame();
-                    stopCounter();
-                }
-            }
-        }, 20L, 20L);
-    }
-
-    public void pauseCounter() {
-        isPaused = true;
-    }
-
-    public void resumeCounter() {
-        isPaused = false;
-    }
-
-    public void stopCounter() {
-        if (counterTask != null)
-            counterTask.cancel();
-    }
-
-    public void resetCounter() {
-        counter = 0;
-    }
-
-    private void updatePlayers() {
-        if (isPaused) {
-            for (Player player : players)
-                player.spigot().sendMessage(ChatMessageType.ACTION_BAR, new TextComponent(ChatColor.DARK_PURPLE + ChatColor.BOLD.toString() + "The Timer is paused..."));
-            return;
-        }
-
-        int x = isReversed ? maxValue - counter : counter;
-        int minutes = (int)Math.floor((double) x / 60);
-        int seconds = x % 60;
-        StringBuilder  sb = new StringBuilder();
-        if (minutes != 0) {
-            sb.append(minutes).append(":");
-        }
-        sb.append(seconds < 10 ? "0" + seconds : seconds);
-        String output = sb.toString();
-        for (Player player : players) {
-            player.spigot().sendMessage(ChatMessageType.ACTION_BAR, new TextComponent(ChatColor.DARK_PURPLE + ChatColor.BOLD.toString() + outputText + output));
-        }
-    }
-}

src/main/java/de/ventority/randomizedminigames/misc/Timer/Timer.java

@@ -0,0 +1,140 @@
+package de.ventority.randomizedminigames.misc.Timer;
+
+import de.ventority.randomizedminigames.Minigames.MinigameBase;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.util.MinigameHandler;
+import net.md_5.bungee.api.ChatMessageType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.scheduler.BukkitTask;
+
+import java.util.List;
+
+
+public class Timer {
+    private int counter = 0;
+    private BukkitTask counterTask;
+    private int stopTime;
+    private List<Player> players;
+    private MinigameBase minigame;
+    private boolean isPaused = false;
+    private Runnable methodToCall;
+    private boolean isReversed = false;
+    private String customText;
+    private int countedSeconds = 0;
+    private String defaultText;
+
+    public Timer(List<Player> players, MinigameBase minigame, String text) {
+        this.players = players;
+        this.minigame = minigame;
+        this.customText = text;
+        this.stopTime = MinigameHandler.getSettings(minigame.getOwner()).getTimeLimit();
+    }
+
+    public Timer(List<Player> players, MinigameBase minigame, Runnable method, String text) {
+        this.players = players;
+        this.minigame = minigame;
+        this.methodToCall = method;
+        this.customText = text;
+        this.stopTime = MinigameHandler.getSettings(minigame.getOwner()).getTimeLimit();
+    }
+
+    public void startCounter() {
+        if (counterTask != null && !counterTask.isCancelled()) {
+            return;
+        }
+        counter = 0;
+        countedSeconds = 0;
+
+        counterTask = Bukkit.getScheduler().runTaskTimer(RandomizedMinigames.serverSettingsHandler.getPlugin(), () -> {
+            countedSeconds = counter / 20;
+            updateText();
+            updatePlayers();
+            if (!isPaused) {
+                counter++;
+                if (countedSeconds == stopTime && MinigameHandler.getSettings(minigame.getOwner()).isTimed) {
+                    if (methodToCall != null)
+                        methodToCall.run();
+                    else
+                        minigame.stopGame();
+                    stopCounter();
+                }
+            }
+        }, 0L, 1L);
+    }
+
+    public void pauseCounter() {
+        isPaused = true;
+    }
+
+    public void resumeCounter() {
+        isPaused = false;
+    }
+
+    public void stopCounter() {
+        if (counterTask != null)
+            counterTask.cancel();
+    }
+
+    private String updateText() {
+        int x = isReversed ? stopTime - countedSeconds : countedSeconds;
+
+        int days = x / 86400;
+        int hours = (x % 86400) / 3600;
+        int minutes = (x % 3600) / 60;
+        int seconds = x % 60;
+        StringBuilder sb = new StringBuilder();
+        if (days > 0)
+            sb.append(days).append("d ");
+        if (hours > 0 || days > 0)
+            sb.append(hours).append(":");
+        if (minutes < 10 && (hours > 0 || days > 0))
+            sb.append("0");
+        sb.append(minutes).append(":");
+        if (seconds < 10)
+            sb.append("0");
+        sb.append(seconds);
+        String output = sb.toString();
+        return isPaused ? "The Timer is paused...  " : customText + output;
+    }
+
+    public void resetCounter() {
+        counter = 0;
+    }
+
+    private void updatePlayers() {
+//        int amplitude = 40;
+//
+//        int step = counter % (amplitude * 2);
+//        int brightness = step <= amplitude ? step : (amplitude * 2 - step);
+//
+//        int baseRed = 125;
+//        int baseGreen = 0;
+//        int baseBlue = 130;
+//
+//
+//        Color c = new Color(
+//                baseRed + 2*brightness,
+//                baseGreen,
+//                baseBlue + 2*brightness
+//        );
+//
+        TextComponent msg = new TextComponent(defaultText);
+//        msg.setColor(ChatColor.of(c));
+        msg.setBold(true);
+
+        for (Player player : players) {
+            player.spigot().sendMessage(ChatMessageType.ACTION_BAR, msg);
+        }
+
+    }
+
+    public void setStopTime(int seconds) {
+        this.stopTime = seconds;
+    }
+
+    public void setReversed(boolean reversed) {
+        this.isReversed = reversed;
+    }
+}

src/main/java/de/ventority/randomizedminigames/util/MinigameHandler.java

@@ -1,8 +1,6 @@
-package de.ventority.randomizedminigames.misc;
+package de.ventority.randomizedminigames.util;
 
-import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
+import de.ventority.randomizedminigames.Minigames.*;
-import de.ventority.randomizedminigames.Minigames.ForceItemBattleSameItems;
-import de.ventority.randomizedminigames.Minigames.MinigameBase;
 import de.ventority.randomizedminigames.RandomizedMinigames;
 import org.bukkit.entity.Player;
 import java.util.ArrayList;
@@ -21,6 +19,8 @@ public class MinigameHandler {
         switch (gameNumber) {
             case 0: minigames.add(new ForceItemBattle(players, caller)); break;
             case 1: minigames.add(new ForceItemBattleSameItems(players, caller)); break;
+            case 2: minigames.add(new BlockRandomizer(players, caller)); break;
+            case 4: minigames.add(new OnlyChests(players, caller)); break;
         }
         getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
     }
@@ -51,11 +51,11 @@ public class MinigameHandler {
 
     public static Settings getSettings(Player player) {
         if (!settings.containsKey(player))
-            settings.put(player, new Settings(player));
+            settings.put(player, new Settings());
         return settings.get(player);
     }
 
     public static void resetSettings(Player player) {
-        settings.put(player, new Settings(player));
+        settings.put(player, new Settings());
     }
 }

src/main/java/de/ventority/randomizedminigames/util/PlayerBackup.java

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.misc;
+package de.ventority.randomizedminigames.util;
 
 import org.bukkit.GameMode;
 import org.bukkit.Location;

src/main/java/de/ventority/randomizedminigames/util/PlayerBackupHandler.java

@@ -0,0 +1,32 @@
+package de.ventority.randomizedminigames.util;
+
+import org.bukkit.entity.Player;
+
+import java.util.HashMap;
+import java.util.List;
+
+public class PlayerBackupHandler {
+    private HashMap<Player, PlayerBackup> playerBackups = new HashMap<>();
+
+    public PlayerBackupHandler(List<Player> players) {
+        for (Player player : players) {
+            PlayerBackup backup = new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation(), player.getGameMode());
+            playerBackups.put(player, backup);
+        }
+    }
+
+    public void restorePlayerBackup(Player player) {
+        PlayerBackup backup = playerBackups.get(player);
+        player.getInventory().setContents(backup.getInventory());
+        player.getInventory().setArmorContents(backup.getArmor());
+        player.setExp(backup.getExp());
+        player.teleport(backup.getLocation());
+        player.setGameMode(backup.getGamemode());
+    }
+
+    public void restoreAll() {
+        for (Player player : playerBackups.keySet()) {
+            restorePlayerBackup(player);
+        }
+    }
+}

src/main/java/de/ventority/randomizedminigames/util/Settings.java

@@ -1,25 +1,22 @@
-package de.ventority.randomizedminigames.misc;
+package de.ventority.randomizedminigames.util;
 
-import de.ventority.randomizedminigames.Minigames.Team;
 import org.bukkit.entity.Player;
 
 import java.util.ArrayList;
 import java.util.List;
 
 public class Settings {
-    private Player owner;
+    private final List<Player> selectedPlayers = new ArrayList<>();
-    private List<Player> selectedPlayers = new ArrayList<>();
     int selectedMinigame;
-    int selectedLimit = 10;
+    int selectedWinLimit = 10;
     List<Team> teams = new ArrayList<>();
-    boolean showScoreboard = true;
+    boolean showScoreboard = false;
     private int selectedTeamCount = 2;
     private int selectedTeamIndex = 0;
-    public int timerStop = 1800;
+    public boolean isTimed = true;
+    private int timeLimit = 1800;
 
-    public Settings(Player owner) {
+    public Settings() {}
-        this.owner = owner;
-    }
 
     public void switchScoreboard() {
         showScoreboard = !showScoreboard;
@@ -50,19 +47,19 @@ public class Settings {
     }
 
     public int getSelectedLimit() {
-        return selectedLimit;
+        return selectedWinLimit;
     }
 
-    public void addToSelectedLimit() {
+    public void addToWinLimit() {
-        selectedLimit++;
+        selectedWinLimit++;
     }
 
-    public void subFromSelectedLimit() {
+    public void subFromWinLimit() {
-        selectedLimit--;
+        selectedWinLimit--;
     }
 
     public void addTeamCount() {
-        if (selectedTeamCount < 6) {}
+        if (selectedTeamCount < 6)
             selectedTeamCount++;
     }
 
@@ -83,6 +80,23 @@ public class Settings {
         return selectedTeamIndex;
     }
 
-    public boolean isTimed;
+    public int getTimeLimit() {
+        return timeLimit;
+    }
 
+    public void setTimeLimit(int timeLimit) {
+        this.timeLimit = timeLimit;
+    }
+
+    public Team getTeam(int i) {
+        return teams.get(i);
+    }
+
+    public void addPlayerToTeam(int i, Player p) {
+        teams.get(i).addPlayer(p);
+    }
+
+    public void removePlayerFromTeam(int i, Player p) {
+        teams.get(i).removePlayer(p);
+    }
 }

src/main/java/de/ventority/randomizedminigames/util/Team.java

@@ -1,12 +1,9 @@
-package de.ventority.randomizedminigames.Minigames;
+package de.ventority.randomizedminigames.util;
 
 import org.bukkit.ChatColor;
 import org.bukkit.entity.Player;
 
-import java.util.ArrayList;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Random;
 
 public class Team {
     private final List<Player> players;
@@ -28,4 +25,8 @@ public class Team {
     public ChatColor getColor() {
         return color;
     }
+
+    public void removePlayer(Player p) {
+        players.remove(p);
+    }
 }

src/main/java/de/ventority/randomizedminigames/util/WorldUtils.java

@@ -0,0 +1,74 @@
+package de.ventority.randomizedminigames.util;
+
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.World.Environment;
+import org.bukkit.entity.Player;
+
+import java.io.File;
+import java.util.Random;
+
+public class WorldUtils {
+
+    public static void resetDefaultWorlds() {
+        String[] worlds = {"world", "world_nether", "world_the_end"};
+
+        // Spieler vorher in Sicherheit bringen
+        World safeWorld = Bukkit.getWorld("world"); // falls schon geladen
+        if (safeWorld == null && !Bukkit.getWorlds().isEmpty()) {
+            safeWorld = Bukkit.getWorlds().get(0);
+        }
+
+        if (safeWorld != null) {
+            for (Player p : Bukkit.getOnlinePlayers()) {
+                p.teleport(safeWorld.getSpawnLocation());
+            }
+        }
+
+        for (String worldName : worlds) {
+            World w = Bukkit.getWorld(worldName);
+            if (w != null) {
+                Bukkit.unloadWorld(w, false);
+            }
+            deleteWorldFolder(new File(Bukkit.getWorldContainer(), worldName));
+        }
+
+        long newSeed = new Random().nextLong();
+
+        WorldCreator overworld = new WorldCreator("world");
+        overworld.environment(Environment.NORMAL);
+        overworld.seed(newSeed);
+        Bukkit.createWorld(overworld);
+
+        WorldCreator nether = new WorldCreator("world_nether");
+        nether.environment(Environment.NETHER);
+        nether.seed(newSeed);
+        Bukkit.createWorld(nether);
+
+        WorldCreator theEnd = new WorldCreator("world_the_end");
+        theEnd.environment(Environment.THE_END);
+        theEnd.seed(newSeed);
+        Bukkit.createWorld(theEnd);
+
+        Bukkit.getLogger().info("Alle Standardwelten wurden neu generiert mit Seed: " + newSeed);
+    }
+
+    private static void deleteWorldFolder(File path) {
+        if (path.exists()) {
+            File[] files = path.listFiles();
+            if (files != null) {
+                for (File file : files) {
+                    if (file.isDirectory()) {
+                        deleteWorldFolder(file);
+                    } else {
+                        file.delete();
+                    }
+                }
+            }
+        }
+        path.delete();
+    }
+}
+
+

src/main/resources/gui/MinigameSetup.json

@@ -0,0 +1,69 @@
+{
+  "title": "Minigame Setup",
+  "rows": 6,
+  "items": [
+    {
+      "slot": -1,
+      "material": "PLAYER_HEAD",
+      "name": "Select Players",
+      "nbt": {
+        "Type": "MinigameSetup",
+        "Action": "startPlayerSelection"
+      }
+    },
+    {
+      "slot": -1,
+      "material": "BOOK",
+      "name": "Set win limit",
+      "nbt": {
+        "Type": "MinigameSetup",
+        "Action": "startLimitSelection"
+      }
+    },
+    {
+      "slot": -1,
+      "material": "EMERALD",
+      "name": "Scoreboard: %scoreboardState%",
+      "nbt": {
+        "Type": "MinigameSetup",
+        "Action": "switchScoreboard"
+      }
+    },
+    {
+      "slot": 50,
+      "material": "GREEN_DYE",
+      "name": "Start",
+      "nbt": {
+        "Type": "MinigameSetup",
+        "Action": "startGame"
+      }
+    },
+    {
+      "slot": -1,
+      "material": "CLOCK",
+      "name": "Set Timer",
+      "nbt": {
+        "Type": "MinigameSetup",
+        "Action": "startTimerSetup"
+      }
+    },
+    {
+      "slot": -1,
+      "material": "TARGET",
+      "name": "Timer: %timer%",
+      "nbt": {
+        "Type": "MinigameSetup",
+        "Action": "toggleTimer"
+      }
+    },
+    {
+      "slot": 49,
+      "material": "ARROW",
+      "name": "Back",
+      "nbt": {
+        "Type": "MinigameSelect",
+        "Action": "homeMenu"
+      }
+    }
+  ]
+}

src/main/resources/obtainableItems.txt

@@ -0,0 +1,776 @@
+STONE
+GRANITE
+POLISHED_GRANITE
+DIORITE
+POLISHED_DIORITE
+ANDESITE
+POLISHED_ANDESITE
+DEEPSLATE
+COBBLED_DEEPSLATE
+POLISHED_DEEPSLATE
+CALCITE
+TUFF
+TUFF_SLAB
+TUFF_STAIRS
+TUFF_WALL
+CHISELED_TUFF
+POLISHED_TUFF
+POLISHED_TUFF_SLAB
+POLISHED_TUFF_STAIRS
+POLISHED_TUFF_WALL
+TUFF_BRICKS
+TUFF_BRICK_SLAB
+TUFF_BRICK_STAIRS
+TUFF_BRICK_WALL
+CHISELED_TUFF_BRICKS
+DRIPSTONE_BLOCK
+GRASS_BLOCK
+DIRT
+COARSE_DIRT
+PODZOL
+ROOTED_DIRT
+MUD
+COBBLESTONE
+OAK_PLANKS
+SPRUCE_PLANKS
+BIRCH_PLANKS
+JUNGLE_PLANKS
+ACACIA_PLANKS
+CHERRY_PLANKS
+DARK_OAK_PLANKS
+MANGROVE_PLANKS
+BAMBOO_PLANKS
+BAMBOO_MOSAIC
+OAK_SAPLING
+SPRUCE_SAPLING
+BIRCH_SAPLING
+JUNGLE_SAPLING
+ACACIA_SAPLING
+DARK_OAK_SAPLING
+MANGROVE_PROPAGULE
+SAND
+GRAVEL
+COAL_BLOCK
+RAW_IRON_BLOCK
+RAW_COPPER_BLOCK
+RAW_GOLD_BLOCK
+IRON_BLOCK
+COPPER_BLOCK
+GOLD_BLOCK
+DIAMOND_BLOCK
+CHISELED_COPPER
+CUT_COPPER
+CUT_COPPER_STAIRS
+CUT_COPPER_SLAB
+OAK_LOG
+SPRUCE_LOG
+BIRCH_LOG
+JUNGLE_LOG
+ACACIA_LOG
+DARK_OAK_LOG
+BAMBOO_BLOCK
+STRIPPED_OAK_LOG
+STRIPPED_SPRUCE_LOG
+STRIPPED_BIRCH_LOG
+STRIPPED_JUNGLE_LOG
+STRIPPED_ACACIA_LOG
+STRIPPED_CHERRY_LOG
+STRIPPED_DARK_OAK_LOG
+STRIPPED_OAK_WOOD
+STRIPPED_SPRUCE_WOOD
+STRIPPED_BIRCH_WOOD
+STRIPPED_JUNGLE_WOOD
+STRIPPED_ACACIA_WOOD
+STRIPPED_DARK_OAK_WOOD
+STRIPPED_BAMBOO_BLOCK
+OAK_WOOD
+SPRUCE_WOOD
+BIRCH_WOOD
+JUNGLE_WOOD
+ACACIA_WOOD
+DARK_OAK_WOOD
+MANGROVE_WOOD
+OAK_LEAVES
+SPRUCE_LEAVES
+BIRCH_LEAVES
+JUNGLE_LEAVES
+ACACIA_LEAVES
+DARK_OAK_LEAVES
+MANGROVE_LEAVES
+GLASS
+TINTED_GLASS
+LAPIS_BLOCK
+SANDSTONE
+CHISELED_SANDSTONE
+CUT_SANDSTONE
+SHORT_GRASS
+SEAGRASS
+SEA_PICKLE
+WHITE_WOOL
+ORANGE_WOOL
+MAGENTA_WOOL
+YELLOW_WOOL
+LIME_WOOL
+PINK_WOOL
+GRAY_WOOL
+CYAN_WOOL
+PURPLE_WOOL
+BLUE_WOOL
+BROWN_WOOL
+GREEN_WOOL
+RED_WOOL
+BLACK_WOOL
+DANDELION
+POPPY
+BLUE_ORCHID
+ALLIUM
+RED_TULIP
+ORANGE_TULIP
+WHITE_TULIP
+PINK_TULIP
+OXEYE_DAISY
+CORNFLOWER
+BROWN_MUSHROOM
+RED_MUSHROOM
+WEEPING_VINES
+TWISTING_VINES
+SUGAR_CANE
+KELP
+PINK_PETALS
+WILDFLOWERS
+LEAF_LITTER
+MOSS_CARPET
+MOSS_BLOCK
+BAMBOO
+OAK_SLAB
+SPRUCE_SLAB
+BIRCH_SLAB
+JUNGLE_SLAB
+ACACIA_SLAB
+DARK_OAK_SLAB
+MANGROVE_SLAB
+BAMBOO_SLAB
+BAMBOO_MOSAIC_SLAB
+STONE_SLAB
+SMOOTH_STONE_SLAB
+SANDSTONE_SLAB
+CUT_SANDSTONE_SLAB
+COBBLESTONE_SLAB
+BRICK_SLAB
+STONE_BRICK_SLAB
+MUD_BRICK_SLAB
+QUARTZ_SLAB
+RED_SANDSTONE_SLAB
+CUT_RED_SANDSTONE_SLAB
+PRISMARINE_SLAB
+PRISMARINE_BRICK_SLAB
+DARK_PRISMARINE_SLAB
+SMOOTH_QUARTZ
+SMOOTH_RED_SANDSTONE
+SMOOTH_SANDSTONE
+SMOOTH_STONE
+BRICKS
+ACACIA_SHELF
+BAMBOO_SHELF
+BIRCH_SHELF
+DARK_OAK_SHELF
+JUNGLE_SHELF
+OAK_SHELF
+SPRUCE_SHELF
+BOOKSHELF
+MOSSY_COBBLESTONE
+OBSIDIAN
+TORCH
+CHEST
+CRAFTING_TABLE
+FARMLAND
+FURNACE
+LADDER
+COBBLESTONE_STAIRS
+SNOW
+ICE
+SNOW_BLOCK
+CACTUS
+CLAY
+JUKEBOX
+OAK_FENCE
+SPRUCE_FENCE
+BIRCH_FENCE
+JUNGLE_FENCE
+ACACIA_FENCE
+DARK_OAK_FENCE
+BAMBOO_FENCE
+PUMPKIN
+CARVED_PUMPKIN
+JACK_O_LANTERN
+SOUL_SAND
+SOUL_SOIL
+BASALT
+POLISHED_BASALT
+SMOOTH_BASALT
+GLOWSTONE
+STONE_BRICKS
+MOSSY_STONE_BRICKS
+CRACKED_STONE_BRICKS
+CHISELED_STONE_BRICKS
+DEEPSLATE_BRICKS
+CRACKED_DEEPSLATE_BRICKS
+DEEPSLATE_TILES
+CRACKED_DEEPSLATE_TILES
+CHISELED_DEEPSLATE
+IRON_BARS
+COPPER_BARS
+IRON_CHAIN
+COPPER_CHAIN
+GLASS_PANE
+MELON
+VINE
+BRICK_STAIRS
+STONE_BRICK_STAIRS
+LILY_PAD
+ENCHANTING_TABLE
+SANDSTONE_STAIRS
+EMERALD_BLOCK
+OAK_STAIRS
+SPRUCE_STAIRS
+BIRCH_STAIRS
+JUNGLE_STAIRS
+ACACIA_STAIRS
+DARK_OAK_STAIRS
+BAMBOO_STAIRS
+BAMBOO_MOSAIC_STAIRS
+COBBLESTONE_WALL
+MOSSY_COBBLESTONE_WALL
+BRICK_WALL
+PRISMARINE_WALL
+RED_SANDSTONE_WALL
+MOSSY_STONE_BRICK_WALL
+GRANITE_WALL
+STONE_BRICK_WALL
+MUD_BRICK_WALL
+ANDESITE_WALL
+SANDSTONE_WALL
+END_STONE_BRICK_WALL
+DIORITE_WALL
+BLACKSTONE_WALL
+POLISHED_BLACKSTONE_WALL
+POLISHED_BLACKSTONE_BRICK_WALL
+COBBLED_DEEPSLATE_WALL
+POLISHED_DEEPSLATE_WALL
+DEEPSLATE_BRICK_WALL
+DEEPSLATE_TILE_WALL
+ANVIL
+CHISELED_QUARTZ_BLOCK
+QUARTZ_BLOCK
+QUARTZ_BRICKS
+QUARTZ_PILLAR
+QUARTZ_STAIRS
+WHITE_TERRACOTTA
+ORANGE_TERRACOTTA
+MAGENTA_TERRACOTTA
+YELLOW_TERRACOTTA
+LIME_TERRACOTTA
+PINK_TERRACOTTA
+GRAY_TERRACOTTA
+CYAN_TERRACOTTA
+PURPLE_TERRACOTTA
+BLUE_TERRACOTTA
+BROWN_TERRACOTTA
+GREEN_TERRACOTTA
+RED_TERRACOTTA
+BLACK_TERRACOTTA
+HAY_BLOCK
+WHITE_CARPET
+ORANGE_CARPET
+MAGENTA_CARPET
+YELLOW_CARPET
+LIME_CARPET
+PINK_CARPET
+GRAY_CARPET
+CYAN_CARPET
+PURPLE_CARPET
+BLUE_CARPET
+BROWN_CARPET
+GREEN_CARPET
+RED_CARPET
+BLACK_CARPET
+TERRACOTTA
+PACKED_ICE
+DIRT_PATH
+SUNFLOWER
+LILAC
+ROSE_BUSH
+PEONY
+WHITE_STAINED_GLASS
+ORANGE_STAINED_GLASS
+MAGENTA_STAINED_GLASS
+YELLOW_STAINED_GLASS
+LIME_STAINED_GLASS
+PINK_STAINED_GLASS
+GRAY_STAINED_GLASS
+CYAN_STAINED_GLASS
+PURPLE_STAINED_GLASS
+BLUE_STAINED_GLASS
+BROWN_STAINED_GLASS
+GREEN_STAINED_GLASS
+RED_STAINED_GLASS
+BLACK_STAINED_GLASS
+WHITE_STAINED_GLASS_PANE
+ORANGE_STAINED_GLASS_PANE
+MAGENTA_STAINED_GLASS_PANE
+YELLOW_STAINED_GLASS_PANE
+LIME_STAINED_GLASS_PANE
+PINK_STAINED_GLASS_PANE
+GRAY_STAINED_GLASS_PANE
+CYAN_STAINED_GLASS_PANE
+PURPLE_STAINED_GLASS_PANE
+BLUE_STAINED_GLASS_PANE
+BROWN_STAINED_GLASS_PANE
+GREEN_STAINED_GLASS_PANE
+RED_STAINED_GLASS_PANE
+BLACK_STAINED_GLASS_PANE
+RED_SANDSTONE
+CHISELED_RED_SANDSTONE
+CUT_RED_SANDSTONE
+RED_SANDSTONE_STAIRS
+MAGMA_BLOCK
+BONE_BLOCK
+WHITE_CONCRETE
+ORANGE_CONCRETE
+MAGENTA_CONCRETE
+YELLOW_CONCRETE
+LIME_CONCRETE
+PINK_CONCRETE
+GRAY_CONCRETE
+CYAN_CONCRETE
+PURPLE_CONCRETE
+BLUE_CONCRETE
+BROWN_CONCRETE
+GREEN_CONCRETE
+RED_CONCRETE
+BLACK_CONCRETE
+WHITE_CONCRETE_POWDER
+ORANGE_CONCRETE_POWDER
+MAGENTA_CONCRETE_POWDER
+YELLOW_CONCRETE_POWDER
+LIME_CONCRETE_POWDER
+PINK_CONCRETE_POWDER
+GRAY_CONCRETE_POWDER
+CYAN_CONCRETE_POWDER
+PURPLE_CONCRETE_POWDER
+BLUE_CONCRETE_POWDER
+BROWN_CONCRETE_POWDER
+GREEN_CONCRETE_POWDER
+RED_CONCRETE_POWDER
+BLACK_CONCRETE_POWDER
+DRIED_GHAST
+BLUE_ICE
+POLISHED_GRANITE_STAIRS
+SMOOTH_RED_SANDSTONE_STAIRS
+MOSSY_STONE_BRICK_STAIRS
+POLISHED_DIORITE_STAIRS
+MOSSY_COBBLESTONE_STAIRS
+STONE_STAIRS
+SMOOTH_SANDSTONE_STAIRS
+SMOOTH_QUARTZ_STAIRS
+GRANITE_STAIRS
+ANDESITE_STAIRS
+POLISHED_ANDESITE_STAIRS
+DIORITE_STAIRS
+COBBLED_DEEPSLATE_STAIRS
+POLISHED_DEEPSLATE_STAIRS
+DEEPSLATE_BRICK_STAIRS
+DEEPSLATE_TILE_STAIRS
+POLISHED_GRANITE_SLAB
+SMOOTH_RED_SANDSTONE_SLAB
+MOSSY_STONE_BRICK_SLAB
+POLISHED_DIORITE_SLAB
+MOSSY_COBBLESTONE_SLAB
+END_STONE_BRICK_SLAB
+SMOOTH_SANDSTONE_SLAB
+SMOOTH_QUARTZ_SLAB
+GRANITE_SLAB
+ANDESITE_SLAB
+POLISHED_ANDESITE_SLAB
+DIORITE_SLAB
+COBBLED_DEEPSLATE_SLAB
+POLISHED_DEEPSLATE_SLAB
+DEEPSLATE_BRICK_SLAB
+DEEPSLATE_TILE_SLAB
+SCAFFOLDING
+REDSTONE
+REDSTONE_TORCH
+REDSTONE_BLOCK
+REPEATER
+COMPARATOR
+PISTON
+STICKY_PISTON
+SLIME_BLOCK
+HONEY_BLOCK
+OBSERVER
+HOPPER
+DISPENSER
+DROPPER
+LECTERN
+TARGET
+LEVER
+SCULK_SENSOR
+CALIBRATED_SCULK_SENSOR
+TRIPWIRE_HOOK
+TRAPPED_CHEST
+TNT
+REDSTONE_LAMP
+NOTE_BLOCK
+STONE_BUTTON
+POLISHED_BLACKSTONE_BUTTON
+OAK_BUTTON
+SPRUCE_BUTTON
+BIRCH_BUTTON
+JUNGLE_BUTTON
+ACACIA_BUTTON
+DARK_OAK_BUTTON
+BAMBOO_BUTTON
+STONE_PRESSURE_PLATE
+POLISHED_BLACKSTONE_PRESSURE_PLATE
+HEAVY_WEIGHTED_PRESSURE_PLATE
+OAK_PRESSURE_PLATE
+SPRUCE_PRESSURE_PLATE
+BIRCH_PRESSURE_PLATE
+JUNGLE_PRESSURE_PLATE
+ACACIA_PRESSURE_PLATE
+DARK_OAK_PRESSURE_PLATE
+BAMBOO_PRESSURE_PLATE
+IRON_DOOR
+OAK_DOOR
+SPRUCE_DOOR
+BIRCH_DOOR
+JUNGLE_DOOR
+ACACIA_DOOR
+DARK_OAK_DOOR
+BAMBOO_DOOR
+COPPER_DOOR
+IRON_TRAPDOOR
+OAK_TRAPDOOR
+SPRUCE_TRAPDOOR
+BIRCH_TRAPDOOR
+JUNGLE_TRAPDOOR
+ACACIA_TRAPDOOR
+DARK_OAK_TRAPDOOR
+BAMBOO_TRAPDOOR
+COPPER_TRAPDOOR
+OAK_FENCE_GATE
+SPRUCE_FENCE_GATE
+BIRCH_FENCE_GATE
+JUNGLE_FENCE_GATE
+ACACIA_FENCE_GATE
+DARK_OAK_FENCE_GATE
+BAMBOO_FENCE_GATE
+POWERED_RAIL
+DETECTOR_RAIL
+RAIL
+ACTIVATOR_RAIL
+SADDLE
+WHITE_HARNESS
+ORANGE_HARNESS
+MAGENTA_HARNESS
+YELLOW_HARNESS
+LIME_HARNESS
+PINK_HARNESS
+GRAY_HARNESS
+CYAN_HARNESS
+PURPLE_HARNESS
+BLUE_HARNESS
+BROWN_HARNESS
+GREEN_HARNESS
+RED_HARNESS
+BLACK_HARNESS
+MINECART
+CHEST_MINECART
+FURNACE_MINECART
+TNT_MINECART
+HOPPER_MINECART
+CARROT_ON_A_STICK
+OAK_BOAT
+OAK_CHEST_BOAT
+SPRUCE_BOAT
+SPRUCE_CHEST_BOAT
+BIRCH_BOAT
+BIRCH_CHEST_BOAT
+JUNGLE_BOAT
+JUNGLE_CHEST_BOAT
+ACACIA_BOAT
+ACACIA_CHEST_BOAT
+DARK_OAK_BOAT
+DARK_OAK_CHEST_BOAT
+BAMBOO_RAFT
+BAMBOO_CHEST_RAFT
+FLINT_AND_STEEL
+BOWL
+APPLE
+BOW
+ARROW
+COAL
+CHARCOAL
+DIAMOND
+EMERALD
+LAPIS_LAZULI
+QUARTZ
+RAW_IRON
+IRON_INGOT
+RAW_COPPER
+COPPER_INGOT
+RAW_GOLD
+GOLD_INGOT
+WOODEN_SWORD
+WOODEN_SHOVEL
+WOODEN_PICKAXE
+WOODEN_AXE
+WOODEN_HOE
+COPPER_SWORD
+COPPER_SHOVEL
+COPPER_PICKAXE
+COPPER_AXE
+COPPER_HOE
+STONE_SWORD
+STONE_SHOVEL
+STONE_PICKAXE
+STONE_AXE
+STONE_HOE
+GOLDEN_SWORD
+GOLDEN_SHOVEL
+GOLDEN_PICKAXE
+GOLDEN_AXE
+GOLDEN_HOE
+IRON_SWORD
+IRON_SHOVEL
+IRON_PICKAXE
+IRON_AXE
+IRON_HOE
+DIAMOND_SWORD
+DIAMOND_SHOVEL
+DIAMOND_PICKAXE
+DIAMOND_AXE
+DIAMOND_HOE
+STICK
+MUSHROOM_STEW
+STRING
+FEATHER
+GUNPOWDER
+WHEAT_SEEDS
+WHEAT
+BREAD
+LEATHER_HELMET
+LEATHER_CHESTPLATE
+LEATHER_LEGGINGS
+LEATHER_BOOTS
+COPPER_HELMET
+COPPER_CHESTPLATE
+COPPER_LEGGINGS
+COPPER_BOOTS
+CHAINMAIL_HELMET
+CHAINMAIL_CHESTPLATE
+CHAINMAIL_LEGGINGS
+CHAINMAIL_BOOTS
+IRON_HELMET
+IRON_CHESTPLATE
+IRON_LEGGINGS
+IRON_BOOTS
+DIAMOND_HELMET
+DIAMOND_CHESTPLATE
+DIAMOND_LEGGINGS
+DIAMOND_BOOTS
+GOLDEN_HELMET
+GOLDEN_CHESTPLATE
+GOLDEN_LEGGINGS
+GOLDEN_BOOTS
+FLINT
+PORKCHOP
+COOKED_PORKCHOP
+PAINTING
+GOLDEN_APPLE
+ENCHANTED_GOLDEN_APPLE
+OAK_SIGN
+SPRUCE_SIGN
+BIRCH_SIGN
+JUNGLE_SIGN
+ACACIA_SIGN
+DARK_OAK_SIGN
+BAMBOO_SIGN
+OAK_HANGING_SIGN
+SPRUCE_HANGING_SIGN
+BIRCH_HANGING_SIGN
+JUNGLE_HANGING_SIGN
+ACACIA_HANGING_SIGN
+DARK_OAK_HANGING_SIGN
+BAMBOO_HANGING_SIGN
+BUCKET
+WATER_BUCKET
+LAVA_BUCKET
+POWDER_SNOW_BUCKET
+SNOWBALL
+LEATHER
+MILK_BUCKET
+PUFFERFISH_BUCKET
+SALMON_BUCKET
+COD_BUCKET
+TROPICAL_FISH_BUCKET
+AXOLOTL_BUCKET
+TADPOLE_BUCKET
+BRICK
+CLAY_BALL
+DRIED_KELP_BLOCK
+PAPER
+BOOK
+SLIME_BALL
+EGG
+COMPASS
+BUNDLE
+WHITE_BUNDLE
+ORANGE_BUNDLE
+MAGENTA_BUNDLE
+YELLOW_BUNDLE
+LIME_BUNDLE
+PINK_BUNDLE
+GRAY_BUNDLE
+CYAN_BUNDLE
+PURPLE_BUNDLE
+BLUE_BUNDLE
+BROWN_BUNDLE
+GREEN_BUNDLE
+RED_BUNDLE
+BLACK_BUNDLE
+FISHING_ROD
+CLOCK
+SPYGLASS
+GLOWSTONE_DUST
+COD
+SALMON
+TROPICAL_FISH
+PUFFERFISH
+COOKED_COD
+COOKED_SALMON
+INK_SAC
+WHITE_DYE
+ORANGE_DYE
+MAGENTA_DYE
+YELLOW_DYE
+LIME_DYE
+PINK_DYE
+GRAY_DYE
+CYAN_DYE
+PURPLE_DYE
+BLUE_DYE
+GREEN_DYE
+RED_DYE
+BLACK_DYE
+BONE_MEAL
+BONE
+SUGAR
+CAKE
+WHITE_BED
+ORANGE_BED
+MAGENTA_BED
+YELLOW_BED
+LIME_BED
+PINK_BED
+GRAY_BED
+CYAN_BED
+PURPLE_BED
+BLUE_BED
+GREEN_BED
+RED_BED
+BLACK_BED
+CRAFTER
+SHEARS
+MELON_SLICE
+DRIED_KELP
+PUMPKIN_SEEDS
+MELON_SEEDS
+BEEF
+COOKED_BEEF
+CHICKEN
+COOKED_CHICKEN
+ROTTEN_FLESH
+ENDER_PEARL
+GOLD_NUGGET
+GLASS_BOTTLE
+SPIDER_EYE
+FERMENTED_SPIDER_EYE
+BLAZE_POWDER
+MAGMA_CREAM
+BREWING_STAND
+CAULDRON
+FIRE_CHARGE
+WIND_CHARGE
+WRITABLE_BOOK
+WRITTEN_BOOK
+BREEZE_ROD
+ITEM_FRAME
+CARROT
+POTATO
+BAKED_POTATO
+MAP
+GOLDEN_CARROT
+SKELETON_SKULL
+PUMPKIN_PIE
+FIREWORK_ROCKET
+ARMOR_STAND
+LEAD
+MUTTON
+COOKED_MUTTON
+WHITE_BANNER
+ORANGE_BANNER
+MAGENTA_BANNER
+YELLOW_BANNER
+LIME_BANNER
+PINK_BANNER
+GRAY_BANNER
+CYAN_BANNER
+PURPLE_BANNER
+BLUE_BANNER
+GREEN_BANNER
+RED_BANNER
+BLACK_BANNER
+BEETROOT
+BEETROOT_SEEDS
+BEETROOT_SOUP
+SHIELD
+IRON_NUGGET
+COPPER_NUGGET
+TRIDENT
+NAUTILUS_SHELL
+HEART_OF_THE_SEA
+CROSSBOW
+SUSPICIOUS_STEW
+LOOM
+GOAT_HORN
+COMPOSTER
+BARREL
+SMOKER
+BLAST_FURNACE
+CARTOGRAPHY_TABLE
+FLETCHING_TABLE
+GRINDSTONE
+SMITHING_TABLE
+STONECUTTER
+BELL
+LANTERN
+COPPER_LANTERN
+SWEET_BERRIES
+CAMPFIRE
+BLACKSTONE
+BLACKSTONE_SLAB
+BLACKSTONE_STAIRS
+POLISHED_BLACKSTONE
+POLISHED_BLACKSTONE_SLAB
+POLISHED_BLACKSTONE_STAIRS
+CHISELED_POLISHED_BLACKSTONE
+POLISHED_BLACKSTONE_BRICKS
+POLISHED_BLACKSTONE_BRICK_SLAB
+POLISHED_BLACKSTONE_BRICK_STAIRS
+CRACKED_POLISHED_BLACKSTONE_BRICKS
+POINTED_DRIPSTONE
+BRUSH
+COPPER_GRATE
+COPPER_BULB
+COPPER_CHEST