Fixed many bugs

Continued adding Team functionality
FIB and FIB with same Items works now as expected
Added customizable Timers
Minor changes

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

@@ -93,4 +93,12 @@ public abstract class BaseWindow {
         return p;
     }
 
+    protected String getNBT(ItemStack item, String key) {
+        if (item == null) return "ItemIsNull";
+        ItemMeta meta = item.getItemMeta();
+        NamespacedKey nsKey = new NamespacedKey(RandomizedMinigames.serverSettingsHandler.getPlugin(), key);
+        if (meta == null) return "NoItemMeta";
+        PersistentDataContainer data = meta.getPersistentDataContainer();
+        return data.get(nsKey, PersistentDataType.STRING);
+    }
 }

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

@@ -16,7 +16,6 @@ public class MinigameSetup extends BaseWindow {
 
     @Override
     protected void fillGUI() {
-        System.out.println("Hallo");
         ItemStack playerSelect = new ItemStack(Material.PLAYER_HEAD);
         addNBT(playerSelect, "Type", "MinigameSetup");
         addNBT(playerSelect, "Action", "startPlayerSelection");
@@ -42,6 +41,17 @@ public class MinigameSetup extends BaseWindow {
         setItemName(start, "Start");
         addItemToGUI(50, start);
 
+        ItemStack timer = new ItemStack(Material.CLOCK);
+        addNBT(timer, "Type", "MinigameSetup");
+        addNBT(timer, "Action", "startTimerSetup");
+        setItemName(timer, "Set Timer");
+        addItemToGUI(timer);
+
+        ItemStack enableTimer = new ItemStack(Material.TARGET);
+        addNBT(enableTimer, "Type", "MinigameSetup");
+        addNBT(enableTimer, "Action", "toggleTimer");
+        setItemName(enableTimer, "Timer: " + (playerSettings.isTimed ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
+        addItemToGUI(enableTimer);
 
         ItemStack back = new ItemStack(Material.ARROW);
         addNBT(back, "Type", "MinigameSelect");

src/main/java/de/ventority/randomizedminigames/GUI/MinigameSetups/MinigamesDisplayWindow.java

@@ -19,7 +19,7 @@ public class MinigamesDisplayWindow extends BaseWindow {
             ItemStack item = new ItemStack(minigame.getMaterial(), 1);
             setItemName(item, minigame.getName());
             addNBT(item, "Type", "MinigameSelect");
-            addNBT(item, "Action", "openMinigameSetup");
+            addNBT(item, "Action", minigame.getAction());
             addNBT(item, "selectedMinigame", Integer.toString(minigame.getNumber()));
             addItemToGUI(item);
         }

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

@@ -15,6 +15,7 @@ public class PlayerSelection extends BaseWindow {
         super(p);
     }
 
+
     @Override
     protected void fillGUI() {
         for (Player player : Bukkit.getOnlinePlayers()) {
@@ -39,7 +40,7 @@ public class PlayerSelection extends BaseWindow {
         SkullMeta meta = (SkullMeta) head.getItemMeta();
         if (meta != null) {
             meta.setOwningPlayer(player);
-            meta.setDisplayName((MinigameHandler.getSettings(player).getSelectedPlayers().contains(player) ?
+            meta.setDisplayName((MinigameHandler.getSettings(p).getSelectedPlayers().contains(player) ?
                     ChatColor.GREEN : ChatColor.RED) + player.getName());
             head.setItemMeta(meta);
         }

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

@@ -0,0 +1,75 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class SetTimeLimit extends BaseWindow {
+    public SetTimeLimit(Player p) {
+        super(p);
+    }
+
+    @Override
+    protected void fillGUI() {
+        ItemStack add30 = new ItemStack(Material.RED_DYE);
+        addNBT(add30, "Type", "MinigameSetup");
+        addNBT(add30, "Action", "add30ToTimeLimit");
+        setItemName(add30, "+30min");
+        addItemToGUI(16, add30);
+
+        ItemStack add10 = new ItemStack(Material.RED_DYE);
+        addNBT(add10, "Type", "MinigameSetup");
+        addNBT(add10, "Action", "add10ToTimeLimit");
+        setItemName(add10, "+10min");
+        addItemToGUI(15, add10);
+
+        ItemStack add1 = new ItemStack(Material.RED_DYE);
+        addNBT(add1, "Type", "MinigameSetup");
+        addNBT(add1, "Action", "add1ToTimeLimit");
+        setItemName(add1, "+1min");
+        addItemToGUI(14, add1);
+
+        ItemStack sub30 = new ItemStack(Material.GREEN_DYE);
+        addNBT(sub30, "Type", "MinigameSetup");
+        addNBT(sub30, "Action", "sub30FromTimeLimit");
+        setItemName(sub30, "-30min");
+        addItemToGUI(10, sub30);
+
+        ItemStack sub10 = new ItemStack(Material.GREEN_DYE);
+        addNBT(sub10, "Type", "MinigameSetup");
+        addNBT(sub10, "Action", "sub10FromTimeLimit");
+        setItemName(sub10, "-10min");
+        addItemToGUI(11, sub10);
+
+        ItemStack sub1 = new ItemStack(Material.GREEN_DYE);
+        addNBT(sub1, "Type", "MinigameSetup");
+        addNBT(sub1, "Action", "sub1FromTimeLimit");
+        setItemName(sub1, "-1min");
+        addItemToGUI(12, sub1);
+
+        ItemStack display = new ItemStack(Material.PAPER);
+        addNBT(display, "Type", "MinigameSetup");
+        addNBT(display, "Action", "none");
+        setItemName(display, formattedTime(MinigameHandler.getSettings(p).timerStop));
+        addItemToGUI(13, display);
+
+        ItemStack back = new ItemStack(Material.ARROW);
+        addNBT(back, "Type", "MinigameSetup");
+        addNBT(back, "Action", "homeMenu");
+        setItemName(back, "Back");
+        addItemToGUI(49, back);
+    }
+
+    private String formattedTime(int time) {
+        int minutes = (int)Math.floor((double) time / 60);
+        int seconds = time % 60;
+        StringBuilder  sb = new StringBuilder();
+        if (minutes != 0) {
+            sb.append(minutes).append(":");
+        }
+        sb.append(seconds);
+        return sb.toString();
+    }
+}

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

@@ -0,0 +1,41 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class TeamCountSelection extends BaseWindow {
+    public TeamCountSelection(Player p) {
+        super(p);
+    }
+
+
+    @Override
+    protected void fillGUI() {
+        ItemStack add = new ItemStack(Material.RED_DYE);
+        addNBT(add, "Type", "MinigameSetup");
+        addNBT(add, "Action", "addTeamCount");
+        setItemName(add, "Add");
+        addItemToGUI(14, add);
+
+        ItemStack sub = new ItemStack(Material.GREEN_DYE);
+        addNBT(sub, "Type", "MinigameSetup");
+        addNBT(sub, "Action", "subTeamCount");
+        setItemName(sub, "Sub");
+        addItemToGUI(12, sub);
+
+        ItemStack display = new ItemStack(Material.PAPER);
+        addNBT(display, "Type", "MinigameSetup");
+        addNBT(display, "Action", "none");
+        setItemName(display, "" + MinigameHandler.getSettings(p).getTeamCount());
+        addItemToGUI(13, display);
+
+        ItemStack next = new ItemStack(Material.ARROW);
+        addNBT(next, "Type", "MinigameSetup");
+        addNBT(next, "Action", "TeamSetupSelection");
+        setItemName(next, "Next");
+        addItemToGUI(49, next);
+    }
+}

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

@@ -0,0 +1,57 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.SkullMeta;
+
+public class TeamPlayerSelection extends BaseWindow {
+    public TeamPlayerSelection(Player p) {
+        super(p);
+    }
+
+
+    @Override
+    protected void fillGUI() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
+                ItemStack item = getPlayerHead(player);
+                addNBT(item, "Type", "MinigameSetup");
+                addNBT(item, "Action", "clickedPlayerInTeams");
+                addNBT(item, "Player", player.getDisplayName());
+                addItemToGUI(item);
+            }
+        }
+        final org.bukkit.ChatColor[] colors = new org.bukkit.ChatColor[]{org.bukkit.ChatColor.GREEN,
+                org.bukkit.ChatColor.RED, org.bukkit.ChatColor.BLUE, org.bukkit.ChatColor.DARK_PURPLE,
+                org.bukkit.ChatColor.BLACK, org.bukkit.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));
+        addItemToGUI(4, selectedTeam);
+
+        ItemStack back = new ItemStack(Material.ARROW);
+        addNBT(back, "Type", "MinigameSetup");
+        addNBT(back, "Action", "homeMenu");
+        setItemName(back, "Back");
+        addItemToGUI(49, back);
+    }
+
+    private ItemStack getPlayerHead(Player player) {
+        ItemStack head = new ItemStack(Material.PLAYER_HEAD);
+        SkullMeta meta = (SkullMeta) head.getItemMeta();
+        if (meta != null) {
+            meta.setOwningPlayer(player);
+            meta.setDisplayName((MinigameHandler.getSettings(p).getSelectedPlayers().contains(player) ?
+                    ChatColor.GREEN : ChatColor.RED) + player.getName());
+            head.setItemMeta(meta);
+        }
+        return head;
+    }
+}

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

@@ -0,0 +1,31 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.misc.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};
+
+    public TeamSetupSelection(Player p) {
+        super(p);
+    }
+
+    @Override
+    protected void fillGUI() {
+        for (int i = 0; i < MinigameHandler.getSettings(p).getTeamCount(); i++) {
+            ItemStack item = new ItemStack(material[i], 1);
+            setItemName(item, colors[i] + "Team #" + (i + 1));
+            addNBT(item, "Type", "MinigameSetup");
+            addNBT(item, "Action", "selectTeam");
+            addNBT(item, "selectedTeam", Integer.toString(i));
+            addItemToGUI(item);
+        }
+    }
+}

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

@@ -1,6 +1,7 @@
 package de.ventority.randomizedminigames.GUI.handlers;
 
 import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
+import de.ventority.randomizedminigames.GUI.MinigameSetups.TeamCountSelection;
 import de.ventority.randomizedminigames.RandomizedMinigames;
 import de.ventority.randomizedminigames.misc.MinigameHandler;
 import de.ventority.randomizedminigames.misc.Settings;
@@ -15,10 +16,14 @@ public class MinigameSelectHandler extends GUIHandler{
     @Override
     public void handle() {
         Settings settings = MinigameHandler.getSettings((Player) event.getWhoClicked());
-        if (action.equals("openMinigameSetup")) {
+        if (action.equals("startForceItem") || action.equals("startForceItemSameItem")) {
             settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
             new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
         }
+        if (action.equals("startForceItemTeams")) {
+            settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
+            new TeamCountSelection((Player)event.getWhoClicked()).buildWindow();
+        }
         if (action.equals("homeMenu")) {
             new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
         }

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

@@ -1,8 +1,6 @@
 package de.ventority.randomizedminigames.GUI.handlers;
 
-import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
+import de.ventority.randomizedminigames.GUI.MinigameSetups.*;
-import de.ventority.randomizedminigames.GUI.MinigameSetups.PlayerSelection;
-import de.ventority.randomizedminigames.GUI.MinigameSetups.SetLimit;
 import de.ventority.randomizedminigames.misc.MinigameHandler;
 import de.ventority.randomizedminigames.misc.Settings;
 import org.bukkit.Bukkit;
@@ -42,6 +40,16 @@ public class MinigameSetupHandler extends GUIHandler {
             new SetLimit((Player)event.getWhoClicked()).buildWindow();
         }
 
+        if (action.equals("addTeamCount")) {
+            playerSettings.addTeamCount();
+            new TeamCountSelection((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("subTeamCount")) {
+            playerSettings.subTeamCount();
+            new TeamCountSelection((Player)event.getWhoClicked()).buildWindow();
+        }
+
         if (action.equals("startPlayerSelection")) {
             new PlayerSelection((Player)event.getWhoClicked()).buildWindow();
         }
@@ -55,8 +63,43 @@ public class MinigameSetupHandler extends GUIHandler {
             new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
         }
 
+        if (action.equals("toggleTimer")) {
+            playerSettings.isTimed = !playerSettings.isTimed;
+            new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
+        }
+
         if (action.equals("startGame")) {
             MinigameHandler.createMinigame(playerSettings.getSelectedMinigame(), (Player) event.getWhoClicked());
+            event.getWhoClicked().closeInventory();
+        }
+
+        if (action.equals("TeamSetupSelection")) {
+            new TeamSetupSelection((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("selectTeam")) {
+            MinigameHandler.getSettings(((Player) event.getWhoClicked()).getPlayer()).setSelectedTeamIndex(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedTeam")));
+            new TeamPlayerSelection((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("clickedPlayerInTeams")) {
+            return;
+        }
+
+        if (action.equals("startTimerSetup")) {
+            new SetTimeLimit((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.contains("FromTimeLimit") || action.contains("ToTimeLimit")) {
+            switch (action) {
+                case "add30ToTimeLimit": playerSettings.timerStop = playerSettings.timerStop + 30*60; break;
+                case "add10ToTimeLimit": playerSettings.timerStop = playerSettings.timerStop + 10*60; break;
+                case "add1ToTimeLimit": playerSettings.timerStop = playerSettings.timerStop + 60; break;
+                case "sub30FromTimeLimit": playerSettings.timerStop = playerSettings.timerStop - 30*60; break;
+                case "sub10FromTimeLimit": playerSettings.timerStop = playerSettings.timerStop - 10*60; break;
+                case "sub1FromTimeLimit": playerSettings.timerStop = playerSettings.timerStop - 60; break;
+            }
+            new SetTimeLimit((Player)event.getWhoClicked()).buildWindow();
         }
     }
 }

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

@@ -19,6 +19,7 @@ import org.bukkit.event.inventory.CraftItemEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
+import de.ventority.randomizedminigames.misc.Timer;
 
 import java.util.*;
 
@@ -32,6 +33,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
     private final HashMap<Player, PlayerBackup> backups;
     private final Player owner;
     protected Settings settings;
+    private Timer timer;
+    private List<Player> disconnected = new ArrayList<>();
 
     private final List<Material> SURVIVAL_ITEMS = Arrays.stream(Material.values())
             .filter(Material::isItem)
@@ -53,13 +56,19 @@ public class ForceItemBattle implements MinigameBase, Listener {
                         !name.contains("END_GATEWAY") &&
                         !name.contains("NETHER_PORTAL") &&
                         !name.contains("POTTED_") &&
-                        !name.contains("MUSIC");
+                        !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, "");
 
         id = new Random().nextInt(1024);
         currentItems = new HashMap<>();
@@ -80,7 +89,8 @@ 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()));
+            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);
             ItemMeta meta = skip.getItemMeta();
@@ -89,6 +99,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
             skip.setItemMeta(meta);
             player.getInventory().addItem(skip);
         }
+        timer.startCounter();
     }
 
     @Override
@@ -119,9 +130,12 @@ public class ForceItemBattle implements MinigameBase, Listener {
         if (i == null) return;
         if (currentItems.get(p).getType() == i.getType()) {
             currentScores.replace(p, currentScores.get(p) + 1);
+            p.sendMessage("Du hast " + i.getTranslationKey().replace("block.minecraft.", "")
+                    .replace("_", " ")
+                    .replace("item.minecraft.", "") + " gefunden!");
             if (settings.getScoreboardStatus())
                 scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
-            if (checkWin(p)) {
+            if (!settings.isTimed && checkWin(p)) {
                 stopGame(p);
                 return;
             }
@@ -150,32 +164,37 @@ public class ForceItemBattle implements MinigameBase, Listener {
             if (player != winner) {
                 player.teleport(winner);
                 player.setGameMode(GameMode.SPECTATOR);
-                player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
+                player.sendTitle(winner.getDisplayName() + " won!", "Resetting game...", 10, 70, 20);
-                //restorePlayer(player);
+            } else {
+                player.sendTitle("You won. Congratulations!", "Your score was: " + currentScores.get(winner), 10, 70, 20);
             }
             if (settings.getScoreboardStatus())
                 player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
         }
     }
-
+    public void stopGame() {
+        Map.Entry<Player, Integer> bestEntry = currentScores.entrySet()
+                .stream()
+                .max(Map.Entry.comparingByValue())
+                .orElse(null);
+        assert bestEntry != null;
+        stopGame(bestEntry.getKey());
+    }
     private void stopGame(Player winner) {
         showEndMessage(winner);
-        for (Player p : itemDisplays.keySet()) {
+        timer.pauseCounter();
-            itemDisplays.get(p).setVisible(false);
+        Timer t = new Timer(10, contestants, this, this::killGame, true, "Resetting game in: ");
-            itemDisplays.get(p).removePlayer(p);
+        t.startCounter();
-        }
-        itemDisplays.clear();
-        if (settings.getScoreboardStatus()) {
-            scoreboardManager.removeScoreboard();
-            scoreboardManager = null;
-        }
-        MinigameHandler.resetSettings(owner);
-        MinigameHandler.deleteGame(this);
     }
 
     private void removePlayer(Player p) {
+        contestants.remove(p);
+        if (itemDisplays.get(p) != null) {
             itemDisplays.get(p).setVisible(false);
             itemDisplays.get(p).removePlayer(p);
+            itemDisplays.remove(p);
+        }
+
         if (settings.getScoreboardStatus())
             p.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
         if (contestants.isEmpty())
@@ -183,9 +202,12 @@ public class ForceItemBattle implements MinigameBase, Listener {
     }
 
     public void killGame() {
-        for (Player player : contestants) {
+        for (Player p : contestants) {
-            if (settings.getScoreboardStatus())
+            restorePlayer(p);
-                player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
+        }
+        for (Player p : itemDisplays.keySet()) {
+            itemDisplays.get(p).setVisible(false);
+            itemDisplays.get(p).removePlayer(p);
         }
         itemDisplays.clear();
 
@@ -193,6 +215,11 @@ public class ForceItemBattle implements MinigameBase, Listener {
             scoreboardManager.removeScoreboard();
             scoreboardManager = null;
         }
+
+        if (settings.getScoreboardStatus())
+            for (Player player : contestants)
+                player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
+        itemDisplays.clear();
         MinigameHandler.resetSettings(owner);
         MinigameHandler.deleteGame(this);
     }
@@ -204,6 +231,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
         p.getInventory().clear();
         p.getInventory().setContents(backup.getInventory());
         p.getInventory().setArmorContents(backup.getArmor());
+        p.setGameMode(backup.getGamemode());
     }
 
     public List<Player> getPlayers() {
@@ -216,6 +244,10 @@ public class ForceItemBattle implements MinigameBase, Listener {
         checkItem(p, curItem);
     }
 
+    public Player getOwner() {
+        return owner;
+    }
+
     @EventHandler
     public void onItemPickup(EntityPickupItemEvent e) {
         Player eventPlayer;
@@ -239,8 +271,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
     @EventHandler
     public void onPlayerLeave(PlayerQuitEvent e) {
         if (contestants.contains(e.getPlayer())) {
+            disconnected.add(e.getPlayer());
             removePlayer(e.getPlayer());
-            restorePlayer(e.getPlayer());
         }
     }
 }

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

@@ -35,7 +35,6 @@ public class ForceItemBattleTeams extends ForceItemBattle{
                 if (team.getPlayers().contains(player)) winningTeam = team;
             player.sendTitle(winningTeam.getColor() + winningTeam.getColor().name() + "Team " + ChatColor.RESET + " won!",
                     "Resetting players...", 10, 70, 20);
-            //restorePlayer(player);
             player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
         }
     }

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

@@ -4,7 +4,8 @@ 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");
+    //ForceItemBattleTeams(Material.GOLDEN_SWORD, "Force Item Battle (Teams)", 2, "startForceItemTeams"),;
 
     final Material material;
     final String name;

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

@@ -13,4 +13,6 @@ public interface MinigameBase extends Listener {
     void addPlayers(List<Player> players);
     List<Player> getPlayers();
     void killGame();
+    void stopGame();
+    Player getOwner();
 }

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

@@ -4,13 +4,11 @@ import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
 import de.ventority.randomizedminigames.Minigames.ForceItemBattleSameItems;
 import de.ventority.randomizedminigames.Minigames.MinigameBase;
 import de.ventority.randomizedminigames.RandomizedMinigames;
-import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 
-
 import static org.bukkit.Bukkit.getServer;
 
 public class MinigameHandler {

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

@@ -1,5 +1,6 @@
 package de.ventority.randomizedminigames.misc;
 
+import org.bukkit.GameMode;
 import org.bukkit.Location;
 import org.bukkit.inventory.ItemStack;
 
@@ -8,12 +9,14 @@ public class PlayerBackup {
     private final ItemStack[] armor;
     private final float exp;
     private final Location location;
+    private GameMode gamemode;
 
-    public PlayerBackup(ItemStack[] inventory, ItemStack[] armor, float exp, Location location) {
+    public PlayerBackup(ItemStack[] inventory, ItemStack[] armor, float exp, Location location, GameMode gamemode) {
         this.inventory = inventory;
         this.armor = armor;
         this.exp = exp;
         this.location = location;
+        this.gamemode = gamemode;
     }
 
     public ItemStack[] getInventory() {
@@ -32,4 +35,8 @@ public class PlayerBackup {
         return location;
     }
 
+    public GameMode getGamemode() {
+        return gamemode;
+    }
+
 }

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

@@ -13,6 +13,9 @@ public class Settings {
     int selectedLimit = 10;
     List<Team> teams = new ArrayList<>();
     boolean showScoreboard = true;
+    private int selectedTeamCount = 2;
+    private int selectedTeamIndex = 0;
+    public int timerStop = 1800;
 
     public Settings(Player owner) {
         this.owner = owner;
@@ -31,7 +34,6 @@ public class Settings {
     }
 
     public void addPlayersToSelection(Player toAdd) {
-        System.out.println(toAdd.getName());
         selectedPlayers.add(toAdd);
     }
 
@@ -58,4 +60,29 @@ public class Settings {
     public void subFromSelectedLimit() {
         selectedLimit--;
     }
+
+    public void addTeamCount() {
+        if (selectedTeamCount < 6) {}
+            selectedTeamCount++;
+    }
+
+    public void subTeamCount() {
+        if (selectedTeamCount > 2)
+            selectedTeamCount--;
+    }
+
+    public int getTeamCount() {
+        return selectedTeamCount;
+    }
+
+    public void setSelectedTeamIndex(int selectedTeamIndex) {
+        this.selectedTeamIndex = selectedTeamIndex;
+    }
+
+    public int getSelectedTeamIndex() {
+        return selectedTeamIndex;
+    }
+
+    public boolean isTimed;
+
 }

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

@@ -0,0 +1,108 @@
+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));
+        }
+    }
+}