Finishes the changes for parkour arenas, hopefully

src/main/java/net/knarcraft/minigames/command/JoinArenaTabCompleter.java

@@ -1,6 +1,6 @@
 package net.knarcraft.minigames.command;
 
-import net.knarcraft.minigames.util.TabCompleteHelper;
+import net.knarcraft.minigames.arena.ArenaGameMode;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
@@ -9,22 +9,37 @@ import org.jetbrains.annotations.Nullable;
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.function.Supplier;
 
 /**
- * The tab-completer for the join command
+ * An abstract class for an arena joining tab-completer
  */
-public class JoinArenaTabCompleter implements TabCompleter {
+public abstract class JoinArenaTabCompleter implements TabCompleter {
+
+    private final ArenaGameMode gameMode;
+    private final Supplier<List<String>> arenaNameSupplier;
+
+    /**
+     * Implements a new join arena tab completer
+     *
+     * @param arenaNameSupplier <p>The supplier to ask for arena names</p>
+     * @param gameMode          <p>An instance of one of the available game-modes</p>
+     */
+    public JoinArenaTabCompleter(Supplier<List<String>> arenaNameSupplier, ArenaGameMode gameMode) {
+        this.arenaNameSupplier = arenaNameSupplier;
+        this.gameMode = gameMode;
+    }
 
     @Override
     public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
                                                 @NotNull String label, @NotNull String[] arguments) {
         if (arguments.length == 1) {
-            return TabCompleteHelper.getArenas();
+            return arenaNameSupplier.get();
         } else if (arguments.length == 2) {
             List<String> gameModes = new ArrayList<>();
-            gameModes.add("default");
-            gameModes.add("inverted");
-            gameModes.add("random");
+            for (ArenaGameMode gameMode : gameMode.getValues()) {
+                gameModes.add(gameMode.name().toLowerCase());
+            }
             return gameModes;
         } else {
             return new ArrayList<>();

src/main/java/net/knarcraft/minigames/command/dropper/CreateDropperArenaCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -13,7 +13,7 @@ import org.jetbrains.annotations.NotNull;
 /**
  * The command for creating a new dropper arena
  */
-public class CreateArenaCommand implements CommandExecutor {
+public class CreateDropperArenaCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,

src/main/java/net/knarcraft/minigames/command/dropper/DropperGroupListCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -17,7 +17,7 @@ import java.util.UUID;
 /**
  * The command for listing groups and the stages within
  */
-public class GroupListCommand implements TabExecutor {
+public class DropperGroupListCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,

src/main/java/net/knarcraft/minigames/command/dropper/DropperGroupSetCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -18,7 +18,7 @@ import java.util.List;
 /**
  * The command for setting the group of an arena
  */
-public class GroupSetCommand implements TabExecutor {
+public class DropperGroupSetCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
@@ -62,7 +62,7 @@ public class GroupSetCommand implements TabExecutor {
     public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                                       @NotNull String[] arguments) {
         if (arguments.length == 1) {
-            return TabCompleteHelper.getArenas();
+            return TabCompleteHelper.getDropperArenas();
         } else if (arguments.length == 2) {
             List<String> possibleValues = new ArrayList<>();
             possibleValues.add("none");

src/main/java/net/knarcraft/minigames/command/dropper/DropperGroupSwapCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -17,7 +17,7 @@ import java.util.UUID;
 /**
  * The command for swapping the order of two arenas in a group
  */
-public class GroupSwapCommand implements TabExecutor {
+public class DropperGroupSwapCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,

src/main/java/net/knarcraft/minigames/command/dropper/EditDropperArenaCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -15,7 +15,7 @@ import org.jetbrains.annotations.NotNull;
 /**
  * The command for editing an existing dropper arena
  */
-public class EditArenaCommand implements CommandExecutor {
+public class EditDropperArenaCommand implements CommandExecutor {
 
     private final DropperConfiguration configuration;
 
@@ -24,7 +24,7 @@ public class EditArenaCommand implements CommandExecutor {
      *
      * @param configuration <p>The configuration to use</p>
      */
-    public EditArenaCommand(DropperConfiguration configuration) {
+    public EditDropperArenaCommand(DropperConfiguration configuration) {
         this.configuration = configuration;
     }
 

src/main/java/net/knarcraft/minigames/command/dropper/EditDropperArenaTabCompleter.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.util.TabCompleteHelper;
 import org.bukkit.command.Command;
@@ -13,15 +13,15 @@ import java.util.List;
 /**
  * The tab-completer for the edit arena command
  */
-public class EditArenaTabCompleter implements TabCompleter {
+public class EditDropperArenaTabCompleter implements TabCompleter {
 
     @Override
     public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
                                                 @NotNull String label, @NotNull String[] args) {
         if (args.length == 1) {
-            return TabCompleteHelper.getArenas();
+            return TabCompleteHelper.getDropperArenas();
         } else if (args.length == 2) {
-            return TabCompleteHelper.getArenaProperties();
+            return TabCompleteHelper.getDropperArenaProperties();
         } else if (args.length == 3) {
             //TODO: Tab-complete possible values for the given property
             return null;

src/main/java/net/knarcraft/minigames/command/dropper/JoinDropperArenaCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -17,7 +17,7 @@ import org.jetbrains.annotations.NotNull;
 /**
  * The command used to join a dropper arena
  */
-public class JoinArenaCommand implements CommandExecutor {
+public class JoinDropperArenaCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
@@ -31,10 +31,9 @@ public class JoinArenaCommand implements CommandExecutor {
             return false;
         }
 
-        // Disallow joining if the player is already in a dropper arena
-        DropperArenaSession existingSession = MiniGames.getInstance().getDropperArenaPlayerRegistry().getArenaSession(player.getUniqueId());
-        if (existingSession != null) {
-            commandSender.sendMessage("You are already in a dropper arena!");
+        // Disallow joining if the player is already in a mini-game arena
+        if (MiniGames.getInstance().getSession(player.getUniqueId()) != null) {
+            commandSender.sendMessage("You are already playing a mini-game!");
             return false;
         }
 
@@ -99,7 +98,7 @@ public class JoinArenaCommand implements CommandExecutor {
             return false;
         } else {
             // Make sure to update the state again in the air to remove a potential swimming state
-            newSession.getEntryState().setArenaState(specifiedArena.getPlayerHorizontalVelocity());
+            newSession.getEntryState().setArenaState();
             return true;
         }
     }

src/main/java/net/knarcraft/minigames/command/dropper/JoinDropperArenaTabCompleter.java

@@ -0,0 +1,19 @@
+package net.knarcraft.minigames.command.dropper;
+
+import net.knarcraft.minigames.arena.dropper.DropperArenaGameMode;
+import net.knarcraft.minigames.command.JoinArenaTabCompleter;
+import net.knarcraft.minigames.util.TabCompleteHelper;
+
+/**
+ * The tab-completer for the join command
+ */
+public class JoinDropperArenaTabCompleter extends JoinArenaTabCompleter {
+
+    /**
+     * Implements a new join arena tab completer
+     */
+    public JoinDropperArenaTabCompleter() {
+        super(TabCompleteHelper::getDropperArenas, DropperArenaGameMode.DEFAULT);
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/dropper/ListDropperArenaCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.util.TabCompleteHelper;
 import org.bukkit.command.Command;
@@ -13,13 +13,13 @@ import java.util.List;
 /**
  * A command for listing existing dropper arenas
  */
-public class ListArenaCommand implements TabExecutor {
+public class ListDropperArenaCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label,
                              @NotNull String[] arguments) {
         sender.sendMessage("Dropper arenas:");
-        for (String arenaName : TabCompleteHelper.getArenas()) {
+        for (String arenaName : TabCompleteHelper.getDropperArenas()) {
             sender.sendMessage(arenaName);
         }
         return true;

src/main/java/net/knarcraft/minigames/command/dropper/RemoveDropperArenaCommand.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.MiniGames;
 import net.knarcraft.minigames.arena.dropper.DropperArena;
@@ -10,7 +10,7 @@ import org.jetbrains.annotations.NotNull;
 /**
  * The method used for removing an existing arena
  */
-public class RemoveArenaCommand implements CommandExecutor {
+public class RemoveDropperArenaCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,

src/main/java/net/knarcraft/minigames/command/dropper/RemoveDropperArenaTabCompleter.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.minigames.command.dropper;
 
 import net.knarcraft.minigames.util.TabCompleteHelper;
 import org.bukkit.command.Command;
@@ -13,14 +13,14 @@ import java.util.List;
 /**
  * The tab-completer for the remove arena command
  */
-public class RemoveArenaTabCompleter implements TabCompleter {
+public class RemoveDropperArenaTabCompleter implements TabCompleter {
 
     @Nullable
     @Override
     public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                                       @NotNull String[] arguments) {
         if (arguments.length == 1) {
-            return TabCompleteHelper.getArenas();
+            return TabCompleteHelper.getDropperArenas();
         } else {
             return new ArrayList<>();
         }

src/main/java/net/knarcraft/minigames/command/parkour/CreateParkourArenaCommand.java

@@ -0,0 +1,53 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaHandler;
+import net.knarcraft.minigames.util.StringSanitizer;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The command for creating a new parkour arena
+ */
+public class CreateParkourArenaCommand implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        if (!(commandSender instanceof Player player)) {
+            commandSender.sendMessage("This command must be used by a player");
+            return false;
+        }
+
+        // Abort if no name was specified
+        if (arguments.length < 1) {
+            return false;
+        }
+
+        // Remove known characters that are likely to cause trouble if used in an arena name
+        String arenaName = StringSanitizer.removeUnwantedCharacters(arguments[0]);
+
+        // An arena name is required
+        if (arenaName.isBlank()) {
+            return false;
+        }
+
+        ParkourArenaHandler arenaHandler = MiniGames.getInstance().getParkourArenaHandler();
+
+        ParkourArena existingArena = arenaHandler.getArena(arenaName);
+        if (existingArena != null) {
+            commandSender.sendMessage("There already exists a parkour arena with that name!");
+            return false;
+        }
+
+        ParkourArena arena = new ParkourArena(arenaName, player.getLocation(), arenaHandler);
+        arenaHandler.addArena(arena);
+        commandSender.sendMessage("The arena was successfully created!");
+        return true;
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/EditParkourArenaCommand.java

@@ -0,0 +1,128 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaEditableProperty;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.List;
+
+/**
+ * The command for editing an existing dropper arena
+ */
+public class EditParkourArenaCommand implements CommandExecutor {
+
+    /**
+     * Instantiates a new edit arena command
+     */
+    public EditParkourArenaCommand() {
+    }
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        //TODO: Checkpoints are quite different from everything else, so some custom code is needed for dealing with them
+        if (!(commandSender instanceof Player player)) {
+            commandSender.sendMessage("This command must be used by a player");
+            return false;
+        }
+
+        if (arguments.length < 2) {
+            return false;
+        }
+
+        ParkourArena specifiedArena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[0]);
+        if (specifiedArena == null) {
+            commandSender.sendMessage("Unable to find the specified dropper arena.");
+            return false;
+        }
+
+        ParkourArenaEditableProperty editableProperty = ParkourArenaEditableProperty.getFromArgumentString(arguments[1]);
+        if (editableProperty == null) {
+            commandSender.sendMessage("Unknown property specified.");
+            return false;
+        }
+
+        String currentValueFormat = "Current value of %s is: %s";
+
+        if (arguments.length < 3) {
+            // Print the current value of the property
+            String value = editableProperty.getCurrentValueAsString(specifiedArena);
+            commandSender.sendMessage(String.format(currentValueFormat, editableProperty.getArgumentString(), value));
+            return true;
+        } else {
+            boolean successful = changeValue(specifiedArena, editableProperty, arguments[2], player);
+            if (successful) {
+                player.sendMessage(String.format("Property %s changed to: %s", editableProperty, arguments[2]));
+            } else {
+                player.sendMessage("Unable to change the property. Make sure your input is valid!");
+            }
+            return successful;
+        }
+    }
+
+    /**
+     * Changes the given property to the given value
+     *
+     * @param arena    <p>The arena to change the property for</p>
+     * @param property <p>The property to change</p>
+     * @param value    <p>The new value of the property</p>
+     * @param player   <p>The player trying to change the value</p>
+     * @return <p>True if the value was successfully changed</p>
+     */
+    private boolean changeValue(@NotNull ParkourArena arena, @NotNull ParkourArenaEditableProperty property,
+                                @NotNull String value, @NotNull Player player) {
+        return switch (property) {
+            case WIN_BLOCK_TYPE -> arena.setWinBlockType(parseMaterial(value));
+            case SPAWN_LOCATION -> arena.setSpawnLocation(parseLocation(player, value));
+            case NAME -> arena.setName(value);
+            case EXIT_LOCATION -> arena.setExitLocation(parseLocation(player, value));
+            case WIN_LOCATION -> arena.setWinLocation(parseLocation(player, value));
+            case CHECKPOINT_ADD -> arena.addCheckpoint(parseLocation(player, value));
+            case CHECKPOINT_CLEAR -> arena.clearCheckpoints();
+            case KILL_PLANE_BLOCKS -> arena.setKillPlaneBlocks(new HashSet<>(List.of(value.split(","))));
+        };
+    }
+
+    /**
+     * Parses the given location string
+     *
+     * @param player         <p>The player changing a location</p>
+     * @param locationString <p>The location string to parse</p>
+     * @return <p>The parsed location, or the player's location if not parse-able</p>
+     */
+    private @NotNull Location parseLocation(Player player, String locationString) {
+        if ((locationString.trim() + ",").matches("([0-9]+.?[0-9]*,){3}")) {
+            String[] parts = locationString.split(",");
+            Location newLocation = player.getLocation().clone();
+            newLocation.setX(Double.parseDouble(parts[0].trim()));
+            newLocation.setY(Double.parseDouble(parts[1].trim()));
+            newLocation.setZ(Double.parseDouble(parts[2].trim()));
+            return newLocation;
+        } else {
+            return player.getLocation().clone();
+        }
+    }
+
+    /**
+     * Parses the given material name
+     *
+     * @param materialName <p>The material name to parse</p>
+     * @return <p>The parsed material, or AIR if not valid</p>
+     */
+    private @NotNull Material parseMaterial(String materialName) {
+        Material material = Material.matchMaterial(materialName);
+        if (material == null) {
+            material = Material.AIR;
+        }
+        return material;
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/EditParkourArenaTabCompleter.java

@@ -0,0 +1,33 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.util.TabCompleteHelper;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The tab-completer for the edit arena command
+ */
+public class EditParkourArenaTabCompleter implements TabCompleter {
+
+    @Override
+    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
+                                                @NotNull String label, @NotNull String[] args) {
+        if (args.length == 1) {
+            return TabCompleteHelper.getParkourArenas();
+        } else if (args.length == 2) {
+            return TabCompleteHelper.getParkourArenaProperties();
+        } else if (args.length == 3) {
+            //TODO: Tab-complete possible values for the given property
+            return null;
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/JoinParkourArenaCommand.java

@@ -0,0 +1,121 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaGameMode;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaGroup;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaPlayerRegistry;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaSession;
+import net.knarcraft.minigames.config.ParkourConfiguration;
+import net.knarcraft.minigames.util.PlayerTeleporter;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The command used to join a parkour arena
+ */
+public class JoinParkourArenaCommand implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        if (!(commandSender instanceof Player player)) {
+            commandSender.sendMessage("This command must be used by a player");
+            return false;
+        }
+
+        if (arguments.length < 1) {
+            return false;
+        }
+
+        // Disallow joining if the player is already in a mini-game arena
+        if (MiniGames.getInstance().getSession(player.getUniqueId()) != null) {
+            commandSender.sendMessage("You are already playing a mini-game!");
+            return false;
+        }
+
+        // Make sure the arena exists
+        ParkourArena specifiedArena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[0]);
+        if (specifiedArena == null) {
+            commandSender.sendMessage("Unable to find the specified parkour arena.");
+            return false;
+        }
+
+        // Deny vehicles as allowing this is tricky, and will cause problems in some cases
+        if (player.isInsideVehicle() || !player.getPassengers().isEmpty()) {
+            commandSender.sendMessage("You cannot join an arena while inside a vehicle or carrying a passenger.");
+            return false;
+        }
+
+        return joinArena(specifiedArena, player, arguments);
+    }
+
+    /**
+     * Performs the actual arena joining
+     *
+     * @param specifiedArena <p>The arena the player wants to join</p>
+     * @param player         <p>The player joining the arena</p>
+     * @param arguments      <p>The arguments given</p>
+     * @return <p>Whether the arena was joined successfully</p>
+     */
+    private boolean joinArena(ParkourArena specifiedArena, Player player, String[] arguments) {
+        // Find the specified game-mode
+        ParkourArenaGameMode gameMode;
+        if (arguments.length > 1) {
+            gameMode = ParkourArenaGameMode.matchGamemode(arguments[1]);
+        } else {
+            gameMode = ParkourArenaGameMode.DEFAULT;
+        }
+
+        // Make sure the player has beaten the necessary levels
+        ParkourArenaGroup arenaGroup = MiniGames.getInstance().getParkourArenaHandler().getGroup(specifiedArena.getArenaId());
+        if (arenaGroup != null && !doGroupChecks(specifiedArena, arenaGroup, gameMode, player)) {
+            return false;
+        }
+
+        // Register the player's session
+        ParkourArenaSession newSession = new ParkourArenaSession(specifiedArena, player, gameMode);
+        ParkourArenaPlayerRegistry playerRegistry = MiniGames.getInstance().getParkourArenaPlayerRegistry();
+        playerRegistry.registerPlayer(player.getUniqueId(), newSession);
+
+        // Try to teleport the player to the arena
+        boolean teleported = PlayerTeleporter.teleportPlayer(player, specifiedArena.getSpawnLocation(), false, false);
+        if (!teleported) {
+            player.sendMessage("Unable to teleport you to the parkour arena. Make sure you're not in a vehicle," +
+                    "and not carrying a passenger!");
+            newSession.triggerQuit(false);
+            return false;
+        } else {
+            // Make sure to update the state again in the air to remove a potential swimming state
+            newSession.getEntryState().setArenaState();
+            return true;
+        }
+    }
+
+    /**
+     * Performs necessary check for the given arena's group
+     *
+     * @param parkourArena  <p>The arena the player is trying to join</p>
+     * @param arenaGroup    <p>The arena group the arena belongs to</p>
+     * @param arenaGameMode <p>The game-mode the player selected</p>
+     * @param player        <p>The the player trying to join the arena</p>
+     * @return <p>False if any checks failed</p>
+     */
+    private boolean doGroupChecks(@NotNull ParkourArena parkourArena, @NotNull ParkourArenaGroup arenaGroup,
+                                  @NotNull ParkourArenaGameMode arenaGameMode, @NotNull Player player) {
+        ParkourConfiguration configuration = MiniGames.getInstance().getParkourConfiguration();
+
+        // Require that the player has beaten the previous arena on the same game-mode before trying this one
+        if (configuration.mustDoGroupedInSequence() &&
+                !arenaGroup.canPlay(arenaGameMode, player, parkourArena.getArenaId())) {
+            player.sendMessage("You have not yet beaten the previous arena!");
+            return false;
+        }
+
+        return true;
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/JoinParkourArenaTabCompleter.java

@@ -0,0 +1,19 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.arena.parkour.ParkourArenaGameMode;
+import net.knarcraft.minigames.command.JoinArenaTabCompleter;
+import net.knarcraft.minigames.util.TabCompleteHelper;
+
+/**
+ * The tab-completer for the join command
+ */
+public class JoinParkourArenaTabCompleter extends JoinArenaTabCompleter {
+
+    /**
+     * Implements a new join arena tab completer
+     */
+    public JoinParkourArenaTabCompleter() {
+        super(TabCompleteHelper::getParkourArenas, ParkourArenaGameMode.DEFAULT);
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/ListParkourArenaCommand.java

@@ -0,0 +1,35 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.util.TabCompleteHelper;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A command for listing existing parkour arenas
+ */
+public class ListParkourArenaCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label,
+                             @NotNull String[] arguments) {
+        sender.sendMessage("Parkour arenas:");
+        for (String arenaName : TabCompleteHelper.getParkourArenas()) {
+            sender.sendMessage(arenaName);
+        }
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                                      @NotNull String[] arguments) {
+        return new ArrayList<>();
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/ParkourGroupListCommand.java

@@ -0,0 +1,95 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaGroup;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaHandler;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * The command for listing groups and the stages within
+ */
+public class ParkourGroupListCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        ParkourArenaHandler arenaHandler = MiniGames.getInstance().getParkourArenaHandler();
+        if (arguments.length == 0) {
+            displayExistingGroups(arenaHandler, commandSender);
+            return true;
+        } else if (arguments.length == 1) {
+            return displayOrderedArenaNames(arenaHandler, commandSender, arguments[0]);
+        } else {
+            return false;
+        }
+    }
+
+    /**
+     * Displays all currently existing parkour arena groups
+     *
+     * @param arenaHandler <p>The arena handler to get groups from</p>
+     * @param sender       <p>The command sender to display the groups to</p>
+     */
+    private void displayExistingGroups(@NotNull ParkourArenaHandler arenaHandler, @NotNull CommandSender sender) {
+        StringBuilder builder = new StringBuilder("Parkour arena groups:").append("\n");
+        arenaHandler.getAllGroups().stream().sorted().forEachOrdered((group) ->
+                builder.append(group.getGroupName()).append("\n"));
+        sender.sendMessage(builder.toString());
+    }
+
+    /**
+     * Displays the ordered stages in a specified group to the specified command sender
+     *
+     * @param arenaHandler <p>The arena handler to get groups from</p>
+     * @param sender       <p>The command sender to display the stages to</p>
+     * @param groupName    <p>The name of the group to display stages for</p>
+     * @return <p>True if the stages were successfully displayed</p>
+     */
+    private boolean displayOrderedArenaNames(@NotNull ParkourArenaHandler arenaHandler, @NotNull CommandSender sender,
+                                             @NotNull String groupName) {
+        ParkourArenaGroup arenaGroup = arenaHandler.getGroup(groupName);
+        if (arenaGroup == null) {
+            sender.sendMessage("Unable to find the specified group!");
+            return false;
+        }
+
+        // Send a list of all stages (arenas in the group)
+        StringBuilder builder = new StringBuilder(groupName).append("'s stages:").append("\n");
+        int counter = 1;
+        for (UUID arenaId : arenaGroup.getArenas()) {
+            ParkourArena arena = arenaHandler.getArena(arenaId);
+            if (arena != null) {
+                builder.append(counter++).append(". ").append(arena.getArenaName()).append("\n");
+            }
+        }
+        sender.sendMessage(builder.toString());
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                                      @NotNull String[] arguments) {
+        if (arguments.length == 1) {
+            List<String> groupNames = new ArrayList<>();
+            Set<ParkourArenaGroup> arenaGroups = MiniGames.getInstance().getParkourArenaHandler().getAllGroups();
+            for (ParkourArenaGroup group : arenaGroups) {
+                groupNames.add(group.getGroupName());
+            }
+            return groupNames;
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/ParkourGroupSetCommand.java

@@ -0,0 +1,79 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaGroup;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaHandler;
+import net.knarcraft.minigames.util.StringSanitizer;
+import net.knarcraft.minigames.util.TabCompleteHelper;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The command for setting the group of an arena
+ */
+public class ParkourGroupSetCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        if (arguments.length < 2) {
+            return false;
+        }
+
+        ParkourArenaHandler arenaHandler = MiniGames.getInstance().getParkourArenaHandler();
+
+        ParkourArena specifiedArena = arenaHandler.getArena(arguments[0]);
+        if (specifiedArena == null) {
+            commandSender.sendMessage("Unable to find the specified parkour arena.");
+            return false;
+        }
+
+        String groupName = StringSanitizer.removeUnwantedCharacters(arguments[1]);
+
+        if (groupName.isBlank()) {
+            return false;
+        }
+
+        ParkourArenaGroup arenaGroup;
+        if (groupName.equalsIgnoreCase("null") || groupName.equalsIgnoreCase("none")) {
+            arenaGroup = null;
+        } else {
+            arenaGroup = arenaHandler.getGroup(groupName);
+            if (arenaGroup == null) {
+                arenaGroup = new ParkourArenaGroup(groupName);
+            }
+        }
+
+        arenaHandler.setGroup(specifiedArena.getArenaId(), arenaGroup);
+
+        commandSender.sendMessage("The arena's group has been updated");
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                                      @NotNull String[] arguments) {
+        if (arguments.length == 1) {
+            return TabCompleteHelper.getParkourArenas();
+        } else if (arguments.length == 2) {
+            List<String> possibleValues = new ArrayList<>();
+            possibleValues.add("none");
+            possibleValues.add("GroupName");
+            for (ParkourArenaGroup group : MiniGames.getInstance().getParkourArenaHandler().getAllGroups()) {
+                possibleValues.add(group.getGroupName());
+            }
+            return possibleValues;
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/ParkourGroupSwapCommand.java

@@ -0,0 +1,102 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaGroup;
+import net.knarcraft.minigames.arena.parkour.ParkourArenaHandler;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabExecutor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+/**
+ * The command for swapping the order of two arenas in a group
+ */
+public class ParkourGroupSwapCommand implements TabExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        if (arguments.length < 2) {
+            return false;
+        }
+
+        ParkourArenaHandler arenaHandler = MiniGames.getInstance().getParkourArenaHandler();
+
+        ParkourArena arena1 = arenaHandler.getArena(arguments[0]);
+        if (arena1 == null) {
+            commandSender.sendMessage("Unable to find the first specified parkour arena.");
+            return false;
+        }
+
+        ParkourArena arena2 = arenaHandler.getArena(arguments[1]);
+        if (arena2 == null) {
+            commandSender.sendMessage("Unable to find the second specified parkour arena.");
+            return false;
+        }
+
+        ParkourArenaGroup arena1Group = arenaHandler.getGroup(arena1.getArenaId());
+        ParkourArenaGroup arena2Group = arenaHandler.getGroup(arena2.getArenaId());
+        if (arena1Group == null || !arena1Group.equals(arena2Group)) {
+            commandSender.sendMessage("You cannot swap arenas in different groups!");
+            return false;
+        }
+
+        arena1Group.swapArenas(arena1Group.getArenas().indexOf(arena1.getArenaId()),
+                arena1Group.getArenas().indexOf(arena2.getArenaId()));
+        commandSender.sendMessage("The arenas have been swapped!");
+        return true;
+    }
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                                      @NotNull String[] arguments) {
+        ParkourArenaHandler arenaHandler = MiniGames.getInstance().getParkourArenaHandler();
+        if (arguments.length == 1) {
+            List<String> arenaNames = new ArrayList<>();
+            for (ParkourArena parkourArena : arenaHandler.getArenasInAGroup()) {
+                arenaNames.add(parkourArena.getArenaName());
+            }
+            return arenaNames;
+        } else if (arguments.length == 2) {
+            return getArenaNamesInSameGroup(arguments[0]);
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+    /**
+     * Gets the names of all arenas in the same group as the specified arena
+     *
+     * @param arenaName <p>The name of the specified arena</p>
+     * @return <p>The names of the arenas in the same group</p>
+     */
+    private List<String> getArenaNamesInSameGroup(String arenaName) {
+        ParkourArenaHandler arenaHandler = MiniGames.getInstance().getParkourArenaHandler();
+        ParkourArena arena1 = arenaHandler.getArena(arenaName);
+        if (arena1 == null) {
+            return new ArrayList<>();
+        }
+
+        // Only display other arenas in the selected group
+        List<String> arenaNames = new ArrayList<>();
+        ParkourArenaGroup group = arenaHandler.getGroup(arena1.getArenaId());
+        if (group == null) {
+            return new ArrayList<>();
+        }
+        for (UUID arenaId : group.getArenas()) {
+            ParkourArena arena = arenaHandler.getArena(arenaId);
+            if (arena != null && arena.getArenaId() != arena1.getArenaId()) {
+                arenaNames.add(arena.getArenaName());
+            }
+        }
+        return arenaNames;
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/RemoveParkourArenaCommand.java

@@ -0,0 +1,36 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.MiniGames;
+import net.knarcraft.minigames.arena.parkour.ParkourArena;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The method used for removing an existing arena
+ */
+public class RemoveParkourArenaCommand implements CommandExecutor {
+
+    @Override
+    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                             @NotNull String[] arguments) {
+        // Abort if no name was specified
+        if (arguments.length < 1) {
+            return false;
+        }
+
+        // Get the specified arena
+        ParkourArena targetArena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[0]);
+        if (targetArena == null) {
+            commandSender.sendMessage("Unable to find the specified arena");
+            return false;
+        }
+
+        // Remove the arena
+        MiniGames.getInstance().getParkourArenaHandler().removeArena(targetArena);
+        commandSender.sendMessage("The specified arena has been successfully removed");
+        return true;
+    }
+
+}

src/main/java/net/knarcraft/minigames/command/parkour/RemoveParkourArenaTabCompleter.java

@@ -0,0 +1,29 @@
+package net.knarcraft.minigames.command.parkour;
+
+import net.knarcraft.minigames.util.TabCompleteHelper;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandSender;
+import org.bukkit.command.TabCompleter;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The tab-completer for the remove arena command
+ */
+public class RemoveParkourArenaTabCompleter implements TabCompleter {
+
+    @Nullable
+    @Override
+    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
+                                      @NotNull String[] arguments) {
+        if (arguments.length == 1) {
+            return TabCompleteHelper.getParkourArenas();
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+}