Split GUI-events into handlers

Rewritten personal Settings handling
Simplified GUI-implementation
Further worked on Teams

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

@@ -17,13 +17,11 @@ import java.util.Objects;
 public abstract class BaseWindow {
     protected final Player p;
     protected final Inventory gui;
-    protected String status;
 
-    public BaseWindow(Player p, String status) {
+    public BaseWindow(Player p) {
         this.p = p;
         gui = Bukkit.createInventory(p, 54, RandomizedMinigames.serverSettingsHandler.getServerName()
                 + ChatColor.RESET + ChatColor.DARK_GRAY);
-        this.status = status;
     }
 
     protected void fillBorder() {
@@ -95,7 +93,4 @@ public abstract class BaseWindow {
         return p;
     }
 
-    private String getStatus() {
-        return status;
-    }
 }

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

@@ -1,18 +1,11 @@
 package de.ventority.randomizedminigames.GUI;
 
-import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
+import de.ventority.randomizedminigames.GUI.handlers.MinigameSelectHandler;
-import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigamesDisplayWindow;
+import de.ventority.randomizedminigames.GUI.handlers.MinigameSetupHandler;
-import de.ventority.randomizedminigames.GUI.MinigameSetups.PlayerSelection;
+import de.ventority.randomizedminigames.GUI.handlers.SettingsHandler;
-import de.ventority.randomizedminigames.GUI.MinigameSetups.SetLimit;
-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;
 import org.bukkit.event.Listener;
 import org.bukkit.event.inventory.InventoryClickEvent;
@@ -31,16 +24,12 @@ public class GUIClickEvent implements Listener {
         if (inventory.getItem(0) == null) return;
         if (isMinigamePlugin(inventory.getItem(0))) {
             event.setCancelled(true);
-            if (getNBT(event.getCurrentItem(), "Action").equals("none"))
+            if (event.getCurrentItem().getType() == (Material.BLACK_STAINED_GLASS_PANE)) return;
-                return;
+            switch (getNBT(event.getCurrentItem(), "Type")) {
-            if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSelect")) {
+                case "none": return;
-                handleMinigame(event, getNBT(event.getCurrentItem(), "Action"));
+                case "MinigameSelect": new MinigameSelectHandler(event, getNBT(event.getCurrentItem(), "Action")).handle();
-            }
+                case "MinigameSetup": new MinigameSetupHandler(event, getNBT(event.getCurrentItem(), "Action")).handle();
-            if (getNBT(event.getCurrentItem(), "Type").equals("Misc")) {
+                case "Misc": new SettingsHandler(event, getNBT(event.getCurrentItem(), "Action")).handle();
-                handleSettings(event, getNBT(event.getCurrentItem(), "Action"));
-            }
-            if (getNBT(event.getCurrentItem(), "Type").equals("MinigameSetup")) {
-                handleMinigameSetup(event, getNBT(event.getCurrentItem(), "Action"));
             }
         }
     }
@@ -57,71 +46,4 @@ public class GUIClickEvent implements Listener {
     private boolean isMinigamePlugin(ItemStack item) {
         return getNBT(item, "ItemMiniGame") != null && getNBT(item, "ItemMiniGame").equals("true");
     }
-
-    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();
-        }
-        if (action.equals("homeMenu")) {
-            new MinigameSetup((Player) event.getWhoClicked(), action).buildWindow();
-        }
-    }
-
-    private void handleSettings(InventoryClickEvent event, String action) {
-        event.getWhoClicked().closeInventory();
-        if (action.equals("selectSettings")) {
-            new SettingsWindow((Player)event.getWhoClicked(), "Settings");
-        }
-
-    }
-
-    private void handleMinigameSetup(InventoryClickEvent event, String action) {
-        if (action.equals("homeMenu")) {
-            event.getWhoClicked().closeInventory();
-            new MinigameSetup((Player) event.getWhoClicked(), "Minigame").buildWindow();
-        }
-
-        DataInputHandler data = RandomizedMinigames.dataInputHandler;
-        if (action.equals("clickedPlayer")) {
-            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("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,8 +1,8 @@
 package de.ventority.randomizedminigames.GUI.MinigameSetups;
 
 import de.ventority.randomizedminigames.GUI.BaseWindow;
-import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
-import de.ventority.randomizedminigames.misc.DataInputHandler;
+import de.ventority.randomizedminigames.misc.Settings;
 import net.md_5.bungee.api.ChatColor;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
@@ -10,38 +10,35 @@ import org.bukkit.inventory.ItemStack;
 
 public class MinigameSetup extends BaseWindow {
 
-    public MinigameSetup(Player p, String status) {
+    public MinigameSetup(Player p) {
-        super(p, status);
+        super(p);
     }
 
     @Override
     protected void fillGUI() {
+        System.out.println("Hallo");
         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;
+        Settings playerSettings = MinigameHandler.getSettings(p);
         ItemStack scoreboard = new ItemStack(Material.EMERALD);
         addNBT(scoreboard, "Type", "MinigameSetup");
         addNBT(scoreboard, "Action", "switchScoreboard");
-        addNBT(scoreboard, "selectedMinigame", status);
+        setItemName(scoreboard, "Scoreboard: " + (playerSettings.getScoreboardStatus() ? (ChatColor.GREEN + "On") : ChatColor.RED + "Off"));
-        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");
-        addNBT(start, "selectedMinigame", status);
         setItemName(start, "Start");
         addItemToGUI(50, start);
 

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

@@ -9,8 +9,8 @@ import org.bukkit.inventory.meta.ItemMeta;
 
 public class MinigamesDisplayWindow extends BaseWindow {
 
-    public MinigamesDisplayWindow(Player p, String status) {
+    public MinigamesDisplayWindow(Player p) {
-        super(p, status);
+        super(p);
     }
 
     @Override

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

@@ -11,18 +11,17 @@ import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.SkullMeta;
 
 public class PlayerSelection extends BaseWindow {
-    public PlayerSelection(Player p, String status) {
+    public PlayerSelection(Player p) {
-        super(p, status);
+        super(p);
     }
 
     @Override
     protected void fillGUI() {
         for (Player player : Bukkit.getOnlinePlayers()) {
             if (!MinigameHandler.getOccupiedPlayers().contains(player)) {
-                ItemStack item = getPlayerHead(player, RandomizedMinigames.dataInputHandler.getSelectedPlayers(p).contains(player));
+                ItemStack item = getPlayerHead(player);
                 addNBT(item, "Type", "MinigameSetup");
                 addNBT(item, "Action", "clickedPlayer");
-                addNBT(item, "selectedMinigame", status);
                 addNBT(item, "Player", player.getDisplayName());
                 addItemToGUI(item);
             }
@@ -31,17 +30,17 @@ public class PlayerSelection extends BaseWindow {
         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) {
+    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((selected ? ChatColor.GREEN : ChatColor.RED) + player.getName());
+            meta.setDisplayName((MinigameHandler.getSettings(player).getSelectedPlayers().contains(player) ?
+                    ChatColor.GREEN : ChatColor.RED) + player.getName());
             head.setItemMeta(meta);
         }
         return head;

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

@@ -2,13 +2,14 @@ package de.ventority.randomizedminigames.GUI.MinigameSetups;
 
 import de.ventority.randomizedminigames.GUI.BaseWindow;
 import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
 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) {
+    public SetLimit(Player p) {
-        super(p, status);
+        super(p);
     }
 
     @Override
@@ -16,28 +17,24 @@ public class SetLimit extends BaseWindow {
         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, "" + MinigameHandler.getSettings(p).getSelectedLimit());
-        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

@@ -5,8 +5,8 @@ import org.bukkit.entity.Player;
 
 public class TeamOverview extends BaseWindow {
 
-    public TeamOverview(Player p, String status) {
+    public TeamOverview(Player p) {
-        super(p, status);
+        super(p);
     }
 
     @Override

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

@@ -6,8 +6,8 @@ import org.bukkit.inventory.ItemStack;
 
 public class SettingsWindow extends BaseWindow{
 
-    public SettingsWindow(Player p, String status) {
+    public SettingsWindow(Player p) {
-        super(p, status);
+        super(p);
     }
 
     @Override

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

@@ -0,0 +1,30 @@
+package de.ventority.randomizedminigames.GUI.handlers;
+
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import org.bukkit.NamespacedKey;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.persistence.PersistentDataContainer;
+import org.bukkit.persistence.PersistentDataType;
+
+public abstract class GUIHandler {
+    protected final InventoryClickEvent event;
+    protected final String action;
+
+    public GUIHandler(InventoryClickEvent event, String action) {
+        this.event = event;
+        this.action = action;
+    }
+
+    public abstract void handle();
+
+    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/handlers/MinigameSelectHandler.java

@@ -0,0 +1,26 @@
+package de.ventority.randomizedminigames.GUI.handlers;
+
+import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
+import de.ventority.randomizedminigames.RandomizedMinigames;
+import de.ventority.randomizedminigames.misc.MinigameHandler;
+import de.ventority.randomizedminigames.misc.Settings;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class MinigameSelectHandler extends GUIHandler{
+    public MinigameSelectHandler(InventoryClickEvent event, String action) {
+        super(event, action);
+    }
+
+    @Override
+    public void handle() {
+        Settings settings = MinigameHandler.getSettings((Player) event.getWhoClicked());
+        if (action.equals("openMinigameSetup")) {
+            settings.selectMinigame(Integer.parseInt(getNBT(event.getCurrentItem(), "selectedMinigame")));
+            new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
+        }
+        if (action.equals("homeMenu")) {
+            new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
+        }
+    }
+}

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

@@ -0,0 +1,62 @@
+package de.ventority.randomizedminigames.GUI.handlers;
+
+import de.ventority.randomizedminigames.GUI.MinigameSetups.MinigameSetup;
+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;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class MinigameSetupHandler extends GUIHandler {
+
+    public MinigameSetupHandler(InventoryClickEvent event, String action) {
+        super(event, action);
+    }
+
+    @Override
+    public void handle() {
+        if (action.equals("homeMenu")) {
+            new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
+        }
+
+        Settings playerSettings = MinigameHandler.getSettings(((Player) event.getWhoClicked()).getPlayer());
+        if (action.equals("clickedPlayer")) {
+            Player toWork = Bukkit.getPlayer(getNBT(event.getCurrentItem(), "Player"));
+            if (playerSettings.getSelectedPlayers().contains(toWork)) {
+                playerSettings.removePlayersFromSelection(toWork);
+            } else {
+                playerSettings.addPlayersToSelection(toWork);
+            }
+            new PlayerSelection((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("subFromLimit")) {
+            playerSettings.subFromSelectedLimit();
+            new SetLimit((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("addToLimit")) {
+            playerSettings.addToSelectedLimit();
+            new SetLimit((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("startPlayerSelection")) {
+            new PlayerSelection((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("startLimitSelection")) {
+            new SetLimit((Player)event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("switchScoreboard")) {
+            playerSettings.switchScoreboard();
+            new MinigameSetup((Player) event.getWhoClicked()).buildWindow();
+        }
+
+        if (action.equals("startGame")) {
+            MinigameHandler.createMinigame(playerSettings.getSelectedMinigame(), (Player) event.getWhoClicked());
+        }
+    }
+}

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

@@ -0,0 +1,18 @@
+package de.ventority.randomizedminigames.GUI.handlers;
+
+import de.ventority.randomizedminigames.GUI.SettingsWindow;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryClickEvent;
+
+public class SettingsHandler extends GUIHandler {
+    public SettingsHandler(InventoryClickEvent event, String action) {
+        super(event, action);
+    }
+
+    @Override
+    public void handle() {
+        if (action.equals("selectSettings")) {
+            new SettingsWindow((Player)event.getWhoClicked());
+        }
+    }
+}

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

@@ -1,9 +1,9 @@
 package de.ventority.randomizedminigames.Minigames;
 
 import de.ventority.randomizedminigames.GUI.InGame.GamesScoreboardManager;
-import de.ventority.randomizedminigames.RandomizedMinigames;
 import de.ventority.randomizedminigames.misc.MinigameHandler;
 import de.ventority.randomizedminigames.misc.PlayerBackup;
+import de.ventority.randomizedminigames.misc.Settings;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
 import org.bukkit.GameMode;
@@ -20,11 +20,7 @@ import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.inventory.meta.ItemMeta;
 
-import java.util.Arrays;
+import java.util.*;
-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;
@@ -35,7 +31,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
     protected final List<Player> contestants;
     private final HashMap<Player, PlayerBackup> backups;
     private final Player owner;
-    protected final int limit;
+    protected Settings settings;
+
     private final List<Material> SURVIVAL_ITEMS = Arrays.stream(Material.values())
             .filter(Material::isItem)
             .filter(m -> {
@@ -62,7 +59,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
 
 
     public ForceItemBattle(List<Player> players, Player owner) {
-        limit = RandomizedMinigames.dataInputHandler.getSelectedLimit(owner);
+        settings = MinigameHandler.getSettings(owner);
+
         id = new Random().nextInt(1024);
         currentItems = new HashMap<>();
         currentScores = new HashMap<>();
@@ -70,19 +68,23 @@ public class ForceItemBattle implements MinigameBase, Listener {
         backups = new HashMap<>();
         contestants = players;
         this.owner = owner;
-        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+        if (MinigameHandler.getSettings(owner).getScoreboardStatus())
             scoreboardManager = new GamesScoreboardManager(players, getName());
         for (Player player : players) {
             currentItems.put(player, null);
             currentScores.put(player, 0);
-            BossBar bar = Bukkit.createBossBar("Hallo", BarColor.PURPLE, BarStyle.SOLID);
+
+            BossBar bar = Bukkit.createBossBar("Null", BarColor.PURPLE, BarStyle.SOLID);
             bar.addPlayer(player);
             bar.setVisible(true);
             itemDisplays.put(player, bar);
+
             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();
+            assert meta != null;
             meta.setDisplayName(ChatColor.RED + "Skip");
             skip.setItemMeta(meta);
             player.getInventory().addItem(skip);
@@ -117,7 +119,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
         if (i == null) return;
         if (currentItems.get(p).getType() == i.getType()) {
             currentScores.replace(p, currentScores.get(p) + 1);
-            if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+            if (settings.getScoreboardStatus())
                 scoreboardManager.setPunkte(p.getName(), scoreboardManager.getPunkte(p.getName()) + 1);
             if (checkWin(p)) {
                 stopGame(p);
@@ -140,7 +142,7 @@ public class ForceItemBattle implements MinigameBase, Listener {
     }
 
     protected boolean checkWin(Player p) {
-        return currentScores.get(p) == limit;
+        return currentScores.get(p) == settings.getSelectedLimit();
     }
 
     protected void showEndMessage(Player winner) {
@@ -151,8 +153,8 @@ public class ForceItemBattle implements MinigameBase, Listener {
                 player.sendTitle(winner.getDisplayName() + " won!", "Resetting players...", 10, 70, 20);
                 //restorePlayer(player);
             }
-            if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+            if (settings.getScoreboardStatus())
-                player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+                player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
         }
     }
 
@@ -163,35 +165,35 @@ public class ForceItemBattle implements MinigameBase, Listener {
             itemDisplays.get(p).removePlayer(p);
         }
         itemDisplays.clear();
-        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
+        if (settings.getScoreboardStatus()) {
             scoreboardManager.removeScoreboard();
             scoreboardManager = null;
         }
-        RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
+        MinigameHandler.resetSettings(owner);
         MinigameHandler.deleteGame(this);
     }
 
     private void removePlayer(Player p) {
         itemDisplays.get(p).setVisible(false);
         itemDisplays.get(p).removePlayer(p);
-        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+        if (settings.getScoreboardStatus())
-            p.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+            p.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
         if (contestants.isEmpty())
             stopGame(owner);
     }
 
     public void killGame() {
         for (Player player : contestants) {
-            if (RandomizedMinigames.dataInputHandler.getScoreboardStatus())
+            if (settings.getScoreboardStatus())
-                player.setScoreboard(Bukkit.getScoreboardManager().getMainScoreboard());
+                player.setScoreboard(Objects.requireNonNull(Bukkit.getScoreboardManager()).getMainScoreboard());
         }
         itemDisplays.clear();
 
-        if (RandomizedMinigames.dataInputHandler.getScoreboardStatus()) {
+        if (settings.getScoreboardStatus()) {
             scoreboardManager.removeScoreboard();
             scoreboardManager = null;
         }
-        RandomizedMinigames.dataInputHandler.removeSelectionEntry(owner);
+        MinigameHandler.resetSettings(owner);
         MinigameHandler.deleteGame(this);
     }
 

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

@@ -2,9 +2,7 @@ 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;
@@ -17,14 +15,13 @@ import org.bukkit.plugin.java.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());
+        this.getCommand("minigames").setExecutor(new executeMinigame());
         for (World world : Bukkit.getWorlds()) {
             world.setGameRule(GameRule.ANNOUNCE_ADVANCEMENTS, false);
         }

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

@@ -5,7 +5,7 @@ import de.ventority.randomizedminigames.misc.MinigameHandler;
 import org.bukkit.command.*;
 import org.bukkit.entity.Player;
 
-public class SelectMinigame implements CommandExecutor {
+public class executeMinigame implements CommandExecutor {
     @Override
     public boolean onCommand(CommandSender commandSender, Command command, String s, String[] args) {
         if (!(commandSender instanceof Player)) {
@@ -20,11 +20,11 @@ public class SelectMinigame implements CommandExecutor {
             return true;
         }
 
-        if (MinigameHandler.getOccupiedPlayers().contains(player)) {
+        if (MinigameHandler.getOccupiedPlayers().contains(player))
             return true;
-        }
 
-        new MinigamesDisplayWindow(player, "MinigameSelect").buildWindow();
+        MinigameHandler.resetSettings(player);
+        new MinigamesDisplayWindow(player).buildWindow();
         return true;
     }
 

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

@@ -1,69 +0,0 @@
-package de.ventority.randomizedminigames.misc;
-
-import de.ventority.randomizedminigames.Minigames.Team;
-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<>();
-    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)) {
-            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 removeSelectionEntry(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);
-    }
-
-    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/GeneralSettings.java

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

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

@@ -7,6 +7,7 @@ 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;
 
 
@@ -15,8 +16,10 @@ import static org.bukkit.Bukkit.getServer;
 public class MinigameHandler {
     private static final List<MinigameBase> minigames = new ArrayList<>();
 
+    private static final HashMap<Player, Settings> settings = new HashMap<>();
+
     public static void createMinigame(int gameNumber, Player caller) {
-        List<Player> players = RandomizedMinigames.dataInputHandler.getSelectedPlayers(caller);
+        List<Player> players = settings.get(caller).getSelectedPlayers();
         switch (gameNumber) {
             case 0: minigames.add(new ForceItemBattle(players, caller)); break;
             case 1: minigames.add(new ForceItemBattleSameItems(players, caller)); break;
@@ -47,4 +50,14 @@ public class MinigameHandler {
         for (MinigameBase minigame : minigames)
             minigame.killGame();
     }
+
+    public static Settings getSettings(Player player) {
+        if (!settings.containsKey(player))
+            settings.put(player, new Settings(player));
+        return settings.get(player);
+    }
+
+    public static void resetSettings(Player player) {
+        settings.put(player, new Settings(player));
+    }
 }

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

@@ -0,0 +1,61 @@
+package de.ventority.randomizedminigames.misc;
+
+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 List<Player> selectedPlayers = new ArrayList<>();
+    int selectedMinigame;
+    int selectedLimit = 10;
+    List<Team> teams = new ArrayList<>();
+    boolean showScoreboard = true;
+
+    public Settings(Player owner) {
+        this.owner = owner;
+    }
+
+    public void switchScoreboard() {
+        showScoreboard = !showScoreboard;
+    }
+
+    public boolean getScoreboardStatus() {
+        return showScoreboard;
+    }
+
+    public List<Player> getSelectedPlayers() {
+        return selectedPlayers;
+    }
+
+    public void addPlayersToSelection(Player toAdd) {
+        System.out.println(toAdd.getName());
+        selectedPlayers.add(toAdd);
+    }
+
+    public void removePlayersFromSelection(Player toRemove) {
+        selectedPlayers.remove(toRemove);
+    }
+
+    public int getSelectedMinigame() {
+        return selectedMinigame;
+    }
+
+    public void selectMinigame(int minigame) {
+        selectedMinigame = minigame;
+    }
+
+    public int getSelectedLimit() {
+        return selectedLimit;
+    }
+
+    public void addToSelectedLimit() {
+        selectedLimit++;
+    }
+
+    public void subFromSelectedLimit() {
+        selectedLimit--;
+    }
+}