Merge branch “duo_mode”

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

@@ -2,10 +2,13 @@ package de.lunarakai.minecleaner;
 
 import java.io.File;
 import java.io.IOException;
+import java.util.Arrays;
 import java.util.Collection;
 import java.util.HashMap;
+import java.util.Iterator;
 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;
@@ -106,16 +109,74 @@ public class ArenaList {
         return false;
     }
 
-    public void setArenaForPlayer(Player player, MinecleanerArena arena) {
+    public void setArenaForPlayers(Player[] players, MinecleanerArena arena) {
         if(arena != null) {
-            playersInArena.put(player.getUniqueId(), arena);
+            for(int i = 0; i < players.length; i++) {
+                playersInArena.put(players[i].getUniqueId(), arena);
+            }
         } else {
-            playersInArena.remove(player.getUniqueId());
+            for(int i = 0; i < players.length; i++) {
+                playersInArena.remove(players[i].getUniqueId());
+            }
         }
     }
 
     public MinecleanerArena getPlayerArena(Player player) {
-        return playersInArena.get(player.getUniqueId());
+        if(playersInArena.get(player.getUniqueId()) == null) {
+            return null;
+        }
+        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) {
+            int i = 0;
+            for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+                Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                players[i] = iteratorPlayer;
+                i++;
+            }
+        } else {
+            Arrays.fill(players, player);
+        }
+        return getPlayerArena(players);
+    }
+
+    public MinecleanerArena getPlayerArena(Player[] players) {
+        return playersInArena.get(players[0].getUniqueId());
+//        if(plugin.getGroupManager().getGroup(players[0]) != null) {
+//            if(players.length == 1) {
+//                return null;
+//            }
+//            MinecleanerArena[] arenas = new MinecleanerArena[players.length];
+//            for(int i = 0; i < players.length; i++) {
+//                if(playersInArena.get(players[i].getUniqueId()) != null) {
+//                    if(playersInArena.get(Bukkit.getPlayer(plugin.getGroupManager().getGroup(players[0]).getOwner()).getUniqueId()) != null)  {
+//                        arenas[i] = playersInArena.get(players[i].getUniqueId());
+//                        continue;
+//                    }
+//                    arenas[i] = null;
+//                } else {
+//                    arenas = null;
+//                }
+//            }
+//            if(playersInArena.get(players[0].getUniqueId()) == null)  {
+//                return null;
+//            }
+//
+//            if(arenas != null && arenas[0] != null) {
+//                MinecleanerArena[] finalArenas = arenas;
+//                boolean match = Arrays.stream(arenas).allMatch(s -> s.equals(finalArenas[0]));
+//                if(match) {
+//                    return arenas[0];
+//                } else {
+//                    return null;
+//                }
+//            }
+//            return null;
+//
+//        } else {
+//            return playersInArena.get(players[0].getUniqueId());
+//        }
     }
 
     public MinecleanerArena getArenaAtBlock(Block block) {
@@ -127,8 +188,8 @@ public class ArenaList {
     }
 
     public void removeArena(MinecleanerArena arena) {
-        if(arena.hasPlayer()) {
-            plugin.getManager().leaveArena(arena.getCurrentPlayer(), true);
+        if(arena.hasPlayers()) {
+            plugin.getManager().leaveArena(arena.getCurrentPlayers(), true, true);
         }
         
         for(UUID id : arena.getBlockDisplays()) {

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

@@ -43,7 +43,7 @@ public class MinecleanerArena {
     private TextDisplay textDisplay;
     private boolean hasMadeFirstClick = false;
     private int flagsPlaced = 0;
-    private Player currentPlayer;
+    private Player[] currentPlayers;
     private long currentGameStartTime;
     private long ingameTime;
     private Game currentMinecleanerGame;
@@ -235,13 +235,13 @@ public class MinecleanerArena {
         new BukkitRunnable() {
             @Override
                 public void run() {
-                if(arenaStatus == ArenaStatus.PLAYING && currentPlayer != null) {
+                if(arenaStatus == ArenaStatus.PLAYING && currentPlayers != null) {
                     if(!currentMinecleanerGame.gameover) {
                         ingameTime++;
                     }
                     if(plugin.isStatisticsEnabled()) {
-                        if(plugin.getManager().getSettingsValue("additionaldisplay", currentPlayer) != 0
-                                || plugin.getManager().getSettingsValue("timer", currentPlayer) != 0) {
+                        if(plugin.getManager().getSettingsValue("additionaldisplay", currentPlayers[0]) != 0
+                                || plugin.getManager().getSettingsValue("timer", currentPlayers[0]) != 0) {
                             updateIngameInfoTexts();
                         }
                     }
@@ -254,19 +254,19 @@ public class MinecleanerArena {
 
     }
 
-    public void addJoiningPlayer(Player player) {
-        Preconditions.checkNotNull(player);
+    public void addJoiningPlayers(Player[] players) {
+        Preconditions.checkNotNull(players);
         Preconditions.checkState(arenaStatus == ArenaStatus.INACTIVE);
         this.arenaStatus = ArenaStatus.CONFIRM_PLAYING;
-        this.currentPlayer = player;
+        this.currentPlayers = players;
     }
 
-    public void removePlayer() {
+    public void removePlayers() {
         int sizeWidth = BoardSize.boardSizesWidth[widthIndex];
         int sizeHeight = BoardSize.boardSizesHeight[widthIndex];
 
         this.arenaStatus = ArenaStatus.INACTIVE;
-        this.currentPlayer = null;
+        this.currentPlayers = null;
         this.currentMinecleanerGame = null;
 
         // load chunk of block -1 and x+1
@@ -382,8 +382,8 @@ public class MinecleanerArena {
     }
 
     private void showTextDisplay() {
-        Player player = this.getCurrentPlayer();
-        World world = player.getWorld();
+        Player[] players = this.getCurrentPlayers();
+        World world = players[0].getWorld();
 
         double textCenterX = centerLocation.getX();
         double textCenterY = centerLocation.getY() + ((double) BoardSize.boardSizesHeight[widthIndex] / 3 - 2.75 - widthIndex);
@@ -417,7 +417,7 @@ public class MinecleanerArena {
             }
         }
 
-        Location textDisplayLocation = new Location(player.getWorld(), textCenterX, textCenterY, textCenterZ);
+        Location textDisplayLocation = new Location(players[0].getWorld(), textCenterX, textCenterY, textCenterZ);
 
         textDisplay = world.spawn(textDisplayLocation.add(-1, 2 + widthIndex, -0.25), TextDisplay.class, textdisplay -> {
             Transformation transformation = textdisplay.getTransformation();
@@ -445,12 +445,14 @@ public class MinecleanerArena {
     public void updateIngameInfoTexts() {
         String timer = "";
         if(plugin.isStatisticsEnabled()) {
-            if(plugin.getManager().getSettingsValue("timer", currentPlayer) != 0) {
+            if(plugin.getManager().getSettingsValue("timer", currentPlayers[0]) != 0) {
                 timer = ChatColor.GOLD + " Zeit: " + MinecleanerStringUtil.timeToString((ingameTime/20)*1000, true)  + " ";
             }
-            if(plugin.getManager().getSettingsValue("additionaldisplay", currentPlayer) != 0 && plugin.isStatisticsEnabled()) {
+            if(plugin.getManager().getSettingsValue("additionaldisplay", currentPlayers[0]) != 0 && plugin.isStatisticsEnabled()) {
                 String componentActionBar = ChatColor.GREEN + "Flaggen gesetzt: " + flagsPlaced + ChatColor.RED + "  Minen insgesamt: " + BoardSize.mineCounter[widthIndex];
-                currentPlayer.sendActionBar(Component.text(componentActionBar + " " + timer));
+                for(int i = 0; i < currentPlayers.length; i++) {
+                    currentPlayers[i].sendActionBar(Component.text(componentActionBar + " " + timer));
+                }
             }
         }
 
@@ -495,7 +497,7 @@ public class MinecleanerArena {
         if (currentMinecleanerGame != null && !currentMinecleanerGame.gameover) {
             Cell cell = currentMinecleanerGame.getCell(x, y);
             if (!cell.isRevealed()) {
-                Player player = this.currentPlayer;
+                Player[] players = this.currentPlayers;
 
                 currentMinecleanerGame.flag(x, y);
                 if (currentMinecleanerGame.gameover) {
@@ -503,7 +505,7 @@ public class MinecleanerArena {
                          arenaStatus = ArenaStatus.COMPLETED;
                     }, 5L);
 
-                    plugin.getManager().handleGameover(player, this, true);
+                    plugin.getManager().handleGameover(players, this, true);
                 }
                 if (cell.isFlagged() == true) {
                     flagsPlaced = flagsPlaced + 1;
@@ -523,7 +525,7 @@ public class MinecleanerArena {
         if (currentMinecleanerGame != null && !currentMinecleanerGame.gameover) {
             Cell cell = currentMinecleanerGame.getCell(x, y);
             if (!cell.isFlagged()) {
-                Player player = this.currentPlayer;
+                Player[] players = this.currentPlayers;
 
                 if (!hasMadeFirstClick) {
                     currentMinecleanerGame.firstClick(x, y);
@@ -537,7 +539,7 @@ public class MinecleanerArena {
                     Bukkit.getScheduler().runTaskLater(plugin, () -> {
                         arenaStatus = ArenaStatus.COMPLETED;
                     }, 5L);
-                    plugin.getManager().handleGameover(player, this, !(cell.isRevealed() && cell.isExploded()));
+                    plugin.getManager().handleGameover(players, this, !(cell.isRevealed() && cell.isExploded()));
                 } else {
                     updateIngameInfoTexts();
                 }
@@ -692,12 +694,12 @@ public class MinecleanerArena {
         return name;
     }
 
-    public boolean hasPlayer() {
-        return currentPlayer != null;
+    public boolean hasPlayers() {
+        return currentPlayers != null;
     }
 
-    public Player getCurrentPlayer() {
-        return currentPlayer;
+    public Player[] getCurrentPlayers() {
+        return currentPlayers;
     }
 
     public Location getLocation() {

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

@@ -0,0 +1,138 @@
+package de.lunarakai.minecleaner;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+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<>();
+
+            players.add(owner);
+        }
+
+        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 Set<MinecleanerGroup> groups;
+
+    public MinecleanerGroupManager() {
+        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;
+    }
+
+    public 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.util.Arrays;
 import java.util.Iterator;
+import java.util.UUID;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
@@ -86,9 +91,9 @@ public class MinecleanerListener implements Listener {
                             }
                         }
                     }
-                } else if(arena.hasPlayer() && arena.getArenaStatus() == ArenaStatus.COMPLETED && !hasRightClicked && (plugin.getManager().getSettingsValue("allowmanualreset", e.getPlayer()) == 1)) {
+                } else if(arena.hasPlayers() && arena.getArenaStatus() == ArenaStatus.COMPLETED && !hasRightClicked && (plugin.getManager().getSettingsValue("allowmanualreset", e.getPlayer()) == 1)) {
                     plugin.getManager().getSchedulerGameOver().cancel();
-                    plugin.getManager().leaveArena(arenaClicked.getCurrentPlayer(), false);
+                    plugin.getManager().leaveArena(arenaClicked.getCurrentPlayers(), false, true);
                 }
             } else {
                 arena = plugin.getArenaList().getArenaAtBlock(block);
@@ -96,7 +101,23 @@ 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 = 1;
+                            if(plugin.getGroupManager().getGroup(e.getPlayer()) != null) {
+                                arraySize = plugin.getGroupManager().getGroup(e.getPlayer()).getPlayers().size();
+                            }
+                            Player[] players = new Player[arraySize];
+
+                            if(plugin.getGroupManager().getGroup(e.getPlayer()) != null) {
+                                int i = 0;
+                                for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(e.getPlayer()).getPlayers().iterator(); iterator.hasNext();) {
+                                    Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                                    players[i] = iteratorPlayer;
+                                    i++;
+                                }
+                            } else {
+                                Arrays.fill(players, e.getPlayer());
+                            }
+                            plugin.getManager().joinArena(players, arena);
                         } else {
                             e.getPlayer().sendMessage(ChatColor.YELLOW + "Hier spielt schon jemand anderes");
                         }
@@ -124,7 +145,16 @@ public class MinecleanerListener implements Listener {
                         int slot = e.getRawSlot();
                         boolean hasConfirmed = slot == 1 ? true : false;
                         if(hasConfirmed) {
-                            plugin.getManager().startGame(player);
+                            Player[] players;
+                            if(plugin.getGroupManager().getGroup(player) != null) {
+                                players = new Player[plugin.getGroupManager().getGroup(player).getPlayers().size()];
+                                players[0] = player;
+                            } else {
+                                players = new Player[1];
+                                players[0] = player;
+                            }
+                            plugin.getManager().startGame(players);
+
                             //player.closeInventory();
                         }
                         player.closeInventory();
@@ -140,7 +170,18 @@ public class MinecleanerListener implements Listener {
             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);
                 }
             }
         }
@@ -151,21 +192,106 @@ public class MinecleanerListener implements Listener {
         final Player player = e.getPlayer();
         MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
         if(arena != null) {
-            if(arena.isTooFarAway(player)) {
-                player.sendMessage(ChatColor.YELLOW + "Du hast dich zu weit von der Arena entfernt. Das Spiel wurde abgebrochen.");
-                plugin.getManager().leaveArena(player, false);
+            if(plugin.getGroupManager().getGroup(player) == null) {
+                if((arena.isTooFarAway(player))) {
+                    player.sendMessage(ChatColor.YELLOW + "Du hast dich zu weit von der Arena entfernt. Das Spiel wurde abgebrochen.");
+                    Player[] players = new Player[] {
+                            player
+                    };
+                    plugin.getManager().leaveArena(players, false, true);
+                }
+            } else {
+                Player ownerPlayer = Bukkit.getPlayer(plugin.getGroupManager().getGroup(player).getOwner());
+                if(ownerPlayer.equals(player)) {
+                    if(arena.isTooFarAway(ownerPlayer)) {
+
+                        for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+                            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                            if(iteratorPlayer == ownerPlayer) {
+                                iteratorPlayer.sendMessage(Component.text("Du hast dich zu weit von der Arena entfernt. Das Spiel wurde abgebrochen.", NamedTextColor.YELLOW));
+                                continue;
+                            }
+                            assert iteratorPlayer != null;
+                            iteratorPlayer.sendMessage(Component.text("Der Ersteller der Gruppe hat sich zu weit von der Arena entfernt. Das Spiel wurde abgebrochen.", NamedTextColor.YELLOW));
+                        }
+                        Player[] players = new Player[] {
+                                ownerPlayer
+                        };
+                        plugin.getManager().leaveArena(players, false, true);
+                    }
+                }
             }
         }
     }
 
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent e) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(e.getPlayer());
+        Player player = e.getPlayer();
+        MinecleanerGroupManager groupManager = plugin.getGroupManager();
+        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+
         if(arena != null) {
-            plugin.getManager().leaveArena(e.getPlayer(), false);
+            if(groupManager.getGroup(player) != null) {
+                MinecleanerGroupManager.MinecleanerGroup group = groupManager.getGroup(player);
+                Player ownerPlayer = Bukkit.getPlayer(group.getOwner());
+                if(player == ownerPlayer) {
+                    Player[] players = iterateOverGroupMembersOnCreatorPlayerQuit(player, groupManager, group);
+                    plugin.getManager().leaveArena(players, false, true);
+                } else {
+                    iterateOverGroupMembersOnPlayerQuit(player, group);
+                }
+            } else {
+                Player[] players = new Player[] {
+                        e.getPlayer()
+                };
+                plugin.getManager().leaveArena(players, false, true);
+            }
+        } else  {
+            if(groupManager.getGroup(player) != null) {
+                MinecleanerGroupManager.MinecleanerGroup group = groupManager.getGroup(player);
+                Player ownerPlayer = Bukkit.getPlayer(group.getOwner());
+                if(player == ownerPlayer) {
+                    iterateOverGroupMembersOnCreatorPlayerQuit(player, groupManager, group);
+                } else {
+                    iterateOverGroupMembersOnPlayerQuit(player, group);
+                }
+            } else {
+                return;
+            }
         }
     }
 
+    private void iterateOverGroupMembersOnPlayerQuit(Player player, MinecleanerGroupManager.MinecleanerGroup group) {
+        Player[] players = new Player[group.players.size()];
+        int i = 0;
+        for(Iterator<UUID> iterator = group.getPlayers().iterator(); iterator.hasNext();) {
+            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+            if(iteratorPlayer == player) {
+                i++;
+                continue;
+            }
+            players[i] = iteratorPlayer;
+            iteratorPlayer.sendMessage(Component.text(player.getName() + " hat den Server verlassen und wurde aus der Gruppe entfernt.", NamedTextColor.YELLOW));
+        }
+        group.removePlayerFromGroup(player);
+    }
+
+    private Player[] iterateOverGroupMembersOnCreatorPlayerQuit(Player player, MinecleanerGroupManager groupManager, MinecleanerGroupManager.MinecleanerGroup group) {
+        Player[] players = new Player[group.players.size()];
+        int i = 0;
+        for(Iterator<UUID> iterator = group.getPlayers().iterator(); iterator.hasNext();) {
+            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+            if(iteratorPlayer == player) {
+                i++;
+                continue;
+            }
+            players[i] = iteratorPlayer;
+            iteratorPlayer.sendMessage(Component.text("Die " + plugin.getDisplayedPluginName() + "gruppe in der du dich befindest wurde aufgelöst. Die Person, welche die Gruppe erstellt hat, hat den Server verlassen", NamedTextColor.YELLOW));
+        }
+        groupManager.deleteGroup(group);
+        return players;
+    }
+
     @EventHandler
     public void onBlockBurn(BlockBurnEvent e) {
         if(plugin.getArenaList().getArenaAtBlock(e.getBlock()) != null) {

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

@@ -2,11 +2,16 @@ package de.lunarakai.minecleaner;
 
 import de.iani.cubesidestats.api.SettingKey;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Map.Entry;
+import java.util.Objects;
 import java.util.UUID;
 import java.util.function.Consumer;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.OfflinePlayer;
@@ -131,61 +136,160 @@ public class MinecleanerManager {
     }
 
 
-    public void joinArena(Player player, MinecleanerArena arena) {
-        if (!player.hasPermission(MinecleanerPlugin.PERMISSION_PLAY)) {
+    public void joinArena(Player[] players, MinecleanerArena arena) {
+        if ((plugin.getGroupManager().getGroup(players[0]) == null && !players[0].hasPermission(MinecleanerPlugin.PERMISSION_PLAY)) || (plugin.getGroupManager().getGroup(players[0]) != null && !Bukkit.getPlayer(plugin.getGroupManager().getGroup(players[0]).getOwner()).hasPermission(MinecleanerPlugin.PERMISSION_PLAY))) {
             return;
         }
-        Preconditions.checkArgument(plugin.getArenaList().getPlayerArena(player) == null, "player is in an arena");
-        Preconditions.checkArgument(arena.getArenaStatus() == ArenaStatus.INACTIVE, "arena is in use");
-        arena.addJoiningPlayer(player);
-        plugin.getArenaList().setArenaForPlayer(player, arena);
-        player.openInventory(confirmPlayingInventory);
-    }
 
-    public void leaveArena(Player player, boolean message) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
-        arena.setArenaStaus(ArenaStatus.INACTIVE);
-        Preconditions.checkArgument(arena != null, "player is in no arena");
-        player.closeInventory();
-        arena.removePlayer();
-        plugin.getArenaList().setArenaForPlayer(player, null);
-        if(message) {
-            player.sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
+        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);
+        for(int i = 0; i < players.length; i++) {
+            if(plugin.getGroupManager().getGroup(players[i]) == null) {
+                players[i].openInventory(confirmPlayingInventory);
+                break;
+            }
+            if(players[i] == Bukkit.getPlayer(plugin.getGroupManager().getGroup(players[i]).getOwner())) {
+                players[i].openInventory(confirmPlayingInventory);
+            }
         }
     }
 
-    public void startGame(Player player) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+    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);
+        }
+        Player[] players1 = group != null ? new Player[group.getPlayers().size()] : new Player[1];
+        if(plugin.getGroupManager().getGroup(players[0]) != null) {
+            int i = 0;
+            for(Iterator<UUID> iterator = group.getPlayers().iterator(); iterator.hasNext();) {
+                Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                players1[i] = iteratorPlayer;
+                i++;
+            }
+        } else {
+            players1 = players;
+        }
+
+        Preconditions.checkArgument(arena != null, "player is in no arena");
+
+        if(reset) {
+            arena.setArenaStaus(ArenaStatus.INACTIVE);
+            for(int i = 0; i < players1.length; i++) {
+                players1[i].closeInventory();
+            }
+            arena.removePlayers();
+            if(message) {
+                for(int i = 0; i < players.length; i++) {
+                    players1[i].sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
+                }
+            }
+        }
+
+        plugin.getArenaList().setArenaForPlayers(players1, null);
+    }
+
+
+    public void startGame(Player[] 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();
-        player.sendMessage(ChatColor.YELLOW + "Du hast eine neue Runde " + plugin.getDisplayedPluginName() + " gestartet.");
+
+
+        if(plugin.getGroupManager().getGroup(players[0]) != null) {
+            for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(players[0]).getPlayers().iterator(); iterator.hasNext();) {
+                Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                assert iteratorPlayer != null;
+                iteratorPlayer.sendMessage(Component.text("Du hast eine neue Runde " + plugin.getDisplayedPluginName() + " gestartet.", NamedTextColor.YELLOW));
+            }
+        } else {
+            players[0].sendMessage(Component.text("Du hast eine neue Runde " + plugin.getDisplayedPluginName() + " gestartet.", NamedTextColor.YELLOW));
+        }
     }
 
-    public void handleGameover(Player player, MinecleanerArena arena, boolean isSuccessfullyCleared) {
-        World world = player.getWorld();
+    public void handleGameover(Player[] player, MinecleanerArena arena, boolean isSuccessfullyCleared) {
+
+        if(plugin.getGroupManager().getGroup(player[0]) != null) {
+            World world = player[0].getWorld();
+
+            if(!isSuccessfullyCleared) {
+                world.playSound(player[0].getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.5f, 0.5f);
+
+                for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player[0]).getPlayers().iterator(); iterator.hasNext();) {
+                        Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                    assert iteratorPlayer != null;
+                    iteratorPlayer.sendMessage(Component.text("Game Over! Ihr konntest das " + plugin.getDisplayedPluginName() + "-Feld nicht erfolgreich lösen!", NamedTextColor.YELLOW));
+                    if(plugin.isStatisticsEnabled()) {
+
+                        PlayerStatistics ps = plugin.getCubesideStatistics().getStatistics(iteratorPlayer.getUniqueId());
+                        ps.increaseScore(statisticsTotalGamesPlayed.get(arena.getWidthIndex()), 1);
+                    }
+                }
+
+                arena.showMines();
+                scheduleArenaReset(Bukkit.getPlayer(plugin.getGroupManager().getGroup(player[0]).getOwner()), arena);
+                return;
+            }
+
+            int millis = (int) (System.currentTimeMillis() - arena.getCurrentGameStartTime());
+            world.playSound(player[0].getLocation(), Sound.ENTITY_PLAYER_LEVELUP, 0.5f, 0.5f);
+            MinecleanerGroupManager.MinecleanerGroup group = plugin.getGroupManager().getGroup(player[0]);
+
+            for(UUID currentPlayer : group.getPlayers()) {
+
+                Player iteratorPlayer = Bukkit.getPlayer(currentPlayer);
+                if(iteratorPlayer != null)
+                    iteratorPlayer.sendMessage(Component.text(
+                            "Glückwunsch, ihr konntet das " + plugin.getDisplayedPluginName() + "-Feld in ", NamedTextColor.YELLOW)
+                            .append(Component.text(MinecleanerStringUtil.timeToString(millis, false), NamedTextColor.RED))
+                            .append(Component.text(" erfolgreich lösen!", NamedTextColor.YELLOW)));
+
+                if(!plugin.isStatisticsEnabled())
+                    continue;
+
+                PlayerStatistics ps = plugin.getCubesideStatistics().getStatistics(currentPlayer);
+                ps.increaseScore(statisticsTotalGamesPlayed.get(arena.getWidthIndex()), 1);
+                ps.increaseScore(statisticsWonGamesTotal, 1);
+                ps.increaseScore(statisticsGames.get(arena.getWidthIndex()), 1);
+
+                int wIndex = arena.getWidthIndex();
+                increaseScore(wIndex, ps, group.getPlayers().size());
+            }
+            scheduleArenaReset(Bukkit.getPlayer(group.getOwner()), arena);
+            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);
-            player.sendMessage(ChatColor.YELLOW + "Game Over! Du konntest das " + plugin.getDisplayedPluginName() + "-Feld nicht erfolgreich lösen!");
+            world.playSound(player[0].getLocation(), Sound.ENTITY_GENERIC_EXPLODE, 0.5f, 0.5f);
+            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);
@@ -202,49 +306,66 @@ 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!");
                     }
                 });
             }
 
             int wIndex = arena.getWidthIndex();
-            switch (wIndex) {
-                case 0: {
-                    ps.increaseScore(statisticsPointsAcquired, plugin.getConfig().getInt("winpoints.size.small"));
-                    break;
-                }
-                case 1: {
-                    ps.increaseScore(statisticsPointsAcquired, plugin.getConfig().getInt("winpoints.size.medium"));
-                    break;
-                }
-                case 2: {
-                    ps.increaseScore(statisticsPointsAcquired, plugin.getConfig().getInt("winpoints.size.large"));
-                    break;
-                }
-                case 3: {
-                    ps.increaseScore(statisticsPointsAcquired, plugin.getConfig().getInt("winpoints.size.expert"));
-                }
-                default: {
-                    ps.increaseScore(statisticsPointsAcquired, 0);
-                    break;
-                }
-            }
+            increaseScore(wIndex, ps, 1);
         } 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 increaseScore(int wIndex, PlayerStatistics ps, int groupSize) {
+        switch (wIndex) {
+            case 0: {
+                ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.small") /groupSize));
+                break;
+            }
+            case 1: {
+                ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.medium") /groupSize));
+                break;
+            }
+            case 2: {
+                ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.large") /groupSize));
+                break;
+            }
+            case 3: {
+                ps.increaseScore(statisticsPointsAcquired, (int) Math.floor((double) plugin.getConfig().getInt("winpoints.size.expert") /groupSize));
+                break;
+            }
+            default: {
+                ps.increaseScore(statisticsPointsAcquired, 0);
+                break;
+            }
+        }
     }
 
     private void scheduleArenaReset(Player player, MinecleanerArena arena) {
         schedulerGameOver = Bukkit.getScheduler().runTaskLater(plugin, () -> {
             if(arena.getArenaStatus() == ArenaStatus.COMPLETED) {
-                if (arena.getCurrentPlayer() == null) {
-                    arena.removePlayer();
+                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];
+                    int i = 0;
+                    if(plugin.getGroupManager().getGroup(player) != null) {
+                        for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+                            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+                            players[i] = iteratorPlayer;
+                            i++;
+                        }
+                    } else {
+                        Arrays.fill(players, player);
+                    }
+                    leaveArena(players, false, true);
                 }
             }
         }, plugin.getManager().getSettingsValue("resettime", player) * 20L);
@@ -252,13 +373,12 @@ public class MinecleanerManager {
 
     public void clearAllArenas() {
         for(MinecleanerArena arena : plugin.getArenaList().getArenas()) {
-            if(arena.hasPlayer()) {
-                leaveArena(arena.getCurrentPlayer(), true);
+            if(arena.hasPlayers()) {
+                leaveArena(arena.getCurrentPlayers(), true, true);
             }
         }
     }
 
-
     public void handleFieldClick(@NotNull Player player, int x, int y, boolean hasRightClicked) {
         MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
         Preconditions.checkArgument(arena != null, "player is in no arena");

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

@@ -1,6 +1,19 @@
 package de.lunarakai.minecleaner;
 
+
+import de.lunarakai.minecleaner.commands.CreateCommand;
+import de.lunarakai.minecleaner.commands.DeleteCommand;
+import de.lunarakai.minecleaner.commands.DeletePlayerScoreCommand;
+import de.lunarakai.minecleaner.commands.InfoCommand;
+import de.lunarakai.minecleaner.commands.ListCommand;
+import de.lunarakai.minecleaner.commands.ListPlayersInArenaCommand;
 import de.lunarakai.minecleaner.commands.SettingsCommand;
+import de.lunarakai.minecleaner.commands.StatsCommand;
+import de.lunarakai.minecleaner.commands.groups.AcceptCommand;
+import de.lunarakai.minecleaner.commands.groups.DenyCommand;
+import de.lunarakai.minecleaner.commands.groups.DismantleGroupCommand;
+import de.lunarakai.minecleaner.commands.groups.InviteCommand;
+import de.lunarakai.minecleaner.commands.groups.ListGroupMembersCommand;
 import net.kyori.adventure.key.Key;
 import net.kyori.adventure.translation.GlobalTranslator;
 import net.kyori.adventure.translation.TranslationRegistry;
@@ -9,12 +22,6 @@ import org.bukkit.plugin.java.JavaPlugin;
 import de.iani.cubesidestats.api.CubesideStatisticsAPI;
 import de.iani.cubesideutils.bukkit.commands.CommandRouter;
 import de.iani.playerUUIDCache.PlayerUUIDCache;
-import de.lunarakai.minecleaner.commands.CreateCommand;
-import de.lunarakai.minecleaner.commands.DeleteCommand;
-import de.lunarakai.minecleaner.commands.DeletePlayerScoreCommand;
-import de.lunarakai.minecleaner.commands.InfoCommand;
-import de.lunarakai.minecleaner.commands.ListCommand;
-import de.lunarakai.minecleaner.commands.StatsCommand;
 
 import java.util.Locale;
 import java.util.ResourceBundle;
@@ -25,6 +32,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 +72,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"));
@@ -71,6 +80,14 @@ public final class MinecleanerPlugin extends JavaPlugin {
         minecleanerCommand.addCommandMapping(new DeleteCommand(this), "delete");
         minecleanerCommand.addCommandMapping(new ListCommand(this), "list");
         minecleanerCommand.addCommandMapping(new InfoCommand(this), "info");
+        minecleanerCommand.addCommandMapping(new ListPlayersInArenaCommand(this), "currentplayers");
+
+        // Groups
+        minecleanerCommand.addCommandMapping(new InviteCommand(this), "invite");
+        minecleanerCommand.addCommandMapping(new AcceptCommand(this), "accept");
+        minecleanerCommand.addCommandMapping(new DenyCommand(this), "deny");
+        minecleanerCommand.addCommandMapping(new DismantleGroupCommand(this), "dismantlegroup");
+        minecleanerCommand.addCommandMapping(new ListGroupMembersCommand(this), "groupmembers");
 
         if(isStatisticsEnabled()) {
             minecleanerCommand.addCommandMapping(new SettingsCommand(this), "settings");
@@ -84,6 +101,9 @@ public final class MinecleanerPlugin extends JavaPlugin {
         if(minecleanerManager != null) {
             minecleanerManager.clearAllArenas();
         }
+        if(minecleanerGroupManager != null) {
+            minecleanerGroupManager.deleteAllGroups();
+        }
     }
 
     public ArenaList getArenaList() {
@@ -94,6 +114,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/commands/DeleteCommand.java

@@ -2,7 +2,6 @@ package de.lunarakai.minecleaner.commands;
 
 import java.util.Collection;
 import java.util.List;
-
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
@@ -18,7 +17,6 @@ import de.iani.cubesideutils.bukkit.commands.exceptions.RequiresPlayerException;
 import de.iani.cubesideutils.commands.ArgsParser;
 import de.lunarakai.minecleaner.MinecleanerArena;
 import de.lunarakai.minecleaner.MinecleanerPlugin;
-import net.md_5.bungee.api.ChatColor;
 
 import static de.lunarakai.minecleaner.utils.MinecleanerComponentUtils.createLangComponent;
 
@@ -67,5 +65,4 @@ public class DeleteCommand extends SubCommand {
     public Collection<String> onTabComplete(CommandSender sender, Command command, String alias, ArgsParser args) {
         return List.of();
     }
-    
 }

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

@@ -1,37 +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 de.lunarakai.minecleaner.MinecleanerPlugin;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-
-public class InviteCommand extends SubCommand {
-    /*
-        TODO:
-            - Invite other Players to play in Duo Mode
-            - Add Functionality to support multiple Players in the same game
-            - use settings of player that invited the other player
-     */
-
-    @Override
-    public String getUsage() {
-        return "<Player>";
-    }
-
-    @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 {
-        return false;
-    }
-}

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

@@ -2,7 +2,6 @@ package de.lunarakai.minecleaner.commands;
 
 import java.util.Collection;
 import java.util.List;
-
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.Location;
 import org.bukkit.command.Command;

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

@@ -0,0 +1,63 @@
+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 de.lunarakai.minecleaner.MinecleanerArena;
+import de.lunarakai.minecleaner.MinecleanerPlugin;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import java.util.Arrays;
+import java.util.Collection;
+import java.util.List;
+
+public class ListPlayersInArenaCommand extends SubCommand {
+    private final MinecleanerPlugin plugin;
+
+    public ListPlayersInArenaCommand(MinecleanerPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public String getUsage() {
+        return "<name>";
+    }
+
+    @Override
+    public boolean requiresPlayer() {
+        return true;
+    }
+
+    @Override
+    public String getRequiredPermission() {
+        return MinecleanerPlugin.PERMISSION_ADMIN;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command command, String s, String s1, ArgsParser argsParser) throws DisallowsCommandBlockException, RequiresPlayerException, NoPermissionException, IllegalSyntaxException, InternalCommandException {
+        Player player = (Player) sender;
+        MinecleanerArena arena = plugin.getArenaList().getArenaAtBlock(player.getLocation().getBlock().getRelative(BlockFace.DOWN));
+        if(arena == null) {
+            Block target = player.getTargetBlockExact(6);
+            if(target != null) {
+                arena = plugin.getArenaList().getArenaAtBlock(target);
+            }
+        }
+        if(arena != null) {
+           player.sendMessage(Component.text("Players in Arena: " + Arrays.toString(arena.getCurrentPlayers()), NamedTextColor.GRAY));
+        } else {
+            player.sendMessage(Component.text("Hier befindet sich keine Arena.", NamedTextColor.GRAY));
+        }
+        return true;
+    }
+
+    @Override
+    public Collection<String> onTabComplete(CommandSender sender, Command command, String alias, ArgsParser args) {
+        return List.of();
+    }
+}

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

@@ -2,7 +2,6 @@ package de.lunarakai.minecleaner.commands;
 
 import java.util.Map.Entry;
 import java.util.function.Consumer;
-
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 import org.bukkit.command.Command;

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

@@ -0,0 +1,58 @@
+package de.lunarakai.minecleaner.commands.groups;
+
+import de.iani.cubesideutils.bukkit.commands.SubCommand;
+import de.iani.cubesideutils.bukkit.commands.exceptions.DisallowsCommandBlockException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.IllegalSyntaxException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.InternalCommandException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.NoPermissionException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.RequiresPlayerException;
+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 AcceptCommand extends SubCommand {
+    private final MinecleanerPlugin plugin;
+
+    public AcceptCommand(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).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.", NamedTextColor.YELLOW));
+        }
+        return true;
+    }
+}

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

@@ -0,0 +1,65 @@
+package de.lunarakai.minecleaner.commands.groups;
+
+import de.iani.cubesideutils.bukkit.commands.exceptions.DisallowsCommandBlockException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.IllegalSyntaxException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.InternalCommandException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.NoPermissionException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.RequiresPlayerException;
+import de.iani.cubesideutils.bukkit.commands.SubCommand;
+import de.iani.cubesideutils.commands.ArgsParser;
+import de.lunarakai.minecleaner.MinecleanerGroupManager;
+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());
+            MinecleanerGroupManager.MinecleanerGroup invitedGroup = plugin.getGroupManager().getInvitedGroup(player);
+            invitedGroup.removePlayerFromInvitedList(player);
+            if(plugin.getGroupManager().getGroup(Bukkit.getPlayer(invitedGroup.getOwner())).invitedPlayers.isEmpty()) {
+                plugin.getGroupManager().deleteGroup(invitedGroup);
+            }
+
+            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/DismantleGroupCommand.java

@@ -0,0 +1,66 @@
+package de.lunarakai.minecleaner.commands.groups;
+
+import de.iani.cubesideutils.bukkit.commands.SubCommand;
+import de.iani.cubesideutils.bukkit.commands.exceptions.DisallowsCommandBlockException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.IllegalSyntaxException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.InternalCommandException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.NoPermissionException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.RequiresPlayerException;
+import de.iani.cubesideutils.commands.ArgsParser;
+import de.lunarakai.minecleaner.MinecleanerPlugin;
+import java.util.Iterator;
+import java.util.UUID;
+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 DismantleGroupCommand extends SubCommand {
+    private final MinecleanerPlugin plugin;
+
+    public DismantleGroupCommand(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().getGroup(player) == null) {
+            player.sendMessage(Component.text("Du bist in keiner Gruppe die du auflösen könntest.", NamedTextColor.YELLOW));
+            return true;
+        }
+        Player groupOwnerPlayer = Bukkit.getPlayer(plugin.getGroupManager().getGroup(player).getOwner());
+
+        if(player != groupOwnerPlayer) {
+            player.sendMessage(Component.text("Du bist nicht berechtigt deine Gruppe aufzulösen.", NamedTextColor.YELLOW));
+            return true;
+        }
+
+
+        for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+            iteratorPlayer.sendMessage(Component.text("Die Gruppe in der du dich befindest wurde aufgelöst.", NamedTextColor.YELLOW));
+        }
+        plugin.getGroupManager().deleteGroup(plugin.getGroupManager().getGroup(player));
+
+        return true;
+    }
+}

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

@@ -0,0 +1,85 @@
+package de.lunarakai.minecleaner.commands.groups;
+
+import de.iani.cubesideutils.bukkit.commands.SubCommand;
+import de.iani.cubesideutils.bukkit.commands.exceptions.DisallowsCommandBlockException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.IllegalSyntaxException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.InternalCommandException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.NoPermissionException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.RequiresPlayerException;
+import de.iani.cubesideutils.commands.ArgsParser;
+import de.lunarakai.minecleaner.MinecleanerGroupManager;
+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 InviteCommand extends SubCommand {
+    /*
+        TODO:
+            - Invite other Players to play in Duo Mode
+            - Add Functionality to support multiple Players in the same game
+            - use settings of player that invited the other player
+     */
+
+    private final MinecleanerPlugin plugin;
+
+    public InviteCommand(MinecleanerPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public String getUsage() {
+        return "<Player>";
+    }
+
+    @Override
+    public boolean requiresPlayer() {
+        return true;
+    }
+
+    @Override
+    public String getRequiredPermission() {
+        return MinecleanerPlugin.PERMISSION_PLAY;
+    }
+
+    @Override
+    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(Component.text(commandString + getUsage(), NamedTextColor.DARK_RED));
+            return true;
+        }
+        String playerName = args.getNext().trim();
+        Player invitedPlayer = plugin.getServer().getPlayer(playerName);
+
+        if(invitedPlayer == player) {
+            player.sendMessage(Component.text("Du kannst dich nicht selber in eine Gruppe einladen.", NamedTextColor.DARK_RED));
+            return true;
+        }
+
+        MinecleanerGroupManager groupManager = plugin.getGroupManager();
+        if(groupManager.getInvitedGroup(player) != null) {
+            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;
+        }
+
+        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;
+        }
+
+        if(groupManager.getGroup(player) == null) {
+            groupManager.createGroup(player);
+        }
+
+        assert invitedPlayer != null;
+        player.sendMessage(Component.text("Du hast " + invitedPlayer.getName() + " in eine " + plugin.getDisplayedPluginName() + "-Gruppe eingeladen", NamedTextColor.GREEN));
+        invitedPlayer.sendMessage(Component.text("Du wurdest von " + player.getName() + " in eine " + plugin.getDisplayedPluginName() + "-Gruppe eingeladen.", NamedTextColor.GREEN));
+        groupManager.getGroup(player).invitePlayerToGroup(invitedPlayer);
+
+        return true;
+    }
+}

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

@@ -0,0 +1,62 @@
+package de.lunarakai.minecleaner.commands.groups;
+
+import de.iani.cubesideutils.bukkit.commands.SubCommand;
+import de.iani.cubesideutils.bukkit.commands.exceptions.DisallowsCommandBlockException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.IllegalSyntaxException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.InternalCommandException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.NoPermissionException;
+import de.iani.cubesideutils.bukkit.commands.exceptions.RequiresPlayerException;
+import de.iani.cubesideutils.commands.ArgsParser;
+import de.lunarakai.minecleaner.MinecleanerPlugin;
+import java.util.Iterator;
+import java.util.UUID;
+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 ListGroupMembersCommand extends SubCommand {
+    private final MinecleanerPlugin plugin;
+
+    public ListGroupMembersCommand(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().getGroup(player) == null) {
+            player.sendMessage(Component.text("Du bist in keiner Gruppe.", NamedTextColor.YELLOW));
+            return true;
+        }
+
+        player.sendMessage(Component.text("-- Mitglieder deiner " + plugin.getDisplayedPluginName() + "gruppe --", NamedTextColor.AQUA));
+        for(Iterator<UUID> iterator = plugin.getGroupManager().getGroup(player).getPlayers().iterator(); iterator.hasNext();) {
+            Player iteratorPlayer = Bukkit.getPlayer(iterator.next());
+            String ownerString = "";
+            if(iteratorPlayer == Bukkit.getPlayer(plugin.getGroupManager().getGroup(player).getOwner())) {
+                ownerString = " (Ersteller der Gruppe)";
+            }
+            player.sendMessage(Component.text("  - " + iteratorPlayer.getName(), NamedTextColor.GREEN).append(Component.text(ownerString, NamedTextColor.RED)));
+        }
+        return true;
+    }
+}