start duo

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

@@ -2,6 +2,7 @@ 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.UUID;
@@ -106,16 +107,29 @@ 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) {
+    public MinecleanerArena getPlayersArena(Player[] players) {
-        return playersInArena.get(player.getUniqueId());
+        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;
+        }
     }
 
     public MinecleanerArena getArenaAtBlock(Block block) {
@@ -127,8 +141,8 @@ public class ArenaList {
     }
 
     public void removeArena(MinecleanerArena arena) {
-        if(arena.hasPlayer()) {
+        if(arena.hasPlayers()) {
-            plugin.getManager().leaveArena(arena.getCurrentPlayer(), true);
+            plugin.getManager().leaveArena(arena.getCurrentPlayers(), 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
+                        if(plugin.getManager().getSettingsValue("additionaldisplay", currentPlayers[0]) != 0
-                                || plugin.getManager().getSettingsValue("timer", currentPlayer) != 0) {
+                                || plugin.getManager().getSettingsValue("timer", currentPlayers[0]) != 0) {
                             updateIngameInfoTexts();
                         }
                     }
@@ -254,19 +254,19 @@ public class MinecleanerArena {
 
     }
 
-    public void addJoiningPlayer(Player player) {
+    public void addJoiningPlayers(Player[] players) {
-        Preconditions.checkNotNull(player);
+        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();
+        Player[] players = this.getCurrentPlayers();
-        World world = player.getWorld();
+        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() {
+    public boolean hasPlayers() {
-        return currentPlayer != null;
+        return currentPlayers != null;
     }
 
-    public Player getCurrentPlayer() {
+    public Player[] getCurrentPlayers() {
-        return currentPlayer;
+        return currentPlayers;
     }
 
     public Location getLocation() {

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

@@ -0,0 +1,74 @@
+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/MinecleanerListener.java

@@ -34,7 +34,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().getPlayerArena(e.getPlayer());
+            MinecleanerArena arena = plugin.getArenaList().getPlayersArena(e.getPlayer());
             if(arena != null) {
                 e.setCancelled(true);
                 MinecleanerArena arenaClicked = plugin.getArenaList().getArenaAtBlock(block);
@@ -86,9 +86,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);
                 }
             } else {
                 arena = plugin.getArenaList().getArenaAtBlock(block);
@@ -116,7 +116,7 @@ public class MinecleanerListener implements Listener {
     @EventHandler
     public void onPlayerInventoryClick(InventoryClickEvent e) {
         if(e.getWhoClicked() instanceof Player player) {
-            MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+            MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
             if(arena != null) {
                 if(e.getInventory().equals(plugin.getManager().getConfirmPlayingInventory())) {
                     e.setCancelled(true);
@@ -124,7 +124,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(MinecleanerGroup.isInGroup(player)) {
+                                players = new Player[MinecleanerGroup.getGroupSize()];
+                                players[0] = player;
+                            } else {
+                                players = new Player[1];
+                                players[0] = player;
+                            }
+                            plugin.getManager().startGame(players);
+
                             //player.closeInventory();
                         }
                         player.closeInventory();
@@ -137,7 +146,7 @@ public class MinecleanerListener implements Listener {
     @EventHandler
     public void onPlayerInventoryClose(InventoryCloseEvent e) {
         if(e.getPlayer() instanceof Player player) {
-            MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+            MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
             if(arena != null) {
                 if(arena.getArenaStatus() == ArenaStatus.CONFIRM_PLAYING && e.getInventory().equals(plugin.getManager().getConfirmPlayingInventory())) {
                     plugin.getManager().leaveArena(player, false);
@@ -149,7 +158,7 @@ public class MinecleanerListener implements Listener {
     @EventHandler
     public void onPlayerMove(PlayerMoveEvent e) {
         final Player player = e.getPlayer();
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(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.");
@@ -160,7 +169,7 @@ public class MinecleanerListener implements Listener {
 
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent e) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(e.getPlayer());
+        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(e.getPlayer());
         if(arena != null) {
             plugin.getManager().leaveArena(e.getPlayer(), false);
         }

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

@@ -1,11 +1,9 @@
 package de.lunarakai.minecleaner;
 
 import de.iani.cubesidestats.api.SettingKey;
-import java.util.ArrayList;
+
-import java.util.HashMap;
+import java.util.*;
-import java.util.List;
 import java.util.Map.Entry;
-import java.util.UUID;
 import java.util.function.Consumer;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
@@ -131,35 +129,42 @@ public class MinecleanerManager {
     }
 
 
-    public void joinArena(Player player, MinecleanerArena arena) {
+    public void joinArena(Player[] players, MinecleanerArena arena) {
-        if (!player.hasPermission(MinecleanerPlugin.PERMISSION_PLAY)) {
+        if (!players[0].hasPermission(MinecleanerPlugin.PERMISSION_PLAY)) {
             return;
         }
-        Preconditions.checkArgument(plugin.getArenaList().getPlayerArena(player) == null, "player is in an arena");
+        Preconditions.checkArgument(plugin.getArenaList().getPlayersArena(players) == null, "player is in an arena");
         Preconditions.checkArgument(arena.getArenaStatus() == ArenaStatus.INACTIVE, "arena is in use");
-        arena.addJoiningPlayer(player);
+        arena.addJoiningPlayers(players);
-        plugin.getArenaList().setArenaForPlayer(player, arena);
+        plugin.getArenaList().setArenaForPlayers(players, arena);
-        player.openInventory(confirmPlayingInventory);
+        players[0].openInventory(confirmPlayingInventory);
     }
 
-    public void leaveArena(Player player, boolean message) {
+    public void leaveArena(Player[] players, boolean message) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(players);
         arena.setArenaStaus(ArenaStatus.INACTIVE);
         Preconditions.checkArgument(arena != null, "player is in no arena");
-        player.closeInventory();
+        for(int i = 0; i < players.length; i++) {
-        arena.removePlayer();
+            players[i].closeInventory();
-        plugin.getArenaList().setArenaForPlayer(player, null);
+        }
+        arena.removePlayers();
+        plugin.getArenaList().setArenaForPlayers(players, null);
         if(message) {
-            player.sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
+            for(int i = 0; i < players.length; i++) {
+                players[i].sendMessage(ChatColor.YELLOW + "Das " + plugin.getDisplayedPluginName() + "spiel wurde abgebrochen.");
+            }
         }
     }
 
-    public void startGame(Player player) {
+    public void startGame(Player[] players) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(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.");
+        for(int i = 0; i < players.length; i++) {
+            players[i].sendMessage(ChatColor.YELLOW + "Du hast eine neue Runde " + plugin.getDisplayedPluginName() + " gestartet.");
+        }
+
     }
 
     public void handleGameover(Player player, MinecleanerArena arena, boolean isSuccessfullyCleared) {
@@ -241,8 +246,8 @@ public class MinecleanerManager {
     private void scheduleArenaReset(Player player, MinecleanerArena arena) {
         schedulerGameOver = Bukkit.getScheduler().runTaskLater(plugin, () -> {
             if(arena.getArenaStatus() == ArenaStatus.COMPLETED) {
-                if (arena.getCurrentPlayer() == null) {
+                if (arena.getCurrentPlayers() == null) {
-                    arena.removePlayer();
+                    arena.removePlayers();
                 } else {
                     leaveArena(player, false);
                 }
@@ -252,15 +257,15 @@ public class MinecleanerManager {
 
     public void clearAllArenas() {
         for(MinecleanerArena arena : plugin.getArenaList().getArenas()) {
-            if(arena.hasPlayer()) {
+            if(arena.hasPlayers()) {
-                leaveArena(arena.getCurrentPlayer(), true);
+                leaveArena(arena.getCurrentPlayers(), true);
             }
         }
     }
 
 
     public void handleFieldClick(@NotNull Player player, int x, int y, boolean hasRightClicked) {
-        MinecleanerArena arena = plugin.getArenaList().getPlayerArena(player);
+        MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
         Preconditions.checkArgument(arena != null, "player is in no arena");
         Preconditions.checkState(arena.getArenaStatus() == ArenaStatus.PLAYING, "not running");
 

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().getPlayerArena(player);
+                    MinecleanerArena arena = plugin.getArenaList().getPlayersArena(player);
                     plugin.getManager().updateSettingsValue("timer", 0, player);
                     if(arena != null) {
                         arena.updateIngameInfoTexts();

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

@@ -0,0 +1,50 @@
+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.MinecleanerGroup;
+import de.lunarakai.minecleaner.MinecleanerPlugin;
+import net.kyori.adventure.text.Component;
+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;
+
+    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() {
+            UUID groupUUID = invitedPlayersHashMap.get(player.getUniqueId());
+
+        } else {
+            player.sendMessage(Component.text("Du wurdest in keine Gruppe eingeladen."));
+        }
+        return false;
+    }
+}

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

@@ -0,0 +1,14 @@
+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/InviteCommand.java

@@ -3,9 +3,14 @@ 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.MinecleanerGroup;
 import de.lunarakai.minecleaner.MinecleanerPlugin;
+import net.md_5.bungee.api.ChatColor;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
 
 public class InviteCommand extends SubCommand {
     /*
@@ -15,6 +20,12 @@ public class InviteCommand extends SubCommand {
             - 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>";
@@ -31,7 +42,21 @@ public class InviteCommand extends SubCommand {
     }
 
     @Override
-    public boolean onCommand(CommandSender commandSender, Command command, String s, String s1, ArgsParser argsParser) throws DisallowsCommandBlockException, RequiresPlayerException, NoPermissionException, IllegalSyntaxException, InternalCommandException {
+    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());
+            return true;
+        }
+        String playerName = args.getNext().trim();
+        Player invitedPlayer = plugin.getServer().getPlayer(playerName);
+
+        MinecleanerGroup group = new MinecleanerGroup();
+        group.createGroup(player);
+        UUID groupUUID = group.getGroupUUID(player);
+
+        group.invitePlayerToGroup(groupUUID, invitedPlayer);
+
         return false;
     }
 }