Working Limit selection

Scoreboard toggleable
Started implemention of Teambased games
Minor changes

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

@@ -30,20 +30,24 @@ public abstract class BaseWindow {
         ItemStack stack;
         for (int i = 0; i < 9; i++) {
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
+            addNBT(stack, "Action", "none");
             setItemName(stack, " ");
             addItemToGUI(i, stack);
         }
         for (int i = 1; i < 5; i++) {
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
+            addNBT(stack, "Action", "none");
             setItemName(stack, " ");
             addItemToGUI(9 * i, stack);
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
+            addNBT(stack, "Action", "none");
             setItemName(stack, " ");
             addItemToGUI(8 + 9 * i, stack);
         }
         for (int i = 0; i < 9; i++) {
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
             setItemName(stack, " ");
+            addNBT(stack, "Action", "none");
             addItemToGUI(i + 5 * 9, stack);
         }
     }

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

@@ -3,6 +3,7 @@ package de.ventority.randomizedminigames.GUI;
 import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
 import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
 import de.ventority.randomizedminigames.GUI.MinigameSetups.PlayerSelection;
+import de.ventority.randomizedminigames.GUI.MinigameSetups.SetLimit;
 import de.ventority.randomizedminigames.SelectMinigame;
 import de.ventority.randomizedminigames.misc.DataInputHandler;
 import de.ventority.randomizedminigames.misc.MinigameHandler;
@@ -24,14 +25,14 @@ import org.bukkit.persistence.PersistentDataType;
 public class GUIClickEvent implements Listener {
     @EventHandler
     public void onClickEvent(InventoryClickEvent event) {
-        event.setCancelled(true);
         Inventory inventory = event.getClickedInventory();
         if (event.getCurrentItem() == null) return;
-        if (event.getCurrentItem().getType() == Material.BLACK_STAINED_GLASS) return;
         if (inventory == null) return;
         if (inventory.getItem(0) == null) return;
         if (isMinigamePlugin(inventory.getItem(0))) {
-            event.getWhoClicked().closeInventory();
+            event.setCancelled(true);
+            if (getNBT(event.getCurrentItem(), "Action").equals("none"))
+                return;
             if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSelect")) {
                 handleMinigame(event, getNBT(event.getCurrentItem(), "Action"));
             }
@@ -58,6 +59,7 @@ public class GUIClickEvent implements Listener {
     }
 
     private void handleMinigame(InventoryClickEvent event, String action) {
+        event.getWhoClicked().closeInventory();
         if (action.equals("openMinigameSetup")) {
             RandomizedMinigames.dataInputHandler.setSelectedMinigame((Player) event.getWhoClicked(), Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
             new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
@@ -68,6 +70,7 @@ public class GUIClickEvent implements Listener {
     }
 
     private void handleSettings(InventoryClickEvent event, String action) {
+        event.getWhoClicked().closeInventory();
         if (action.equals("selectSettings")) {
             new SettingsWindow((Player)event.getWhoClicked(), "Settings");
         }
@@ -76,10 +79,12 @@ public class GUIClickEvent implements Listener {
 
     private void handleMinigameSetup(InventoryClickEvent event, String action) {
         if (action.equals("homeMenu")) {
-            new MinigamesDisplayWindow((Player) event.getWhoClicked(), "Minigame").buildWindow();
+            event.getWhoClicked().closeInventory();
+            new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
         }
+
+        DataInputHandler data = RandomizedMinigames.dataInputHandler;
         if (action.equals("clickedPlayer")) {
-            DataInputHandler data = RandomizedMinigames.dataInputHandler;
             Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
             if (data.getSelectedPlayers((Player) event.getWhoClicked()).contains(toWork)) {
                 data.removePlayersFromSelection((Player) event.getWhoClicked(), toWork);
@@ -88,10 +93,34 @@ public class GUIClickEvent implements Listener {
             }
             new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
         }
+
+        if (action.equals("subFromLimit")) {
+            data.subFromSelectedLimit((Player) event.getWhoClicked());
+            new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
+        }
+
+        if (action.equals("addToLimit")) {
+            data.addToSelectedLimit((Player) event.getWhoClicked());
+            new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
+        }
+
         if (action.equals("startPlayerSelection")) {
+            event.getWhoClicked().closeInventory();
             new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
         }
+
+        if (action.equals("startLimitSelection")) {
+            event.getWhoClicked().closeInventory();
+            new SetLimit((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
+        }
+
+        if (action.equals("switchScoreboard")) {
+            data.switchScoreboard();
+            new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
+        }
+
         if (action.equals("startGame")) {
+            event.getWhoClicked().closeInventory();
             MinigameHandler.createMinigame(RandomizedMinigames.dataInputHandler.getSelectedMinigame((Player) event.getWhoClicked()), (Player) event.getWhoClicked());
         }
     }

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

@@ -1,6 +1,9 @@
 package de.ventority.randomizedminigames.GUI.MinigameSetups;
 
 import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.misc.DataInputHandler;
+import net.md_5.bungee.api.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
@@ -13,13 +16,28 @@ public class MinigameSetup extends BaseWindow {
 
     @Override
     protected void fillGUI() {
-        ItemStack playerSelect = new ItemStack(Material.GOLD_INGOT);
+        ItemStack playerSelect = new ItemStack(Material.PLAYER_HEAD);
         addNBT(playerSelect, "Type", "MinigameSetup");
         addNBT(playerSelect, "Action", "startPlayerSelection");
         addNBT(playerSelect, "selectedMinigame", status);
         setItemName(playerSelect, "Select Players");
         addItemToGUI(playerSelect);
 
+        ItemStack setLimit = new ItemStack(Material.BOOK);
+        addNBT(setLimit, "Type", "MinigameSetup");
+        addNBT(setLimit, "Action", "startLimitSelection");
+        addNBT(setLimit, "selectedMinigame", status);
+        setItemName(setLimit, "Set win limit");
+        addItemToGUI(setLimit);
+
+        DataInputHandler data = RandomizedMinigames.dataInputHandler;
+        ItemStack scoreboard = new ItemStack(Material.EMERALD);
+        addNBT(scoreboard, "Type", "MinigameSetup");
+        addNBT(scoreboard, "Action", "switchScoreboard");
+        addNBT(scoreboard, "selectedMinigame", status);
+        setItemName(scoreboard, "Scoreboard: " + (data.getScoreboardStatus() ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
+        addItemToGUI(scoreboard);
+
         ItemStack start = new ItemStack(Material.GREEN_DYE);
         addNBT(start, "Type", "MinigameSetup");
         addNBT(start, "Action", "startGame");
@@ -27,6 +45,7 @@ public class MinigameSetup extends BaseWindow {
         setItemName(start, "Start");
         addItemToGUI(50, start);
 
+
         ItemStack back = new ItemStack(Material.ARROW);
         addNBT(back, "Type", "MinigameSelect");
         addNBT(back, "Action", "homeMenu");

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

@@ -0,0 +1,44 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class SetLimit extends BaseWindow {
+    public SetLimit(Player p, String status) {
+        super(p, status);
+    }
+
+    @Override
+    protected void fillGUI() {
+        ItemStack add = new ItemStack(Material.RED_DYE);
+        addNBT(add, "Type", "MinigameSetup");
+        addNBT(add, "Action", "addToLimit");
+        addNBT(add, "selectedMinigame", status);
+        setItemName(add, "Add");
+        addItemToGUI(14, add);
+
+        ItemStack sub = new ItemStack(Material.GREEN_DYE);
+        addNBT(sub, "Type", "MinigameSetup");
+        addNBT(sub, "Action", "subFromLimit");
+        addNBT(sub, "selectedMinigame", status);
+        setItemName(sub, "Sub");
+        addItemToGUI(12, sub);
+
+        ItemStack display = new ItemStack(Material.PAPER);
+        addNBT(display, "Type", "MinigameSetup");
+        addNBT(display, "Action", "none");
+        addNBT(display, "selectedMinigame", status);
+        setItemName(display, RandomizedMinigames.dataInputHandler.getSelectedLimit(p).toString());
+        addItemToGUI(13, display);
+
+        ItemStack back = new ItemStack(Material.ARROW);
+        addNBT(back, "Type", "MinigameSetup");
+        addNBT(back, "Action", "homeMenu");
+        addNBT(back, "selectedMinigame", status);
+        setItemName(back, "Back");
+        addItemToGUI(49, back);
+    }
+}

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

@@ -0,0 +1,16 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import org.bukkit.entity.Player;
+
+public class TeamOverview extends BaseWindow {
+
+    public TeamOverview(Player p, String status) {
+        super(p, status);
+    }
+
+    @Override
+    protected void fillGUI() {
+
+    }
+}

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

@@ -5,6 +5,7 @@ import de.ventority.randomizedminigames.RandomizedMinigames;
 import de.ventority.randomizedminigames.misc.MinigameHandler;
 import de.ventority.randomizedminigames.misc.PlayerBackup;
 import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
 import org.bukkit.boss.BarColor;
@@ -17,10 +18,13 @@ import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.inventory.CraftItemEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
 
+import java.util.Arrays;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Random;
+import java.util.stream.Collectors;
 
 public class ForceItemBattle implements MinigameBase, Listener {
     protected final HashMap<Player, ItemStack> currentItems;
@@ -28,12 +32,37 @@ public class ForceItemBattle implements MinigameBase, Listener {
     protected final HashMap<Player, BossBar> itemDisplays;
     private final int id;
     private GamesScoreboardManager scoreboardManager;
-    private final List<Player> contestants;
+    protected final List<Player> contestants;
     private final HashMap<Player, PlayerBackup> backups;
     private final Player owner;
+    protected final int limit;
+    private final List<Material> SURVIVAL_ITEMS = Arrays.stream(Material.values())
+            .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");
+            })
+            .toList();
 
 
     public ForceItemBattle(List<Player> players, Player owner) {
+        limit = RandomizedMinigames.dataInputHandler.getSelectedLimit(owner);
         id = new Random().nextInt(1024);
         currentItems = new HashMap<>();
         currentScores = new HashMap<>();
@@ -41,6 +70,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
         backups = new HashMap<>();
         contestants = players;
         this.owner = owner;
+        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+            scoreboardManager = new GamesScoreboardManager(players, getName());
         for (Player player : players) {
             currentItems.put(player, null);
             currentScores.put(player, 0);
@@ -48,10 +79,14 @@ public class ForceItemBattle implements MinigameBase, Listener {
             bar.addPlayer(player);
             bar.setVisible(true);
             itemDisplays.put(player, bar);
-            updatePlayerItem(player);
+            updatePlayerItem(player, getRandomItem());
             backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation()));
+            ItemStack skip = new ItemStack(Material.BARRIER, 3);
+            ItemMeta meta = skip.getItemMeta();
+            meta.setDisplayName(ChatColor.RED + "Skip");
+            skip.setItemMeta(meta);
+            player.getInventory().addItem(skip);
         }
-        scoreboardManager = new GamesScoreboardManager(players, getName());
     }
 
     @Override
@@ -75,47 +110,40 @@ public class ForceItemBattle implements MinigameBase, Listener {
     }
 
     protected ItemStack getRandomItem() {
-        Material m;
+        return new ItemStack(SURVIVAL_ITEMS.get(new Random().nextInt(0, SURVIVAL_ITEMS.size())));
-        do {
-            int i = new Random().nextInt(0, Material.values().length);
-            m = Material.values()[i];
-        } while (!m.isItem());
-        return new ItemStack(m);
     }
 
     protected void checkItem(Player p, ItemStack i) {
         if (i == null) return;
         if (currentItems.get(p).getType() == i.getType()) {
             currentScores.replace(p, currentScores.get(p) + 1);
-            scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
+            if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+                scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
             if (checkWin(p)) {
                 stopGame(p);
                 return;
             }
-            updatePlayerItem(p);
+            updatePlayerItem(p, getRandomItem());
         }
     }
 
-    protected void updatePlayerItem(Player player) {
+    protected void updatePlayerItem(Player player, ItemStack item) {
-        currentItems.replace(player, getRandomItem());
+        currentItems.replace(player, item);
         String key = currentItems.get(player).getType().getTranslationKey();
         String displayName = key.replace("block.minecraft.", "")
                 .replace("_", " ")
                 .replace("item.minecraft.", "");
         itemDisplays.get(player).setTitle(displayName);
         ItemStack[] contents = player.getInventory().getContents();
-        for (ItemStack item : contents)
+        for (ItemStack i : contents)
-            checkItem(player, item);
+            checkItem(player, i);
     }
 
-    private boolean checkWin(Player p) {
+    protected boolean checkWin(Player p) {
-        if (currentScores.get(p) == 3) {
+        return currentScores.get(p) == limit;
-            return true;
-        }
-        return false;
     }
 
-    private void stopGame(Player winner) {
+    protected void showEndMessage(Player winner) {
         for (Player player : contestants) {
             if (player != winner) {
                 player.teleport(winner);
@@ -123,37 +151,47 @@ public class ForceItemBattle implements MinigameBase, Listener {
                 player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
                 //restorePlayer(player);
             }
-            player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+            if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+                player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
         }
+    }
+
+    private void stopGame(Player winner) {
+        showEndMessage(winner);
         for (Player p : itemDisplays.keySet()) {
             itemDisplays.get(p).setVisible(false);
             itemDisplays.get(p).removePlayer(p);
         }
         itemDisplays.clear();
-
+        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
-        scoreboardManager.removeScoreboard();
+            scoreboardManager.removeScoreboard();
-        scoreboardManager = null;
+            scoreboardManager = null;
-        RandomizedMinigames.dataInputHandler.removeEntry(owner);
+        }
+        RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
         MinigameHandler.deleteGame(this);
     }
 
     private void removePlayer(Player p) {
         itemDisplays.get(p).setVisible(false);
         itemDisplays.get(p).removePlayer(p);
-        p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+            p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
         if (contestants.isEmpty())
             stopGame(owner);
     }
 
     public void killGame() {
         for (Player player : contestants) {
-            player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+            if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+                player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
         }
         itemDisplays.clear();
 
-        scoreboardManager.removeScoreboard();
+        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
-        scoreboardManager = null;
+            scoreboardManager.removeScoreboard();
-        RandomizedMinigames.dataInputHandler.removeEntry(owner);
+            scoreboardManager = null;
+        }
+        RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
         MinigameHandler.deleteGame(this);
     }
 
@@ -170,6 +208,12 @@ public class ForceItemBattle implements MinigameBase, Listener {
         return contestants;
     }
 
+    public void skipItem(Player p) {
+        ItemStack curItem = currentItems.get(p);
+        p.getInventory().addItem(curItem);
+        checkItem(p, curItem);
+    }
+
     @EventHandler
     public void onItemPickup(EntityPickupItemEvent e) {
         Player eventPlayer;
@@ -185,10 +229,11 @@ public class ForceItemBattle implements MinigameBase, Listener {
     public void onItemCraft(CraftItemEvent e) {
         if (e.getCurrentItem() == null)
             return;
-        Player p = (Player)e.getWhoClicked();
+        Player p = (Player) e.getWhoClicked();
         if (currentItems.containsKey(p))
             checkItem(p, e.getCurrentItem());
     }
+
     @EventHandler
     public void onPlayerLeave(PlayerQuitEvent e) {
         if (contestants.contains(e.getPlayer())) {

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

@@ -15,20 +15,20 @@ public class ForceItemBattleSameItems extends ForceItemBattle {
     }
 
     @Override
-    protected void updatePlayerItem(Player player) {
+    protected void updatePlayerItem(Player player, ItemStack item) {
         if (this.items == null || this.items.isEmpty()) {
             items = new ArrayList<>();
-            items.add(getRandomItem());
+            items.add(item);
         }
         if (currentScores.get(player) == items.size()) {
-            items.add(getRandomItem());
+            items.add(item);
         }
         currentItems.replace(player, items.get(currentScores.get(player)));
         String key = currentItems.get(player).getType().getTranslationKey();
         itemDisplays.get(player).setTitle(key.replace("block.minecraft.", "")
                                                 .replace("_", " ")
                                                 .replace("item.minecraft.", ""));
-        for (ItemStack item : player.getInventory().getContents())
+        for (ItemStack i : player.getInventory().getContents())
-            checkItem(player, item);
+            checkItem(player, i);
     }
 }

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

@@ -1,13 +1,44 @@
 package de.ventority.randomizedminigames.Minigames;
 
+import net.md_5.bungee.api.ChatColor;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
 import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
 
 import java.util.List;
 
 public class ForceItemBattleTeams extends ForceItemBattle{
-    private List<Team> teams;
+    private final List<Team> teams;
     public ForceItemBattleTeams(List<Player> players, Player owner, List<Team> teams) {
         super(players, owner);
         this.teams = teams;
     }
+
+    @Override
+    protected void updatePlayerItem(Player p, ItemStack item) {
+        for (Team team : teams) {
+            for (Player curPlayer : team.getPlayers()) {
+                super.updatePlayerItem(curPlayer, item);
+            }
+        }
+    }
+
+    @Override
+    protected void showEndMessage(Player winner) {
+        for (Player player : contestants) {
+            player.teleport(winner);
+            if (player != winner)
+                player.setGameMode(GameMode.SPECTATOR);
+            Team winningTeam = new Team(null, null);
+            for (Team team : teams)
+                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/Team.java

@@ -9,36 +9,23 @@ import java.util.List;
 import java.util.Random;
 
 public class Team {
-    private HashMap<String, List<Player>> teams;
+    private final List<Player> players;
-    private HashMap<String, ChatColor> colors;
+    private final ChatColor color;
-    public Team(HashMap<String, List<Player>> teams) {
+
-        this.teams = teams;
+    public Team(List<Player> members, ChatColor color) {
+        players = members;
+        this.color = color;
     }
 
-    public List<Player> getPlayersOf(String team) {
+    public List<Player> getPlayers() {
-        return teams.get(team);
+        return players;
     }
 
-    public void addPlayer(String team, Player p) {
+    public void addPlayer(Player p) {
-        teams.get(team).add(p);
+        players.add(p);
     }
 
-    public void createTeam(String team) {
+    public ChatColor getColor() {
-        teams.put(team, new ArrayList<>());
+        return color;
-        ChatColor[] colors = ChatColor.values();
-        ChatColor color;
-        Random rnd = new Random();
-        do color = colors[rnd.nextInt(colors.length)];
-        while (!color.isColor() || colorExists(color));
-    }
-
-    private boolean colorExists(ChatColor color) {
-        for (ChatColor c : colors.values())
-            if (c.equals(color)) return true;
-        return false;
-    }
-
-    public ChatColor getColor(String team) {
-        return colors.get(team);
     }
 }

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

@@ -1,18 +1,33 @@
 package de.ventority.randomizedminigames;
 
 import de.ventority.randomizedminigames.GUI.GUIClickEvent;
+import de.ventority.randomizedminigames.Minigames.ForceItemBattle;
+import de.ventority.randomizedminigames.Minigames.Minigame;
+import de.ventority.randomizedminigames.Minigames.MinigameBase;
 import de.ventority.randomizedminigames.misc.DataInputHandler;
 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 {
+public final class RandomizedMinigames extends JavaPlugin implements Listener {
     public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
     public static DataInputHandler dataInputHandler = new DataInputHandler();
+
     @Override
     public void onEnable() {
         init();
         getServer().getPluginManager().registerEvents(new GUIClickEvent(), this);
+        getServer().getPluginManager().registerEvents(this, this);
         this.getCommand("minigames").setExecutor(new SelectMinigame());
+        for (World world : Bukkit.getWorlds()) {
+            world.setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
+        }
     }
 
     @Override
@@ -23,4 +38,28 @@ public final class RandomizedMinigames extends JavaPlugin {
     private void init() {
         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/SelectMinigame.java

@@ -1,14 +1,30 @@
 package de.ventority.randomizedminigames;
 
 import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
 import org.bukkit.command.*;
 import org.bukkit.entity.Player;
 
 public class SelectMinigame implements CommandExecutor {
     @Override
     public boolean onCommand(CommandSender commandSender, Command command, String s, String[] args) {
-        MinigamesDisplayWindow window = new MinigamesDisplayWindow((Player) commandSender, "MinigameSelect");
+        if (!(commandSender instanceof Player)) {
-        window.buildWindow();
+            commandSender.sendMessage("Dieser Befehl kann nur von einem Spieler ausgeführt werden.");
+            return true;
+        }
+
+        Player player = (Player) commandSender;
+        if (args.length > 0 && args[0].equalsIgnoreCase("killall")) {
+            player.sendMessage("Alle Minigame-Instanzen werden beendet!");
+            MinigameHandler.killAll();
+            return true;
+        }
+
+        if (MinigameHandler.getOccupiedPlayers().contains(player)) {
+            return true;
+        }
+
+        new MinigamesDisplayWindow(player, "MinigameSelect").buildWindow();
         return true;
     }
 

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

@@ -1,6 +1,6 @@
 package de.ventority.randomizedminigames.misc;
 
-import de.ventority.randomizedminigames.Minigames.MinigameBase;
+import de.ventority.randomizedminigames.Minigames.Team;
 import org.bukkit.entity.Player;
 
 import java.util.ArrayList;
@@ -10,6 +10,17 @@ import java.util.List;
 public class DataInputHandler {
     private final HashMap<Player, List<Player>> selectedPlayers = new HashMap<>();
     private final HashMap<Player, Integer> selectedMinigame = new HashMap<>();
+    private final HashMap<Player, Integer> selectedLimit = new HashMap<>();
+    private final HashMap<Player, List<Team>> teams = new HashMap<>();
+    private boolean showScoreboard = true;
+
+    public void switchScoreboard() {
+        showScoreboard = !showScoreboard;
+    }
+
+    public boolean getScoreboardStatus() {
+        return showScoreboard;
+    }
 
     public List<Player> getSelectedPlayers(Player p) {
         if (!selectedPlayers.containsKey(p)) {
@@ -27,7 +38,7 @@ public class DataInputHandler {
         selectedPlayers.get(owner).remove(toRemove);
     }
 
-    public void removeEntry(Player player) {
+    public void removeSelectionEntry(Player player) {
         selectedPlayers.remove(player);
     }
 
@@ -38,4 +49,21 @@ public class DataInputHandler {
     public void setSelectedMinigame(Player player, int minigame) {
         selectedMinigame.put(player, minigame);
     }
+
+    public Integer getSelectedLimit(Player p) {
+        if (!selectedLimit.containsKey(p)) {
+            selectedLimit.put(p, 10);
+        }
+        return selectedLimit.get(p);
+    }
+
+    public void addToSelectedLimit(Player p) {
+        selectedLimit.put(p, selectedLimit.get(p) + 1);
+    }
+
+    public void subFromSelectedLimit(Player p) {
+        selectedLimit.put(p, selectedLimit.get(p) - 1);
+    }
+
+
 }

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

@@ -24,6 +24,13 @@ public class MinigameHandler {
         getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
     }
 
+    public static List<MinigameBase> getMinigames() {
+        if (minigames.isEmpty()) {
+            return null;
+        }
+        return minigames;
+    }
+
     public static void deleteGame(MinigameBase minigame) {
         minigames.remove(minigame);
     }