i'm very eepy, but it compiles and works normally if you don't interact with the group system uwu

src/main/java/de/lunarakai/minecleaner/ArenaList.java

@@ -2,11 +2,10 @@ package de.lunarakai.minecleaner;
 
 import java.io.File;
 import java.io.IOException;
-import java.util.Arrays;
+import java.util.*;
-import java.util.Collection;
-import java.util.HashMap;
-import java.util.UUID;
 import java.util.logging.Level;
+
+import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.block.Block;
 import org.bukkit.configuration.ConfigurationSection;
@@ -119,17 +118,37 @@ public class ArenaList {
         }
     }
 
-    public MinecleanerArena getPlayersArena(Player[] players) {
+    public MinecleanerArena getPlayerArena(Player player) {
-        MinecleanerArena[] arenas = new MinecleanerArena[players.length];
+        int arraySize = plugin.getGroupManager().getGroup(player) != null ? plugin.getGroupManager().getGroup(player).getPlayers().size() : 1;
-        for(int i = 0; i < players.length; i++) {
+        Player[] players = new Player[arraySize];
-            arenas[i] = playersInArena.get(players[i].getUniqueId());
+
-        }
+        if(plugin.getGroupManager().getGroup(player) != null) {
-        boolean match = Arrays.stream(arenas).allMatch(s -> s.equals(arenas[0]));
+            for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
-        if(match) {
+                Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
-            return arenas[0];
+                Arrays.fill(players, iteratorPlayer);
+            }
         } else {
-            return null;
+            Arrays.fill(players, player);
         }
+        return getPlayerArena(players);
+    }
+
+    public MinecleanerArena getPlayerArena(Player[] players) {
+        if(plugin.getGroupManager().getGroup(players[0]) != null) {
+            MinecleanerArena[] arenas = new MinecleanerArena[players.length];
+            for(int i = 0; i < players.length; i++) {
+                arenas[i] = playersInArena.get(players[i].getUniqueId());
+            }
+            boolean match = Arrays.stream(arenas).allMatch(s -> s.equals(arenas[0]));
+            if(match) {
+                return arenas[0];
+            } else {
+                return null;
+            }
+        } else {
+            return playersInArena.get(players[0].getUniqueId());
+        }
+
     }
 
     public MinecleanerArena getArenaAtBlock(Block block) {
@@ -142,7 +161,7 @@ public class ArenaList {
 
     public void removeArena(MinecleanerArena arena) {
         if(arena.hasPlayers()) {
-            plugin.getManager().leaveArena(arena.getCurrentPlayers(), true);
+            plugin.getManager().leaveArena(arena.getCurrentPlayers(), true, true);
         }
         
         for(UUID id : arena.getBlockDisplays()) {

src/main/java/de/lunarakai/minecleaner/MinecleanerGroup.java

@@ -1,74 +0,0 @@
-package de.lunarakai.minecleaner;
-
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.UUID;
-
-public class MinecleanerGroup {
-    private final Player groupCreator;
-    private final ArrayList<UUID> groups;
-    private final HashMap<UUID, UUID> playerGroupMap;
-    private final HashMap<UUID, UUID> invitedPlayerGroupMap;
-
-    private int groupSize;
-
-    public MinecleanerGroup() {
-        this.groupCreator = null;
-        this.groups = new ArrayList<>();
-        this.playerGroupMap = new HashMap<>();
-        this.invitedPlayerGroupMap = new HashMap<>();
-    }
-
-    public void createGroup(Player player) {
-        UUID groupUUID = UUID.randomUUID();
-        groups.add(groupUUID);
-        playerGroupMap.put(player.getUniqueId(), groupUUID);
-        groupSize++;
-    }
-
-    private void deleteGroup(UUID groupUUID) {
-        groups.remove(groupUUID);
-    }
-
-    public void addPlayerToGroup(Player player) {
-
-    }
-
-    public void invitePlayerToGroup(UUID groupUUID, Player player) {
-        invitedPlayerGroupMap.put(groupUUID, player.getUniqueId());
-        player.sendMessage("You have been invited. :)");
-    }
-
-    private void removePlayerFromGroup(Player player) {
-        playerGroupMap.remove(player.getUniqueId());
-    }
-
-    public void removePlayerFromInvitedMap(UUID playerUUID) {
-        invitedPlayerGroupMap.remove(playerUUID);
-    }
-
-    public UUID getGroupUUID(Player player) {
-        return playerGroupMap.get(player.getUniqueId());
-    }
-
-    public MinecleanerGroup getGroup(Player player) {
-        return
-    }
-
-    public Player getGroupCreator(UUID groupUUID) {
-        return groupCreator;
-    }
-    public boolean isInGroup(Player player) {
-        // TODO
-    }
-
-    public boolean isInvited(Player player) {
-        return invitedPlayerGroupMap.containsKey(player.getUniqueId());
-    }
-
-    public int getGroupSize() {
-        return groupSize;
-    }
-}

src/main/java/de/lunarakai/minecleaner/MinecleanerGroupManager.java

@@ -0,0 +1,137 @@
+package de.lunarakai.minecleaner;
+
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+
+public class MinecleanerGroupManager {
+
+    public class MinecleanerGroup {
+
+        public UUID owner;
+        public HashSet<UUID> players;
+        public Set<UUID> invitedPlayers;
+
+        public MinecleanerGroup(UUID owner){
+            this.owner = owner;
+            this.players = new HashSet<>();
+            this.invitedPlayers = new HashSet<>();
+        }
+
+        public UUID getOwner() {
+            return owner;
+        }
+
+        public Set<UUID> getInvitedPlayers() {
+            return invitedPlayers;
+        }
+
+        public HashSet<UUID> getPlayers() {
+            return players;
+        }
+
+        public void addPlayerToGroup(Player player) {
+            UUID playerUUID = player.getUniqueId();
+
+            if(!isPlayerInvited(playerUUID)) {
+                return;
+            }
+
+            invitedPlayers.remove(playerUUID);
+            players.add(playerUUID);
+        }
+
+        public void removePlayerFromGroup(Player player) {
+            UUID playerUUID = player.getUniqueId();
+            if(getOwner() == playerUUID) {
+                for(Iterator<UUID> iterator = getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+                    if(getOwner() == iterator.next()) {
+                        continue;
+                    }
+                    Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                    iteratorPlayer.sendMessage(Component.text("Die Gruppe wurde aufgelöst, da die Person, welche die Gruppe erstellt hat, aus der Gruppe entfernt wurde.", NamedTextColor.YELLOW));
+
+                }
+                deleteGroup(getGroup(Bukkit.getPlayer(owner)));
+            }
+            players.remove(playerUUID);
+            if(players.size() < 2) {
+                Bukkit.getPlayer(owner).sendMessage(Component.text("Die Gruppe wurde aufgelöst, da du nur noch alleine in der Gruppe bist", NamedTextColor.YELLOW));
+                deleteGroup(getGroup(Bukkit.getPlayer(owner)));
+            }
+        }
+
+        public boolean isPlayerInvited(UUID playerUUID) {
+            return invitedPlayers.contains(playerUUID);
+        }
+
+        public boolean isInGroup(UUID playerUUID) {
+            return players.contains(playerUUID) || owner.equals(playerUUID);
+        }
+
+        public boolean invitePlayerToGroup(Player player) {
+            UUID playerUUID = player.getUniqueId();
+            if(isPlayerInvited(playerUUID) || isInGroup(playerUUID))
+                return false;
+
+            invitedPlayers.add(player.getUniqueId());
+            return true;
+        }
+
+        public void removePlayerFromInvitedList(Player player) {
+            UUID playerUUID = player.getUniqueId();
+            if(!isPlayerInvited(playerUUID)) {
+                return;
+            }
+            invitedPlayers.remove(playerUUID);
+        }
+    }
+
+    private final UUID groupCreator;
+    private final Set<MinecleanerGroup> groups;
+
+    public MinecleanerGroupManager() {
+        this.groupCreator = null;
+        this.groups = new HashSet<>();
+    }
+
+    public void createGroup(Player player) {
+
+        if (getGroup(player) != null) {
+            return;
+        }
+
+        groups.add(new MinecleanerGroup(player.getUniqueId()));
+    }
+
+    public MinecleanerGroup getGroup(Player player){
+        UUID playerUUID = player.getUniqueId();
+        for (MinecleanerGroup group : groups) {
+            if (group.isInGroup(playerUUID)) {
+                return group;
+            }
+        }
+        return null;
+    }
+
+    public MinecleanerGroup getInvitedGroup(Player player){
+        UUID playerUUID = player.getUniqueId();
+        for (MinecleanerGroup group : groups) {
+            if (group.isPlayerInvited(playerUUID)) {
+                return group;
+            }
+        }
+        return null;
+    }
+
+    private void deleteGroup(MinecleanerGroup minecleanerGroup) {
+        groups.remove(minecleanerGroup);
+    }
+
+    public void deleteAllGroups() {
+        groups.clear();
+    }
+}

src/main/java/de/lunarakai/minecleaner/MinecleanerListener.java

@@ -1,6 +1,11 @@
 package de.lunarakai.minecleaner;
 
+import java.sql.Array;
+import java.util.Arrays;
 import java.util.Iterator;
+import java.util.UUID;
+
+import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
@@ -34,7 +39,7 @@ public class MinecleanerListener implements Listener {
         if(e.getHand() != EquipmentSlot.HAND) return;
         if((e.getAction() == Action.LEFT_CLICK_BLOCK || e.getAction() == Action.RIGHT_CLICK_BLOCK)) {
             Block block = e.getClickedBlock();
-            MinecleanerArena arena = plugin.getArenaList().getPlayersArena(e.getPlayer());
+            MinecleanerArena arena = plugin.getArenaList().getPlayerArena(e.getPlayer());
             if(arena != null) {
                 e.setCancelled(true);
                 MinecleanerArena arenaClicked = plugin.getArenaList().getArenaAtBlock(block);
@@ -88,7 +93,7 @@ public class MinecleanerListener implements Listener {
                     }
                 } else if(arena.hasPlayers() && arena.getArenaStatus() == ArenaStatus.COMPLETED && !hasRightClicked && (plugin.getManager().getSettingsValue("allowmanualreset", e.getPlayer()) == 1)) {
                     plugin.getManager().getSchedulerGameOver().cancel();
-                    plugin.getManager().leaveArena(arenaClicked.getCurrentPlayers(), false);
+                    plugin.getManager().leaveArena(arenaClicked.getCurrentPlayers(), false, true);
                 }
             } else {
                 arena = plugin.getArenaList().getArenaAtBlock(block);
@@ -96,7 +101,18 @@ public class MinecleanerListener implements Listener {
                     e.setCancelled(true);
                     if(e.getHand() == EquipmentSlot.HAND) {
                         if(arena.getArenaStatus() == ArenaStatus.INACTIVE) {
-                            plugin.getManager().joinArena(e.getPlayer(), arena);
+                            int arraySize = plugin.getGroupManager().getGroup(e.getPlayer()) != null ? plugin.getGroupManager().getGroup(e.getPlayer()).getPlayers().size() : 1;
+                            Player[] players = new Player[arraySize];
+
+                            if(plugin.getGroupManager().getGroup(e.getPlayer()) != null) {
+                                for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(e.getPlayer()).getPlayers().iterator(); iterator.hasNext();) {
+                                    Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                                    Arrays.fill(players, iteratorPlayer);
+                                }
+                            } else {
+                                Arrays.fill(players, e.getPlayer());
+                            }
+                            plugin.getManager().joinArena(players, arena);
                         } else {
                             e.getPlayer().sendMessage(ChatColor.YELLOW + "Hier spielt schon jemand anderes");
                         }
@@ -116,7 +132,7 @@ public class MinecleanerListener implements Listener {
     @EventHandler
     public void onPlayerInventoryClick(InventoryClickEvent e) {
         if(e.getWhoClicked() instanceof Player player) {
-            MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
+            MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
             if(arena != null) {
                 if(e.getInventory().equals(plugin.getManager().getConfirmPlayingInventory())) {
                     e.setCancelled(true);
@@ -125,8 +141,8 @@ public class MinecleanerListener implements Listener {
                         boolean hasConfirmed = slot == 1 ? true : false;
                         if(hasConfirmed) {
                             Player[] players;
-                            if(MinecleanerGroup.isInGroup(player)) {
+                            if(plugin.getGroupManager().getGroup(player) != null) {
-                                players = new Player[MinecleanerGroup.getGroupSize()];
+                                players = new Player[plugin.getGroupManager().getGroup(player).getPlayers().size()];
                                 players[0] = player;
                             } else {
                                 players = new Player[1];
@@ -146,10 +162,21 @@ public class MinecleanerListener implements Listener {
     @EventHandler
     public void onPlayerInventoryClose(InventoryCloseEvent e) {
         if(e.getPlayer() instanceof Player player) {
-            MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
+            MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
             if(arena != null) {
                 if(arena.getArenaStatus() == ArenaStatus.CONFIRM_PLAYING && e.getInventory().equals(plugin.getManager().getConfirmPlayingInventory())) {
-                    plugin.getManager().leaveArena(player, false);
+                    int arraySize = plugin.getGroupManager().getGroup(player) != null ? plugin.getGroupManager().getGroup(player).getPlayers().size() : 1;
+                    Player[] players = new Player[arraySize];
+
+                    if(plugin.getGroupManager().getGroup(player) != null) {
+                        for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+                            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                            Arrays.fill(players, iteratorPlayer);
+                        }
+                    } else {
+                        Arrays.fill(players, player);
+                    }
+                    plugin.getManager().leaveArena(players, false, true);
                 }
             }
         }
@@ -158,20 +185,43 @@ public class MinecleanerListener implements Listener {
     @EventHandler
     public void onPlayerMove(PlayerMoveEvent e) {
         final Player player = e.getPlayer();
-        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
+        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
         if(arena != null) {
-            if(arena.isTooFarAway(player)) {
+            if(arena.isTooFarAway(player) && plugin.getGroupManager().getGroup(player) == null) {
                 player.sendMessage(ChatColor.YELLOW + "Du hast dich zu weit von der Arena entfernt. Das Spiel wurde abgebrochen.");
-                plugin.getManager().leaveArena(player, false);
+                Player[] players = new Player[] {
+                        player
+                };
+                plugin.getManager().leaveArena(players, false, true);
             }
         }
     }
 
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent e) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(e.getPlayer());
+        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(e.getPlayer());
         if(arena != null) {
-            plugin.getManager().leaveArena(e.getPlayer(), false);
+            if(plugin.getGroupManager().getGroup(e.getPlayer()) != null) {
+                if(plugin.getGroupManager().getGroup(e.getPlayer()).getOwner().equals(e.getPlayer())) {
+                    Player[] players = new Player[plugin.getGroupManager().getGroup(e.getPlayer()).getPlayers().size()];
+                    for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(e.getPlayer()).getPlayers().iterator(); iterator.hasNext();) {
+                        Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                        Arrays.fill(players, iteratorPlayer);
+                    }
+                    plugin.getManager().leaveArena(players, false, true);
+                    return;
+                }
+                Player[] players = new Player[] {
+                        e.getPlayer()
+                };
+                plugin.getGroupManager().getGroup(e.getPlayer()).removePlayerFromGroup(e.getPlayer());
+                plugin.getManager().leaveArena(players, false, false);
+            } else {
+                Player[] players = new Player[] {
+                        e.getPlayer()
+                };
+                plugin.getManager().leaveArena(players, false, true);
+            }
         }
     }
 

src/main/java/de/lunarakai/minecleaner/MinecleanerManager.java

@@ -133,31 +133,52 @@ public class MinecleanerManager {
         if (!players[0].hasPermission(MinecleanerPlugin.PERMISSION_PLAY)) {
             return;
         }
-        Preconditions.checkArgument(plugin.getArenaList().getPlayersArena(players) == null, "player is in an arena");
+        Preconditions.checkArgument(plugin.getArenaList().getPlayerArena(players) == null, "player is in an arena");
         Preconditions.checkArgument(arena.getArenaStatus() == ArenaStatus.INACTIVE, "arena is in use");
         arena.addJoiningPlayers(players);
         plugin.getArenaList().setArenaForPlayers(players, arena);
-        players[0].openInventory(confirmPlayingInventory);
-    }
-
-    public void leaveArena(Player[] players, boolean message) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(players);
-        arena.setArenaStaus(ArenaStatus.INACTIVE);
-        Preconditions.checkArgument(arena != null, "player is in no arena");
         for(int i = 0; i < players.length; i++) {
-            players[i].closeInventory();
+            if(plugin.getGroupManager().getGroup(players[i]) == null) {
-        }
+                players[i].openInventory(confirmPlayingInventory);
-        arena.removePlayers();
+                break;
-        plugin.getArenaList().setArenaForPlayers(players, null);
+            }
-        if(message) {
+            if(players[i] == Bukkit.getPlayer(plugin.getGroupManager().getGroup(players[i]).getOwner())) {
-            for(int i = 0; i < players.length; i++) {
+                players[i].openInventory(confirmPlayingInventory);
-                players[i].sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
             }
         }
     }
 
+    public void leaveArena(Player[] players, boolean message, boolean reset) {
+        MinecleanerGroupManager.MinecleanerGroup group = null;
+        MinecleanerArena arena;
+        if(plugin.getGroupManager().getGroup(players[0]) != null) {
+            group = plugin.getGroupManager().getGroup(players[0]);
+            arena = plugin.getArenaList().getPlayerArena(Objects.requireNonNull(Bukkit.getPlayer(group.getOwner())));
+        } else {
+            arena = plugin.getArenaList().getPlayerArena(players);
+        }
+
+        Preconditions.checkArgument(arena != null, "player is in no arena");
+
+        if(reset) {
+            arena.setArenaStaus(ArenaStatus.INACTIVE);
+            for(int i = 0; i < players.length; i++) {
+                players[i].closeInventory();
+            }
+            arena.removePlayers();
+            if(message) {
+                for(int i = 0; i < players.length; i++) {
+                    players[i].sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
+                }
+            }
+        }
+
+        plugin.getArenaList().setArenaForPlayers(players, null);
+    }
+
+
     public void startGame(Player[] players) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(players);
+        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(players);
         Preconditions.checkArgument(arena != null, "player is in no arena");
         Preconditions.checkState(arena.getArenaStatus() == ArenaStatus.CONFIRM_PLAYING, "not confirming playing status");
         arena.startNewGame();
@@ -167,30 +188,35 @@ public class MinecleanerManager {
 
     }
 
-    public void handleGameover(Player player, MinecleanerArena arena, boolean isSuccessfullyCleared) {
+    public void handleGameover(Player[] player, MinecleanerArena arena, boolean isSuccessfullyCleared) {
-        World world = player.getWorld();
+        if(plugin.getGroupManager().getGroup(player[0]) != null) {
+            // Todo
+            //  eigene Extra Punkte
+            return;
+        }
+        World world = player[0].getWorld();
         PlayerStatistics ps = null;
         StatisticKey sg = null;
         if(plugin.isStatisticsEnabled()) {
-            ps = plugin.getCubesideStatistics().getStatistics(player.getUniqueId());
+            ps = plugin.getCubesideStatistics().getStatistics(player[0].getUniqueId());
             sg = statisticsTotalGamesPlayed.get(arena.getWidthIndex());
         }
 
         if(!isSuccessfullyCleared) {
-            world.playSound(player.getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.5f, 0.5f);
+            world.playSound(player[0].getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.5f, 0.5f);
-            player.sendMessage(ChatColor.YELLOW + "Game Over! Du konntest das " + plugin.getDisplayedPluginName() + "-Feld nicht erfolgreich lösen!");
+            player[0].sendMessage(ChatColor.YELLOW + "Game Over! Du konntest das " + plugin.getDisplayedPluginName() + "-Feld nicht erfolgreich lösen!");
             arena.showMines();
             
             if(sg != null && plugin.isStatisticsEnabled()) {
                 ps.increaseScore(sg, 1);
             }
 
-            scheduleArenaReset(player, arena);
+            scheduleArenaReset(player[0], arena);
             return;
         }
         int millis = (int) (System.currentTimeMillis() - arena.getCurrentGameStartTime());
         
-        world.playSound(player.getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 0.5f);
+        world.playSound(player[0].getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 0.5f);
 
         if(sg != null && plugin.isStatisticsEnabled()) {
             ps.increaseScore(sg, 1);
@@ -207,9 +233,9 @@ public class MinecleanerManager {
             if(sg != null) {
                 ps.minScore(sg, millis, isUpdated -> {
                     if(isUpdated != null && isUpdated) {
-                        player.sendMessage(ChatColor.GOLD + "Herzlichen Glückwunsch! Du hast eine neue Bestzeit erreicht! " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) );
+                        player[0].sendMessage(ChatColor.GOLD + "Herzlichen Glückwunsch! Du hast eine neue Bestzeit erreicht! " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) );
                     } else {
-                        player.sendMessage(ChatColor.YELLOW + "Glückwunsch, du konntest das " + plugin.getDisplayedPluginName() + "-Feld in " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) + ChatColor.YELLOW + " erfolgreich lösen!");
+                        player[0].sendMessage(ChatColor.YELLOW + "Glückwunsch, du konntest das " + plugin.getDisplayedPluginName() + "-Feld in " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) + ChatColor.YELLOW + " erfolgreich lösen!");
                     }
                 });
             }
@@ -237,10 +263,10 @@ public class MinecleanerManager {
                 }
             }
         } else {
-            player.sendMessage(ChatColor.YELLOW + "Glückwunsch, du konntest das " + plugin.getDisplayedPluginName() + "-Feld in " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) + ChatColor.YELLOW + " erfolgreich lösen!");
+            player[0].sendMessage(ChatColor.YELLOW + "Glückwunsch, du konntest das " + plugin.getDisplayedPluginName() + "-Feld in " + ChatColor.RED + MinecleanerStringUtil.timeToString(millis, false) + ChatColor.YELLOW + " erfolgreich lösen!");
         }
 
-        scheduleArenaReset(player, arena);
+        scheduleArenaReset(player[0], arena);
     }
 
     private void scheduleArenaReset(Player player, MinecleanerArena arena) {
@@ -249,7 +275,17 @@ public class MinecleanerManager {
                 if (arena.getCurrentPlayers() == null) {
                     arena.removePlayers();
                 } else {
-                    leaveArena(player, false);
+                    int arraySize = plugin.getGroupManager().getGroup(player) != null ? plugin.getGroupManager().getGroup(player).getPlayers().size() : 1;
+                    Player[] players = new Player[arraySize];
+                    if(plugin.getGroupManager().getGroup(player) != null) {
+                        for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+                            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                            Arrays.fill(players, iteratorPlayer);
+                        }
+                    } else {
+                        Arrays.fill(players, player);
+                    }
+                    leaveArena(players, false, true);
                 }
             }
         }, plugin.getManager().getSettingsValue("resettime", player) * 20L);
@@ -258,14 +294,13 @@ public class MinecleanerManager {
     public void clearAllArenas() {
         for(MinecleanerArena arena : plugin.getArenaList().getArenas()) {
             if(arena.hasPlayers()) {
-                leaveArena(arena.getCurrentPlayers(), true);
+                leaveArena(arena.getCurrentPlayers(), true, true);
             }
         }
     }
 
-
     public void handleFieldClick(@NotNull Player player, int x, int y, boolean hasRightClicked) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
+        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
         Preconditions.checkArgument(arena != null, "player is in no arena");
         Preconditions.checkState(arena.getArenaStatus() == ArenaStatus.PLAYING, "not running");
 

src/main/java/de/lunarakai/minecleaner/MinecleanerPlugin.java

@@ -25,6 +25,7 @@ public final class MinecleanerPlugin extends JavaPlugin {
     public static final String PERMISSION_ADMIN = "minecleaner.admin";
 
     private MinecleanerManager minecleanerManager;
+    private MinecleanerGroupManager minecleanerGroupManager;
     private ArenaList arenaList;
     private CubesideStatisticsAPI cubesideStatistics;
     private PlayerUUIDCache playerUUIDCache;
@@ -64,6 +65,7 @@ public final class MinecleanerPlugin extends JavaPlugin {
         arenaList.load();
 
         minecleanerManager = new MinecleanerManager(this);
+        minecleanerGroupManager = new MinecleanerGroupManager();
         getServer().getPluginManager().registerEvents(new MinecleanerListener(this), this);
 
         CommandRouter minecleanerCommand = new CommandRouter(getCommand("minecleaner"));
@@ -84,6 +86,9 @@ public final class MinecleanerPlugin extends JavaPlugin {
         if(minecleanerManager != null) {
             minecleanerManager.clearAllArenas();
         }
+        if(minecleanerGroupManager != null) {
+            minecleanerGroupManager.deleteAllGroups();
+        }
     }
 
     public ArenaList getArenaList() {
@@ -94,6 +99,8 @@ public final class MinecleanerPlugin extends JavaPlugin {
         return minecleanerManager;
     }
 
+    public MinecleanerGroupManager getGroupManager() { return minecleanerGroupManager; }
+
     public boolean isStatisticsEnabled() {
         return cubesideStatistics != null;
     }

src/main/java/de/lunarakai/minecleaner/MinecleanerSettingsInventory.java

@@ -100,7 +100,7 @@ public class MinecleanerSettingsInventory extends AbstractWindow {
                 if(plugin.getManager().getSettingsValue("timer", player) == 0) {
                     plugin.getManager().updateSettingsValue("timer", 1, player);
                 } else {
-                    MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
+                    MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
                     plugin.getManager().updateSettingsValue("timer", 0, player);
                     if(arena != null) {
                         arena.updateIngameInfoTexts();

src/main/java/de/lunarakai/minecleaner/commands/DenyCommand.java

@@ -1,14 +0,0 @@
-package de.lunarakai.minecleaner.commands;
-
-import de.iani.cubesideutils.bukkit.commands.SubCommand;
-import de.iani.cubesideutils.bukkit.commands.exceptions.*;
-import de.iani.cubesideutils.commands.ArgsParser;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-
-public class DenyCommand extends SubCommand {
-    @Override
-    public boolean onCommand(CommandSender commandSender, Command command, String s, String s1, ArgsParser argsParser) throws DisallowsCommandBlockException, RequiresPlayerException, NoPermissionException, IllegalSyntaxException, InternalCommandException {
-        return false;
-    }
-}

src/main/java/de/lunarakai/minecleaner/commands/groups/AcceptCommand.java

@@ -1,18 +1,16 @@
-package de.lunarakai.minecleaner.commands;
+package de.lunarakai.minecleaner.commands.groups;
 
 import de.iani.cubesideutils.bukkit.commands.SubCommand;
 import de.iani.cubesideutils.bukkit.commands.exceptions.*;
 import de.iani.cubesideutils.commands.ArgsParser;
-import de.lunarakai.minecleaner.MinecleanerGroup;
 import de.lunarakai.minecleaner.MinecleanerPlugin;
 import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
-import java.util.HashMap;
-import java.util.UUID;
-
 public class AcceptCommand extends SubCommand {
     private final MinecleanerPlugin plugin;
 
@@ -39,12 +37,18 @@ public class AcceptCommand extends SubCommand {
     public boolean onCommand(CommandSender commandSender, Command command, String s, String s1, ArgsParser argsParser) throws DisallowsCommandBlockException, RequiresPlayerException, NoPermissionException, IllegalSyntaxException, InternalCommandException {
         Player player = (Player) commandSender;
 
-        if() {
+        if(plugin.getGroupManager().getInvitedGroup(player) != null && plugin.getGroupManager().getGroup(player) == null) {
-            UUID groupUUID = invitedPlayersHashMap.get(player.getUniqueId());
+            Player groupOwner = Bukkit.getPlayer(plugin.getGroupManager().getInvitedGroup(player).getOwner());
+            plugin.getGroupManager().getInvitedGroup(player).addPlayerToGroup(player);
 
+            assert groupOwner != null;
+            groupOwner.sendMessage(Component.text(player.getName() + " hat deine Einladung angenommen.", NamedTextColor.GREEN));
+            player.sendMessage(Component.text("Du hast die Einladung angenommen", NamedTextColor.GREEN));
+
+            return true;
         } else {
-            player.sendMessage(Component.text("Du wurdest in keine Gruppe eingeladen."));
+            player.sendMessage(Component.text("Du wurdest in keine Gruppe eingeladen.", NamedTextColor.YELLOW));
         }
-        return false;
+        return true;
     }
 }

src/main/java/de/lunarakai/minecleaner/commands/groups/DenyCommand.java

@@ -0,0 +1,56 @@
+package de.lunarakai.minecleaner.commands.groups;
+
+import de.iani.cubesideutils.bukkit.commands.SubCommand;
+import de.iani.cubesideutils.bukkit.commands.exceptions.*;
+import de.iani.cubesideutils.commands.ArgsParser;
+import de.lunarakai.minecleaner.MinecleanerPlugin;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+public class DenyCommand extends SubCommand {
+
+    private final MinecleanerPlugin plugin;
+
+    public DenyCommand(MinecleanerPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public String getUsage() {
+        return "";
+    }
+
+    @Override
+    public boolean requiresPlayer() {
+        return true;
+    }
+
+    @Override
+    public String getRequiredPermission() {
+        return MinecleanerPlugin.PERMISSION_PLAY;
+    }
+
+
+    @Override
+    public boolean onCommand(CommandSender commandSender, Command command, String s, String s1, ArgsParser argsParser) throws DisallowsCommandBlockException, RequiresPlayerException, NoPermissionException, IllegalSyntaxException, InternalCommandException {
+        Player player = (Player) commandSender;
+
+        if(plugin.getGroupManager().getInvitedGroup(player) != null && plugin.getGroupManager().getGroup(player) == null) {
+            Player groupOwner = Bukkit.getPlayer(plugin.getGroupManager().getInvitedGroup(player).getOwner());
+            plugin.getGroupManager().getInvitedGroup(player).removePlayerFromInvitedList(player);
+
+            assert groupOwner != null;
+            groupOwner.sendMessage(Component.text(player.getName() + " hat deine Einladung abgelehnt.", NamedTextColor.RED));
+            player.sendMessage(Component.text("Du hast die Einladung abgelehnt", NamedTextColor.YELLOW));
+
+            return true;
+        } else {
+            player.sendMessage(Component.text("Du wurdest in keine Gruppe eingeladen.", NamedTextColor.YELLOW));
+        }
+        return true;
+    }
+}

src/main/java/de/lunarakai/minecleaner/commands/groups/InviteCommand.java

@@ -1,17 +1,17 @@
-package de.lunarakai.minecleaner.commands;
+package de.lunarakai.minecleaner.commands.groups;
 
 import de.iani.cubesideutils.bukkit.commands.SubCommand;
 import de.iani.cubesideutils.bukkit.commands.exceptions.*;
 import de.iani.cubesideutils.commands.ArgsParser;
-import de.lunarakai.minecleaner.MinecleanerGroup;
+import de.lunarakai.minecleaner.MinecleanerGroupManager;
 import de.lunarakai.minecleaner.MinecleanerPlugin;
-import net.md_5.bungee.api.ChatColor;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
 
-import java.util.UUID;
-
 public class InviteCommand extends SubCommand {
     /*
         TODO:
@@ -45,18 +45,30 @@ public class InviteCommand extends SubCommand {
     public boolean onCommand(CommandSender sender, Command command, String s, String commandString, ArgsParser args) throws DisallowsCommandBlockException, RequiresPlayerException, NoPermissionException, IllegalSyntaxException, InternalCommandException {
         Player player = (Player) sender;
         if(args.remaining() < 1 || args.remaining() >= 2) {
-            sender.sendMessage(ChatColor.DARK_RED + commandString + getUsage());
+            sender.sendMessage(Component.text(commandString + getUsage(), NamedTextColor.DARK_RED));
             return true;
         }
         String playerName = args.getNext().trim();
         Player invitedPlayer = plugin.getServer().getPlayer(playerName);
 
-        MinecleanerGroup group = new MinecleanerGroup();
+        MinecleanerGroupManager groupManager = plugin.getGroupManager();
-        group.createGroup(player);
+        if(groupManager.getInvitedGroup(player) != null) {
-        UUID groupUUID = group.getGroupUUID(player);
+            player.sendMessage(Component.text("Du wurdest bereits in eine Gruppe eingeladen. Bitte kümmere dich zuerst um die Einladung bevor du eine eigene Gruppe erstellst.", NamedTextColor.YELLOW));
+            return true;
+        }
 
-        group.invitePlayerToGroup(groupUUID, invitedPlayer);
+        if(groupManager.getGroup(player) != null && Bukkit.getPlayer(groupManager.getGroup(player).getOwner()).equals(player)) {
+            player.sendMessage(Component.text("Nur als Ersteller der Gruppe bist du berechtigt Leute einzuladen.", NamedTextColor.YELLOW));
+            return true;
+        }
 
-        return false;
+        if(groupManager.getGroup(player) == null) {
+            groupManager.createGroup(player);
+        }
+
+        assert invitedPlayer != null;
+        groupManager.getGroup(player).invitePlayerToGroup(invitedPlayer);
+
+        return true;
     }
 }