Fixed some bugs

Started adding Team functionality
Some minor changes

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

@@ -22,7 +22,7 @@ public abstract class BaseWindow {
     public BaseWindow(Player p, String status) {
         this.p = p;
         gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
-                + ChatColor.RESET + ChatColor.DARK_GRAY + status);
+                + ChatColor.RESET + ChatColor.DARK_GRAY);
         this.status = status;
     }
 
@@ -30,27 +30,27 @@ public abstract class BaseWindow {
         ItemStack stack;
         for (int i = 0; i < 9; i++) {
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.setItem(i, stack);
+            setItemName(stack, " ");
-            setItemName(stack, " " + i);
+            addItemToGUI(i, stack);
         }
         for (int i = 1; i < 5; i++) {
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.setItem(9 * i, stack);
+            setItemName(stack, " ");
-            setItemName(stack, " " + 9 * i);
+            addItemToGUI(9 * i, stack);
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.setItem(8 + 9 * i, stack);
+            setItemName(stack, " ");
-            setItemName(stack, " " + 8 + 9 * i);
+            addItemToGUI(8 + 9 * i, stack);
         }
         for (int i = 0; i < 9; i++) {
             stack = new ItemStack(Material.BLACK_STAINED_GLASS_PANE, 1);
-            gui.setItem(i + 5 * 9, stack);
+            setItemName(stack, " ");
-            setItemName(stack, " " + i + 5 * 9);
+            addItemToGUI(i + 5 * 9, stack);
         }
     }
 
     protected abstract void fillGUI();
 
-    protected void buildWindow() {
+    public void buildWindow() {
         fillBorder();
         fillGUI();
         addNBT(Objects.requireNonNull(gui.getItem(0)), "ItemMiniGame", "true");
@@ -63,12 +63,24 @@ public abstract class BaseWindow {
         if (meta == null) return;
         PersistentDataContainer data = meta.getPersistentDataContainer();
         data.set(key1, PersistentDataType.STRING, value);
+        item.setItemMeta(meta);
     }
 
     protected void setItemName(ItemStack item, String name) {
         ItemMeta meta = item.getItemMeta();
         if (meta == null) return;
         meta.setDisplayName(name);
+        item.setItemMeta(meta);
+    }
+
+    protected void addItemToGUI(int index, ItemStack item) {
+        addNBT(item, "ItemMiniGame", "true");
+        gui.setItem(index, item);
+    }
+
+    protected void addItemToGUI(ItemStack item) {
+        addNBT(item, "ItemMiniGame", "true");
+        gui.addItem(item);
     }
 
     public Inventory getGUI() {

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

@@ -1,8 +1,15 @@
 package de.ventority.randomizedminigames.GUI;
 
-import de.ventority.randomizedminigames.MinigameHandler;
+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.SelectMinigame;
+import de.ventority.randomizedminigames.misc.DataInputHandler;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
 import de.ventority.randomizedminigames.Minigames.Minigame;
 import de.ventority.randomizedminigames.RandomizedMinigames;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
 import org.bukkit.NamespacedKey;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -17,18 +24,23 @@ 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.setCancelled(true);
             event.getWhoClicked().closeInventory();
-            if (getNBT(event.getCurrentItem(), "Type").equals("Minigame")) {
+            if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSelect")) {
                 handleMinigame(event, getNBT(event.getCurrentItem(), "Action"));
             }
             if (getNBT(event.getCurrentItem(), "Type").equals("Misc")) {
                 handleSettings(event, getNBT(event.getCurrentItem(), "Action"));
             }
+            if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSetup")) {
+                handleMinigameSetup(event, getNBT(event.getCurrentItem(), "Action"));
+            }
         }
     }
 
@@ -42,18 +54,16 @@ public class GUIClickEvent implements Listener {
     }
 
     private boolean isMinigamePlugin(ItemStack item) {
-        String s = getNBT(item, "ItemMiniGame");
+        return getNBT(item, "ItemMiniGame") != null && getNBT(item, "ItemMiniGame").equals("true");
-        System.out.println(s);
-        System.out.println(item.getItemMeta().getDisplayName());
-        System.out.println(s != null && s.equals("true"));
-        return s != null && s.equals("true");
     }
 
     private void handleMinigame(InventoryClickEvent event, String action) {
-        for (Minigame minigame : Minigame.values()) {
+        if (action.equals("openMinigameSetup")) {
-            if (action.equals(minigame.getAction())) {
+            RandomizedMinigames.dataInputHandler.setSelectedMinigame((Player) event.getWhoClicked(), Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
-                MinigameHandler.createMinigame(minigame.getNumber());
+            new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
         }
+        if (action.equals("homeMenu")) {
+            new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
         }
     }
 
@@ -63,4 +73,26 @@ public class GUIClickEvent implements Listener {
         }
 
     }
+
+    private void handleMinigameSetup(InventoryClickEvent event, String action) {
+        if (action.equals("homeMenu")) {
+            new MinigamesDisplayWindow((Player) event.getWhoClicked(), "Minigame").buildWindow();
+        }
+        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);
+            } else {
+                data.addPlayersToSelection((Player) event.getWhoClicked(), toWork);
+            }
+            new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
+        }
+        if (action.equals("startPlayerSelection")) {
+            new PlayerSelection((Player)event.getWhoClicked(), getNBT(event.getCurrentItem(), "selectedMinigame")).buildWindow();
+        }
+        if (action.equals("startGame")) {
+            MinigameHandler.createMinigame(RandomizedMinigames.dataInputHandler.getSelectedMinigame((Player) event.getWhoClicked()), (Player) event.getWhoClicked());
+        }
+    }
 }

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

@@ -1,4 +1,4 @@
-package de.ventority.randomizedminigames.GUI;
+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;
+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

@@ -0,0 +1,36 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.ItemStack;
+
+public class MinigameSetup extends BaseWindow {
+
+    public MinigameSetup(Player p, String status) {
+        super(p, status);
+    }
+
+    @Override
+    protected void fillGUI() {
+        ItemStack playerSelect = new ItemStack(Material.GOLD_INGOT);
+        addNBT(playerSelect, "Type", "MinigameSetup");
+        addNBT(playerSelect, "Action", "startPlayerSelection");
+        addNBT(playerSelect, "selectedMinigame", status);
+        setItemName(playerSelect, "Select Players");
+        addItemToGUI(playerSelect);
+
+        ItemStack start = new ItemStack(Material.GREEN_DYE);
+        addNBT(start, "Type", "MinigameSetup");
+        addNBT(start, "Action", "startGame");
+        addNBT(start, "selectedMinigame", status);
+        setItemName(start, "Start");
+        addItemToGUI(50, start);
+
+        ItemStack back = new ItemStack(Material.ARROW);
+        addNBT(back, "Type", "MinigameSelect");
+        addNBT(back, "Action", "homeMenu");
+        setItemName(back, "Back");
+        addItemToGUI(49, back);
+    }
+}

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

@@ -1,17 +1,11 @@
-package de.ventority.randomizedminigames.GUI;
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
 
+import de.ventority.randomizedminigames.GUI.BaseWindow;
 import de.ventority.randomizedminigames.Minigames.Minigame;
-import de.ventority.randomizedminigames.RandomizedMinigames;
-import net.md_5.bungee.api.ChatColor;
-import org.bukkit.Bukkit;
 import org.bukkit.Material;
-import org.bukkit.NamespacedKey;
 import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.persistence.PersistentDataContainer;
-import org.bukkit.persistence.PersistentDataType;
 
 public class MinigamesDisplayWindow extends BaseWindow {
 
@@ -19,24 +13,17 @@ public class MinigamesDisplayWindow extends BaseWindow{
         super(p, status);
     }
 
-    public void buildWindow() {
-        fillBorder();
-        fillGUI();
-        p.openInventory(gui);
-    }
-
     @Override
     protected void fillGUI() {
         for (Minigame minigame : Minigame.values()) {
             ItemStack item = new ItemStack(minigame.getMaterial(), 1);
-            ItemMeta meta = item.getItemMeta();
             setItemName(item, minigame.getName());
-            addNBT(item, "Type", "Minigame");
+            addNBT(item, "Type", "MinigameSelect");
-            addNBT(item, "Action", minigame.getAction());
+            addNBT(item, "Action", "openMinigameSetup");
-            item.setItemMeta(meta);
+            addNBT(item, "selectedMinigame", Integer.toString(minigame.getNumber()));
-            gui.addItem(item);
+            addItemToGUI(item);
         }
-        addSettings();
+        //addSettings();
     }
 
     private void addSettings() {
@@ -46,6 +33,6 @@ public class MinigamesDisplayWindow extends BaseWindow{
         addNBT(settings, "Type", "Misc");
         addNBT(settings, "Action", "selectSettings");
         settings.setItemMeta(settingsMeta);
-        gui.setItem(45, settings);
+        addItemToGUI(45, settings);
     }
 }

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

@@ -0,0 +1,49 @@
+package de.ventority.randomizedminigames.GUI.MinigameSetups;
+
+import de.ventority.randomizedminigames.GUI.BaseWindow;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+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 PlayerSelection extends BaseWindow {
+    public PlayerSelection(Player p, String status) {
+        super(p, status);
+    }
+
+    @Override
+    protected void fillGUI() {
+        for (Player player : Bukkit.getOnlinePlayers()) {
+            if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
+                ItemStack item = getPlayerHead(player, RandomizedMinigames.dataInputHandler.getSelectedPlayers(p).contains(player));
+                addNBT(item, "Type", "MinigameSetup");
+                addNBT(item, "Action", "clickedPlayer");
+                addNBT(item, "selectedMinigame", status);
+                addNBT(item, "Player", player.getDisplayName());
+                addItemToGUI(item);
+            }
+        }
+
+        ItemStack back = new ItemStack(Material.ARROW);
+        addNBT(back, "Type", "MinigameSetup");
+        addNBT(back, "Action", "homeMenu");
+        addNBT(back, "selectedMinigame", status);
+        setItemName(back, "Back");
+        addItemToGUI(49, back);
+    }
+
+    private ItemStack getPlayerHead(Player player, boolean selected) {
+        ItemStack head = new ItemStack(Material.PLAYER_HEAD);
+        SkullMeta meta = (SkullMeta) head.getItemMeta();
+        if (meta != null) {
+            meta.setOwningPlayer(player);
+            meta.setDisplayName((selected ? ChatColor.GREEN : ChatColor.RED) + player.getName());
+            head.setItemMeta(meta);
+        }
+        return head;
+    }
+}

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

@@ -1,12 +0,0 @@
-package de.ventority.randomizedminigames;
-
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class GeneralSettings {
-    public List<Player> contestants = new ArrayList<>();
-    public String keyword;
-
-}

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

@@ -1,7 +1,8 @@
 package de.ventority.randomizedminigames.Minigames;
 
-import de.ventority.randomizedminigames.GUI.GamesScoreboardManager;
+import de.ventority.randomizedminigames.GUI.InGame.GamesScoreboardManager;
-import de.ventority.randomizedminigames.MinigameHandler;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
 import de.ventority.randomizedminigames.misc.PlayerBackup;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
@@ -12,7 +13,6 @@ import org.bukkit.boss.BossBar;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
 import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.inventory.CraftItemEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
@@ -20,7 +20,6 @@ import org.bukkit.inventory.ItemStack;
 
 import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
 import java.util.Random;
 
 public class ForceItemBattle implements MinigameBase, Listener {
@@ -31,15 +30,17 @@ public class ForceItemBattle implements MinigameBase, Listener {
     private GamesScoreboardManager scoreboardManager;
     private final List<Player> contestants;
     private final HashMap<Player, PlayerBackup> backups;
+    private final Player owner;
 
 
-    public ForceItemBattle(List<Player> players) {
+    public ForceItemBattle(List<Player> players, Player owner) {
         id = new Random().nextInt(1024);
         currentItems = new HashMap<>();
         currentScores = new HashMap<>();
         itemDisplays = new HashMap<>();
         backups = new HashMap<>();
         contestants = players;
+        this.owner = owner;
         for (Player player : players) {
             currentItems.put(player, null);
             currentScores.put(player, 0);
@@ -47,7 +48,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
             bar.addPlayer(player);
             bar.setVisible(true);
             itemDisplays.put(player, bar);
-            System.out.println(itemDisplays.get(player).getTitle());
             updatePlayerItem(player);
             backups.put(player, new PlayerBackup(player.getInventory().getContents(), player.getInventory().getArmorContents(), player.getExp(), player.getLocation()));
         }
@@ -90,6 +90,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
             scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
             if (checkWin(p)) {
                 stopGame(p);
+                return;
             }
             updatePlayerItem(p);
         }
@@ -109,7 +110,6 @@ public class ForceItemBattle implements MinigameBase, Listener {
 
     private boolean checkWin(Player p) {
         if (currentScores.get(p) == 3) {
-            System.out.println(currentScores.get(p) + ", " + p.getName() + " wins");
             return true;
         }
         return false;
@@ -120,9 +120,10 @@ public class ForceItemBattle implements MinigameBase, Listener {
             if (player != winner) {
                 player.teleport(winner);
                 player.setGameMode(GameMode.SPECTATOR);
-                player.sendTitle(winner.getDisplayName() + " hat gewonnen!", "Die Player werden jetzt zurückgesetzt.", 10, 70, 20);
+                player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
-                restorePlayer(player);
+                //restorePlayer(player);
             }
+            player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
         }
         for (Player p : itemDisplays.keySet()) {
             itemDisplays.get(p).setVisible(false);
@@ -132,13 +133,28 @@ public class ForceItemBattle implements MinigameBase, Listener {
 
         scoreboardManager.removeScoreboard();
         scoreboardManager = null;
+        RandomizedMinigames.dataInputHandler.removeEntry(owner);
         MinigameHandler.deleteGame(this);
     }
 
     private void removePlayer(Player p) {
         itemDisplays.get(p).setVisible(false);
         itemDisplays.get(p).removePlayer(p);
-        scoreboardManager.getScoreboard().getPlayers().remove(p);
+        p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+        if (contestants.isEmpty())
+            stopGame(owner);
+    }
+
+    public void killGame() {
+        for (Player player : contestants) {
+            player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+        }
+        itemDisplays.clear();
+
+        scoreboardManager.removeScoreboard();
+        scoreboardManager = null;
+        RandomizedMinigames.dataInputHandler.removeEntry(owner);
+        MinigameHandler.deleteGame(this);
     }
 
     private void restorePlayer(Player p) {
@@ -150,6 +166,10 @@ public class ForceItemBattle implements MinigameBase, Listener {
         p.getInventory().setArmorContents(backup.getArmor());
     }
 
+    public List<Player> getPlayers() {
+        return contestants;
+    }
+
     @EventHandler
     public void onItemPickup(EntityPickupItemEvent e) {
         Player eventPlayer;

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

@@ -10,8 +10,8 @@ public class ForceItemBattleSameItems extends ForceItemBattle {
     private  List<ItemStack> items;
 
 
-    public ForceItemBattleSameItems(List<Player> players) {
+    public ForceItemBattleSameItems(List<Player> players, Player owner) {
-        super(players);
+        super(players, owner);
     }
 
     @Override

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

@@ -0,0 +1,13 @@
+package de.ventority.randomizedminigames.Minigames;
+
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+public class ForceItemBattleTeams extends ForceItemBattle{
+    private List<Team> teams;
+    public ForceItemBattleTeams(List<Player> players, Player owner, List<Team> teams) {
+        super(players, owner);
+        this.teams = teams;
+    }
+}

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

@@ -11,4 +11,6 @@ public interface MinigameBase extends Listener {
     String getName();
     ItemStack getSymbol();
     void addPlayers(List<Player> players);
+    List<Player> getPlayers();
+    void killGame();
 }

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

@@ -0,0 +1,44 @@
+package de.ventority.randomizedminigames.Minigames;
+
+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 HashMap<String, List<Player>> teams;
+    private HashMap<String, ChatColor> colors;
+    public Team(HashMap<String, List<Player>> teams) {
+        this.teams = teams;
+    }
+
+    public List<Player> getPlayersOf(String team) {
+        return teams.get(team);
+    }
+
+    public void addPlayer(String team, Player p) {
+        teams.get(team).add(p);
+    }
+
+    public void createTeam(String team) {
+        teams.put(team, new ArrayList<>());
+        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,11 +1,13 @@
 package de.ventority.randomizedminigames;
 
 import de.ventority.randomizedminigames.GUI.GUIClickEvent;
+import de.ventority.randomizedminigames.misc.DataInputHandler;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
 import org.bukkit.plugin.java.JavaPlugin;
 
 public final class RandomizedMinigames extends JavaPlugin {
     public static final ServerSettingsHandler serverSettingsHandler = new ServerSettingsHandler();
-    public static String keyword = "";
+    public static DataInputHandler dataInputHandler = new DataInputHandler();
     @Override
     public void onEnable() {
         init();
@@ -15,7 +17,7 @@ public final class RandomizedMinigames extends JavaPlugin {
 
     @Override
     public void onDisable() {
-        // Plugin shutdown logic
+        MinigameHandler.killAll();
     }
 
     private void init() {

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

@@ -1,13 +1,13 @@
 package de.ventority.randomizedminigames;
 
-import de.ventority.randomizedminigames.GUI.MinigamesDisplayWindow;
+import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
 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");
+        MinigamesDisplayWindow window = new MinigamesDisplayWindow((Player) commandSender, "MinigameSelect");
         window.buildWindow();
         return true;
     }

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

@@ -33,4 +33,6 @@ public class ServerSettingsHandler {
     public Plugin getPlugin() {
         return plugin;
     }
+
+    public String keyword;
 }

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

@@ -0,0 +1,41 @@
+package de.ventority.randomizedminigames.misc;
+
+import de.ventority.randomizedminigames.Minigames.MinigameBase;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+
+public class DataInputHandler {
+    private final HashMap<Player, List<Player>> selectedPlayers = new HashMap<>();
+    private final HashMap<Player, Integer> selectedMinigame = new HashMap<>();
+
+    public List<Player> getSelectedPlayers(Player p) {
+        if (!selectedPlayers.containsKey(p)) {
+            selectedPlayers.put(p, new ArrayList<>());
+            selectedPlayers.get(p).add(p);
+        }
+        return selectedPlayers.get(p);
+    }
+
+    public void addPlayersToSelection(Player owner, Player toAdd) {
+        selectedPlayers.get(owner).add(toAdd);
+    }
+
+    public void removePlayersFromSelection(Player owner, Player toRemove) {
+        selectedPlayers.get(owner).remove(toRemove);
+    }
+
+    public void removeEntry(Player player) {
+        selectedPlayers.remove(player);
+    }
+
+    public int getSelectedMinigame(Player player) {
+        return selectedMinigame.get(player);
+    }
+
+    public void setSelectedMinigame(Player player, int minigame) {
+        selectedMinigame.put(player, minigame);
+    }
+}

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

@@ -0,0 +1,5 @@
+package de.ventority.randomizedminigames.misc;
+
+public class GeneralSettings {
+    public String keyword;
+}

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

@@ -1,8 +1,9 @@
-package de.ventority.randomizedminigames;
+package de.ventority.randomizedminigames.misc;
 
 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;
@@ -14,11 +15,11 @@ import static org.bukkit.Bukkit.getServer;
 public class MinigameHandler {
     private static final List<MinigameBase> minigames = new ArrayList<>();
 
-    public static void createMinigame(int gameNumber) {
+    public static void createMinigame(int gameNumber, Player caller) {
-        List<Player> players = Bukkit.getOnlinePlayers().stream().map(p -> ((Player) p)).toList();
+        List<Player> players = RandomizedMinigames.dataInputHandler.getSelectedPlayers(caller);
         switch (gameNumber) {
-            case 0: minigames.add(new ForceItemBattle(players));
+            case 0: minigames.add(new ForceItemBattle(players, caller)); break;
-            case 1: minigames.add(new ForceItemBattleSameItems(players));
+            case 1: minigames.add(new ForceItemBattleSameItems(players, caller)); break;
         }
         getServer().getPluginManager().registerEvents(minigames.getFirst(), RandomizedMinigames.serverSettingsHandler.getPlugin());
     }
@@ -26,4 +27,17 @@ public class MinigameHandler {
     public static void deleteGame(MinigameBase minigame) {
         minigames.remove(minigame);
     }
+
+    public static List<Player> getOccupiedPlayers() {
+        List<Player> lst = new ArrayList<>();
+        for (MinigameBase minigame : minigames) {
+            lst.addAll(minigame.getPlayers());
+        }
+        return lst;
+    }
+
+    public static void killAll() {
+        for (MinigameBase minigame : minigames)
+            minigame.killGame();
+    }
 }