HEADER

@@ -1,15 +0,0 @@
-MiniGames - A mini-games plugin for spigot
-Copyright (C) 2023 Kristian Knarvik (EpicKnarvik97)
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation, either version 3 of the License, or
-(at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
-
-You should have received a copy of the GNU General Public License
-along with this program.  If not, see <http://www.gnu.org/licenses/>.

README.md

@@ -1,115 +1,37 @@
-# MiniGames
+# Dropper
 
-This plugin adds several mini-games.
-
-To create a dropper arena, simply use `/droppercreate <name>`, where \<name> is simply the name used to differentiate
-and recognize the arena. Your location will be used as the spawn location for anyone joining the dropper arena. To start
+This is a plugin for a dropper mini-game (try to reach the bottom without hitting any obstacles).
+To create an arena, simply use `/droppercreate <name>`, where \<name> is simply the name used to differentiate and
+recognize the arena. Your location will be used as the spawn location for anyone joining the dropper arena. To start
 playing, simply use `/dropperjoin <name>`, where \<name> is the same as you specified upon creation.
-To modify the arena, use `/dropperedit <name> <property> <value>`.
-
-To create a parkour arena, simply use `/parkourcreate <name>`, where \<name> is simply the name used to differentiate
-and recognize the arena. Your location will be used as the spawn location for anyone joining the dropper arena. To start
-playing, simply use `/parkourjoin <name>`, where \<name> is the same as you specified upon creation.
-To modify the arena, use `/parkouredit <name> <property> <value>`. Use `/parkouredit checkpointAdd here` to add a
-checkpoint at your current location.
+To modify
 
 ## Permissions
 
-The only permission normal players will need is `minigames.join` which is set to true by default.
-
 | Node           | Description                                        |
-|--------------------------|------------------------------------------------------|
-| minigames.admin          | Gives all permissions.                               |
-| minigames.dropper        | Gives all dropper-related permissions.               |
-| minigames.parkour        | Gives all parkour-related permissions.               |
-| minigames.join           | Allows a player to participate in mini-game arenas.  |
-| minigames.join.dropper   | Allows a player to participate in dropper arenas.    |
-| minigames.join.parkour   | Allows a player to participate in parkour arenas.    |
-| minigames.create         | Allows a player to create a new mini-game arena.     |
-| minigames.create.dropper | Allows a player to create a new dropper arena.       |
-| minigames.create.parkour | Allows a player to create a new parkour arena.       |
-| minigames.edit           | Allows a player to edit an existing mini-game arena. |
-| minigames.edit.dropper   | Allows a player to edit an existing dropper arena.   |
-| minigames.edit.parkour   | Allows a player to edit an existing parkour arena.   |
-| minigames.remove         | Allows a player to remove a mini-game arena.         |
-| minigames.remove.dropper | Allows a player to remove a dropper arena.           |
-| minigames.remove.parkour | Allows a player to remove a parkour arena.           |
+|----------------|----------------------------------------------------|
+| dropper.admin  | Gives all permissions.                             |
+| dropper.join   | Allows a player to participate in dropper arenas.  |
+| dropper.create | Allows a player to create a new dropper arena.     |
+| dropper.edit   | Allows a player to edit an existing dropper arena. |
+| dropper.remove | Allows a player to remove a dropper arena.         |
 
 ## Commands
 
 | Command                                | Alias    | Arguments                   | Description                                                                         |
-|----------------------------------------|----------|------------------------------|-------------------------------------------------------------------------------------|
-| /miniGamesReload                       | /mreload |                              | Reloads all data from disk.                                                         |
-| /miniGamesLeave                        | /mleave  |                              | Leaves the current mini-game.                                                       |
-| /miniGamesMenu                         | /mmenu   |                              | Shows a menu of actions if used while in an arena                                   |
-| [/miniGamesReward](#minigamesreward)   | /mreward | [See this](#minigamesreward) | Adds or removes rewards for an arena                                                |
+|----------------------------------------|----------|-----------------------------|-------------------------------------------------------------------------------------|
 | /dropperList                           | /dlist   |                             | Lists available dropper arenas.                                                     |
 | [/dropperJoin](#dropperjoin)           | /djoin   | \<arena> \[mode]            | Joins the selected arena.                                                           |
+| /dropperLeave                          | /dleave  |                             | Leaves the current dropper arena.                                                   |
 | /dropperCreate                         | /dcreate | \<name>                     | Creates a new dropper arena with the given name. The spawn is set to your location. |
 | /dropperRemove                         | /dremove | \<arena>                    | Removes the specified dropper arena.                                                |
 | [/dropperEdit](#dropperedit)           | /dedit   | \<arena> \<option> \[value] | Gets or sets a dropper arena option.                                                |
+| /dropperReload                         | /dreload |                             | Reloads all data from disk.                                                         |
 | [/dropperGroupSet](#droppergroupset)   | /dgset   | \<arena> \<group>           | Puts the given arena in the given group. Use "none" to remove an existing group.    |
 | /dropperGroupList                      | /dglist  | \[group]                    | Lists groups, or the stages of a group if a group is specified.                     |
 | [/dropperGroupSwap](#droppergroupswap) | /dgswap  | \<arena1> \<arena2>         | Swaps the two arenas in the group's ordered list.                                   |
-| /parkourList                           | /plist   |                              | Lists available parkour arenas.                                                     |
-| [/parkourJoin](#parkourjoin)           | /pjoin   | \<arena> \[mode]             | Joins the selected arena.                                                           |
-| /parkourCreate                         | /pcreate | \<name>                      | Creates a new parkour arena with the given name. The spawn is set to your location. |
-| /parkourRemove                         | /premove | \<arena>                     | Removes the specified parkour arena.                                                |
-| [/parkourEdit](#parkouredit)           | /pedit   | \<arena> \<option> \[value]  | Gets or sets a parkour arena option.                                                |
-| /parkourGroupSet                       | /pgset   | \<arena> \<group>            | Puts the given arena in the given group. Use "none" to remove an existing group.    |
-| /parkourGroupList                      | /pglist  | \[group]                     | Lists groups, or the stages of a group if a group is specified.                     |
-| [/parkourGroupSwap](#droppergroupswap) | /pgswap  | \<arena1> \<arena2>          | Swaps the two arenas in the group's ordered list.                                   |
 
-### Command explanation mini-games
-
-#### /miniGamesReward
-
-This command is used to set the rewards for an arena. Rewards can be set for six conditions; a reward for each time the
-arena is cleared, a reward for the first time the arena is cleared, a reward for beating your own least deaths record, a
-reward for beating your own least time record, a record for beating the global least deaths record and a record for
-beating the global least time record. You can give an item, give money, give a permission or execute a console command
-with the winning player as an argument.
-
-Note, you can add as many rewards as you want for each reward condition, so you can add a permission and an amount of
-currency on the player's first win for example.
-
-`/mreward add dropper|parkour <name> <condition> <type> [value] [value] ...`
-
-`/mreward clear dropper|parkour <name> <condition>`
-
-| Argument  | Type                                                                                                      | Usage                                                       |
-|-----------|-----------------------------------------------------------------------------------------------------------|-------------------------------------------------------------|
-| action    | add / clear                                                                                               | Whether you are adding a reward or clearing rewards.        |
-| type      | dropper / parkour                                                                                         | The type of arena to change rewards for                     |
-| name      | _Arena name_                                                                                              | The name of the arena to change rewards for                 |
-| condition | WIN / FIRST_WIN / PERSONAL_DEATH_RECORD / PERSONAL_TIME_RECORD / GLOBAL_DEATH_RECORD / GLOBAL_TIME_RECORD | The condition to change rewards for.                        |
-| type      | COMMAND / ECONOMY / ITEM / PERMISSION                                                                     | The type of reward to add                                   |
-| value     | [See reward types](#reward-types)                                                                         | Input for the reward type. Valid values depend on the type. |
-
-##### Reward types
-
-###### Economy
-
-This reward requires an argument which is a number above zero, which is the amount of currency granted to players.
-
-###### Permission
-
-This reward requires an argument which is the permission string you want to grant the player.
-
-###### Command
-
-The reward requires the command as an argument. Type the full command with spaces and everything, but omit the `/` at
-the beginning of the command. Use %player_name% or anything that matches the
-RegEx `[<%(\\[{]player[_\\-]?(name)?[>%)\\]}]` (\<player>. \<player-name>, %player_name%, {player}, etc.) as the
-placeholder for the rewarded player's name.
-
-###### Item
-
-If used with no arguments, the item in your main hand is used. You can specify a material in the first argument to give
-one item of the specified type. You can specify a positive whole number as the second argument to specify the amount of
-items to give.
-
-### Command explanation dropper
+### Command explanation
 
 #### /dropperJoin
 
@@ -177,58 +99,10 @@ You could use `/droppergroupswap Sea Savanna` to change the order to:
 3. Nether
 4. Sea
 
-### Command explanation parkour
-
-#### /parkourJoin
-
-This command is used for joining a dropper arena.
-
-`/parkourjoin <arena> [mode]`
-
-| Argument | Usage                                                                                                     |
-|----------|-----------------------------------------------------------------------------------------------------------|
-| arena    | The name of the arena to join.                                                                            |
-| mode     | Additional challenge modes can be played after an arena has been cleared once. Available modes: hardcore. |
-
-#### /parkourEdit
-
-This command allows editing the specified property for the specified parkour arena.
-
-`/parkouredit <arena> <option> [value]`
-
-| Argument | Usage                                 |
-|----------|---------------------------------------|
-| arena    | The name of the arena to edit.        |
-| option   | The option to display or change.      |
-| value    | The new value of the selected option. |
-
-These are all the options that can be changed for an arena.
-
-| Option          | Details                                                                                                                                                                                       |
-|-----------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| name            | The name of the arena. Used mainly to select the arena in commands. Note that underscore (_) cannot be used if you want to utilize placeholders, as it's used to split placeholder arguments. |
-| spawnLocation   | The spawn location of any player joining the arena. Use `56.546,64.0,44.45` to specify coordinates, or `here`, `this` or any other string to select your current location.                    |
-| exitLocation    | The location players will be sent to when exiting the arena. If not set, the player will be sent to where they joined from. Valid values are the same as for spawnLocation.                   |
-| winBlockType    | The type of block players must hit to win the arena. It can be any material as long as it's a block, and not a type of air.                                                                   |
-| winLocation     | The location players must reach to win the arena (see spawnLocation for valid values). If set, this overrides, and is used instead of, the win block type.                                    |
-| checkpointAdd   | Adds a new checkpoint to the arena's checkpoints (see spawnLocation for valid values).                                                                                                        |
-| checkpointClear | Clears all current checkpoints. Give any value to execute. If not given a value, current checkpoints are shown.                                                                               |
-| killPlaneBlocks | A comma-separated list of materials which will force a loss when stepped on. +WOOL and other [material tags](#notes-about-material-tags) are supported as well.                               |
-| obstacleBlocks  | A comma-separated list of materials which will force a loss when touched from any direction. +WOOL and other [material tags](#notes-about-material-tags) are supported as well.               |
-
 ## Configuration options
 
-### Shared
-
 | Name                              | Type                | Default                             | Description                                                                                                                                                                                                                       |
-|---------------------|------------------|---------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| liquidHitBoxDepth   | -1 < decimal < 0 | -0.8    | This decides how far inside a non-solid block the player must go before detection triggers (-1, 0). The closer to -1 it is, the more accurate it will seem to the player, but the likelihood of not detecting the hit increases.  | 
-| solidHitBoxDistance | 0 < decimal < 1  | 0.2     | This decides the distance the player must be from a block below them before a hit triggers (0, 1). If too low, the likelihood of detecting the hit decreases, but it won't look like the player hit the block without being near. |
-
-### Dropper
-
-| Name                              | Type                | Default                             | Description                                                                                                                                                                                                                                           |
-|-----------------------------------|---------------------|-------------------------------------|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+|-----------------------------------|---------------------|-------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
 | blockSneaking                     | true/false          | true                                | Whether to block using the shift key to drop faster than the intended drop speed                                                                                                                                                  |
 | blockSprinting                    | true/false          | true                                | Whether to block using the sprint key for slightly improved air speed                                                                                                                                                             |
 | verticalVelocity                  | 0 < decimal <= 75   | 1.0                                 | The vertical velocity used as default for all arenas. Must be greater than 0. 3.92 is the max speed of a falling player.                                                                                                          |
@@ -237,19 +111,11 @@ These are all the options that can be changed for an arena.
 | mustDoGroupedInSequence           | true/false          | true                                | Whether grouped dropper arenas must be played in the correct sequence                                                                                                                                                             |
 | ignoreRecordsUntilGroupBeatenOnce | true/false          | false                               | Whether records won't be registered unless the player has already beaten all arenas in a group. That means players are required to do a second play-through to register a record for a grouped arena.                             |
 | mustDoNormalModeFirst             | true/false          | true                                | Whether a player must do the normal/default game-mode before playing any other game-modes                                                                                                                                         |
+| makePlayersInvisible              | true/false          | false                               | Whether players should be made invisible while playing in a dropper arena                                                                                                                                                         |
+| disableHitCollision               | true/false          | true                                | Whether players should have their entity hit collision disabled while in an arena. This prevents players from pushing each-other if in the same arena.                                                                            |
 | liquidHitBoxDepth                 | -1 < decimal < 0    | -0.8                                | This decides how far inside a non-solid block the player must go before detection triggers (-1, 0). The closer to -1 it is, the more accurate it will seem to the player, but the likelihood of not detecting the hit increases.  | 
 | solidHitBoxDistance               | 0 < decimal < 1     | 0.2                                 | This decides the distance the player must be from a block below them before a hit triggers (0, 1). If too low, the likelihood of detecting the hit decreases, but it won't look like the player hit the block without being near. |
-| blockWhitelist                    | list                | [see this](#blockwhitelist-default) | A whitelist for which blocks won't trigger a loss when hit/passed through. The win block check happens before the loss check, so even blocks on the whitelist can be used as the win-block. "+" denotes a [material tag](#notes-about-material-tags). |
-
-### Parkour
-
-| Name                              | Type       | Default                              | Description                                                                                                                                                                                                                                                |
-|-----------------------------------|------------|--------------------------------------|------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| enforceCheckpointOrder            | true/false | false                                | Whether to enforce the order in which a player must reach checkpoints. Enabling this ensures that a player cannot trigger a previous checkpoint by accident. It also ensures players cannot skip a checkpoint, even if the arena layout makes it possible. |
-| mustDoGroupedInSequence           | true/false | true                                 | Whether grouped dropper arenas must be played in the correct sequence                                                                                                                                                                                      |
-| ignoreRecordsUntilGroupBeatenOnce | true/false | false                                | Whether records won't be registered unless the player has already beaten all arenas in a group. That means players are required to do a second play-through to register a record for a grouped arena.                                                      |
-| killPlaneBlocks                   | list       | [see this](#killplaneblocks-default) | The types of blocks compromising parkour arenas' kill planes. Add any materials you want to use for the "bottom" of your parkour arenas. +WOOL and other [material tags](#notes-about-material-tags) are supported.                                        |
-| obstacleBlocks                    | list       | [see this](#obstacleblocks-default)  | The types of blocks treated as obstacles in every direction. +WOOL and other [material tags](#notes-about-material-tags) are supported.                                                                                                                    |
+| blockWhitelist                    | list                | [see this](#blockwhitelist-default) | A whitelist for which blocks won't trigger a loss when hit/passed through. The win block check happens before the loss check, so even blocks on the whitelist can be used as the win-block. "+" denotes a material tag.           |
 
 #### blockWhitelist default:
 
@@ -266,72 +132,20 @@ These are all the options that can be changed for an arena.
 - +CORALS
 - +WALL_CORALS
 
-#### killPlaneBlocks default:
-
-- LAVA
-- MAGMA_BLOCK
-
-#### obstacleBlocks default:
-
-- END_ROD
-- LIGHTNING_ROD
-- CHAIN
-
 ## Record placeholders
 
 Player records can be displayed on a leaderboard by using PlaceholderAPI. If you want to display a sign-based
 leaderboard, you can use the [Placeholder Signs](https://git.knarcraft.net/EpicKnarvik97/PlaceholderSigns) plugin. The
 format for the built-in placeholders is as follows:
 
-`%gameMode_record_recordType_gameModeType_identifierType_identifier_recordPlacing_infoType%`
+`%dropper_record_recordType_gameModeType_identifierType_identifier_recordPlacing_infoType%`
 
 | Variable       | Values                      | Description                                                                                                                        |
 |----------------|-----------------------------|------------------------------------------------------------------------------------------------------------------------------------|
-| gameMode       | dropper / parkour           | A selection of which game-mode you are getting a record for                                                                        |
-| record         |                             | This must be as-is. It's a selector in case placeholders are added for more than records.                                          |
+| dropper_record |                             | Denotes that it's a placeholder for a dropper record. Must be present as-is.                                                       |
 | recordType     | deaths / time               | Selects the type of record to get (deaths or time).                                                                                |
 | gameModeType   | default / inverted / random | Selects the game-mode to get the record for.                                                                                       |
 | identifierType | arena / group               | The type of thing the following identifier points to (an arena or an arena group).                                                 |
 | identifier     | ?                           | An identifier (the name or UUID) for an arena or a group (whichever was chosen as identifierType).                                 |
 | recordPlacing  | 1 / 2 / 3 / ...             | The position of the record to get (1 = first place, 2 = second place, etc.).                                                       |
 | infoType       | player / value / combined   | The type of info to get. Player gets the player name, Value gets the value of the achieved record. Combined gets "Player: Record". |
-
-## Notes about material tags
-
-Where a list of material is allowed, this plugin supports using material tags that specify a set of blocks. This makes
-it much easier to add a lot of blocks without ending up with hundreds of individual materials. To specify
-such a tag, use a `+` character, and then the tag name.
-See <a href="https://hub.spigotmc.org/javadocs/spigot/org/bukkit/Tag.html">the documentation</a> for a complete overview
-of all tags. Only those with type `Tag<Material>` can be used.
-
-Example tags:
-
-- +WOOL
-- +WALL_SIGNS
-- +ACACIA_LOGS
-- +ALL_SIGNS
-- +DIAMOND_ORES
-- +DIRT
-- +DOORS
-- +DRAGON_IMMUNE
-- +FENCE_GATES
-- +FENCES
-
-## Language customization
-
-Most or all strings are customizable. If you place a strings.yml file in the plugin folder, it will take
-priority over built-in languages. If you want to change strings, look at MiniGames/src/main/resources/strings.yml for
-the proper keys. All strings have the format: ENUM: "Displayed string". The enum must be identical as it defines which
-string you have changed. All strings belonging to a language are beneath the language code and indented with two spaces.
-
-The easiest way to add a new language is to copy an existing language and paste it into your custom strings.yml and
-change strings as necessary. If you don't include all strings, the remaining will use the built-in English translation.
-Remember to change the language code to whichever you use for your custom language.
-
-The interval messages are unique in that if several values are separated by comma (option1,option2,option3), a random
-message will be chosen each time it's displayed.
-
-## License
-
-MiniGames is licensed under the GNU Public License Version 3.0. This includes every source and resource file. See the
-HEADER file for a more detailed license description.

pom.xml

@@ -5,13 +5,13 @@
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>net.knarcraft</groupId>
-    <artifactId>MiniGames</artifactId>
-    <version>1.2</version>
+    <artifactId>Dropper</artifactId>
+    <version>1.0-SNAPSHOT</version>
     <packaging>jar</packaging>
 
-    <name>MiniGames</name>
+    <name>Dropper</name>
 
-    <description>A plugin which adds various mini-games</description>
+    <description>A plugin for dropper mini-games</description>
     <properties>
         <java.version>16</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -40,26 +40,6 @@
                         </goals>
                         <configuration>
                             <createDependencyReducedPom>false</createDependencyReducedPom>
-                            <filters>
-                                <filter>
-                                    <artifact>net.knarcraft:knarlib</artifact>
-                                    <includes>
-                                        <include>net/knarcraft/knarlib/**</include>
-                                    </includes>
-                                </filter>
-                                <filter>
-                                    <artifact>net.knarcraft:knargui</artifact>
-                                    <includes>
-                                        <include>net/knarcraft/knargui/**</include>
-                                    </includes>
-                                </filter>
-                                <filter>
-                                    <excludes>
-                                        <exclude>*.MF</exclude>
-                                        <exclude>*.yml</exclude>
-                                    </excludes>
-                                </filter>
-                            </filters>
                         </configuration>
                     </execution>
                 </executions>
@@ -82,21 +62,13 @@
             <id>placeholderapi</id>
             <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
         </repository>
-        <repository>
-            <id>knarcraft-repo</id>
-            <url>https://git.knarcraft.net/api/packages/EpicKnarvik97/maven</url>
-        </repository>
-        <repository>
-            <id>jitpack.io</id>
-            <url>https://jitpack.io</url>
-        </repository>
     </repositories>
 
     <dependencies>
         <dependency>
             <groupId>org.spigotmc</groupId>
             <artifactId>spigot-api</artifactId>
-            <version>1.20-R0.1-SNAPSHOT</version>
+            <version>1.19.4-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>
         <dependency>
@@ -105,29 +77,17 @@
             <version>24.0.1</version>
             <scope>provided</scope>
         </dependency>
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>5.9.2</version>
+            <scope>test</scope>
+        </dependency>
         <dependency>
             <groupId>me.clip</groupId>
             <artifactId>placeholderapi</artifactId>
             <version>2.10.0</version>
             <scope>provided</scope>
         </dependency>
-        <dependency>
-            <groupId>net.knarcraft</groupId>
-            <artifactId>knargui</artifactId>
-            <version>1.0-SNAPSHOT</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>net.knarcraft</groupId>
-            <artifactId>knarlib</artifactId>
-            <version>1.2.3-SNAPSHOT</version>
-            <scope>compile</scope>
-        </dependency>
-        <dependency>
-            <groupId>com.github.MilkBowl</groupId>
-            <artifactId>VaultAPI</artifactId>
-            <version>1.7</version>
-            <scope>provided</scope>
-        </dependency>
     </dependencies>
 </project>

src/main/java/net/knarcraft/dropper/Dropper.java

@@ -0,0 +1,205 @@
+package net.knarcraft.dropper;
+
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.DropperArenaData;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
+import net.knarcraft.dropper.arena.DropperArenaPlayerRegistry;
+import net.knarcraft.dropper.arena.DropperArenaRecordsRegistry;
+import net.knarcraft.dropper.arena.DropperArenaSession;
+import net.knarcraft.dropper.arena.record.IntegerRecord;
+import net.knarcraft.dropper.arena.record.LongRecord;
+import net.knarcraft.dropper.command.CreateArenaCommand;
+import net.knarcraft.dropper.command.EditArenaCommand;
+import net.knarcraft.dropper.command.EditArenaTabCompleter;
+import net.knarcraft.dropper.command.GroupListCommand;
+import net.knarcraft.dropper.command.GroupSetCommand;
+import net.knarcraft.dropper.command.GroupSwapCommand;
+import net.knarcraft.dropper.command.JoinArenaCommand;
+import net.knarcraft.dropper.command.JoinArenaTabCompleter;
+import net.knarcraft.dropper.command.LeaveArenaCommand;
+import net.knarcraft.dropper.command.ListArenaCommand;
+import net.knarcraft.dropper.command.ReloadCommand;
+import net.knarcraft.dropper.command.RemoveArenaCommand;
+import net.knarcraft.dropper.command.RemoveArenaTabCompleter;
+import net.knarcraft.dropper.config.DropperConfiguration;
+import net.knarcraft.dropper.container.SerializableMaterial;
+import net.knarcraft.dropper.container.SerializableUUID;
+import net.knarcraft.dropper.listener.CommandListener;
+import net.knarcraft.dropper.listener.DamageListener;
+import net.knarcraft.dropper.listener.MoveListener;
+import net.knarcraft.dropper.listener.PlayerLeaveListener;
+import net.knarcraft.dropper.placeholder.DropperRecordExpansion;
+import org.bukkit.Bukkit;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.command.TabCompleter;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginManager;
+import org.bukkit.plugin.java.JavaPlugin;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.logging.Level;
+
+/**
+ * The dropper plugin's main class
+ */
+@SuppressWarnings("unused")
+public final class Dropper extends JavaPlugin {
+
+    private static Dropper instance;
+    private DropperConfiguration configuration;
+    private DropperArenaHandler arenaHandler;
+    private DropperArenaPlayerRegistry playerRegistry;
+    private DropperRecordExpansion dropperRecordExpansion;
+
+    /**
+     * Gets an instance of this plugin
+     *
+     * @return <p>An instance of this plugin, or null if not initialized yet.</p>
+     */
+    public static Dropper getInstance() {
+        return instance;
+    }
+
+    /**
+     * Gets the arena handler for this instance
+     *
+     * @return <p>A dropper arena handler</p>
+     */
+    public DropperArenaHandler getArenaHandler() {
+        return this.arenaHandler;
+    }
+
+    /**
+     * Gets the arena player registry for this instance
+     *
+     * @return <p>A dropper arena player registry</p>
+     */
+    public DropperArenaPlayerRegistry getPlayerRegistry() {
+        return this.playerRegistry;
+    }
+
+    /**
+     * Gets the dropper configuration
+     *
+     * @return <p>The dropper configuration</p>
+     */
+    public DropperConfiguration getDropperConfiguration() {
+        return this.configuration;
+    }
+
+    /**
+     * Logs a message
+     *
+     * @param level   <p>The message level to log at</p>
+     * @param message <p>The message to log</p>
+     */
+    public static void log(Level level, String message) {
+        Dropper.getInstance().getLogger().log(level, message);
+    }
+
+    /**
+     * Reloads all configurations and data from disk
+     */
+    public void reload() {
+        // Load all arenas again
+        this.arenaHandler.loadArenas();
+        this.arenaHandler.loadGroups();
+
+        // Reload configuration
+        this.reloadConfig();
+        this.configuration.load(this.getConfig());
+
+        // Clear record caches
+        this.dropperRecordExpansion.clearCaches();
+    }
+
+    @Override
+    public void onLoad() {
+        super.onLoad();
+        // Register serialization classes
+        ConfigurationSerialization.registerClass(SerializableMaterial.class);
+        ConfigurationSerialization.registerClass(DropperArenaRecordsRegistry.class);
+        ConfigurationSerialization.registerClass(SerializableUUID.class);
+        ConfigurationSerialization.registerClass(DropperArenaData.class);
+        ConfigurationSerialization.registerClass(DropperArenaGroup.class);
+        ConfigurationSerialization.registerClass(ArenaGameMode.class);
+        ConfigurationSerialization.registerClass(LongRecord.class);
+        ConfigurationSerialization.registerClass(IntegerRecord.class);
+    }
+
+    @Override
+    public void onEnable() {
+        // Plugin startup logic
+        instance = this;
+        this.saveDefaultConfig();
+        getConfig().options().copyDefaults(true);
+        saveConfig();
+        reloadConfig();
+        this.configuration = new DropperConfiguration(this.getConfig());
+        this.configuration.load();
+        this.playerRegistry = new DropperArenaPlayerRegistry();
+        this.arenaHandler = new DropperArenaHandler();
+        this.arenaHandler.loadArenas();
+        this.arenaHandler.loadGroups();
+
+        PluginManager pluginManager = getServer().getPluginManager();
+        pluginManager.registerEvents(new DamageListener(), this);
+        pluginManager.registerEvents(new MoveListener(this.configuration), this);
+        pluginManager.registerEvents(new PlayerLeaveListener(), this);
+        pluginManager.registerEvents(new CommandListener(), this);
+
+        registerCommand("dropperReload", new ReloadCommand(), null);
+        registerCommand("dropperCreate", new CreateArenaCommand(), null);
+        registerCommand("dropperList", new ListArenaCommand(), null);
+        registerCommand("dropperJoin", new JoinArenaCommand(), new JoinArenaTabCompleter());
+        registerCommand("dropperLeave", new LeaveArenaCommand(), null);
+        registerCommand("dropperEdit", new EditArenaCommand(this.configuration), new EditArenaTabCompleter());
+        registerCommand("dropperRemove", new RemoveArenaCommand(), new RemoveArenaTabCompleter());
+        registerCommand("dropperGroupSet", new GroupSetCommand(), null);
+        registerCommand("dropperGroupSwap", new GroupSwapCommand(), null);
+        registerCommand("dropperGroupList", new GroupListCommand(), null);
+
+        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
+            this.dropperRecordExpansion = new DropperRecordExpansion(this);
+            if (!this.dropperRecordExpansion.register()) {
+                log(Level.WARNING, "Unable to register PlaceholderAPI expansion!");
+            }
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        // Throw out currently playing players before exiting
+        for (Player player : getServer().getOnlinePlayers()) {
+            DropperArenaSession session = playerRegistry.getArenaSession(player.getUniqueId());
+            if (session != null) {
+                session.triggerQuit(true);
+            }
+        }
+    }
+
+    /**
+     * Registers a command
+     *
+     * @param commandName     <p>The name of the command to register (defined in plugin.yml)</p>
+     * @param commandExecutor <p>The executor for the command</p>
+     * @param tabCompleter    <p>The tab-completer to use, or null</p>
+     */
+    private void registerCommand(@NotNull String commandName, @NotNull CommandExecutor commandExecutor,
+                                 @Nullable TabCompleter tabCompleter) {
+        PluginCommand command = this.getCommand(commandName);
+        if (command != null) {
+            command.setExecutor(commandExecutor);
+            if (tabCompleter != null) {
+                command.setTabCompleter(tabCompleter);
+            }
+        } else {
+            log(Level.SEVERE, "Unable to register the command " + commandName);
+        }
+    }
+
+}

src/main/java/net/knarcraft/dropper/arena/ArenaEditableProperty.java

@@ -1,6 +1,5 @@
-package net.knarcraft.minigames.arena.dropper;
+package net.knarcraft.dropper.arena;
 
-import net.knarcraft.minigames.arena.EditablePropertyType;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -9,67 +8,50 @@ import java.util.function.Function;
 /**
  * All editable properties of a dropper arena
  */
-public enum DropperArenaEditableProperty {
+public enum ArenaEditableProperty {
 
     /**
      * The name of the arena
      */
-    NAME("name", DropperArena::getArenaName, EditablePropertyType.ARENA_NAME),
+    NAME("name", DropperArena::getArenaName),
 
     /**
      * The arena's spawn location
      */
-    SPAWN_LOCATION("spawnLocation", (arena) -> String.valueOf(arena.getSpawnLocation()),
-            EditablePropertyType.LOCATION),
+    SPAWN_LOCATION("spawnLocation", (arena) -> String.valueOf(arena.getSpawnLocation())),
 
     /**
      * The arena's exit location
      */
-    EXIT_LOCATION("exitLocation", (arena) -> String.valueOf(arena.getExitLocation()),
-            EditablePropertyType.LOCATION),
+    EXIT_LOCATION("exitLocation", (arena) -> String.valueOf(arena.getExitLocation())),
 
     /**
      * The arena's vertical velocity
      */
-    VERTICAL_VELOCITY("verticalVelocity", (arena) -> String.valueOf(arena.getPlayerVerticalVelocity()),
-            EditablePropertyType.VERTICAL_VELOCITY),
+    VERTICAL_VELOCITY("verticalVelocity", (arena) -> String.valueOf(arena.getPlayerVerticalVelocity())),
 
     /**
      * The arena's horizontal velocity
      */
-    HORIZONTAL_VELOCITY("horizontalVelocity", (arena) -> String.valueOf(arena.getPlayerHorizontalVelocity()),
-            EditablePropertyType.HORIZONTAL_VELOCITY),
+    HORIZONTAL_VELOCITY("horizontalVelocity", (arena) -> String.valueOf(arena.getPlayerHorizontalVelocity())),
 
     /**
      * The arena's win block type
      */
-    WIN_BLOCK_TYPE("winBlockType", (arena) -> arena.getWinBlockType().toString(),
-            EditablePropertyType.BLOCK_TYPE),
+    WIN_BLOCK_TYPE("winBlockType", (arena) -> arena.getWinBlockType().toString()),
     ;
 
     private final @NotNull String argumentString;
     private final Function<DropperArena, String> currentValueProvider;
-    private final EditablePropertyType propertyType;
 
     /**
      * Instantiates a new arena editable property
      *
      * @param argumentString <p>The argument string used to specify this property</p>
      */
-    DropperArenaEditableProperty(@NotNull String argumentString, Function<DropperArena, String> currentValueProvider,
-                                 EditablePropertyType propertyType) {
+    ArenaEditableProperty(@NotNull String argumentString, Function<DropperArena, String> currentValueProvider) {
         this.argumentString = argumentString;
         this.currentValueProvider = currentValueProvider;
-        this.propertyType = propertyType;
-    }
-
-    /**
-     * Gets the type of property this editable property represents
-     *
-     * @return <p>The type of this property</p>
-     */
-    public EditablePropertyType getPropertyType() {
-        return this.propertyType;
     }
 
     /**
@@ -97,8 +79,8 @@ public enum DropperArenaEditableProperty {
      * @param argumentString <p>The argument string used to specify an editable property</p>
      * @return <p>The corresponding editable property, or null if not found</p>
      */
-    public static @Nullable DropperArenaEditableProperty getFromArgumentString(String argumentString) {
-        for (DropperArenaEditableProperty property : DropperArenaEditableProperty.values()) {
+    public static @Nullable ArenaEditableProperty getFromArgumentString(String argumentString) {
+        for (ArenaEditableProperty property : ArenaEditableProperty.values()) {
             if (property.argumentString.equalsIgnoreCase(argumentString)) {
                 return property;
             }

src/main/java/net/knarcraft/dropper/arena/ArenaGameMode.java

@@ -1,6 +1,5 @@
-package net.knarcraft.minigames.arena.dropper;
+package net.knarcraft.dropper.arena;
 
-import net.knarcraft.minigames.arena.ArenaGameMode;
 import org.bukkit.configuration.serialization.ConfigurationSerializable;
 import org.jetbrains.annotations.NotNull;
 
@@ -10,7 +9,7 @@ import java.util.Map;
 /**
  * A representation of possible arena game-modes
  */
-public enum DropperArenaGameMode implements ConfigurationSerializable, ArenaGameMode {
+public enum ArenaGameMode implements ConfigurationSerializable {
 
     /**
      * The default game-mode. Failing once throws the player out.
@@ -34,14 +33,14 @@ public enum DropperArenaGameMode implements ConfigurationSerializable, ArenaGame
      * @param gameMode <p>The game-mode string to match</p>
      * @return <p>The specified arena game-mode</p>
      */
-    public static @NotNull DropperArenaGameMode matchGameMode(@NotNull String gameMode) {
+    public static @NotNull ArenaGameMode matchGamemode(@NotNull String gameMode) {
         String sanitized = gameMode.trim().toLowerCase();
         if (sanitized.matches("(invert(ed)?|inverse)")) {
-            return DropperArenaGameMode.INVERTED;
-        } else if (sanitized.matches("rand(om)?_?(inverted)?")) {
-            return DropperArenaGameMode.RANDOM_INVERTED;
+            return ArenaGameMode.INVERTED;
+        } else if (sanitized.matches("rand(om)?")) {
+            return ArenaGameMode.RANDOM_INVERTED;
         } else {
-            return DropperArenaGameMode.DEFAULT;
+            return ArenaGameMode.DEFAULT;
         }
     }
 
@@ -60,13 +59,8 @@ public enum DropperArenaGameMode implements ConfigurationSerializable, ArenaGame
      * @return <p>The deserialized arena game-mode</p>
      */
     @SuppressWarnings("unused")
-    public static DropperArenaGameMode deserialize(Map<String, Object> data) {
-        return DropperArenaGameMode.valueOf((String) data.get("name"));
-    }
-
-    @Override
-    public @NotNull DropperArenaGameMode[] getValues() {
-        return DropperArenaGameMode.values();
+    public static ArenaGameMode deserialize(Map<String, Object> data) {
+        return ArenaGameMode.valueOf((String) data.get("name"));
     }
 
 }

src/main/java/net/knarcraft/dropper/arena/ArenaStorageKey.java

@@ -1,11 +1,11 @@
-package net.knarcraft.minigames.arena.dropper;
+package net.knarcraft.dropper.arena;
 
 import org.jetbrains.annotations.NotNull;
 
 /**
  * A representation of each key used for storing arena data
  */
-public enum DropperArenaStorageKey {
+public enum ArenaStorageKey {
 
     /**
      * The key for an arena's id
@@ -43,14 +43,9 @@ public enum DropperArenaStorageKey {
     WIN_BLOCK_TYPE("winBlockType"),
 
     /**
-     * The key for this arena's data
+     * The hey for this arena's data
      */
     DATA("arenaData"),
-
-    /**
-     * The key for this arena's rewards
-     */
-    REWARDS("rewards"),
     ;
 
     private final @NotNull String key;
@@ -60,7 +55,7 @@ public enum DropperArenaStorageKey {
      *
      * @param key <p>The string path of the configuration key this value represents.</p>
      */
-    DropperArenaStorageKey(@NotNull String key) {
+    ArenaStorageKey(@NotNull String key) {
         this.key = key;
     }
 

src/main/java/net/knarcraft/dropper/arena/DropperArena.java

@@ -1,34 +1,22 @@
-package net.knarcraft.minigames.arena.dropper;
+package net.knarcraft.dropper.arena;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.Arena;
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.reward.Reward;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.config.DropperConfiguration;
-import net.knarcraft.minigames.util.DropperArenaStorageHelper;
-import net.knarcraft.minigames.util.StringSanitizer;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.config.DropperConfiguration;
+import net.knarcraft.dropper.util.StringSanitizer;
 import org.bukkit.Location;
 import org.bukkit.Material;
-import org.bukkit.block.Block;
+import org.bukkit.World;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
-import java.io.IOException;
 import java.util.HashMap;
-import java.util.HashSet;
 import java.util.Map;
-import java.util.Set;
 import java.util.UUID;
-import java.util.logging.Level;
-
-import static net.knarcraft.minigames.util.InputValidationHelper.isInvalid;
 
 /**
  * A representation of one dropper arena
  */
-public class DropperArena implements Arena {
+public class DropperArena {
 
     /**
      * An unique and persistent identifier for this arena
@@ -75,10 +63,6 @@ public class DropperArena implements Arena {
 
     private final DropperArenaHandler dropperArenaHandler;
 
-    private Map<RewardCondition, Set<Reward>> rewards = new HashMap<>();
-
-    private static final DropperConfiguration dropperConfiguration = MiniGames.getInstance().getDropperConfiguration();
-
     /**
      * Instantiates a new dropper arena
      *
@@ -89,14 +73,13 @@ public class DropperArena implements Arena {
      * @param playerVerticalVelocity   <p>The velocity to use for players' vertical velocity</p>
      * @param playerHorizontalVelocity <p>The velocity to use for players' horizontal velocity (-1 to 1)</p>
      * @param winBlockType             <p>The material of the block players have to hit to win this dropper arena</p>
-     * @param rewards                  <p>The rewards given by this arena</p>
      * @param dropperArenaData         <p>The arena data keeping track of which players have done what in this arena</p>
      * @param arenaHandler             <p>The arena handler used for saving any changes</p>
      */
     public DropperArena(@NotNull UUID arenaId, @NotNull String arenaName, @NotNull Location spawnLocation,
                         @Nullable Location exitLocation, double playerVerticalVelocity, float playerHorizontalVelocity,
-                        @NotNull Material winBlockType, @NotNull Map<RewardCondition, Set<Reward>> rewards,
-                        @NotNull DropperArenaData dropperArenaData, @NotNull DropperArenaHandler arenaHandler) {
+                        @NotNull Material winBlockType, @NotNull DropperArenaData dropperArenaData,
+                        @NotNull DropperArenaHandler arenaHandler) {
         this.arenaId = arenaId;
         this.arenaName = arenaName;
         this.spawnLocation = spawnLocation;
@@ -106,7 +89,6 @@ public class DropperArena implements Arena {
         this.winBlockType = winBlockType;
         this.dropperArenaData = dropperArenaData;
         this.dropperArenaHandler = arenaHandler;
-        this.rewards = rewards;
     }
 
     /**
@@ -121,7 +103,7 @@ public class DropperArena implements Arena {
      */
     public DropperArena(@NotNull String arenaName, @NotNull Location spawnLocation,
                         @NotNull DropperArenaHandler arenaHandler) {
-        DropperConfiguration configuration = MiniGames.getInstance().getDropperConfiguration();
+        DropperConfiguration configuration = Dropper.getInstance().getDropperConfiguration();
         this.arenaId = UUID.randomUUID();
         this.arenaName = arenaName;
         this.spawnLocation = spawnLocation;
@@ -129,8 +111,8 @@ public class DropperArena implements Arena {
         this.playerVerticalVelocity = configuration.getVerticalVelocity();
         this.playerHorizontalVelocity = configuration.getHorizontalVelocity();
 
-        Map<ArenaGameMode, ArenaRecordsRegistry> recordRegistries = new HashMap<>();
-        for (ArenaGameMode arenaGameMode : DropperArenaGameMode.values()) {
+        Map<ArenaGameMode, DropperArenaRecordsRegistry> recordRegistries = new HashMap<>();
+        for (ArenaGameMode arenaGameMode : ArenaGameMode.values()) {
             recordRegistries.put(arenaGameMode, new DropperArenaRecordsRegistry(this.arenaId));
         }
 
@@ -139,51 +121,51 @@ public class DropperArena implements Arena {
         this.dropperArenaHandler = arenaHandler;
     }
 
-    @Override
+    /**
+     * Gets this arena's data
+     *
+     * @return <p>This arena's data</p>
+     */
     public @NotNull DropperArenaData getData() {
         return this.dropperArenaData;
     }
 
-    @Override
+    /**
+     * Gets the id of this arena
+     *
+     * @return <p>This arena's identifier</p>
+     */
     public @NotNull UUID getArenaId() {
         return this.arenaId;
     }
 
-    @Override
+    /**
+     * Gets the name of this arena
+     *
+     * @return <p>The name of this arena</p>
+     */
     public @NotNull String getArenaName() {
         return this.arenaName;
     }
 
-    @Override
+    /**
+     * Gets this arena's spawn location
+     *
+     * <p>The spawn location is the location every player starts from when entering the dropper.</p>
+     *
+     * @return <p>This arena's spawn location.</p>
+     */
     public @NotNull Location getSpawnLocation() {
-        return this.spawnLocation.clone();
+        return this.spawnLocation;
     }
 
-    @Override
+    /**
+     * Gets this arena's exit location
+     *
+     * @return <p>This arena's exit location, or null if no such location is set.</p>
+     */
     public @Nullable Location getExitLocation() {
-        return this.exitLocation != null ? this.exitLocation.clone() : null;
-    }
-
-    @Override
-    public void addReward(@NotNull RewardCondition rewardCondition, @NotNull Reward reward) {
-        this.rewards.computeIfAbsent(rewardCondition, k -> new HashSet<>());
-        this.rewards.get(rewardCondition).add(reward);
-        this.saveArena();
-    }
-
-    @Override
-    public void clearRewards(@NotNull RewardCondition rewardCondition) {
-        this.rewards.remove(rewardCondition);
-        this.saveArena();
-    }
-
-    @Override
-    public @NotNull Set<Reward> getRewards(RewardCondition rewardCondition) {
-        if (this.rewards.containsKey(rewardCondition) && this.rewards.get(rewardCondition) != null) {
-            return this.rewards.get(rewardCondition);
-        } else {
-            return new HashSet<>();
-        }
+        return this.exitLocation;
     }
 
     /**
@@ -227,36 +209,6 @@ public class DropperArena implements Arena {
         return StringSanitizer.sanitizeArenaName(this.getArenaName());
     }
 
-    @Override
-    public boolean removeData() {
-        return DropperArenaStorageHelper.removeDropperArenaData(getArenaId());
-    }
-
-    @Override
-    public boolean saveData() {
-        try {
-            DropperArenaStorageHelper.saveDropperArenaData(getData());
-            return true;
-        } catch (IOException exception) {
-            return false;
-        }
-    }
-
-    @Override
-    public boolean willCauseWin(Block block) {
-        return block.getType() == winBlockType;
-    }
-
-    @Override
-    public boolean willCauseLoss(Block block) {
-        return !dropperConfiguration.getBlockWhitelist().contains(block.getType());
-    }
-
-    @Override
-    public boolean winLocationIsSolid() {
-        return winBlockType.isSolid();
-    }
-
     /**
      * Sets the spawn location for this arena
      *
@@ -268,7 +220,7 @@ public class DropperArena implements Arena {
             return false;
         } else {
             this.spawnLocation = newLocation;
-            this.saveArena();
+            dropperArenaHandler.saveArenas();
             return true;
         }
     }
@@ -284,7 +236,7 @@ public class DropperArena implements Arena {
             return false;
         } else {
             this.exitLocation = newLocation;
-            this.saveArena();
+            dropperArenaHandler.saveArenas();
             return true;
         }
     }
@@ -300,8 +252,8 @@ public class DropperArena implements Arena {
             String oldName = this.getArenaNameSanitized();
             this.arenaName = arenaName;
             // Update the arena lookup map to make sure the new name can be used immediately
-            this.dropperArenaHandler.updateLookupName(oldName, this.getArenaNameSanitized());
-            this.saveArena();
+            dropperArenaHandler.updateLookupName(oldName, this.getArenaNameSanitized());
+            dropperArenaHandler.saveArenas();
             return true;
         } else {
             return false;
@@ -321,7 +273,7 @@ public class DropperArena implements Arena {
             return false;
         } else {
             this.winBlockType = material;
-            this.saveArena();
+            dropperArenaHandler.saveArenas();
             return true;
         }
     }
@@ -339,7 +291,7 @@ public class DropperArena implements Arena {
             return false;
         } else {
             this.playerHorizontalVelocity = horizontalVelocity;
-            this.saveArena();
+            dropperArenaHandler.saveArenas();
             return true;
         }
     }
@@ -355,24 +307,11 @@ public class DropperArena implements Arena {
             return false;
         } else {
             this.playerVerticalVelocity = verticalVelocity;
-            this.saveArena();
+            dropperArenaHandler.saveArenas();
             return true;
         }
     }
 
-    /**
-     * Saves this arena to disk
-     */
-    public void saveArena() {
-        try {
-            DropperArenaStorageHelper.saveSingleDropperArena(this);
-        } catch (IOException exception) {
-            MiniGames.log(Level.SEVERE, "Unable to save arena! " +
-                    "Data loss can occur!");
-            MiniGames.log(Level.SEVERE, exception.getMessage());
-        }
-    }
-
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof DropperArena otherArena)) {
@@ -381,4 +320,15 @@ public class DropperArena implements Arena {
         return this.getArenaNameSanitized().equals(otherArena.getArenaNameSanitized());
     }
 
+    /**
+     * Checks whether the given location is valid
+     *
+     * @param location <p>The location to validate</p>
+     * @return <p>False if the location is valid</p>
+     */
+    private boolean isInvalid(Location location) {
+        World world = location.getWorld();
+        return world == null || !world.getWorldBorder().isInside(location);
+    }
+
 }

src/main/java/net/knarcraft/dropper/arena/DropperArenaData.java

@@ -0,0 +1,127 @@
+package net.knarcraft.dropper.arena;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.container.SerializableUUID;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * Data stored for an arena
+ *
+ * @param arenaId          <p>The id of the arena this data belongs to</p>
+ * @param recordRegistries <p>The records belonging to the arena</p>
+ * @param playersCompleted <p>A list of all player that have completed this arena</p>
+ */
+public record DropperArenaData(@NotNull UUID arenaId,
+                               @NotNull Map<ArenaGameMode, DropperArenaRecordsRegistry> recordRegistries,
+                               @NotNull Map<ArenaGameMode, Set<UUID>> playersCompleted) implements ConfigurationSerializable {
+
+    /**
+     * Instantiates a new dropper arena data object
+     *
+     * @param arenaId          <p>The id of the arena this data belongs to</p>
+     * @param recordRegistries <p>The registries of this arena's records</p>
+     * @param playersCompleted <p>The set of the players that have cleared this arena for each game-mode</p>
+     */
+    public DropperArenaData(@NotNull UUID arenaId,
+                            @NotNull Map<ArenaGameMode, DropperArenaRecordsRegistry> recordRegistries,
+                            @NotNull Map<ArenaGameMode, Set<UUID>> playersCompleted) {
+        this.arenaId = arenaId;
+        this.recordRegistries = recordRegistries;
+        this.playersCompleted = new HashMap<>(playersCompleted);
+    }
+
+    /**
+     * Gets whether the given player has cleared this arena
+     *
+     * @param arenaGameMode <p>The game-mode to check for</p>
+     * @param player        <p>The player to check</p>
+     * @return <p>True if the player has cleared the arena this data belongs to</p>
+     */
+    public boolean hasNotCompleted(@NotNull ArenaGameMode arenaGameMode, @NotNull Player player) {
+        return !this.playersCompleted.getOrDefault(arenaGameMode, new HashSet<>()).contains(player.getUniqueId());
+    }
+
+    /**
+     * Registers the given player as having completed this arena
+     *
+     * @param player <p>The player that completed this data's arena</p>
+     */
+    public boolean addCompleted(@NotNull ArenaGameMode arenaGameMode, @NotNull Player player) {
+        // Make sure to add an empty set to prevent a NullPointerException
+        if (!this.playersCompleted.containsKey(arenaGameMode)) {
+            this.playersCompleted.put(arenaGameMode, new HashSet<>());
+        }
+
+        boolean added = this.playersCompleted.get(arenaGameMode).add(player.getUniqueId());
+        // Persistently save the completion
+        if (added) {
+            Dropper.getInstance().getArenaHandler().saveData(this.arenaId);
+        }
+        return added;
+    }
+
+    @NotNull
+    @Override
+    public Map<String, Object> serialize() {
+        Map<String, Object> data = new HashMap<>();
+        data.put("arenaId", new SerializableUUID(this.arenaId));
+        data.put("recordsRegistry", this.recordRegistries);
+
+        // Convert normal UUIDs to serializable UUIDs
+        Map<ArenaGameMode, Set<SerializableUUID>> serializablePlayersCompleted = new HashMap<>();
+        for (ArenaGameMode arenaGameMode : this.playersCompleted.keySet()) {
+            Set<SerializableUUID> playersCompleted = new HashSet<>();
+            for (UUID playerCompleted : this.playersCompleted.get(arenaGameMode)) {
+                playersCompleted.add(new SerializableUUID(playerCompleted));
+            }
+            serializablePlayersCompleted.put(arenaGameMode, playersCompleted);
+        }
+        data.put("playersCompleted", serializablePlayersCompleted);
+        return data;
+    }
+
+    /**
+     * Deserializes a dropper arena data from the given data
+     *
+     * @param data <p>The data to deserialize</p>
+     * @return <p>The deserialized dropper arena data</p>
+     */
+    @SuppressWarnings({"unused", "unchecked"})
+    public static @NotNull DropperArenaData deserialize(@NotNull Map<String, Object> data) {
+        SerializableUUID serializableUUID = (SerializableUUID) data.get("arenaId");
+        Map<ArenaGameMode, DropperArenaRecordsRegistry> recordsRegistry =
+                (Map<ArenaGameMode, DropperArenaRecordsRegistry>) data.get("recordsRegistry");
+        Map<ArenaGameMode, Set<SerializableUUID>> playersCompletedData =
+                (Map<ArenaGameMode, Set<SerializableUUID>>) data.get("playersCompleted");
+
+        if (recordsRegistry == null) {
+            recordsRegistry = new HashMap<>();
+        } else if (playersCompletedData == null) {
+            playersCompletedData = new HashMap<>();
+        }
+
+        // Convert the serializable UUIDs to normal UUIDs
+        Map<ArenaGameMode, Set<UUID>> allPlayersCompleted = new HashMap<>();
+        for (ArenaGameMode arenaGameMode : playersCompletedData.keySet()) {
+            Set<UUID> playersCompleted = new HashSet<>();
+            for (SerializableUUID completedId : playersCompletedData.get(arenaGameMode)) {
+                playersCompleted.add(completedId.uuid());
+            }
+            allPlayersCompleted.put(arenaGameMode, playersCompleted);
+
+            if (!recordsRegistry.containsKey(arenaGameMode) || recordsRegistry.get(arenaGameMode) == null) {
+                recordsRegistry.put(arenaGameMode, new DropperArenaRecordsRegistry(serializableUUID.uuid()));
+            }
+        }
+        return new DropperArenaData(serializableUUID.uuid(), recordsRegistry, allPlayersCompleted);
+    }
+
+}

src/main/java/net/knarcraft/dropper/arena/DropperArenaGroup.java

@@ -1,8 +1,8 @@
-package net.knarcraft.minigames.arena;
+package net.knarcraft.dropper.arena;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.util.StringSanitizer;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.container.SerializableUUID;
+import net.knarcraft.dropper.util.StringSanitizer;
 import org.bukkit.configuration.serialization.ConfigurationSerializable;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -15,12 +15,9 @@ import java.util.UUID;
 import java.util.logging.Level;
 
 /**
- * A group containing a list of arenas
- *
- * @param <K> <p>The type of arena stored</p>
- * @param <S> <p>The type of arena group stored in the given arena handler</p>
+ * A sorted group of arenas that must be completed in sequence
  */
-public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> implements ConfigurationSerializable {
+public class DropperArenaGroup implements ConfigurationSerializable {
 
     /**
      * The unique id for this group of arenas
@@ -32,11 +29,6 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
      */
     private final String groupName;
 
-    /**
-     * The arena handler used to convert uuids to arenas
-     */
-    private final ArenaHandler<K, S> arenaHandler;
-
     /**
      * The arenas in this group, ordered from stage 1 to stage n
      */
@@ -46,33 +38,28 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
      * Instantiates a new dropper arena group
      *
      * @param groupName <p>The name of this group</p>
-     * @param arenaHandler <p>The arena handler used to convert uuids to arenas</p>
      */
-    protected ArenaGroup(@NotNull String groupName, @NotNull ArenaHandler<K, S> arenaHandler) {
+    public DropperArenaGroup(@NotNull String groupName) {
         this.groupId = UUID.randomUUID();
         this.groupName = groupName;
         this.arenas = new ArrayList<>();
-        this.arenaHandler = arenaHandler;
     }
 
     /**
-     * Instantiates a new arena group
+     * Instantiates a new dropper arena group
      *
      * @param groupId   <p>The unique id of this group</p>
      * @param groupName <p>The name of this group</p>
      * @param arenas    <p>The arenas in this group</p>
-     * @param arenaHandler <p>The arena handler used to convert uuids to arenas</p>
      */
-    protected ArenaGroup(@NotNull UUID groupId, @NotNull String groupName, @NotNull List<UUID> arenas,
-                         @NotNull ArenaHandler<K, S> arenaHandler) {
+    private DropperArenaGroup(@NotNull UUID groupId, @NotNull String groupName, @NotNull List<UUID> arenas) {
         this.groupId = groupId;
         this.groupName = groupName;
         this.arenas = new ArrayList<>(arenas);
-        this.arenaHandler = arenaHandler;
     }
 
     /**
-     * Gets the id of this arena group
+     * Gets the id of this dropper arena group
      *
      * @return <p>The id of this group</p>
      */
@@ -81,7 +68,7 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
     }
 
     /**
-     * Gets the name of this arena group
+     * Gets the name of this dropper arena group
      *
      * @return <p>The name of this group</p>
      */
@@ -99,9 +86,9 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
     }
 
     /**
-     * Removes the given arena from this group
+     * Removes the given dropper arena from this group
      *
-     * @param arenaId <p>The id of the arena to remove</p>
+     * @param arenaId <p>The id of the dropper arena to remove</p>
      */
     public void removeArena(UUID arenaId) {
         this.arenas.remove(arenaId);
@@ -129,15 +116,6 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
         }
     }
 
-    /**
-     * Gets this group's name, but sanitized
-     *
-     * @return <p>The sanitized group name</p>
-     */
-    public @NotNull String getGroupNameSanitized() {
-        return StringSanitizer.sanitizeArenaName(this.getGroupName());
-    }
-
     /**
      * Checks whether the given player has beaten all arenas in this group on the given game-mode
      *
@@ -146,16 +124,17 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
      * @return <p>True if the player has beaten all arenas, false otherwise</p>
      */
     public boolean hasBeatenAll(ArenaGameMode gameMode, Player player) {
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
         for (UUID anArenaId : this.getArenas()) {
-            K arena = this.arenaHandler.getArena(anArenaId);
-            if (arena == null) {
+            DropperArena dropperArena = arenaHandler.getArena(anArenaId);
+            if (dropperArena == null) {
                 // The arena would only be null if the arena has been deleted, but not removed from this group
-                MiniGames.log(Level.WARNING, "The dropper group " + this.getGroupName() +
+                Dropper.log(Level.WARNING, "The dropper group " + this.getGroupName() +
                         " contains the arena id " + anArenaId + " which is not a valid arena id!");
                 continue;
             }
 
-            if (arena.getData().hasNotCompleted(gameMode, player)) {
+            if (dropperArena.getData().hasNotCompleted(gameMode, player)) {
                 return false;
             }
         }
@@ -171,32 +150,43 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
      * @return <p>True if the player is allowed to play the arena</p>
      * @throws IllegalArgumentException <p>If checking an arena not in this group</p>
      */
-    public boolean cannotPlay(ArenaGameMode gameMode, Player player, UUID arenaId) throws IllegalArgumentException {
+    public boolean canPlay(ArenaGameMode gameMode, Player player, UUID arenaId) throws IllegalArgumentException {
         if (!this.arenas.contains(arenaId)) {
             throw new IllegalArgumentException("Cannot check for playability for arena not in this group!");
         }
 
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
+
         for (UUID anArenaId : this.getArenas()) {
             // If the target arena is reached, allow, as all previous arenas must have been cleared
             if (arenaId.equals(anArenaId)) {
-                return false;
+                return true;
             }
 
-            K arena = this.arenaHandler.getArena(anArenaId);
-            if (arena == null) {
+            DropperArena dropperArena = arenaHandler.getArena(anArenaId);
+            if (dropperArena == null) {
                 // The arena would only be null if the arena has been deleted, but not removed from this group
-                MiniGames.log(Level.WARNING, String.format("The dropper group %s contains the" +
+                Dropper.log(Level.WARNING, String.format("The dropper group %s contains the" +
                         " arena id %s which is not a valid arena id!", this.getGroupName(), anArenaId));
                 continue;
             }
 
             // This is a lower-numbered arena the player has yet to complete
-            if (arena.getData().hasNotCompleted(gameMode, player)) {
-                return true;
+            if (dropperArena.getData().hasNotCompleted(gameMode, player)) {
+                return false;
             }
         }
 
-        return true;
+        return false;
+    }
+
+    /**
+     * Gets this group's name, but sanitized
+     *
+     * @return <p>The sanitized group name</p>
+     */
+    public @NotNull String getGroupNameSanitized() {
+        return StringSanitizer.sanitizeArenaName(this.getGroupName());
     }
 
     /**
@@ -233,9 +223,27 @@ public abstract class ArenaGroup<K extends Arena, S extends ArenaGroup<K, S>> im
         return data;
     }
 
+    /**
+     * Deserializes the given data
+     *
+     * @param data <p>The data to deserialize</p>
+     * @return <p>The deserialized arena group</p>
+     */
+    @SuppressWarnings({"unused", "unchecked"})
+    public static @NotNull DropperArenaGroup deserialize(@NotNull Map<String, Object> data) {
+        UUID id = ((SerializableUUID) data.get("groupId")).uuid();
+        String name = (String) data.get("groupName");
+        List<SerializableUUID> serializableArenas = (List<SerializableUUID>) data.get("arenas");
+        List<UUID> arenas = new ArrayList<>();
+        for (SerializableUUID arenaId : serializableArenas) {
+            arenas.add(arenaId.uuid());
+        }
+        return new DropperArenaGroup(id, name, arenas);
+    }
+
     @Override
     public boolean equals(Object other) {
-        if (!(other instanceof ArenaGroup<?, ?> otherGroup)) {
+        if (!(other instanceof DropperArenaGroup otherGroup)) {
             return false;
         }
         return this.getGroupNameSanitized().equals(otherGroup.getGroupNameSanitized());

src/main/java/net/knarcraft/dropper/arena/DropperArenaHandler.java

@@ -1,10 +1,12 @@
-package net.knarcraft.minigames.arena;
+package net.knarcraft.dropper.arena;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.util.StringSanitizer;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.util.ArenaStorageHelper;
+import net.knarcraft.dropper.util.StringSanitizer;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
+import java.io.IOException;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
@@ -13,34 +15,21 @@ import java.util.UUID;
 import java.util.logging.Level;
 
 /**
- * An interface describing a generic arena handler
- *
- * @param <K> <p>The type of arena stored</p>
- * @param <S> <p>The type of arena group stored</p>
+ * A handler that keeps track of all dropper arenas
  */
-public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>> {
+public class DropperArenaHandler {
 
-    protected Map<UUID, K> arenas = new HashMap<>();
-    protected Map<UUID, S> arenaGroups = new HashMap<>();
-    protected Map<String, UUID> arenaNameLookup = new HashMap<>();
-    private final ArenaPlayerRegistry<K> playerRegistry;
-
-    /**
-     * Instantiates a new arena handler
-     *
-     * @param playerRegistry <p>The registry keeping track of player sessions</p>
-     */
-    public ArenaHandler(ArenaPlayerRegistry<K> playerRegistry) {
-        this.playerRegistry = playerRegistry;
-    }
+    private Map<UUID, DropperArena> arenas = new HashMap<>();
+    private Map<UUID, DropperArenaGroup> arenaGroups = new HashMap<>();
+    private Map<String, UUID> arenaNameLookup = new HashMap<>();
 
     /**
      * Gets all arenas that are within a group
      *
      * @return <p>All arenas in a group</p>
      */
-    public @NotNull Set<K> getArenasInAGroup() {
-        Set<K> arenas = new HashSet<>();
+    public @NotNull Set<DropperArena> getArenasInAGroup() {
+        Set<DropperArena> arenas = new HashSet<>();
         for (UUID arenaId : arenaGroups.keySet()) {
             arenas.add(this.arenas.get(arenaId));
         }
@@ -48,11 +37,11 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
     }
 
     /**
-     * Gets a copy of all arena groups
+     * Gets a copy of all dropper groups
      *
-     * @return <p>All arena groups</p>
+     * @return <p>All dropper groups</p>
      */
-    public Set<S> getAllGroups() {
+    public Set<DropperArenaGroup> getAllGroups() {
         return new HashSet<>(arenaGroups.values());
     }
 
@@ -62,7 +51,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      * @param arenaId <p>The id of the arena to get the group of</p>
      * @return <p>The group the arena belongs to, or null if not in a group</p>
      */
-    public @Nullable S getGroup(@NotNull UUID arenaId) {
+    public @Nullable DropperArenaGroup getGroup(@NotNull UUID arenaId) {
         return this.arenaGroups.get(arenaId);
     }
 
@@ -72,7 +61,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      * @param arenaId    <p>The id of the arena to change</p>
      * @param arenaGroup <p>The group to add the arena to, or null to remove the current group</p>
      */
-    public void setGroup(@NotNull UUID arenaId, @Nullable S arenaGroup) {
+    public void setGroup(@NotNull UUID arenaId, @Nullable DropperArenaGroup arenaGroup) {
         if (arenaGroup == null) {
             // No need to remove something non-existing
             if (!this.arenaGroups.containsKey(arenaId)) {
@@ -80,7 +69,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
             }
 
             // Remove the existing group
-            S oldGroup = this.arenaGroups.remove(arenaId);
+            DropperArenaGroup oldGroup = this.arenaGroups.remove(arenaId);
             oldGroup.removeArena(arenaId);
         } else {
             // Make sure to remove the arena from the old group's internal tracking
@@ -95,14 +84,14 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
     }
 
     /**
-     * Gets the arena group with the given name
+     * Gets the dropper arena group with the given name
      *
      * @param groupName <p>The name of the group to get</p>
      * @return <p>The group, or null if not found</p>
      */
-    public @Nullable S getGroup(String groupName) {
+    public @Nullable DropperArenaGroup getGroup(String groupName) {
         String sanitized = StringSanitizer.sanitizeArenaName(groupName);
-        for (S arenaGroup : this.arenaGroups.values()) {
+        for (DropperArenaGroup arenaGroup : this.arenaGroups.values()) {
             if (arenaGroup.getGroupNameSanitized().equals(sanitized)) {
                 return arenaGroup;
             }
@@ -128,7 +117,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      *
      * @param arena <p>The arena to add</p>
      */
-    public void addArena(@NotNull K arena) {
+    public void addArena(@NotNull DropperArena arena) {
         this.arenas.put(arena.getArenaId(), arena);
         this.arenaNameLookup.put(arena.getArenaNameSanitized(), arena.getArenaId());
         this.saveArenas();
@@ -140,7 +129,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      * @param arenaId <p>The id of the arena to get</p>
      * @return <p>The arena, or null if no arena could be found</p>
      */
-    public @Nullable K getArena(@NotNull UUID arenaId) {
+    public @Nullable DropperArena getArena(@NotNull UUID arenaId) {
         return this.arenas.get(arenaId);
     }
 
@@ -150,7 +139,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      * @param arenaName <p>The arena to get</p>
      * @return <p>The arena with the given name, or null if not found</p>
      */
-    public @Nullable K getArena(@NotNull String arenaName) {
+    public @Nullable DropperArena getArena(@NotNull String arenaName) {
         return this.arenas.get(this.arenaNameLookup.get(StringSanitizer.sanitizeArenaName(arenaName)));
     }
 
@@ -159,7 +148,7 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      *
      * @return <p>All known arenas</p>
      */
-    public @NotNull Map<UUID, K> getArenas() {
+    public @NotNull Map<UUID, DropperArena> getArenas() {
         return new HashMap<>(this.arenas);
     }
 
@@ -168,14 +157,14 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      *
      * @param arena <p>The arena to remove</p>
      */
-    public void removeArena(@NotNull K arena) {
+    public void removeArena(@NotNull DropperArena arena) {
         UUID arenaId = arena.getArenaId();
-        this.playerRegistry.removeForArena(arena, false);
+        Dropper.getInstance().getPlayerRegistry().removeForArena(arena);
         this.arenas.remove(arenaId);
         this.arenaNameLookup.remove(arena.getArenaNameSanitized());
         this.arenaGroups.remove(arenaId);
-        if (!arena.removeData()) {
-            MiniGames.log(Level.WARNING, "Unable to remove arena data file " + arenaId + ".yml. " +
+        if (!ArenaStorageHelper.removeArenaData(arenaId)) {
+            Dropper.log(Level.WARNING, "Unable to remove dropper arena data file " + arenaId + ".yml. " +
                     "You must remove it manually!");
         }
         this.saveArenas();
@@ -187,44 +176,66 @@ public abstract class ArenaHandler<K extends Arena, S extends ArenaGroup<K, S>>
      * @param arenaId <p>The id of the arena whose data should be saved</p>
      */
     public void saveData(UUID arenaId) {
-        K arena = getArena(arenaId);
-        if (arena != null) {
-            if (!arena.saveData()) {
-                MiniGames.log(Level.WARNING, "Unable to save data for arena with id " + arenaId +
-                        " because of a write exception!");
-            }
-        } else {
-            MiniGames.log(Level.WARNING, "Unable to save data for arena with id " + arenaId +
-                    " because the arena could not be found!");
+        try {
+            ArenaStorageHelper.saveArenaData(this.arenas.get(arenaId).getData());
+        } catch (IOException e) {
+            Dropper.log(Level.SEVERE, "Unable to save arena data! Data loss can occur!");
+            Dropper.log(Level.SEVERE, e.getMessage());
         }
     }
 
     /**
-     * Saves all current groups to disk
+     * Saves all current dropper groups to disk
      */
-    public abstract void saveGroups();
+    public void saveGroups() {
+        try {
+            ArenaStorageHelper.saveDropperArenaGroups(new HashSet<>(this.arenaGroups.values()));
+        } catch (IOException e) {
+            Dropper.log(Level.SEVERE, "Unable to save current arena groups! " +
+                    "Data loss can occur!");
+            Dropper.log(Level.SEVERE, e.getMessage());
+        }
+    }
 
     /**
-     * Loads all groups from disk
+     * Loads all dropper groups from disk
      */
-    protected abstract void loadGroups();
-
-    /**
-     * Loads all arenas and groups from disk
-     */
-    public void load() {
-        loadArenas();
-        loadGroups();
+    public void loadGroups() {
+        Set<DropperArenaGroup> arenaGroups = ArenaStorageHelper.loadDropperArenaGroups();
+        Map<UUID, DropperArenaGroup> arenaGroupMap = new HashMap<>();
+        for (DropperArenaGroup arenaGroup : arenaGroups) {
+            for (UUID arenaId : arenaGroup.getArenas()) {
+                arenaGroupMap.put(arenaId, arenaGroup);
+            }
+        }
+        this.arenaGroups = arenaGroupMap;
     }
 
     /**
      * Saves all current arenas to disk
      */
-    public abstract void saveArenas();
+    public void saveArenas() {
+        try {
+            ArenaStorageHelper.saveArenas(this.arenas);
+        } catch (IOException e) {
+            Dropper.log(Level.SEVERE, "Unable to save current arenas! " +
+                    "Data loss can occur!");
+            Dropper.log(Level.SEVERE, e.getMessage());
+        }
+    }
 
     /**
      * Loads all arenas from disk
      */
-    protected abstract void loadArenas();
+    public void loadArenas() {
+        this.arenas = ArenaStorageHelper.loadArenas();
+
+        // Save a map from arena name to arena id for improved performance
+        this.arenaNameLookup = new HashMap<>();
+        for (Map.Entry<UUID, DropperArena> arena : this.arenas.entrySet()) {
+            String sanitizedName = arena.getValue().getArenaNameSanitized();
+            this.arenaNameLookup.put(sanitizedName, arena.getKey());
+        }
+    }
 
 }

src/main/java/net/knarcraft/dropper/arena/DropperArenaPlayerRegistry.java

@@ -0,0 +1,61 @@
+package net.knarcraft.dropper.arena;
+
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * A registry to keep track of which players are playing in which arenas
+ */
+public class DropperArenaPlayerRegistry {
+
+    private final Map<UUID, DropperArenaSession> arenaPlayers = new HashMap<>();
+
+    /**
+     * Registers that the given player has started playing the given dropper arena session
+     *
+     * @param playerId <p>The id of the player that started playing</p>
+     * @param arena    <p>The arena session to register</p>
+     */
+    public void registerPlayer(@NotNull UUID playerId, @NotNull DropperArenaSession arena) {
+        this.arenaPlayers.put(playerId, arena);
+    }
+
+    /**
+     * Removes this player from players currently playing
+     *
+     * @param playerId <p>The id of the player to remove</p>
+     */
+    public boolean removePlayer(@NotNull UUID playerId) {
+        return this.arenaPlayers.remove(playerId) != null;
+    }
+
+    /**
+     * Gets the player's active dropper arena session
+     *
+     * @param playerId <p>The id of the player to get arena for</p>
+     * @return <p>The player's active arena session, or null if not currently playing</p>
+     */
+    public @Nullable DropperArenaSession getArenaSession(@NotNull UUID playerId) {
+        return this.arenaPlayers.getOrDefault(playerId, null);
+    }
+
+    /**
+     * Removes all active sessions for the given arena
+     *
+     * @param arena <p>The arena to remove sessions for</p>
+     */
+    public void removeForArena(DropperArena arena) {
+        for (Map.Entry<UUID, DropperArenaSession> entry : this.arenaPlayers.entrySet()) {
+            if (entry.getValue().getArena() == arena) {
+                // Kick the player gracefully
+                entry.getValue().triggerQuit(false);
+                this.arenaPlayers.remove(entry.getKey());
+            }
+        }
+    }
+
+}

src/main/java/net/knarcraft/dropper/arena/DropperArenaRecordsRegistry.java

@@ -1,11 +1,12 @@
-package net.knarcraft.minigames.arena;
+package net.knarcraft.dropper.arena;
 
-import net.knarcraft.minigames.arena.record.ArenaRecord;
-import net.knarcraft.minigames.arena.record.IntegerRecord;
-import net.knarcraft.minigames.arena.record.LongRecord;
-import net.knarcraft.minigames.arena.record.SummableArenaRecord;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.property.RecordResult;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.record.ArenaRecord;
+import net.knarcraft.dropper.arena.record.IntegerRecord;
+import net.knarcraft.dropper.arena.record.LongRecord;
+import net.knarcraft.dropper.arena.record.SummableArenaRecord;
+import net.knarcraft.dropper.container.SerializableUUID;
+import net.knarcraft.dropper.property.RecordResult;
 import org.bukkit.configuration.serialization.ConfigurationSerializable;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
@@ -13,24 +14,25 @@ import org.jetbrains.annotations.Nullable;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
 /**
- * A records registry storing records for an arena
+ * A registry keeping track of all records
  */
-public abstract class ArenaRecordsRegistry implements ConfigurationSerializable {
+public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
 
-    protected final UUID arenaId;
+    private final UUID arenaId;
     private final @NotNull Set<IntegerRecord> leastDeaths;
     private final @NotNull Set<LongRecord> shortestTimeMilliSeconds;
 
     /**
      * Instantiates a new empty records registry
      */
-    public ArenaRecordsRegistry(@NotNull UUID arenaId) {
+    public DropperArenaRecordsRegistry(@NotNull UUID arenaId) {
         this.arenaId = arenaId;
         this.leastDeaths = new HashSet<>();
         this.shortestTimeMilliSeconds = new HashSet<>();
@@ -42,7 +44,7 @@ public abstract class ArenaRecordsRegistry implements ConfigurationSerializable
      * @param leastDeaths              <p>The existing least death records to use</p>
      * @param shortestTimeMilliSeconds <p>The existing leash time records to use</p>
      */
-    protected ArenaRecordsRegistry(@NotNull UUID arenaId, @NotNull Set<IntegerRecord> leastDeaths,
+    private DropperArenaRecordsRegistry(@NotNull UUID arenaId, @NotNull Set<IntegerRecord> leastDeaths,
                                         @NotNull Set<LongRecord> shortestTimeMilliSeconds) {
         this.arenaId = arenaId;
         this.leastDeaths = new HashSet<>(leastDeaths);
@@ -79,7 +81,8 @@ public abstract class ArenaRecordsRegistry implements ConfigurationSerializable
             leastDeaths.removeIf((item) -> item.getUserId().equals(playerId));
             leastDeaths.add(new IntegerRecord(playerId, value));
         };
-        return registerRecord(new HashSet<>(leastDeaths), consumer, playerId, deaths);
+        Set<ArenaRecord<Integer>> asInt = new HashSet<>(leastDeaths);
+        return registerRecord(asInt, consumer, playerId, deaths);
     }
 
     /**
@@ -94,13 +97,16 @@ public abstract class ArenaRecordsRegistry implements ConfigurationSerializable
             shortestTimeMilliSeconds.removeIf((item) -> item.getUserId().equals(playerId));
             shortestTimeMilliSeconds.add(new LongRecord(playerId, value));
         };
-        return registerRecord(new HashSet<>(shortestTimeMilliSeconds), consumer, playerId, milliseconds);
+        Set<ArenaRecord<Long>> asLong = new HashSet<>(shortestTimeMilliSeconds);
+        return registerRecord(asLong, consumer, playerId, milliseconds);
     }
 
     /**
      * Saves changed records
      */
-    protected abstract void save();
+    private void save() {
+        Dropper.getInstance().getArenaHandler().saveData(this.arenaId);
+    }
 
     /**
      * Registers a new record if applicable
@@ -170,4 +176,23 @@ public abstract class ArenaRecordsRegistry implements ConfigurationSerializable
         return data;
     }
 
+    /**
+     * Deserializes the given data
+     *
+     * @param data <p>The data to deserialize</p>
+     * @return <p>The deserialized records registry</p>
+     */
+    @SuppressWarnings({"unused", "unchecked"})
+    public static DropperArenaRecordsRegistry deserialize(Map<String, Object> data) {
+        UUID arenaId = ((SerializableUUID) data.get("arenaId")).uuid();
+        Set<IntegerRecord> leastDeaths =
+                (Set<IntegerRecord>) data.getOrDefault("leastDeaths", new HashMap<>());
+        Set<LongRecord> shortestTimeMilliseconds =
+                (Set<LongRecord>) data.getOrDefault("shortestTime", new HashMap<>());
+
+        leastDeaths.removeIf(Objects::isNull);
+        shortestTimeMilliseconds.removeIf(Objects::isNull);
+        return new DropperArenaRecordsRegistry(arenaId, leastDeaths, shortestTimeMilliseconds);
+    }
+
 }

src/main/java/net/knarcraft/dropper/arena/DropperArenaSession.java

@@ -0,0 +1,205 @@
+package net.knarcraft.dropper.arena;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.config.DropperConfiguration;
+import net.knarcraft.dropper.property.RecordResult;
+import net.knarcraft.dropper.util.PlayerTeleporter;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.logging.Level;
+
+/**
+ * A representation of a player's current session in a dropper arena
+ */
+public class DropperArenaSession {
+
+    private final @NotNull DropperArena arena;
+    private final @NotNull Player player;
+    private final @NotNull ArenaGameMode gameMode;
+    private int deaths;
+    private final long startTime;
+    private final PlayerEntryState entryState;
+
+    /**
+     * Instantiates a new dropper arena session
+     *
+     * @param dropperArena <p>The arena that's being played in</p>
+     * @param player       <p>The player playing the arena</p>
+     * @param gameMode     <p>The game-mode</p>
+     */
+    public DropperArenaSession(@NotNull DropperArena dropperArena, @NotNull Player player,
+                               @NotNull ArenaGameMode gameMode) {
+        this.arena = dropperArena;
+        this.player = player;
+        this.gameMode = gameMode;
+        this.deaths = 0;
+        this.startTime = System.currentTimeMillis();
+
+        DropperConfiguration configuration = Dropper.getInstance().getDropperConfiguration();
+        boolean makeInvisible = configuration.makePlayersInvisible();
+        boolean disableCollision = configuration.disableHitCollision();
+        this.entryState = new PlayerEntryState(player, gameMode, makeInvisible, disableCollision);
+        // Make the player fly to improve mobility in the air
+        this.entryState.setArenaState(this.arena.getPlayerHorizontalVelocity());
+    }
+
+    /**
+     * Gets the game-mode the player is playing in this session
+     *
+     * @return <p>The game-mode for this session</p>
+     */
+    public @NotNull ArenaGameMode getGameMode() {
+        return this.gameMode;
+    }
+
+    /**
+     * Gets the state of the player when they joined the session
+     *
+     * @return <p>The player's entry state</p>
+     */
+    public @NotNull PlayerEntryState getEntryState() {
+        return this.entryState;
+    }
+
+    /**
+     * Triggers a win for the player playing in this session
+     */
+    public void triggerWin() {
+        // Stop this session
+        stopSession();
+
+        // Check for, and display, records
+        Dropper dropper = Dropper.getInstance();
+        boolean ignore = dropper.getDropperConfiguration().ignoreRecordsUntilGroupBeatenOnce();
+        DropperArenaGroup group = dropper.getArenaHandler().getGroup(this.arena.getArenaId());
+        if (!ignore || group == null || group.hasBeatenAll(this.gameMode, this.player)) {
+            registerRecord();
+        }
+
+        // Mark the arena as cleared
+        if (this.arena.getData().addCompleted(this.gameMode, this.player)) {
+            this.player.sendMessage("You cleared the arena!");
+        }
+        this.player.sendMessage("You won!");
+
+        // Teleport the player out of the arena
+        teleportToExit(false);
+    }
+
+    /**
+     * Teleports the playing player out of the arena
+     */
+    private void teleportToExit(boolean immediately) {
+        // Teleport the player out of the arena
+        Location exitLocation;
+        if (this.arena.getExitLocation() != null) {
+            exitLocation = this.arena.getExitLocation();
+        } else {
+            exitLocation = this.entryState.getEntryLocation();
+        }
+        PlayerTeleporter.teleportPlayer(this.player, exitLocation, true, immediately);
+    }
+
+    /**
+     * Removes this session from current sessions
+     */
+    private void removeSession() {
+        // Remove this session for game sessions to stop listeners from fiddling more with the player
+        boolean removedSession = Dropper.getInstance().getPlayerRegistry().removePlayer(player.getUniqueId());
+        if (!removedSession) {
+            Dropper.log(Level.SEVERE, "Unable to remove dropper arena session for " + player.getName() + ". " +
+                    "This will have unintended consequences.");
+        }
+    }
+
+    /**
+     * Registers the player's record if necessary, and prints record information to the player
+     */
+    private void registerRecord() {
+        DropperArenaRecordsRegistry recordsRegistry = this.arena.getData().recordRegistries().get(this.gameMode);
+        long timeElapsed = System.currentTimeMillis() - this.startTime;
+        announceRecord(recordsRegistry.registerTimeRecord(this.player.getUniqueId(), timeElapsed), "time");
+        announceRecord(recordsRegistry.registerDeathRecord(this.player.getUniqueId(), this.deaths), "least deaths");
+    }
+
+    /**
+     * Announces a record set by this player
+     *
+     * @param recordResult <p>The result of the record</p>
+     * @param type         <p>The type of record set (time or deaths)</p>
+     */
+    private void announceRecord(@NotNull RecordResult recordResult, @NotNull String type) {
+        if (recordResult == RecordResult.NONE) {
+            return;
+        }
+
+        // Gets a string representation of the played game-mode
+        String gameModeString = switch (this.gameMode) {
+            case DEFAULT -> "default";
+            case INVERTED -> "inverted";
+            case RANDOM_INVERTED -> "random";
+        };
+
+        String recordString = "You just set a %s on the %s game-mode!";
+        recordString = switch (recordResult) {
+            case WORLD_RECORD -> String.format(recordString, "new %s record", gameModeString);
+            case PERSONAL_BEST -> String.format(recordString, "personal %s record", gameModeString);
+            default -> throw new IllegalStateException("Unexpected value: " + recordResult);
+        };
+        player.sendMessage(String.format(recordString, type));
+    }
+
+    /**
+     * Triggers a loss for the player playing in this session
+     */
+    public void triggerLoss() {
+        this.deaths++;
+        //Teleport the player back to the top
+        PlayerTeleporter.teleportPlayer(this.player, this.arena.getSpawnLocation(), true, false);
+        this.entryState.setArenaState(this.arena.getPlayerHorizontalVelocity());
+    }
+
+    /**
+     * Triggers a quit for the player playing in this session
+     */
+    public void triggerQuit(boolean immediately) {
+        // Stop this session
+        stopSession();
+        // Teleport the player out of the arena
+        teleportToExit(immediately);
+
+        player.sendMessage("You quit the arena!");
+    }
+
+    /**
+     * Stops this session, and disables flight mode
+     */
+    private void stopSession() {
+        // Remove this session from game sessions to stop listeners from fiddling more with the player
+        removeSession();
+
+        // Remove flight mode
+        entryState.restore();
+    }
+
+    /**
+     * Gets the arena this session is being played in
+     *
+     * @return <p>The session's arena</p>
+     */
+    public @NotNull DropperArena getArena() {
+        return this.arena;
+    }
+
+    /**
+     * Gets the player playing in this session
+     *
+     * @return <p>This session's player</p>
+     */
+    public @NotNull Player getPlayer() {
+        return this.player;
+    }
+
+}

src/main/java/net/knarcraft/dropper/arena/PlayerEntryState.java

@@ -0,0 +1,102 @@
+package net.knarcraft.dropper.arena;
+
+import org.bukkit.GameMode;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.potion.PotionEffect;
+import org.bukkit.potion.PotionEffectType;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The state of a player before entering a dropper arena
+ */
+public class PlayerEntryState {
+
+    private final Player player;
+    private final Location entryLocation;
+    private final boolean originalIsFlying;
+    private final float originalFlySpeed;
+    private final GameMode originalGameMode;
+    private final boolean originalAllowFlight;
+    private final boolean originalInvulnerable;
+    private final boolean originalIsSwimming;
+    private final boolean originalCollideAble;
+    private final boolean makePlayerInvisible;
+    private final boolean disableHitCollision;
+    private final ArenaGameMode arenaGameMode;
+
+    /**
+     * Instantiates a new player state
+     *
+     * @param player <p>The player whose state should be stored</p>
+     */
+    public PlayerEntryState(@NotNull Player player, @NotNull ArenaGameMode arenaGameMode, boolean makePlayerInvisible,
+                            boolean disableHitCollision) {
+        this.player = player;
+        this.entryLocation = player.getLocation().clone();
+        this.originalFlySpeed = player.getFlySpeed();
+        this.originalIsFlying = player.isFlying();
+        this.originalGameMode = player.getGameMode();
+        this.originalAllowFlight = player.getAllowFlight();
+        this.originalInvulnerable = player.isInvulnerable();
+        this.originalIsSwimming = player.isSwimming();
+        this.arenaGameMode = arenaGameMode;
+        this.originalCollideAble = player.isCollidable();
+        this.makePlayerInvisible = makePlayerInvisible;
+        this.disableHitCollision = disableHitCollision;
+    }
+
+    /**
+     * Sets the state of the stored player to the state used by arenas
+     *
+     * @param horizontalVelocity <p>The horizontal velocity to apply to the player</p>
+     */
+    public void setArenaState(float horizontalVelocity) {
+        this.player.setAllowFlight(true);
+        this.player.setFlying(true);
+        this.player.setGameMode(GameMode.ADVENTURE);
+        this.player.setSwimming(false);
+        if (this.disableHitCollision) {
+            this.player.setCollidable(false);
+        }
+        if (this.makePlayerInvisible) {
+            this.player.addPotionEffect(new PotionEffect(PotionEffectType.INVISIBILITY,
+                    PotionEffect.INFINITE_DURATION, 3));
+        }
+
+        // If playing on the inverted game-mode, negate the horizontal velocity to swap the controls
+        if (arenaGameMode == ArenaGameMode.INVERTED) {
+            this.player.setFlySpeed(-horizontalVelocity);
+        } else {
+            this.player.setFlySpeed(horizontalVelocity);
+        }
+    }
+
+    /**
+     * Restores the stored state for the stored player
+     */
+    public void restore() {
+        this.player.setFlying(this.originalIsFlying);
+        this.player.setGameMode(this.originalGameMode);
+        this.player.setAllowFlight(this.originalAllowFlight);
+        this.player.setFlySpeed(this.originalFlySpeed);
+        this.player.setInvulnerable(this.originalInvulnerable);
+        this.player.setSwimming(this.originalIsSwimming);
+        if (this.disableHitCollision) {
+            this.player.setCollidable(this.originalCollideAble);
+        }
+        if (this.makePlayerInvisible) {
+            this.player.removePotionEffect(PotionEffectType.INVISIBILITY);
+        }
+    }
+
+    /**
+     * Gets the location the player entered from
+     *
+     * @return <p>The location the player entered from</p>
+     */
+    public Location getEntryLocation() {
+        return this.entryLocation;
+    }
+
+}

src/main/java/net/knarcraft/dropper/arena/record/ArenaRecord.java

@@ -1,6 +1,6 @@
-package net.knarcraft.minigames.arena.record;
+package net.knarcraft.dropper.arena.record;
 
-import net.knarcraft.minigames.container.SerializableUUID;
+import net.knarcraft.dropper.container.SerializableUUID;
 import org.bukkit.configuration.serialization.ConfigurationSerializable;
 import org.jetbrains.annotations.NotNull;
 
@@ -44,13 +44,6 @@ public abstract class ArenaRecord<K extends Comparable<K>> implements Comparable
         return record;
     }
 
-    /**
-     * Gets this as a string that should be printed on a sign
-     *
-     * @return <p>This as a string</p>
-     */
-    public abstract String getAsString();
-
     @Override
     public boolean equals(Object other) {
         return other instanceof ArenaRecord<?> && userId.equals(((ArenaRecord<?>) other).userId);
@@ -77,7 +70,7 @@ public abstract class ArenaRecord<K extends Comparable<K>> implements Comparable
 
     @Override
     public String toString() {
-        return userId + ":" + record;
+        return userId + ": " + record;
     }
 
 }

src/main/java/net/knarcraft/dropper/arena/record/IntegerRecord.java

@@ -1,6 +1,6 @@
-package net.knarcraft.minigames.arena.record;
+package net.knarcraft.dropper.arena.record;
 
-import net.knarcraft.minigames.container.SerializableUUID;
+import net.knarcraft.dropper.container.SerializableUUID;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Map;
@@ -19,11 +19,6 @@ public class IntegerRecord extends SummableArenaRecord<Integer> {
         super(userId, record);
     }
 
-    @Override
-    public String getAsString() {
-        return String.valueOf(this.getRecord());
-    }
-
     @Override
     public SummableArenaRecord<Integer> sum(Integer value) {
         return new IntegerRecord(this.getUserId(), this.getRecord() + value);
@@ -42,7 +37,7 @@ public class IntegerRecord extends SummableArenaRecord<Integer> {
      */
     @SuppressWarnings("unused")
     public static IntegerRecord deserialize(@NotNull Map<String, Object> data) {
-        return new IntegerRecord(((SerializableUUID) data.get("userId")).getRawValue(), (Integer) data.get("record"));
+        return new IntegerRecord(((SerializableUUID) data.get("userId")).uuid(), (Integer) data.get("record"));
     }
 
 }

src/main/java/net/knarcraft/dropper/arena/record/LongRecord.java

@@ -1,13 +1,13 @@
-package net.knarcraft.minigames.arena.record;
+package net.knarcraft.dropper.arena.record;
 
-import net.knarcraft.minigames.container.SerializableUUID;
+import net.knarcraft.dropper.container.SerializableUUID;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Map;
 import java.util.UUID;
 
 /**
- * A record storing a Long time
+ * A record storing a Long
  */
 public class LongRecord extends SummableArenaRecord<Long> {
 
@@ -29,22 +29,6 @@ public class LongRecord extends SummableArenaRecord<Long> {
         return new LongRecord(this.getUserId(), this.getRecord() + value);
     }
 
-    @Override
-    public String getAsString() {
-        int seconds = (int) Math.floor(getRecord() / 1000.0);
-        int minutes = 0;
-        if (seconds > 60) {
-            minutes = (int) Math.floor(seconds / 60.0);
-            seconds = seconds % 60;
-        }
-
-        if (minutes > 0) {
-            return minutes + "m" + seconds + "s";
-        } else {
-            return seconds + "s";
-        }
-    }
-
     /**
      * Deserializes the saved arena record
      *
@@ -53,7 +37,7 @@ public class LongRecord extends SummableArenaRecord<Long> {
      */
     @SuppressWarnings("unused")
     public static LongRecord deserialize(@NotNull Map<String, Object> data) {
-        return new LongRecord(((SerializableUUID) data.get("userId")).getRawValue(), ((Number) data.get("record")).longValue());
+        return new LongRecord(((SerializableUUID) data.get("userId")).uuid(), ((Number) data.get("record")).longValue());
     }
 
 }

src/main/java/net/knarcraft/dropper/arena/record/SummableArenaRecord.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.arena.record;
+package net.knarcraft.dropper.arena.record;
 
 import java.util.UUID;
 

src/main/java/net/knarcraft/dropper/command/CreateArenaCommand.java

@@ -1,10 +1,9 @@
-package net.knarcraft.minigames.command.dropper;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaHandler;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.StringSanitizer;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
+import net.knarcraft.dropper.util.StringSanitizer;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -14,14 +13,13 @@ import org.jetbrains.annotations.NotNull;
 /**
  * The command for creating a new dropper arena
  */
-public class CreateDropperArenaCommand implements CommandExecutor {
+public class CreateArenaCommand implements CommandExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                              @NotNull String[] arguments) {
         if (!(commandSender instanceof Player player)) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_PLAYER_ONLY);
+            commandSender.sendMessage("This command must be used by a player");
             return false;
         }
 
@@ -38,18 +36,17 @@ public class CreateDropperArenaCommand implements CommandExecutor {
             return false;
         }
 
-        DropperArenaHandler arenaHandler = MiniGames.getInstance().getDropperArenaHandler();
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
+
         DropperArena existingArena = arenaHandler.getArena(arenaName);
         if (existingArena != null) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_ARENA_NAME_COLLISION);
+            commandSender.sendMessage("There already exists a dropper arena with that name!");
             return false;
         }
 
         DropperArena arena = new DropperArena(arenaName, player.getLocation(), arenaHandler);
         arenaHandler.addArena(arena);
-        MiniGames.getInstance().getStringFormatter().displaySuccessMessage(commandSender,
-                MiniGameMessage.SUCCESS_ARENA_CREATED);
+        commandSender.sendMessage("The arena was successfully created!");
         return true;
     }
 

src/main/java/net/knarcraft/dropper/command/EditArenaCommand.java

@@ -1,11 +1,9 @@
-package net.knarcraft.minigames.command.dropper;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaEditableProperty;
-import net.knarcraft.minigames.config.DropperConfiguration;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaEditableProperty;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.config.DropperConfiguration;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.command.Command;
@@ -17,7 +15,7 @@ import org.jetbrains.annotations.NotNull;
 /**
  * The command for editing an existing dropper arena
  */
-public class EditDropperArenaCommand implements CommandExecutor {
+public class EditArenaCommand implements CommandExecutor {
 
     private final DropperConfiguration configuration;
 
@@ -26,16 +24,15 @@ public class EditDropperArenaCommand implements CommandExecutor {
      *
      * @param configuration <p>The configuration to use</p>
      */
-    public EditDropperArenaCommand(DropperConfiguration configuration) {
+    public EditArenaCommand(DropperConfiguration configuration) {
         this.configuration = configuration;
     }
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                              @NotNull String[] arguments) {
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
         if (!(commandSender instanceof Player player)) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_PLAYER_ONLY);
+            commandSender.sendMessage("This command must be used by a player");
             return false;
         }
 
@@ -43,33 +40,31 @@ public class EditDropperArenaCommand implements CommandExecutor {
             return false;
         }
 
-        DropperArena specifiedArena = MiniGames.getInstance().getDropperArenaHandler().getArena(arguments[0]);
+        DropperArena specifiedArena = Dropper.getInstance().getArenaHandler().getArena(arguments[0]);
         if (specifiedArena == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_NOT_FOUND);
+            commandSender.sendMessage("Unable to find the specified dropper arena.");
             return false;
         }
 
-        DropperArenaEditableProperty editableProperty = DropperArenaEditableProperty.getFromArgumentString(arguments[1]);
+        ArenaEditableProperty editableProperty = ArenaEditableProperty.getFromArgumentString(arguments[1]);
         if (editableProperty == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_UNKNOWN_PROPERTY);
+            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);
-            stringFormatter.displaySuccessMessage(commandSender, stringFormatter.replacePlaceholders(
-                    MiniGameMessage.SUCCESS_CURRENT_VALUE, new String[]{"{property}", "{value}"},
-                    new String[]{editableProperty.getArgumentString(), value}));
+            commandSender.sendMessage(String.format(currentValueFormat, editableProperty.getArgumentString(), value));
             return true;
         } else {
             boolean successful = changeValue(specifiedArena, editableProperty, arguments[2], player);
             if (successful) {
-                stringFormatter.displaySuccessMessage(player, stringFormatter.replacePlaceholder(
-                        MiniGameMessage.SUCCESS_PROPERTY_CHANGED, "{property}",
-                        editableProperty.getArgumentString()));
+                player.sendMessage(String.format("Property %s changed to: %s", editableProperty, arguments[2]));
             } else {
-                stringFormatter.displayErrorMessage(player, MiniGameMessage.ERROR_PROPERTY_INPUT_INVALID);
+                player.sendMessage("Unable to change the property. Make sure your input is valid!");
             }
             return successful;
         }
@@ -84,7 +79,7 @@ public class EditDropperArenaCommand implements CommandExecutor {
      * @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 DropperArena arena, @NotNull DropperArenaEditableProperty property,
+    private boolean changeValue(@NotNull DropperArena arena, @NotNull ArenaEditableProperty property,
                                 @NotNull String value, @NotNull Player player) {
         return switch (property) {
             case WIN_BLOCK_TYPE -> arena.setWinBlockType(parseMaterial(value));

src/main/java/net/knarcraft/dropper/command/EditArenaTabCompleter.java

@@ -0,0 +1,33 @@
+package net.knarcraft.dropper.command;
+
+import net.knarcraft.dropper.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 EditArenaTabCompleter 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();
+        } else if (args.length == 2) {
+            return TabCompleteHelper.getArenaProperties();
+        } 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/dropper/command/GroupListCommand.java

@@ -1,11 +1,9 @@
-package net.knarcraft.minigames.command.dropper;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGroup;
-import net.knarcraft.minigames.arena.dropper.DropperArenaHandler;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -16,17 +14,15 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
 /**
  * The command for listing groups and the stages within
  */
-public class DropperGroupListCommand implements TabExecutor {
+public class GroupListCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                              @NotNull String[] arguments) {
-        DropperArenaHandler arenaHandler = MiniGames.getInstance().getDropperArenaHandler();
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
         if (arguments.length == 0) {
             displayExistingGroups(arenaHandler, commandSender);
             return true;
@@ -61,15 +57,13 @@ public class DropperGroupListCommand implements TabExecutor {
     private boolean displayOrderedArenaNames(@NotNull DropperArenaHandler arenaHandler, @NotNull CommandSender sender,
                                              @NotNull String groupName) {
         DropperArenaGroup arenaGroup = arenaHandler.getGroup(groupName);
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
         if (arenaGroup == null) {
-            stringFormatter.displayErrorMessage(sender, MiniGameMessage.ERROR_GROUP_NOT_FOUND);
+            sender.sendMessage("Unable to find the specified group!");
             return false;
         }
 
         // Send a list of all stages (arenas in the group)
-        StringBuilder builder = new StringBuilder(stringFormatter.replacePlaceholder(
-                MiniGameMessage.SUCCESS_GROUP_STAGES, "{group}", groupName));
+        StringBuilder builder = new StringBuilder(groupName).append("'s stages:").append("\n");
         int counter = 1;
         for (UUID arenaId : arenaGroup.getArenas()) {
             DropperArena arena = arenaHandler.getArena(arenaId);
@@ -77,7 +71,7 @@ public class DropperGroupListCommand implements TabExecutor {
                 builder.append(counter++).append(". ").append(arena.getArenaName()).append("\n");
             }
         }
-        stringFormatter.displaySuccessMessage(sender, builder.toString());
+        sender.sendMessage(builder.toString());
         return true;
     }
 
@@ -87,10 +81,10 @@ public class DropperGroupListCommand implements TabExecutor {
                                       @NotNull String[] arguments) {
         if (arguments.length == 1) {
             List<String> groupNames = new ArrayList<>();
-            for (DropperArenaGroup group : MiniGames.getInstance().getDropperArenaHandler().getAllGroups()) {
+            for (DropperArenaGroup group : Dropper.getInstance().getArenaHandler().getAllGroups()) {
                 groupNames.add(group.getGroupName());
             }
-            return filterMatchingContains(groupNames, arguments[0]);
+            return groupNames;
         } else {
             return new ArrayList<>();
         }

src/main/java/net/knarcraft/dropper/command/GroupSetCommand.java

@@ -1,12 +1,11 @@
-package net.knarcraft.minigames.command.dropper;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGroup;
-import net.knarcraft.minigames.arena.dropper.DropperArenaHandler;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.StringSanitizer;
-import net.knarcraft.minigames.util.TabCompleteHelper;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
+import net.knarcraft.dropper.util.StringSanitizer;
+import net.knarcraft.dropper.util.TabCompleteHelper;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -16,12 +15,10 @@ import org.jetbrains.annotations.Nullable;
 import java.util.ArrayList;
 import java.util.List;
 
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
 /**
  * The command for setting the group of an arena
  */
-public class DropperGroupSetCommand implements TabExecutor {
+public class GroupSetCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
@@ -30,12 +27,11 @@ public class DropperGroupSetCommand implements TabExecutor {
             return false;
         }
 
-        DropperArenaHandler arenaHandler = MiniGames.getInstance().getDropperArenaHandler();
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
 
         DropperArena specifiedArena = arenaHandler.getArena(arguments[0]);
         if (specifiedArena == null) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_ARENA_NOT_FOUND);
+            commandSender.sendMessage("Unable to find the specified dropper arena.");
             return false;
         }
 
@@ -57,8 +53,7 @@ public class DropperGroupSetCommand implements TabExecutor {
 
         arenaHandler.setGroup(specifiedArena.getArenaId(), arenaGroup);
 
-        MiniGames.getInstance().getStringFormatter().displaySuccessMessage(commandSender,
-                MiniGameMessage.SUCCESS_ARENA_GROUP_UPDATED);
+        commandSender.sendMessage("The arena's group has been updated");
         return true;
     }
 
@@ -67,15 +62,15 @@ public class DropperGroupSetCommand implements TabExecutor {
     public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                                       @NotNull String[] arguments) {
         if (arguments.length == 1) {
-            return filterMatchingContains(TabCompleteHelper.getDropperArenas(), arguments[0]);
+            return TabCompleteHelper.getArenas();
         } else if (arguments.length == 2) {
             List<String> possibleValues = new ArrayList<>();
             possibleValues.add("none");
             possibleValues.add("GroupName");
-            for (DropperArenaGroup group : MiniGames.getInstance().getDropperArenaHandler().getAllGroups()) {
+            for (DropperArenaGroup group : Dropper.getInstance().getArenaHandler().getAllGroups()) {
                 possibleValues.add(group.getGroupName());
             }
-            return filterMatchingContains(possibleValues, arguments[1]);
+            return possibleValues;
         } else {
             return new ArrayList<>();
         }

src/main/java/net/knarcraft/dropper/command/GroupSwapCommand.java

@@ -1,11 +1,9 @@
-package net.knarcraft.minigames.command.dropper;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGroup;
-import net.knarcraft.minigames.arena.dropper.DropperArenaHandler;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -16,12 +14,10 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.UUID;
 
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
 /**
  * The command for swapping the order of two arenas in a group
  */
-public class DropperGroupSwapCommand implements TabExecutor {
+public class GroupSwapCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
@@ -30,31 +26,30 @@ public class DropperGroupSwapCommand implements TabExecutor {
             return false;
         }
 
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        DropperArenaHandler arenaHandler = MiniGames.getInstance().getDropperArenaHandler();
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
 
         DropperArena arena1 = arenaHandler.getArena(arguments[0]);
         if (arena1 == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_1_NOT_FOUND);
+            commandSender.sendMessage("Unable to find the first specified dropper arena.");
             return false;
         }
 
         DropperArena arena2 = arenaHandler.getArena(arguments[1]);
         if (arena2 == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_2_NOT_FOUND);
+            commandSender.sendMessage("Unable to find the second specified dropper arena.");
             return false;
         }
 
         DropperArenaGroup arena1Group = arenaHandler.getGroup(arena1.getArenaId());
         DropperArenaGroup arena2Group = arenaHandler.getGroup(arena2.getArenaId());
         if (arena1Group == null || !arena1Group.equals(arena2Group)) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_SWAP_DIFFERENT_GROUPS);
+            commandSender.sendMessage("You cannot swap arenas in different groups!");
             return false;
         }
 
         arena1Group.swapArenas(arena1Group.getArenas().indexOf(arena1.getArenaId()),
                 arena1Group.getArenas().indexOf(arena2.getArenaId()));
-        stringFormatter.displaySuccessMessage(commandSender, MiniGameMessage.SUCCESS_ARENAS_SWAPPED);
+        commandSender.sendMessage("The arenas have been swapped!");
         return true;
     }
 
@@ -62,15 +57,15 @@ public class DropperGroupSwapCommand implements TabExecutor {
     @Override
     public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                                       @NotNull String[] arguments) {
-        DropperArenaHandler arenaHandler = MiniGames.getInstance().getDropperArenaHandler();
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
         if (arguments.length == 1) {
             List<String> arenaNames = new ArrayList<>();
             for (DropperArena dropperArena : arenaHandler.getArenasInAGroup()) {
                 arenaNames.add(dropperArena.getArenaName());
             }
-            return filterMatchingContains(arenaNames, arguments[0]);
+            return arenaNames;
         } else if (arguments.length == 2) {
-            return filterMatchingContains(getArenaNamesInSameGroup(arguments[0]), arguments[1]);
+            return getArenaNamesInSameGroup(arguments[0]);
         } else {
             return new ArrayList<>();
         }
@@ -83,7 +78,7 @@ public class DropperGroupSwapCommand implements TabExecutor {
      * @return <p>The names of the arenas in the same group</p>
      */
     private List<String> getArenaNamesInSameGroup(String arenaName) {
-        DropperArenaHandler arenaHandler = MiniGames.getInstance().getDropperArenaHandler();
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
         DropperArena arena1 = arenaHandler.getArena(arenaName);
         if (arena1 == null) {
             return new ArrayList<>();

src/main/java/net/knarcraft/dropper/command/JoinArenaCommand.java

@@ -0,0 +1,136 @@
+package net.knarcraft.dropper.command;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaPlayerRegistry;
+import net.knarcraft.dropper.arena.DropperArenaSession;
+import net.knarcraft.dropper.config.DropperConfiguration;
+import net.knarcraft.dropper.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 dropper arena
+ */
+public class JoinArenaCommand 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 dropper arena
+        DropperArenaSession existingSession = Dropper.getInstance().getPlayerRegistry().getArenaSession(player.getUniqueId());
+        if (existingSession != null) {
+            commandSender.sendMessage("You are already in a dropper arena!");
+            return false;
+        }
+
+        // Make sure the arena exists
+        DropperArena specifiedArena = Dropper.getInstance().getArenaHandler().getArena(arguments[0]);
+        if (specifiedArena == null) {
+            commandSender.sendMessage("Unable to find the specified dropper 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(DropperArena specifiedArena, Player player, String[] arguments) {
+        // Find the specified game-mode
+        ArenaGameMode gameMode;
+        if (arguments.length > 1) {
+            gameMode = ArenaGameMode.matchGamemode(arguments[1]);
+        } else {
+            gameMode = ArenaGameMode.DEFAULT;
+        }
+
+        // Make sure the player has beaten the necessary levels
+        DropperArenaGroup arenaGroup = Dropper.getInstance().getArenaHandler().getGroup(specifiedArena.getArenaId());
+        if (arenaGroup != null && !doGroupChecks(specifiedArena, arenaGroup, gameMode, player)) {
+            return false;
+        }
+
+        // Make sure the player has beaten the arena once in normal mode before playing another mode
+        if (Dropper.getInstance().getDropperConfiguration().mustDoNormalModeFirst() &&
+                gameMode != ArenaGameMode.DEFAULT &&
+                specifiedArena.getData().hasNotCompleted(ArenaGameMode.DEFAULT, player)) {
+            player.sendMessage("You must complete this arena in normal mode first!");
+            return false;
+        }
+
+        // Register the player's session
+        DropperArenaSession newSession = new DropperArenaSession(specifiedArena, player, gameMode);
+        DropperArenaPlayerRegistry playerRegistry = Dropper.getInstance().getPlayerRegistry();
+        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 dropper 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(specifiedArena.getPlayerHorizontalVelocity());
+            return true;
+        }
+    }
+
+    /**
+     * Performs necessary check for the given arena's group
+     *
+     * @param dropperArena  <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 DropperArena dropperArena, @NotNull DropperArenaGroup arenaGroup,
+                                  @NotNull ArenaGameMode arenaGameMode, @NotNull Player player) {
+        DropperConfiguration configuration = Dropper.getInstance().getDropperConfiguration();
+        // Require that players beat all arenas in the group in the normal game-mode before trying challenge modes
+        if (configuration.mustDoNormalModeFirst() && arenaGameMode != ArenaGameMode.DEFAULT &&
+                !arenaGroup.hasBeatenAll(ArenaGameMode.DEFAULT, player)) {
+            player.sendMessage("You have not yet beaten all arenas in this group!");
+            return false;
+        }
+
+        // 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, dropperArena.getArenaId())) {
+            player.sendMessage("You have not yet beaten the previous arena!");
+            return false;
+        }
+
+        return true;
+    }
+
+}

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

@@ -0,0 +1,34 @@
+package net.knarcraft.dropper.command;
+
+import net.knarcraft.dropper.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 join command
+ */
+public class JoinArenaTabCompleter implements TabCompleter {
+
+    @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();
+        } else if (arguments.length == 2) {
+            List<String> gameModes = new ArrayList<>();
+            gameModes.add("default");
+            gameModes.add("inverted");
+            gameModes.add("random");
+            return gameModes;
+        } else {
+            return new ArrayList<>();
+        }
+    }
+
+}

src/main/java/net/knarcraft/dropper/command/LeaveArenaCommand.java

@@ -1,8 +1,7 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaSession;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArenaSession;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -22,19 +21,18 @@ public class LeaveArenaCommand implements TabExecutor {
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                              @NotNull String[] strings) {
         if (!(commandSender instanceof Player player)) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_PLAYER_ONLY);
+            commandSender.sendMessage("This command must be used by a player");
             return false;
         }
 
-        ArenaSession existingSession = MiniGames.getInstance().getSession(player.getUniqueId());
+        DropperArenaSession existingSession = Dropper.getInstance().getPlayerRegistry().getArenaSession(
+                player.getUniqueId());
         if (existingSession == null) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_NOT_IN_ARENA);
+            commandSender.sendMessage("You are not in a dropper arena!");
             return false;
         }
 
-        existingSession.triggerQuit(false, true);
+        existingSession.triggerQuit(false);
         return true;
     }
 

src/main/java/net/knarcraft/dropper/command/ListArenaCommand.java

@@ -1,8 +1,6 @@
-package net.knarcraft.minigames.command.dropper;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.TabCompleteHelper;
+import net.knarcraft.dropper.util.TabCompleteHelper;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -15,17 +13,15 @@ import java.util.List;
 /**
  * A command for listing existing dropper arenas
  */
-public class ListDropperArenaCommand implements TabExecutor {
+public class ListArenaCommand implements TabExecutor {
 
     @Override
     public boolean onCommand(@NotNull CommandSender sender, @NotNull Command command, @NotNull String label,
                              @NotNull String[] arguments) {
-        StringBuilder builder = new StringBuilder(MiniGames.getInstance().getTranslator().getTranslatedMessage(
-                MiniGameMessage.SUCCESS_DROPPER_ARENAS_LIST));
-        for (String arenaName : TabCompleteHelper.getDropperArenas()) {
-            builder.append("\n").append(arenaName);
+        sender.sendMessage("Dropper arenas:");
+        for (String arenaName : TabCompleteHelper.getArenas()) {
+            sender.sendMessage(arenaName);
         }
-        MiniGames.getInstance().getStringFormatter().displaySuccessMessage(sender, builder.toString());
         return true;
     }
 

src/main/java/net/knarcraft/dropper/command/ReloadCommand.java

@@ -1,7 +1,6 @@
-package net.knarcraft.minigames.command;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabExecutor;
@@ -19,9 +18,8 @@ public class ReloadCommand implements TabExecutor {
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                              @NotNull String[] arguments) {
-        MiniGames.getInstance().reload();
-        MiniGames.getInstance().getStringFormatter().displaySuccessMessage(commandSender,
-                MiniGameMessage.SUCCESS_PLUGIN_RELOADED);
+        Dropper.getInstance().reload();
+        commandSender.sendMessage("Plugin reloaded!");
         return true;
     }
 

src/main/java/net/knarcraft/dropper/command/RemoveArenaCommand.java

@@ -0,0 +1,36 @@
+package net.knarcraft.dropper.command;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArena;
+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 RemoveArenaCommand 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
+        DropperArena targetArena = Dropper.getInstance().getArenaHandler().getArena(arguments[0]);
+        if (targetArena == null) {
+            commandSender.sendMessage("Unable to find the specified arena");
+            return false;
+        }
+
+        // Remove the arena
+        Dropper.getInstance().getArenaHandler().removeArena(targetArena);
+        commandSender.sendMessage("The specified arena has been successfully removed");
+        return true;
+    }
+
+}

src/main/java/net/knarcraft/dropper/command/RemoveArenaTabCompleter.java

@@ -1,6 +1,6 @@
-package net.knarcraft.minigames.command.parkour;
+package net.knarcraft.dropper.command;
 
-import net.knarcraft.minigames.util.TabCompleteHelper;
+import net.knarcraft.dropper.util.TabCompleteHelper;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandSender;
 import org.bukkit.command.TabCompleter;
@@ -10,19 +10,17 @@ import org.jetbrains.annotations.Nullable;
 import java.util.ArrayList;
 import java.util.List;
 
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
 /**
  * The tab-completer for the remove arena command
  */
-public class RemoveParkourArenaTabCompleter implements TabCompleter {
+public class RemoveArenaTabCompleter 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 filterMatchingContains(TabCompleteHelper.getParkourArenas(), arguments[0]);
+            return TabCompleteHelper.getArenas();
         } else {
             return new ArrayList<>();
         }

src/main/java/net/knarcraft/dropper/config/DropperConfiguration.java

@@ -1,16 +1,26 @@
-package net.knarcraft.minigames.config;
+package net.knarcraft.dropper.config;
 
+import net.knarcraft.dropper.Dropper;
+import org.bukkit.Bukkit;
 import org.bukkit.Material;
+import org.bukkit.NamespacedKey;
+import org.bukkit.Tag;
 import org.bukkit.configuration.file.FileConfiguration;
 
+import java.util.ArrayList;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
+import java.util.logging.Level;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
 
 /**
- * The configuration keeping track of dropper settings
+ * The configuration keeping track of the player's current configuration
  */
-public class DropperConfiguration extends MiniGameConfiguration {
+public class DropperConfiguration {
 
+    private FileConfiguration configuration;
     private final static String rootNode = "dropper.";
 
     private double verticalVelocity;
@@ -19,6 +29,10 @@ public class DropperConfiguration extends MiniGameConfiguration {
     private boolean mustDoGroupedInSequence;
     private boolean ignoreRecordsUntilGroupBeatenOnce;
     private boolean mustDoNormalModeFirst;
+    private boolean makePlayersInvisible;
+    private boolean disableHitCollision;
+    private double liquidHitBoxDepth;
+    private double solidHitBoxDistance;
     private boolean blockSneaking;
     private boolean blockSprinting;
     private Set<Material> blockWhitelist;
@@ -29,7 +43,7 @@ public class DropperConfiguration extends MiniGameConfiguration {
      * @param configuration <p>The YAML configuration to use internally</p>
      */
     public DropperConfiguration(FileConfiguration configuration) {
-        super(configuration);
+        this.configuration = configuration;
     }
 
     /**
@@ -95,6 +109,48 @@ public class DropperConfiguration extends MiniGameConfiguration {
         return this.ignoreRecordsUntilGroupBeatenOnce;
     }
 
+    /**
+     * Gets whether players should be made invisible while in an arena
+     *
+     * @return <p>Whether players should be made invisible</p>
+     */
+    public boolean makePlayersInvisible() {
+        return this.makePlayersInvisible;
+    }
+
+    /**
+     * Gets whether entity hit-collision of players in an arena should be disabled
+     *
+     * @return <p>Whether to disable hit collision</p>
+     */
+    public boolean disableHitCollision() {
+        return this.disableHitCollision;
+    }
+
+    /**
+     * Gets the negative depth a player must reach in a liquid block for fail/win detection to trigger
+     *
+     * <p>This decides how far inside a non-solid block the player must go before detection triggers. The closer to -1
+     * it is, the more accurate it will seem to the player, but the likelihood of not detecting the hit increases.</p>
+     *
+     * @return <p>The liquid hit box depth to use</p>
+     */
+    public double getLiquidHitBoxDepth() {
+        return this.liquidHitBoxDepth;
+    }
+
+    /**
+     * Gets the positive distance a player must at most be from a block for fail/win detection to trigger
+     *
+     * <p>This decides the distance the player must be from a block below them before a hit triggers. If too low, the
+     * likelihood of detecting the hit decreases, but it won't look like the player hit the block without being near.</p>
+     *
+     * @return <p>The solid hit box distance to use</p>
+     */
+    public double getSolidHitBoxDistance() {
+        return this.solidHitBoxDistance;
+    }
+
     /**
      * Gets whether players trying to sneak while in a dropper arena to increase their downwards speed should be blocked
      *
@@ -113,24 +169,49 @@ public class DropperConfiguration extends MiniGameConfiguration {
         return this.blockSprinting;
     }
 
-    @Override
-    protected void load() {
+    /**
+     * Loads all configuration values from disk
+     *
+     * @param configuration <p>The configuration to load</p>
+     */
+    public void load(FileConfiguration configuration) {
+        this.configuration = configuration;
+        this.load();
+    }
+
+    /**
+     * Loads all configuration values from disk
+     */
+    public void load() {
         this.verticalVelocity = configuration.getDouble(rootNode + "verticalVelocity", 1.0);
         this.horizontalVelocity = (float) configuration.getDouble(rootNode + "horizontalVelocity", 1.0);
         this.randomlyInvertedTimer = configuration.getInt(rootNode + "randomlyInvertedTimer", 7);
         this.mustDoGroupedInSequence = configuration.getBoolean(rootNode + "mustDoGroupedInSequence", true);
         this.ignoreRecordsUntilGroupBeatenOnce = configuration.getBoolean(rootNode + "ignoreRecordsUntilGroupBeatenOnce", false);
         this.mustDoNormalModeFirst = configuration.getBoolean(rootNode + "mustDoNormalModeFirst", true);
+        this.makePlayersInvisible = configuration.getBoolean(rootNode + "makePlayersInvisible", false);
+        this.disableHitCollision = configuration.getBoolean(rootNode + "disableHitCollision", true);
+        this.liquidHitBoxDepth = configuration.getDouble(rootNode + "liquidHitBoxDepth", -0.8);
+        this.solidHitBoxDistance = configuration.getDouble(rootNode + "solidHitBoxDistance", 0.2);
         this.blockSprinting = configuration.getBoolean(rootNode + "blockSprinting", true);
         this.blockSneaking = configuration.getBoolean(rootNode + "blockSneaking", true);
-        this.blockWhitelist = loadMaterialList(rootNode + "blockWhitelist");
         sanitizeValues();
+
+        loadBlockWhitelist();
     }
 
     /**
      * Sanitizes configuration values to ensure they are within expected bounds
      */
     private void sanitizeValues() {
+        if (this.liquidHitBoxDepth <= -1 || this.liquidHitBoxDepth > 0) {
+            this.liquidHitBoxDepth = -0.8;
+        }
+
+        if (this.solidHitBoxDistance <= 0 || this.solidHitBoxDistance > 1) {
+            this.solidHitBoxDistance = 0.2;
+        }
+
         if (this.horizontalVelocity > 1 || this.horizontalVelocity <= 0) {
             this.horizontalVelocity = 1;
         }
@@ -144,6 +225,55 @@ public class DropperConfiguration extends MiniGameConfiguration {
         }
     }
 
+    /**
+     * Loads the materials specified in the block whitelist
+     */
+    private void loadBlockWhitelist() {
+        this.blockWhitelist = new HashSet<>();
+        List<?> blockWhitelist = configuration.getList(rootNode + "blockWhitelist", new ArrayList<>());
+        for (Object value : blockWhitelist) {
+            if (!(value instanceof String string)) {
+                continue;
+            }
+
+            // Try to parse a material tag first
+            if (parseMaterialTag(string)) {
+                continue;
+            }
+
+            // Try to parse a material name
+            Material matched = Material.matchMaterial(string);
+            if (matched != null) {
+                this.blockWhitelist.add(matched);
+            } else {
+                Dropper.log(Level.WARNING, "Unable to parse: " + string);
+            }
+        }
+    }
+
+    /**
+     * Tries to parse the material tag in the specified material name
+     *
+     * @param materialName <p>The material name that might be a material tag</p>
+     * @return <p>True if a tag was found</p>
+     */
+    private boolean parseMaterialTag(String materialName) {
+        Pattern pattern = Pattern.compile("^\\+([a-zA-Z_]+)");
+        Matcher matcher = pattern.matcher(materialName);
+        if (matcher.find()) {
+            // The material is a material tag
+            Tag<Material> tag = Bukkit.getTag(Tag.REGISTRY_BLOCKS, NamespacedKey.minecraft(
+                    matcher.group(1).toLowerCase()), Material.class);
+            if (tag != null) {
+                this.blockWhitelist.addAll(tag.getValues());
+            } else {
+                Dropper.log(Level.WARNING, "Unable to parse: " + materialName);
+            }
+            return true;
+        }
+        return false;
+    }
+
     @Override
     public String toString() {
         StringBuilder builder = new StringBuilder(
@@ -154,6 +284,10 @@ public class DropperConfiguration extends MiniGameConfiguration {
                         "\n" + "Must do groups in sequence: " + mustDoGroupedInSequence +
                         "\n" + "Ignore records until group beaten once: " + ignoreRecordsUntilGroupBeatenOnce +
                         "\n" + "Must do normal mode first: " + mustDoNormalModeFirst +
+                        "\n" + "Make players invisible: " + makePlayersInvisible +
+                        "\n" + "Disable hit collision: " + disableHitCollision +
+                        "\n" + "Liquid hit box depth: " + liquidHitBoxDepth +
+                        "\n" + "Solid hit box distance: " + solidHitBoxDistance +
                         "\n" + "Block whitelist: ");
         for (Material material : blockWhitelist) {
             builder.append("\n  - ").append(material.name());

src/main/java/net/knarcraft/dropper/container/SerializableMaterial.java

@@ -0,0 +1,37 @@
+package net.knarcraft.dropper.container;
+
+import org.bukkit.Material;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * A material container able to be serialized
+ *
+ * @param material <p>The material stored by this record</p>
+ */
+public record SerializableMaterial(Material material) implements ConfigurationSerializable {
+
+    @NotNull
+    @Override
+    public Map<String, Object> serialize() {
+        Map<String, Object> data = new HashMap<>();
+        data.put("name", material.name());
+        return data;
+    }
+
+    /**
+     * Deserializes a serialized material
+     *
+     * @param data <p>The serialized data</p>
+     * @return <p>The deserialized material</p>
+     */
+    @SuppressWarnings("unused")
+    public static SerializableMaterial deserialize(Map<String, Object> data) {
+        Material material = Material.matchMaterial((String) data.getOrDefault("name", "AIR"));
+        return new SerializableMaterial(material);
+    }
+
+}

src/main/java/net/knarcraft/dropper/container/SerializableUUID.java

@@ -1,5 +1,6 @@
-package net.knarcraft.minigames.container;
+package net.knarcraft.dropper.container;
 
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.HashMap;
@@ -8,28 +9,16 @@ import java.util.UUID;
 
 /**
  * A UUID container able to be serialized
- */
-public class SerializableUUID extends SerializableContainer<UUID> {
-
-    /**
-     * Instantiates a new serializable uuid
  *
-     * @param value <p>The uuid to contain</p>
+ * @param uuid <p>The UUID stored by this record</p>
  */
-    public SerializableUUID(UUID value) {
-        super(value);
-    }
-
-    @Override
-    public SerializableContainer<UUID> getSerializable(UUID value) {
-        return new SerializableUUID(value);
-    }
+public record SerializableUUID(UUID uuid) implements ConfigurationSerializable {
 
     @NotNull
     @Override
     public Map<String, Object> serialize() {
         Map<String, Object> data = new HashMap<>();
-        data.put("id", getRawValue().toString());
+        data.put("id", uuid.toString());
         return data;
     }
 
@@ -49,4 +38,13 @@ public class SerializableUUID extends SerializableContainer<UUID> {
         }
     }
 
+    @Override
+    public boolean equals(Object object) {
+        if (object instanceof SerializableUUID) {
+            return this.uuid.equals(((SerializableUUID) object).uuid);
+        } else {
+            return false;
+        }
+    }
+
 }

src/main/java/net/knarcraft/dropper/listener/CommandListener.java

@@ -1,8 +1,7 @@
-package net.knarcraft.minigames.listener;
+package net.knarcraft.dropper.listener;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaSession;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArenaSession;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -19,18 +18,15 @@ public class CommandListener implements Listener {
     @EventHandler
     public void onCommand(PlayerCommandPreprocessEvent event) {
         Player player = event.getPlayer();
-        ArenaSession existingSession = MiniGames.getInstance().getSession(player.getUniqueId());
+        DropperArenaSession existingSession = Dropper.getInstance().getPlayerRegistry().getArenaSession(
+                player.getUniqueId());
         if (existingSession == null) {
             return;
         }
 
         List<String> allowedCommands = new ArrayList<>();
-        allowedCommands.add("/miniGamesLeave");
-        allowedCommands.add("/mLeave");
-        allowedCommands.add("/dLeave");
-        allowedCommands.add("/pLeave");
-        allowedCommands.add("/miniGamesMenu");
-        allowedCommands.add("/mMenu");
+        allowedCommands.add("/dropperleave");
+        allowedCommands.add("/dleave");
 
         String message = event.getMessage();
         if (!message.startsWith("/")) {
@@ -38,12 +34,12 @@ public class CommandListener implements Listener {
         }
 
         for (String command : allowedCommands) {
-            if (message.equalsIgnoreCase(command)) {
+            if (message.equals(command)) {
                 return;
             }
         }
 
-        MiniGames.getInstance().getStringFormatter().displayErrorMessage(player, MiniGameMessage.ERROR_ILLEGAL_COMMAND);
+        player.sendMessage("You cannot use that command while in an arena!");
         event.setCancelled(true);
     }
 

src/main/java/net/knarcraft/dropper/listener/DamageListener.java

@@ -1,8 +1,8 @@
-package net.knarcraft.minigames.listener;
+package net.knarcraft.dropper.listener;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaSession;
-import net.knarcraft.minigames.arena.dropper.DropperArenaSession;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArenaPlayerRegistry;
+import net.knarcraft.dropper.arena.DropperArenaSession;
 import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -25,15 +25,15 @@ public class DamageListener implements Listener {
         Player player = (Player) event.getEntity();
 
         // We don't care about damage outside arenas
-        ArenaSession arenaSession = MiniGames.getInstance().getSession(player.getUniqueId());
+        DropperArenaSession arenaSession = Dropper.getInstance().getPlayerRegistry().getArenaSession(player.getUniqueId());
         if (arenaSession == null) {
             return;
         }
 
         event.setCancelled(true);
 
-        // Only trigger a loss when a player suffers fall damage in a dropper arena
-        if (arenaSession instanceof DropperArenaSession && event.getCause() == EntityDamageEvent.DamageCause.FALL) {
+        // Only trigger a loss when a player suffers fall damage
+        if (event.getCause() == EntityDamageEvent.DamageCause.FALL) {
             arenaSession.triggerLoss();
         }
     }
@@ -44,7 +44,8 @@ public class DamageListener implements Listener {
             return;
         }
 
-        ArenaSession arenaSession = MiniGames.getInstance().getSession(event.getEntity().getUniqueId());
+        DropperArenaPlayerRegistry registry = Dropper.getInstance().getPlayerRegistry();
+        DropperArenaSession arenaSession = registry.getArenaSession(event.getEntity().getUniqueId());
         if (arenaSession != null) {
             // Cancel combustion for any player in an arena
             event.setCancelled(true);

src/main/java/net/knarcraft/dropper/listener/MoveListener.java

@@ -0,0 +1,166 @@
+package net.knarcraft.dropper.listener;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.DropperArenaPlayerRegistry;
+import net.knarcraft.dropper.arena.DropperArenaSession;
+import net.knarcraft.dropper.config.DropperConfiguration;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.util.Vector;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Calendar;
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * A listener for players moving inside a dropper arena
+ */
+public class MoveListener implements Listener {
+
+    private final DropperConfiguration configuration;
+
+    /**
+     * Instantiates a new move listener
+     *
+     * @param configuration <p>The configuration to use</p>
+     */
+    public MoveListener(DropperConfiguration configuration) {
+        this.configuration = configuration;
+    }
+
+    @EventHandler
+    public void onPlayerMove(PlayerMoveEvent event) {
+        // Ignore if no actual movement is happening
+        if (event.getFrom().equals(event.getTo()) || event.getTo() == null) {
+            return;
+        }
+
+        Player player = event.getPlayer();
+        DropperArenaPlayerRegistry playerRegistry = Dropper.getInstance().getPlayerRegistry();
+        DropperArenaSession arenaSession = playerRegistry.getArenaSession(player.getUniqueId());
+        if (arenaSession == null) {
+            return;
+        }
+        
+        // Prevent the player from flying upwards while in flight mode
+        if (event.getFrom().getY() < event.getTo().getY() ||
+                (configuration.blockSneaking() && event.getPlayer().isSneaking()) ||
+                (configuration.blockSprinting() && event.getPlayer().isSprinting())) {
+            event.setCancelled(true);
+            return;
+        }
+
+
+        // Only do block type checking if the block beneath the player changes
+        if (event.getFrom().getBlock() != event.getTo().getBlock() &&
+                checkForSpecialBlock(arenaSession, event.getTo())) {
+            return;
+        }
+
+        //Updates the player's velocity to the one set by the arena
+        updatePlayerVelocity(arenaSession);
+    }
+
+    /**
+     * Check if the player in the session is triggering a block with a special significance
+     *
+     * <p>This basically looks for the win block, or whether the player is hitting a solid block.</p>
+     *
+     * @param arenaSession <p>The arena session to check for</p>
+     * @param toLocation   <p>The location the player's session is about to hit</p>
+     * @return <p>True if a special block has been hit</p>
+     */
+    private boolean checkForSpecialBlock(DropperArenaSession arenaSession, Location toLocation) {
+        double liquidDepth = configuration.getLiquidHitBoxDepth();
+        double solidDepth = configuration.getSolidHitBoxDistance();
+
+        // Check if the player enters water
+        Material winBlockType = arenaSession.getArena().getWinBlockType();
+        // For water, only trigger when the player enters the water, but trigger earlier for everything else
+        double depth = !winBlockType.isSolid() ? liquidDepth : solidDepth;
+        for (Block block : getBlocksBeneathLocation(toLocation, depth)) {
+            if (block.getType() == winBlockType) {
+                arenaSession.triggerWin();
+                return true;
+            }
+        }
+
+        // Check if the player is about to hit a non-air and non-liquid block
+        Set<Material> whitelisted = configuration.getBlockWhitelist();
+        for (Block block : getBlocksBeneathLocation(toLocation, solidDepth)) {
+            Material blockType = block.getType();
+            if (!blockType.isAir() && !whitelisted.contains(blockType)) {
+                arenaSession.triggerLoss();
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    /**
+     * Gets the blocks at the given location that will be affected by the player's hit-box
+     *
+     * @param location <p>The location to check</p>
+     * @return <p>The blocks beneath the player</p>
+     */
+    private Set<Block> getBlocksBeneathLocation(Location location, double depth) {
+        Set<Block> blocksBeneath = new HashSet<>();
+        double halfPlayerWidth = 0.3;
+        blocksBeneath.add(location.clone().subtract(halfPlayerWidth, depth, halfPlayerWidth).getBlock());
+        blocksBeneath.add(location.clone().subtract(-halfPlayerWidth, depth, halfPlayerWidth).getBlock());
+        blocksBeneath.add(location.clone().subtract(halfPlayerWidth, depth, -halfPlayerWidth).getBlock());
+        blocksBeneath.add(location.clone().subtract(-halfPlayerWidth, depth, -halfPlayerWidth).getBlock());
+        return blocksBeneath;
+    }
+
+    /**
+     * Updates the velocity of the player in the given session
+     *
+     * @param session <p>The session to update the velocity for</p>
+     */
+    private void updatePlayerVelocity(@NotNull DropperArenaSession session) {
+        // Override the vertical velocity
+        Player player = session.getPlayer();
+        Vector playerVelocity = player.getVelocity();
+        double arenaVelocity = session.getArena().getPlayerVerticalVelocity();
+        Vector newVelocity = new Vector(playerVelocity.getX() * 5, -arenaVelocity, playerVelocity.getZ() * 5);
+        player.setVelocity(newVelocity);
+
+        // Toggle the direction of the player's flying, as necessary
+        toggleFlyInversion(session);
+    }
+
+    /**
+     * Toggles the player's flying direction inversion if playing on the random game-mode
+     *
+     * @param session <p>The session to possibly invert flying for</p>
+     */
+    private void toggleFlyInversion(@NotNull DropperArenaSession session) {
+        if (session.getGameMode() != ArenaGameMode.RANDOM_INVERTED) {
+            return;
+        }
+        Player player = session.getPlayer();
+        float horizontalVelocity = session.getArena().getPlayerHorizontalVelocity();
+        float secondsBetweenToggle = configuration.getRandomlyInvertedTimer();
+        int seconds = Calendar.getInstance().get(Calendar.SECOND);
+
+        /*
+         * A trick to make the inversion change after a customizable amount of seconds
+         * If the quotient of dividing the current number of seconds with the set amount of seconds is even, invert.
+         * So, if the number of seconds between toggles is 5, that would mean for the first 5 seconds, the flying would
+         * be inverted. Once 5 seconds have passed, the quotient becomes 1, which is odd, so the flying is no longer
+         * inverted. After 10 seconds, the quotient is 2, which is even, and inverts the flying.
+         */
+        boolean invert = Math.floor(seconds / secondsBetweenToggle) % 2 == 0;
+        player.setFlySpeed(invert ? -horizontalVelocity : horizontalVelocity);
+    }
+
+}

src/main/java/net/knarcraft/dropper/listener/PlayerLeaveListener.java

@@ -0,0 +1,82 @@
+package net.knarcraft.dropper.listener;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.DropperArenaSession;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+import java.util.logging.Level;
+
+/**
+ * A listener for players leaving the server or the arena
+ */
+public class PlayerLeaveListener implements Listener {
+
+    private final Map<UUID, DropperArenaSession> leftSessions = new HashMap<>();
+
+    @EventHandler
+    public void onPlayerLeave(PlayerQuitEvent event) {
+        Player player = event.getPlayer();
+        DropperArenaSession arenaSession = getSession(player);
+        if (arenaSession == null) {
+            return;
+        }
+
+        Dropper.log(Level.WARNING, "Found player " + player.getUniqueId() +
+                " leaving in the middle of a session!");
+        leftSessions.put(player.getUniqueId(), arenaSession);
+    }
+
+    @EventHandler
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        UUID playerId = event.getPlayer().getUniqueId();
+        // Force the player to quit from the session once they re-join
+        if (leftSessions.containsKey(playerId)) {
+            Dropper.log(Level.WARNING, "Found un-exited dropper session!");
+            Bukkit.getScheduler().runTaskLater(Dropper.getInstance(), () -> {
+                leftSessions.get(playerId).triggerQuit(false);
+                Dropper.log(Level.WARNING, "Triggered a quit!");
+                leftSessions.remove(playerId);
+            }, 80);
+        }
+    }
+
+    @EventHandler
+    public void onPlayerTeleport(PlayerTeleportEvent event) {
+        if (event.getTo() == null || event.isCancelled()) {
+            return;
+        }
+
+        DropperArenaSession arenaSession = getSession(event.getPlayer());
+        if (arenaSession == null) {
+            return;
+        }
+
+        if (event.getTo().equals(arenaSession.getArena().getSpawnLocation())) {
+            return;
+        }
+
+        arenaSession.triggerQuit(false);
+    }
+
+    /**
+     * Gets the arena session for the given player
+     *
+     * @param player <p>The player to get the arena session for</p>
+     * @return <p>The player's session, or null if not in a session</p>
+     */
+    private @Nullable DropperArenaSession getSession(@NotNull Player player) {
+        return Dropper.getInstance().getPlayerRegistry().getArenaSession(player.getUniqueId());
+    }
+
+}

src/main/java/net/knarcraft/dropper/placeholder/DropperRecordExpansion.java

@@ -1,17 +1,17 @@
-package net.knarcraft.minigames.placeholder;
+package net.knarcraft.dropper.placeholder;
 
 import me.clip.placeholderapi.expansion.PlaceholderExpansion;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.Arena;
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.ArenaGroup;
-import net.knarcraft.minigames.arena.ArenaHandler;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.record.ArenaRecord;
-import net.knarcraft.minigames.placeholder.parsing.InfoType;
-import net.knarcraft.minigames.placeholder.parsing.SelectionType;
-import net.knarcraft.minigames.property.RecordType;
-import net.knarcraft.minigames.util.GroupRecordHelper;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
+import net.knarcraft.dropper.arena.DropperArenaRecordsRegistry;
+import net.knarcraft.dropper.arena.record.ArenaRecord;
+import net.knarcraft.dropper.placeholder.parsing.InfoType;
+import net.knarcraft.dropper.placeholder.parsing.SelectionType;
+import net.knarcraft.dropper.property.RecordType;
+import net.knarcraft.dropper.util.DropperGroupRecordHelper;
 import org.bukkit.Bukkit;
 import org.bukkit.OfflinePlayer;
 import org.jetbrains.annotations.NotNull;
@@ -27,24 +27,30 @@ import java.util.Objects;
 import java.util.Set;
 import java.util.UUID;
 import java.util.function.Supplier;
-import java.util.logging.Level;
 
 /**
- * A placeholder expansion for parkour record placeholders
+ * A placeholder expansion for dropper record placeholders
  */
-public abstract class RecordExpansion extends PlaceholderExpansion {
+public class DropperRecordExpansion extends PlaceholderExpansion {
 
-    private final ArenaHandler<?, ?> arenaHandler;
+    private final Dropper plugin;
     private final Map<UUID, Set<GroupRecordCache<Integer>>> groupRecordDeathsCache;
     private final Map<UUID, Set<GroupRecordCache<Long>>> groupRecordTimeCache;
 
     /**
      * Initializes a new record expansion
+     *
+     * @param plugin <p>A reference to the dropper plugin</p>
      */
-    public RecordExpansion(ArenaHandler<?, ?> arenaHandler) {
+    public DropperRecordExpansion(Dropper plugin) {
+        this.plugin = plugin;
         this.groupRecordDeathsCache = new HashMap<>();
         this.groupRecordTimeCache = new HashMap<>();
-        this.arenaHandler = arenaHandler;
+    }
+
+    @Override
+    public String getIdentifier() {
+        return "dropper";
     }
 
     @Override
@@ -70,17 +76,10 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
             return parameters;
         }
         RecordType recordType = RecordType.getFromString(parts[1]);
-        ArenaGameMode gameMode = parseGameMode(parts[2]);
+        ArenaGameMode gameMode = ArenaGameMode.matchGamemode(parts[2]);
         SelectionType selectionType = SelectionType.getFromString(parts[3]);
         String identifier = parts[4];
-        int recordNumber;
-        try {
-            recordNumber = Integer.parseInt(parts[5]) - 1;
-        } catch (NumberFormatException exception) {
-            MiniGames.log(Level.WARNING, "Invalid placeholder given. " + parts[5] +
-                    " supplied instead of record placement.");
-            return parameters;
-        }
+        int recordNumber = Integer.parseInt(parts[5]) - 1;
         InfoType infoType = InfoType.getFromString(parts[6]);
 
         if (recordType == null || infoType == null) {
@@ -88,6 +87,7 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
         }
 
         String info = null;
+        DropperArenaHandler arenaHandler = plugin.getArenaHandler();
         if (selectionType == SelectionType.GROUP) {
             info = getGroupRecord(arenaHandler, identifier, gameMode, recordType, recordNumber, infoType);
         } else if (selectionType == SelectionType.ARENA) {
@@ -97,14 +97,6 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
         return Objects.requireNonNullElse(info, parameters);
     }
 
-    /**
-     * Parses the game-mode specified in the given string
-     *
-     * @param gameMode <p>The game-mode to parse</p>
-     * @return <p>The parsed game-mode</p>
-     */
-    protected abstract @NotNull ArenaGameMode parseGameMode(@NotNull String gameMode);
-
     /**
      * Clears all record caches
      */
@@ -114,7 +106,7 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
     }
 
     /**
-     * Gets a piece of record information from an arena group
+     * Gets a piece of record information from a dropper arena group
      *
      * @param arenaHandler <p>The arena handler to get the group from</p>
      * @param identifier   <p>The identifier (name/uuid) selecting the group</p>
@@ -124,11 +116,11 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
      * @param infoType     <p>The type of info (player, value, combined) to get</p>
      * @return <p>The selected information about the record, or null if not found</p>
      */
-    private @Nullable String getGroupRecord(@NotNull ArenaHandler<?, ?> arenaHandler, @NotNull String identifier,
+    private @Nullable String getGroupRecord(@NotNull DropperArenaHandler arenaHandler, @NotNull String identifier,
                                             @NotNull ArenaGameMode gameMode, @NotNull RecordType recordType,
                                             int recordNumber, @NotNull InfoType infoType) {
         // Allow specifying the group UUID or the arena name
-        ArenaGroup<?, ?> group;
+        DropperArenaGroup group;
         try {
             group = arenaHandler.getGroup(UUID.fromString(identifier));
         } catch (IllegalArgumentException exception) {
@@ -140,9 +132,9 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
 
         ArenaRecord<?> record;
         if (recordType == RecordType.DEATHS) {
-            record = getGroupDeathRecord(group, gameMode, recordNumber, arenaHandler);
+            record = getGroupDeathRecord(group, gameMode, recordNumber);
         } else {
-            record = getGroupTimeRecord(group, gameMode, recordNumber, arenaHandler);
+            record = getGroupTimeRecord(group, gameMode, recordNumber);
         }
 
         // If a record number is not found, leave it blank, so it looks neat
@@ -159,14 +151,12 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
      * @param group        <p>The group to get the record from</p>
      * @param gameMode     <p>The game-mode to get the record from</p>
      * @param recordNumber <p>The placing of the record to get (1st place, 2nd place, etc.)</p>
-     * @param arenaHandler <p>The handler to get arenas from</p>
      * @return <p>The record, or null if not found</p>
      */
-    private @Nullable ArenaRecord<?> getGroupTimeRecord(@NotNull ArenaGroup<?, ?> group,
-                                                        @NotNull ArenaGameMode gameMode, int recordNumber,
-                                                        @NotNull ArenaHandler<?, ?> arenaHandler) {
+    private @Nullable ArenaRecord<?> getGroupTimeRecord(@NotNull DropperArenaGroup group,
+                                                        @NotNull ArenaGameMode gameMode, int recordNumber) {
         return getCachedGroupRecord(group, gameMode, RecordType.TIME, recordNumber, groupRecordTimeCache,
-                () -> GroupRecordHelper.getCombinedTime(group, gameMode, arenaHandler));
+                () -> DropperGroupRecordHelper.getCombinedTime(group, gameMode));
     }
 
     /**
@@ -175,14 +165,12 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
      * @param group        <p>The group to get the record from</p>
      * @param gameMode     <p>The game-mode to get the record from</p>
      * @param recordNumber <p>The placing of the record to get (1st place, 2nd place, etc.)</p>
-     * @param arenaHandler <p>The handler to get arenas from</p>
      * @return <p>The record, or null if not found</p>
      */
-    private @Nullable ArenaRecord<?> getGroupDeathRecord(@NotNull ArenaGroup<?, ?> group,
-                                                         @NotNull ArenaGameMode gameMode, int recordNumber,
-                                                         @NotNull ArenaHandler<?, ?> arenaHandler) {
+    private @Nullable ArenaRecord<?> getGroupDeathRecord(@NotNull DropperArenaGroup group,
+                                                         @NotNull ArenaGameMode gameMode, int recordNumber) {
         return getCachedGroupRecord(group, gameMode, RecordType.DEATHS, recordNumber, groupRecordDeathsCache,
-                () -> GroupRecordHelper.getCombinedDeaths(group, gameMode, arenaHandler));
+                () -> DropperGroupRecordHelper.getCombinedDeaths(group, gameMode));
     }
 
     /**
@@ -197,7 +185,7 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
      * @param <K>            <p>The type of the provided records</p>
      * @return <p>The specified record, or null if not found</p>
      */
-    private <K extends Comparable<K>> @Nullable ArenaRecord<?> getCachedGroupRecord(@NotNull ArenaGroup<?, ?> group,
+    private <K extends Comparable<K>> @Nullable ArenaRecord<?> getCachedGroupRecord(@NotNull DropperArenaGroup group,
                                                                                     @NotNull ArenaGameMode gameMode,
                                                                                     @NotNull RecordType recordType,
                                                                                     int recordNumber,
@@ -234,7 +222,7 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
     }
 
     /**
-     * Gets a piece of record information from an arena
+     * Gets a piece of record information from a dropper arena
      *
      * @param arenaHandler <p>The arena handler to get the arena from</p>
      * @param identifier   <p>The identifier (name/uuid) selecting the arena</p>
@@ -244,11 +232,11 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
      * @param infoType     <p>The type of info (player, value, combined) to get</p>
      * @return <p>The selected information about the record, or null if not found</p>
      */
-    private @Nullable String getArenaRecord(@NotNull ArenaHandler<?, ?> arenaHandler, @NotNull String identifier,
+    private @Nullable String getArenaRecord(@NotNull DropperArenaHandler arenaHandler, @NotNull String identifier,
                                             @NotNull ArenaGameMode gameMode, @NotNull RecordType recordType,
                                             int recordNumber, @NotNull InfoType infoType) {
         // Allow specifying the arena UUID or the arena name
-        Arena arena;
+        DropperArena arena;
         try {
             arena = arenaHandler.getArena(UUID.fromString(identifier));
         } catch (IllegalArgumentException exception) {
@@ -257,8 +245,8 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
         if (arena == null) {
             return null;
         }
-        @NotNull Map<ArenaGameMode, ArenaRecordsRegistry> registries = arena.getData().getRecordRegistries();
-        ArenaRecordsRegistry recordsRegistry = registries.get(gameMode);
+        @NotNull Map<ArenaGameMode, DropperArenaRecordsRegistry> registries = arena.getData().recordRegistries();
+        DropperArenaRecordsRegistry recordsRegistry = registries.get(gameMode);
 
         ArenaRecord<?> record = getRecord(recordsRegistry, recordType, recordNumber);
 
@@ -278,7 +266,7 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
      * @param recordNumber    <p>The placing of the record to get (1st place, 2nd place, etc.)</p>
      * @return <p>The record, or null if not found</p>
      */
-    private @Nullable ArenaRecord<?> getRecord(@NotNull ArenaRecordsRegistry recordsRegistry,
+    private @Nullable ArenaRecord<?> getRecord(@NotNull DropperArenaRecordsRegistry recordsRegistry,
                                                @NotNull RecordType recordType, int recordNumber) {
         return switch (recordType) {
             case TIME -> getRecord(new HashSet<>(recordsRegistry.getShortestTimeMilliSecondsRecords()), recordNumber);
@@ -313,8 +301,8 @@ public abstract class RecordExpansion extends PlaceholderExpansion {
     private String getRecordData(@NotNull InfoType infoType, @NotNull ArenaRecord<?> arenaRecord) {
         return switch (infoType) {
             case PLAYER -> getPlayerName(arenaRecord.getUserId());
-            case VALUE -> arenaRecord.getAsString();
-            case COMBINED -> getPlayerName(arenaRecord.getUserId()) + ": " + arenaRecord.getAsString();
+            case VALUE -> arenaRecord.getRecord().toString();
+            case COMBINED -> getPlayerName(arenaRecord.getUserId()) + ": " + arenaRecord.getRecord().toString();
         };
     }
 

src/main/java/net/knarcraft/dropper/placeholder/GroupRecordCache.java

@@ -1,8 +1,8 @@
-package net.knarcraft.minigames.placeholder;
+package net.knarcraft.dropper.placeholder;
 
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.record.ArenaRecord;
-import net.knarcraft.minigames.property.RecordType;
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.record.ArenaRecord;
+import net.knarcraft.dropper.property.RecordType;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.Set;
@@ -15,8 +15,7 @@ import java.util.Set;
  * @param records     <p>The stored records</p>
  * @param createdTime <p>The time this cache was created</p>
  */
-public record GroupRecordCache<K extends Comparable<K>>(@NotNull ArenaGameMode gameMode,
-                                                        @NotNull RecordType recordType,
+public record GroupRecordCache<K extends Comparable<K>>(@NotNull ArenaGameMode gameMode, @NotNull RecordType recordType,
                                                         @NotNull Set<ArenaRecord<K>> records,
                                                         @NotNull Long createdTime) {
 }

src/main/java/net/knarcraft/dropper/placeholder/parsing/InfoType.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.placeholder.parsing;
+package net.knarcraft.dropper.placeholder.parsing;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

src/main/java/net/knarcraft/dropper/placeholder/parsing/SelectionType.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.placeholder.parsing;
+package net.knarcraft.dropper.placeholder.parsing;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

src/main/java/net/knarcraft/dropper/property/RecordResult.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.property;
+package net.knarcraft.dropper.property;
 
 /**
  * A representation of all possible record results

src/main/java/net/knarcraft/dropper/property/RecordType.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.property;
+package net.knarcraft.dropper.property;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;

src/main/java/net/knarcraft/dropper/util/ArenaStorageHelper.java

@@ -0,0 +1,244 @@
+package net.knarcraft.dropper.util;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.ArenaStorageKey;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaData;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaRecordsRegistry;
+import net.knarcraft.dropper.container.SerializableMaterial;
+import net.knarcraft.dropper.container.SerializableUUID;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.configuration.ConfigurationSection;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import java.util.logging.Level;
+
+/**
+ * A helper class for saving and loading arenas
+ */
+public final class ArenaStorageHelper {
+
+    private final static String arenasConfigurationSection = "arenas";
+    private final static String groupsConfigurationSection = "groups";
+    private static final File arenaFile = new File(Dropper.getInstance().getDataFolder(), "arenas.yml");
+    private static final File groupFile = new File(Dropper.getInstance().getDataFolder(), "groups.yml");
+    private static final File arenaDataFolder = new File(Dropper.getInstance().getDataFolder(), "arena_data");
+
+    private ArenaStorageHelper() {
+
+    }
+
+    /**
+     * Saves the given dropper arena groups
+     *
+     * @param arenaGroups <p>The arena groups to save</p>
+     * @throws IOException <p>If unable to write to the file</p>
+     */
+    public static void saveDropperArenaGroups(@NotNull Set<DropperArenaGroup> arenaGroups) throws IOException {
+        YamlConfiguration configuration = new YamlConfiguration();
+        ConfigurationSection groupSection = configuration.createSection(groupsConfigurationSection);
+
+        for (DropperArenaGroup arenaGroup : arenaGroups) {
+            groupSection.set(arenaGroup.getGroupId().toString(), arenaGroup);
+        }
+
+        configuration.save(groupFile);
+    }
+
+    /**
+     * Loads all existing dropper arena groups
+     *
+     * @return <p>The loaded arena groups</p>
+     */
+    public static @NotNull Set<DropperArenaGroup> loadDropperArenaGroups() {
+        YamlConfiguration configuration = YamlConfiguration.loadConfiguration(groupFile);
+        ConfigurationSection groupSection = configuration.getConfigurationSection(groupsConfigurationSection);
+        //If no such section exists, it must be the case that there is no data to load
+        if (groupSection == null) {
+            return new HashSet<>();
+        }
+
+        Set<DropperArenaGroup> arenaGroups = new HashSet<>();
+
+        for (String sectionName : groupSection.getKeys(false)) {
+            arenaGroups.add((DropperArenaGroup) groupSection.get(sectionName));
+        }
+
+        return arenaGroups;
+    }
+
+    /**
+     * Saves the given arenas
+     *
+     * @param arenas <p>The arenas to save</p>
+     * @throws IOException <p>If unable to write to the file</p>
+     */
+    public static void saveArenas(@NotNull Map<UUID, DropperArena> arenas) throws IOException {
+        YamlConfiguration configuration = new YamlConfiguration();
+        ConfigurationSection arenaSection = configuration.createSection(arenasConfigurationSection);
+        for (DropperArena arena : arenas.values()) {
+            //Note: While the arena name is used as the key, as the key has to be sanitized, the un-sanitized arena name
+            // must be stored as well
+            @NotNull ConfigurationSection configSection = arenaSection.createSection(arena.getArenaId().toString());
+            configSection.set(ArenaStorageKey.ID.getKey(), new SerializableUUID(arena.getArenaId()));
+            configSection.set(ArenaStorageKey.NAME.getKey(), arena.getArenaName());
+            configSection.set(ArenaStorageKey.SPAWN_LOCATION.getKey(), arena.getSpawnLocation());
+            configSection.set(ArenaStorageKey.EXIT_LOCATION.getKey(), arena.getExitLocation());
+            configSection.set(ArenaStorageKey.PLAYER_VERTICAL_VELOCITY.getKey(), arena.getPlayerVerticalVelocity());
+            configSection.set(ArenaStorageKey.PLAYER_HORIZONTAL_VELOCITY.getKey(), arena.getPlayerHorizontalVelocity());
+            configSection.set(ArenaStorageKey.WIN_BLOCK_TYPE.getKey(), new SerializableMaterial(arena.getWinBlockType()));
+            saveArenaData(arena.getData());
+        }
+        configuration.save(arenaFile);
+    }
+
+    /**
+     * Loads all arenas
+     *
+     * @return <p>The loaded arenas, or null if the arenas configuration section is missing.</p>
+     */
+    public static @NotNull Map<UUID, DropperArena> loadArenas() {
+        YamlConfiguration configuration = YamlConfiguration.loadConfiguration(arenaFile);
+        ConfigurationSection arenaSection = configuration.getConfigurationSection(arenasConfigurationSection);
+        //If no such section exists, it must be the case that there is no data to load
+        if (arenaSection == null) {
+            return new HashMap<>();
+        }
+
+        Map<UUID, DropperArena> loadedArenas = new HashMap<>();
+
+        for (String sectionName : arenaSection.getKeys(false)) {
+            ConfigurationSection configurationSection = arenaSection.getConfigurationSection(sectionName);
+            //I'm not sure whether this could actually happen
+            if (configurationSection == null) {
+                continue;
+            }
+
+            DropperArena arena = loadArena(configurationSection);
+            if (arena != null) {
+                loadedArenas.put(arena.getArenaId(), arena);
+            }
+        }
+
+        return loadedArenas;
+    }
+
+    /**
+     * Loads an arena from the given configuration section
+     *
+     * @param configurationSection <p>The configuration section containing arena data</p>
+     * @return <p>The loaded arena, or null if invalid</p>
+     */
+    private static @Nullable DropperArena loadArena(@NotNull ConfigurationSection configurationSection) {
+        UUID arenaId = ((SerializableUUID) configurationSection.get(ArenaStorageKey.ID.getKey(),
+                new SerializableUUID(UUID.randomUUID()))).uuid();
+        String arenaName = configurationSection.getString(ArenaStorageKey.NAME.getKey());
+        Location spawnLocation = (Location) configurationSection.get(ArenaStorageKey.SPAWN_LOCATION.getKey());
+        Location exitLocation = (Location) configurationSection.get(ArenaStorageKey.EXIT_LOCATION.getKey());
+        double verticalVelocity = configurationSection.getDouble(ArenaStorageKey.PLAYER_VERTICAL_VELOCITY.getKey());
+        float horizontalVelocity = sanitizeHorizontalVelocity((float) configurationSection.getDouble(
+                ArenaStorageKey.PLAYER_HORIZONTAL_VELOCITY.getKey()));
+        SerializableMaterial winBlockType = (SerializableMaterial) configurationSection.get(
+                ArenaStorageKey.WIN_BLOCK_TYPE.getKey());
+
+        if (arenaName == null || spawnLocation == null) {
+            Dropper.log(Level.SEVERE, "Could not load the arena at configuration " +
+                    "section " + configurationSection.getName() + ". Please check the arenas storage file for issues.");
+            return null;
+        }
+        if (winBlockType == null) {
+            winBlockType = new SerializableMaterial(Material.WATER);
+        }
+
+        DropperArenaData arenaData = loadArenaData(arenaId);
+        if (arenaData == null) {
+            Dropper.log(Level.SEVERE, "Unable to load arena data for " + arenaId);
+
+            Map<ArenaGameMode, DropperArenaRecordsRegistry> recordRegistries = new HashMap<>();
+            for (ArenaGameMode arenaGameMode : ArenaGameMode.values()) {
+                recordRegistries.put(arenaGameMode, new DropperArenaRecordsRegistry(arenaId));
+            }
+            arenaData = new DropperArenaData(arenaId, recordRegistries, new HashMap<>());
+        }
+
+        return new DropperArena(arenaId, arenaName, spawnLocation, exitLocation, verticalVelocity, horizontalVelocity,
+                winBlockType.material(), arenaData, Dropper.getInstance().getArenaHandler());
+    }
+
+    /**
+     * Stores the given arena data to a file
+     *
+     * @param arenaData <p>The arena data to store</p>
+     */
+    public static void saveArenaData(@NotNull DropperArenaData arenaData) throws IOException {
+        YamlConfiguration configuration = new YamlConfiguration();
+        configuration.set(ArenaStorageKey.DATA.getKey(), arenaData);
+
+        configuration.save(getArenaDataFile(arenaData.arenaId()));
+    }
+
+    /**
+     * Loads arena data for the given arena id
+     *
+     * @param arenaId <p>The id of the arena to get data for</p>
+     * @return <p>The loaded arena data</p>
+     */
+    private static @Nullable DropperArenaData loadArenaData(@NotNull UUID arenaId) {
+        File arenaDataFile = getArenaDataFile(arenaId);
+        YamlConfiguration configuration = YamlConfiguration.loadConfiguration(arenaDataFile);
+        return (DropperArenaData) configuration.get(ArenaStorageKey.DATA.getKey());
+    }
+
+    /**
+     * Removes data for the arena with the given id
+     *
+     * @param arenaId <p>The id of the arena to remove data for</p>
+     * @return <p>True if the data was successfully removed</p>
+     */
+    public static boolean removeArenaData(@NotNull UUID arenaId) {
+        return getArenaDataFile(arenaId).delete();
+    }
+
+    /**
+     * Gets the file used to store the given arena id's data
+     *
+     * @param arenaId <p>The id of the arena to get a data file for</p>
+     * @return <p>The file the arena's data is/should be stored in</p>
+     */
+    private static @NotNull File getArenaDataFile(@NotNull UUID arenaId) {
+        File arenaDataFile = new File(arenaDataFolder, arenaId + ".yml");
+        if (!arenaDataFolder.exists() && !arenaDataFolder.mkdirs()) {
+            Dropper.log(Level.SEVERE, "Unable to create the arena data directories");
+        }
+        return arenaDataFile;
+    }
+
+    /**
+     * Sanitizes the given horizontal velocity to make sure it doesn't leave its bounds
+     *
+     * @param horizontalVelocity <p>The horizontal velocity to sanitize</p>
+     * @return <p>The sanitized horizontal velocity</p>
+     */
+    private static float sanitizeHorizontalVelocity(float horizontalVelocity) {
+        if (horizontalVelocity < -1) {
+            return -1;
+        } else if (horizontalVelocity > 1) {
+            return 1;
+        } else {
+            return horizontalVelocity;
+        }
+    }
+
+}

src/main/java/net/knarcraft/dropper/util/DropperGroupRecordHelper.java

@@ -1,11 +1,12 @@
-package net.knarcraft.minigames.util;
+package net.knarcraft.dropper.util;
 
-import net.knarcraft.minigames.arena.Arena;
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.ArenaGroup;
-import net.knarcraft.minigames.arena.ArenaHandler;
-import net.knarcraft.minigames.arena.record.ArenaRecord;
-import net.knarcraft.minigames.arena.record.SummableArenaRecord;
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaGameMode;
+import net.knarcraft.dropper.arena.DropperArena;
+import net.knarcraft.dropper.arena.DropperArenaGroup;
+import net.knarcraft.dropper.arena.DropperArenaHandler;
+import net.knarcraft.dropper.arena.record.ArenaRecord;
+import net.knarcraft.dropper.arena.record.SummableArenaRecord;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.HashMap;
@@ -18,9 +19,9 @@ import java.util.function.BiFunction;
 /**
  * A helper class for getting combined record data for a dropper group
  */
-public final class GroupRecordHelper {
+public final class DropperGroupRecordHelper {
 
-    private GroupRecordHelper() {
+    private DropperGroupRecordHelper() {
 
     }
 
@@ -29,17 +30,15 @@ public final class GroupRecordHelper {
      *
      * @param group    <p>The group to get records from</p>
      * @param gameMode <p>The game-mode to get records for</p>
-     * @param arenaHandler <p>The handler to get arenas from</p>
      * @return <p>The combined death records</p>
      */
-    public static @NotNull Set<ArenaRecord<Integer>> getCombinedDeaths(@NotNull ArenaGroup<?, ?> group,
-                                                                       @NotNull ArenaGameMode gameMode,
-                                                                       @NotNull ArenaHandler<?, ?> arenaHandler) {
+    public static @NotNull Set<ArenaRecord<Integer>> getCombinedDeaths(@NotNull DropperArenaGroup group,
+                                                                       @NotNull ArenaGameMode gameMode) {
         Map<UUID, SummableArenaRecord<Integer>> records = new HashMap<>();
-        @NotNull BiFunction<Arena, ArenaGameMode, Set<SummableArenaRecord<Integer>>> recordSupplier =
-                (arena, aGameMode) -> arena.getData().getRecordRegistries().get(gameMode).getLeastDeathsRecords();
+        @NotNull BiFunction<DropperArena, ArenaGameMode, Set<SummableArenaRecord<Integer>>> recordSupplier =
+                (arena, aGameMode) -> arena.getData().recordRegistries().get(gameMode).getLeastDeathsRecords();
 
-        return getCombined(group, gameMode, records, recordSupplier, arenaHandler);
+        return getCombined(group, gameMode, records, recordSupplier);
     }
 
     /**
@@ -47,17 +46,15 @@ public final class GroupRecordHelper {
      *
      * @param group    <p>The group to get records from</p>
      * @param gameMode <p>The game-mode to get records for</p>
-     * @param arenaHandler <p>The handler to get arenas from</p>
      * @return <p>The combined least-time records</p>
      */
-    public static @NotNull Set<ArenaRecord<Long>> getCombinedTime(@NotNull ArenaGroup<?, ?> group,
-                                                                  @NotNull ArenaGameMode gameMode,
-                                                                  @NotNull ArenaHandler<?, ?> arenaHandler) {
+    public static @NotNull Set<ArenaRecord<Long>> getCombinedTime(@NotNull DropperArenaGroup group,
+                                                                  @NotNull ArenaGameMode gameMode) {
         Map<UUID, SummableArenaRecord<Long>> records = new HashMap<>();
-        @NotNull BiFunction<Arena, ArenaGameMode, Set<SummableArenaRecord<Long>>> recordSupplier =
-                (arena, aGameMode) -> arena.getData().getRecordRegistries().get(gameMode).getShortestTimeMilliSecondsRecords();
+        @NotNull BiFunction<DropperArena, ArenaGameMode, Set<SummableArenaRecord<Long>>> recordSupplier =
+                (arena, aGameMode) -> arena.getData().recordRegistries().get(gameMode).getShortestTimeMilliSecondsRecords();
 
-        return getCombined(group, gameMode, records, recordSupplier, arenaHandler);
+        return getCombined(group, gameMode, records, recordSupplier);
     }
 
     /**
@@ -67,20 +64,20 @@ public final class GroupRecordHelper {
      * @param gameMode       <p>The game-mode to get records for</p>
      * @param records        <p>The map to store the combined records to</p>
      * @param recordSupplier <p>The function that supplies records of this type</p>
-     * @param arenaHandler   <p>The handler to get arenas from</p>
      * @param <K>            <p>The type of the records to combine</p>
      * @return <p>The combined records</p>
      */
-    private static <K extends Comparable<K>> @NotNull Set<ArenaRecord<K>> getCombined(@NotNull ArenaGroup<?, ?> group,
+    private static <K extends Comparable<K>> @NotNull Set<ArenaRecord<K>> getCombined(@NotNull DropperArenaGroup group,
                                                                                       @NotNull ArenaGameMode gameMode,
                                                                                       @NotNull Map<UUID,
                                                                                               SummableArenaRecord<K>> records,
-                                                                                      @NotNull BiFunction<Arena,
+                                                                                      @NotNull BiFunction<DropperArena,
                                                                                               ArenaGameMode,
-                                                                                              Set<SummableArenaRecord<K>>> recordSupplier,
-                                                                                      @NotNull ArenaHandler<?, ?> arenaHandler) {
+                                                                                              Set<SummableArenaRecord<K>>> recordSupplier) {
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
+
         // Get all arenas in the group
-        Set<Arena> arenas = getArenas(arenaHandler, group);
+        Set<DropperArena> arenas = getArenas(arenaHandler, group);
 
         // Calculate the combined records
         Map<UUID, Integer> recordsFound = new HashMap<>();
@@ -116,12 +113,12 @@ public final class GroupRecordHelper {
      * @param group        <p>The group to get arenas for</p>
      * @return <p>The arenas found in the group</p>
      */
-    private static @NotNull Set<Arena> getArenas(@NotNull ArenaHandler<?, ?> arenaHandler,
-                                                 @NotNull ArenaGroup<?, ?> group) {
+    private static @NotNull Set<DropperArena> getArenas(@NotNull DropperArenaHandler arenaHandler,
+                                                        @NotNull DropperArenaGroup group) {
         // Get all arenas in the group
-        Set<Arena> arenas = new HashSet<>();
+        Set<DropperArena> arenas = new HashSet<>();
         for (UUID arenaId : group.getArenas()) {
-            Arena arena = arenaHandler.getArena(arenaId);
+            DropperArena arena = arenaHandler.getArena(arenaId);
             if (arena != null) {
                 arenas.add(arena);
             }
@@ -139,14 +136,14 @@ public final class GroupRecordHelper {
      * @param recordSupplier  <p>The function that supplies record data of this type</p>
      * @param <K>             <p>The type of record to combine</p>
      */
-    private static <K extends Comparable<K>> void combineRecords(@NotNull Set<Arena> arenas,
+    private static <K extends Comparable<K>> void combineRecords(@NotNull Set<DropperArena> arenas,
                                                                  @NotNull ArenaGameMode gameMode,
                                                                  @NotNull Map<UUID,
                                                                          SummableArenaRecord<K>> combinedRecords,
                                                                  @NotNull Map<UUID, Integer> recordsFound,
-                                                                 @NotNull BiFunction<Arena, ArenaGameMode,
+                                                                 @NotNull BiFunction<DropperArena, ArenaGameMode,
                                                                          Set<SummableArenaRecord<K>>> recordSupplier) {
-        for (Arena arena : arenas) {
+        for (DropperArena arena : arenas) {
             Set<SummableArenaRecord<K>> existingRecords = recordSupplier.apply(arena, gameMode);
             // For each arena's record registry, calculate the combined records
             for (SummableArenaRecord<K> value : existingRecords) {

src/main/java/net/knarcraft/dropper/util/PlayerTeleporter.java

@@ -1,7 +1,6 @@
-package net.knarcraft.minigames.util;
+package net.knarcraft.dropper.util;
 
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
+import net.knarcraft.dropper.Dropper;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Entity;
@@ -36,8 +35,7 @@ public final class PlayerTeleporter {
                     passenger.teleport(location);
                 }
             } else {
-                MiniGames.getInstance().getStringFormatter().displayErrorMessage(player,
-                        MiniGameMessage.ERROR_TELEPORT_WITH_PASSENGER);
+                player.sendMessage("You cannot be teleported with a passenger!");
                 return false;
             }
         }
@@ -47,20 +45,19 @@ public final class PlayerTeleporter {
                 player.eject();
                 vehicle.teleport(location);
             } else {
-                MiniGames.getInstance().getStringFormatter().displayErrorMessage(player,
-                        MiniGameMessage.ERROR_TELEPORT_IN_VEHICLE);
+                player.sendMessage("You cannot be teleported while in a vehicle");
                 return false;
             }
         }
-        // Stop the existing player velocity to prevent unevenness between players
+        //Stop the existing player velocity to prevent unevenness between players
         player.setVelocity(new Vector(0, 0, 0));
         player.setInvulnerable(true);
         player.teleport(location);
         player.setVelocity(new Vector(0, 0, 0));
-        // When teleporting a player out of the arena, sometimes the move listener is slow to react, giving the player 
+        //When teleporting a player out of the arena, sometimes the move listener is slow to react, giving the player 
         // lethal velocity, and causing damage. That's why the player is given 5 ticks of invulnerability
         if (!immediately) {
-            Bukkit.getScheduler().runTaskLater(MiniGames.getInstance(), () -> player.setInvulnerable(false), 5);
+            Bukkit.getScheduler().runTaskLater(Dropper.getInstance(), () -> player.setInvulnerable(false), 5);
         } else {
             player.setInvulnerable(false);
         }

src/main/java/net/knarcraft/dropper/util/StringSanitizer.java

@@ -1,4 +1,4 @@
-package net.knarcraft.minigames.util;
+package net.knarcraft.dropper.util;
 
 import org.jetbrains.annotations.NotNull;
 

src/main/java/net/knarcraft/dropper/util/TabCompleteHelper.java

@@ -0,0 +1,46 @@
+package net.knarcraft.dropper.util;
+
+import net.knarcraft.dropper.Dropper;
+import net.knarcraft.dropper.arena.ArenaEditableProperty;
+import net.knarcraft.dropper.arena.DropperArena;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * A helper-class for common tab-completions
+ */
+public final class TabCompleteHelper {
+
+    private TabCompleteHelper() {
+
+    }
+
+    /**
+     * Gets the names of all current arenas
+     *
+     * @return <p>All arena names</p>
+     */
+    public static @NotNull List<String> getArenas() {
+        List<String> arenaNames = new ArrayList<>();
+        for (DropperArena dropperArena : Dropper.getInstance().getArenaHandler().getArenas().values()) {
+            arenaNames.add(dropperArena.getArenaName());
+        }
+        return arenaNames;
+    }
+
+    /**
+     * Gets the argument strings of all arena properties
+     *
+     * @return <p>All arena properties</p>
+     */
+    public static @NotNull List<String> getArenaProperties() {
+        List<String> arenaProperties = new ArrayList<>();
+        for (ArenaEditableProperty property : ArenaEditableProperty.values()) {
+            arenaProperties.add(property.getArgumentString());
+        }
+        return arenaProperties;
+    }
+
+}

src/main/java/net/knarcraft/minigames/MiniGames.java

@@ -1,469 +0,0 @@
-package net.knarcraft.minigames;
-
-import net.knarcraft.knargui.GUIListener;
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.knarlib.formatting.Translator;
-import net.knarcraft.knarlib.property.ColorConversion;
-import net.knarcraft.minigames.arena.ArenaPlayerRegistry;
-import net.knarcraft.minigames.arena.ArenaSession;
-import net.knarcraft.minigames.arena.PlayerVisibilityManager;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaData;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGameMode;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGroup;
-import net.knarcraft.minigames.arena.dropper.DropperArenaHandler;
-import net.knarcraft.minigames.arena.dropper.DropperArenaPlayerRegistry;
-import net.knarcraft.minigames.arena.dropper.DropperArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.dropper.DropperPlayerEntryState;
-import net.knarcraft.minigames.arena.parkour.ParkourArena;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaData;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaGameMode;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaGroup;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaHandler;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaPlayerRegistry;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.parkour.ParkourPlayerEntryState;
-import net.knarcraft.minigames.arena.record.IntegerRecord;
-import net.knarcraft.minigames.arena.record.LongRecord;
-import net.knarcraft.minigames.arena.reward.CommandReward;
-import net.knarcraft.minigames.arena.reward.EconomyReward;
-import net.knarcraft.minigames.arena.reward.ItemReward;
-import net.knarcraft.minigames.arena.reward.PermissionReward;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.command.LeaveArenaCommand;
-import net.knarcraft.minigames.command.MenuCommand;
-import net.knarcraft.minigames.command.ReloadCommand;
-import net.knarcraft.minigames.command.SetArenaRewardCommand;
-import net.knarcraft.minigames.command.SetArenaRewardTabCompleter;
-import net.knarcraft.minigames.command.dropper.CreateDropperArenaCommand;
-import net.knarcraft.minigames.command.dropper.DropperGroupListCommand;
-import net.knarcraft.minigames.command.dropper.DropperGroupSetCommand;
-import net.knarcraft.minigames.command.dropper.DropperGroupSwapCommand;
-import net.knarcraft.minigames.command.dropper.EditDropperArenaCommand;
-import net.knarcraft.minigames.command.dropper.EditDropperArenaTabCompleter;
-import net.knarcraft.minigames.command.dropper.JoinDropperArenaCommand;
-import net.knarcraft.minigames.command.dropper.JoinDropperArenaTabCompleter;
-import net.knarcraft.minigames.command.dropper.ListDropperArenaCommand;
-import net.knarcraft.minigames.command.dropper.RemoveDropperArenaCommand;
-import net.knarcraft.minigames.command.dropper.RemoveDropperArenaTabCompleter;
-import net.knarcraft.minigames.command.parkour.CreateParkourArenaCommand;
-import net.knarcraft.minigames.command.parkour.EditParkourArenaCommand;
-import net.knarcraft.minigames.command.parkour.EditParkourArenaTabCompleter;
-import net.knarcraft.minigames.command.parkour.JoinParkourArenaCommand;
-import net.knarcraft.minigames.command.parkour.JoinParkourArenaTabCompleter;
-import net.knarcraft.minigames.command.parkour.ListParkourArenaCommand;
-import net.knarcraft.minigames.command.parkour.ParkourGroupListCommand;
-import net.knarcraft.minigames.command.parkour.ParkourGroupSetCommand;
-import net.knarcraft.minigames.command.parkour.ParkourGroupSwapCommand;
-import net.knarcraft.minigames.command.parkour.RemoveParkourArenaCommand;
-import net.knarcraft.minigames.command.parkour.RemoveParkourArenaTabCompleter;
-import net.knarcraft.minigames.config.DropperConfiguration;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.config.ParkourConfiguration;
-import net.knarcraft.minigames.config.SharedConfiguration;
-import net.knarcraft.minigames.container.SerializableMaterial;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.listener.CommandListener;
-import net.knarcraft.minigames.listener.DamageListener;
-import net.knarcraft.minigames.listener.InteractListener;
-import net.knarcraft.minigames.listener.MoveListener;
-import net.knarcraft.minigames.listener.PlayerStateChangeListener;
-import net.knarcraft.minigames.manager.EconomyManager;
-import net.knarcraft.minigames.manager.PermissionManager;
-import net.knarcraft.minigames.placeholder.DropperRecordExpansion;
-import net.knarcraft.minigames.placeholder.ParkourRecordExpansion;
-import net.md_5.bungee.api.ChatColor;
-import net.milkbowl.vault.economy.Economy;
-import net.milkbowl.vault.permission.Permission;
-import org.bukkit.Bukkit;
-import org.bukkit.command.CommandExecutor;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.command.TabCompleter;
-import org.bukkit.configuration.serialization.ConfigurationSerialization;
-import org.bukkit.plugin.PluginManager;
-import org.bukkit.plugin.RegisteredServiceProvider;
-import org.bukkit.plugin.ServicesManager;
-import org.bukkit.plugin.java.JavaPlugin;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.UUID;
-import java.util.logging.Level;
-
-/**
- * The dropper plugin's main class
- */
-@SuppressWarnings("unused")
-public final class MiniGames extends JavaPlugin {
-
-    private static MiniGames instance;
-    private SharedConfiguration sharedConfiguration;
-    private DropperConfiguration dropperConfiguration;
-    private ParkourConfiguration parkourConfiguration;
-    private DropperArenaHandler dropperArenaHandler;
-    private ArenaPlayerRegistry<DropperArena> dropperArenaPlayerRegistry;
-    private DropperRecordExpansion dropperRecordExpansion;
-    private ParkourRecordExpansion parkourRecordExpansion;
-    private ParkourArenaHandler parkourArenaHandler;
-    private ArenaPlayerRegistry<ParkourArena> parkourArenaPlayerRegistry;
-    private PlayerVisibilityManager playerVisibilityManager;
-    private Translator translator;
-    private StringFormatter stringFormatter;
-
-    /**
-     * Gets an instance of this plugin
-     *
-     * @return <p>An instance of this plugin, or null if not initialized yet.</p>
-     */
-    public static MiniGames getInstance() {
-        return instance;
-    }
-
-    /**
-     * Gets the dropper arena handler for this instance
-     *
-     * @return <p>A dropper arena handler</p>
-     */
-    public DropperArenaHandler getDropperArenaHandler() {
-        return this.dropperArenaHandler;
-    }
-
-    /**
-     * Gets the parkour arena handler for this instance
-     *
-     * @return <p>A parkour arena handler</p>
-     */
-    public ParkourArenaHandler getParkourArenaHandler() {
-        return this.parkourArenaHandler;
-    }
-
-    /**
-     * Gets the dropper arena player registry for this instance
-     *
-     * @return <p>A dropper arena player registry</p>
-     */
-    public ArenaPlayerRegistry<DropperArena> getDropperArenaPlayerRegistry() {
-        return this.dropperArenaPlayerRegistry;
-    }
-
-    /**
-     * Gets the parkour arena player registry for this instance
-     *
-     * @return <p>A parkour arena player registry</p>
-     */
-    public ArenaPlayerRegistry<ParkourArena> getParkourArenaPlayerRegistry() {
-        return this.parkourArenaPlayerRegistry;
-    }
-
-    /**
-     * Gets the shared configuration
-     *
-     * <p>The configuration for options which don't affect specific types of mini-games.</p>
-     *
-     * @return <p>The shared configuration</p>
-     */
-    public SharedConfiguration getSharedConfiguration() {
-        return this.sharedConfiguration;
-    }
-
-    /**
-     * Gets the dropper configuration
-     *
-     * @return <p>The dropper configuration</p>
-     */
-    public DropperConfiguration getDropperConfiguration() {
-        return this.dropperConfiguration;
-    }
-
-    /**
-     * Gets the parkour configuration
-     *
-     * @return <p>The parkour configuration</p>
-     */
-    public ParkourConfiguration getParkourConfiguration() {
-        return this.parkourConfiguration;
-    }
-
-    /**
-     * Gets the manager keeping track of player visibility
-     *
-     * @return <p>The player visibility manager</p>
-     */
-    public PlayerVisibilityManager getPlayerVisibilityManager() {
-        return this.playerVisibilityManager;
-    }
-
-    /**
-     * Gets the translator to get messages from
-     *
-     * @return <p>The translator</p>
-     */
-    public Translator getTranslator() {
-        return this.translator;
-    }
-
-    /**
-     * Gets the string formatter to get formatted messages from
-     *
-     * @return <p>The string formatter</p>
-     */
-    public StringFormatter getStringFormatter() {
-        return this.stringFormatter;
-    }
-
-    /**
-     * Gets the current session of the given player
-     *
-     * @param playerId <p>The id of the player to get a session for</p>
-     * @return <p>The player's current session, or null if not found</p>
-     */
-    public @Nullable ArenaSession getSession(@NotNull UUID playerId) {
-        ArenaSession dropperArenaSession = dropperArenaPlayerRegistry.getArenaSession(playerId);
-        if (dropperArenaSession != null) {
-            return dropperArenaSession;
-        }
-
-        return parkourArenaPlayerRegistry.getArenaSession(playerId);
-    }
-
-    /**
-     * Logs a message
-     *
-     * @param level   <p>The message level to log at</p>
-     * @param message <p>The message to log</p>
-     */
-    public static void log(Level level, String message) {
-        MiniGames.getInstance().getLogger().log(level, message);
-    }
-
-    /**
-     * Reloads all configurations and data from disk
-     */
-    public void reload() {
-        // Load all arenas again
-        this.dropperArenaHandler.load();
-        this.parkourArenaHandler.load();
-
-        // Reload configuration
-        this.reloadConfig();
-        translator.loadLanguages(this.getDataFolder(), "en",
-                getConfig().getString("language", "en"));
-        this.sharedConfiguration.load(this.getConfig());
-        this.dropperConfiguration.load(this.getConfig());
-        this.parkourConfiguration.load(this.getConfig());
-
-        // Clear record caches
-        this.dropperRecordExpansion.clearCaches();
-        this.parkourRecordExpansion.clearCaches();
-    }
-
-    @Override
-    public void onLoad() {
-        super.onLoad();
-        // Register serialization classes
-        ConfigurationSerialization.registerClass(SerializableMaterial.class);
-        ConfigurationSerialization.registerClass(DropperArenaRecordsRegistry.class);
-        ConfigurationSerialization.registerClass(SerializableUUID.class);
-        ConfigurationSerialization.registerClass(DropperArenaData.class);
-        ConfigurationSerialization.registerClass(DropperArenaGroup.class);
-        ConfigurationSerialization.registerClass(DropperArenaGameMode.class);
-        ConfigurationSerialization.registerClass(LongRecord.class);
-        ConfigurationSerialization.registerClass(IntegerRecord.class);
-        ConfigurationSerialization.registerClass(ParkourArenaRecordsRegistry.class);
-        ConfigurationSerialization.registerClass(ParkourArenaData.class);
-        ConfigurationSerialization.registerClass(ParkourArenaGroup.class);
-        ConfigurationSerialization.registerClass(ParkourArenaGameMode.class);
-        ConfigurationSerialization.registerClass(DropperPlayerEntryState.class);
-        ConfigurationSerialization.registerClass(ParkourPlayerEntryState.class);
-        ConfigurationSerialization.registerClass(CommandReward.class);
-        ConfigurationSerialization.registerClass(EconomyReward.class);
-        ConfigurationSerialization.registerClass(ItemReward.class);
-        ConfigurationSerialization.registerClass(PermissionReward.class);
-        ConfigurationSerialization.registerClass(RewardCondition.class);
-    }
-
-    @Override
-    public void onEnable() {
-        // Plugin startup logic
-        instance = this;
-
-        // Load configuration
-        loadConfiguration();
-
-        // Register all listeners
-        registerListeners();
-
-        // Register all commands
-        registerCommands();
-
-        // Integrate with other plugins
-        doPluginIntegration();
-    }
-
-    @Override
-    public void onDisable() {
-        // Kill all sessions before exiting
-        for (DropperArena arena : dropperArenaHandler.getArenas().values()) {
-            dropperArenaPlayerRegistry.removeForArena(arena, true);
-        }
-        for (ParkourArena arena : parkourArenaHandler.getArenas().values()) {
-            parkourArenaPlayerRegistry.removeForArena(arena, true);
-        }
-    }
-
-    /**
-     * Sets up integration with third-party plugins
-     */
-    private void doPluginIntegration() {
-        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
-            this.dropperRecordExpansion = new DropperRecordExpansion(this);
-            if (!this.dropperRecordExpansion.register()) {
-                log(Level.WARNING, "Unable to register PlaceholderAPI dropper expansion!");
-            }
-            this.parkourRecordExpansion = new ParkourRecordExpansion(this);
-            if (!this.parkourRecordExpansion.register()) {
-                log(Level.WARNING, "Unable to register PlaceholderAPI parkour expansion!");
-            }
-        }
-        if (Bukkit.getPluginManager().getPlugin("Vault") != null) {
-            setupVault();
-        } else {
-            log(Level.WARNING, "Vault not found. Economy and Permission rewards are unavailable.");
-        }
-    }
-
-    /**
-     * Loads all configuration values used by this plugin
-     */
-    private void loadConfiguration() {
-        this.saveDefaultConfig();
-        getConfig().options().copyDefaults(true);
-        saveConfig();
-        reloadConfig();
-
-        setupStringFormatter();
-
-        this.sharedConfiguration = new SharedConfiguration(this.getConfig());
-        this.dropperConfiguration = new DropperConfiguration(this.getConfig());
-        this.parkourConfiguration = new ParkourConfiguration(this.getConfig());
-        this.dropperArenaPlayerRegistry = new DropperArenaPlayerRegistry();
-        this.dropperArenaHandler = new DropperArenaHandler(this.dropperArenaPlayerRegistry);
-        this.dropperArenaHandler.load();
-        this.parkourArenaPlayerRegistry = new ParkourArenaPlayerRegistry();
-        this.parkourArenaHandler = new ParkourArenaHandler(this.parkourArenaPlayerRegistry);
-        this.parkourArenaHandler.load();
-        this.playerVisibilityManager = new PlayerVisibilityManager();
-    }
-
-    /**
-     * Registers all listeners used by this plugin
-     */
-    private void registerListeners() {
-        PluginManager pluginManager = getServer().getPluginManager();
-        pluginManager.registerEvents(new DamageListener(), this);
-        pluginManager.registerEvents(new MoveListener(this.dropperConfiguration, this.parkourConfiguration), this);
-        pluginManager.registerEvents(new PlayerStateChangeListener(), this);
-        pluginManager.registerEvents(new CommandListener(), this);
-        pluginManager.registerEvents(new GUIListener(true), this);
-        pluginManager.registerEvents(new InteractListener(), this);
-    }
-
-    /**
-     * Registers a command
-     *
-     * @param commandName     <p>The name of the command to register (defined in plugin.yml)</p>
-     * @param commandExecutor <p>The executor for the command</p>
-     * @param tabCompleter    <p>The tab-completer to use, or null</p>
-     */
-    private void registerCommand(@NotNull String commandName, @NotNull CommandExecutor commandExecutor,
-                                 @Nullable TabCompleter tabCompleter) {
-        PluginCommand command = this.getCommand(commandName);
-        if (command != null) {
-            command.setExecutor(commandExecutor);
-            if (tabCompleter != null) {
-                command.setTabCompleter(tabCompleter);
-            }
-        } else {
-            log(Level.SEVERE, "Unable to register the command " + commandName);
-        }
-    }
-
-    /**
-     * Registers all commands used by this plugin
-     */
-    private void registerCommands() {
-        registerCommand("miniGamesReload", new ReloadCommand(), null);
-        registerCommand("miniGamesLeave", new LeaveArenaCommand(), null);
-        registerCommand("miniGamesMenu", new MenuCommand(), null);
-        registerCommand("miniGamesReward", new SetArenaRewardCommand(), new SetArenaRewardTabCompleter());
-
-        registerDropperCommands();
-        registerParkourCommands();
-    }
-
-    /**
-     * Registers all commands related to droppers
-     */
-    private void registerDropperCommands() {
-        registerCommand("dropperCreate", new CreateDropperArenaCommand(), null);
-        registerCommand("dropperList", new ListDropperArenaCommand(), null);
-        registerCommand("dropperJoin", new JoinDropperArenaCommand(), new JoinDropperArenaTabCompleter());
-        registerCommand("dropperEdit", new EditDropperArenaCommand(this.dropperConfiguration), new EditDropperArenaTabCompleter());
-        registerCommand("dropperRemove", new RemoveDropperArenaCommand(), new RemoveDropperArenaTabCompleter());
-        registerCommand("dropperGroupSet", new DropperGroupSetCommand(), null);
-        registerCommand("dropperGroupSwap", new DropperGroupSwapCommand(), null);
-        registerCommand("dropperGroupList", new DropperGroupListCommand(), null);
-    }
-
-    /**
-     * Registers all commands related to parkour
-     */
-    private void registerParkourCommands() {
-        registerCommand("parkourCreate", new CreateParkourArenaCommand(), null);
-        registerCommand("parkourList", new ListParkourArenaCommand(), null);
-        registerCommand("parkourJoin", new JoinParkourArenaCommand(), new JoinParkourArenaTabCompleter());
-        registerCommand("parkourEdit", new EditParkourArenaCommand(), new EditParkourArenaTabCompleter());
-        registerCommand("parkourRemove", new RemoveParkourArenaCommand(), new RemoveParkourArenaTabCompleter());
-        registerCommand("parkourGroupSet", new ParkourGroupSetCommand(), null);
-        registerCommand("parkourGroupSwap", new ParkourGroupSwapCommand(), null);
-        registerCommand("parkourGroupList", new ParkourGroupListCommand(), null);
-    }
-
-    /**
-     * Sets up the translator and the string formatter
-     */
-    private void setupStringFormatter() {
-        translator = new Translator();
-        translator.registerMessageCategory(MiniGameMessage.ERROR_PLAYER_ONLY);
-        translator.loadLanguages(this.getDataFolder(), "en",
-                getConfig().getString("language", "en"));
-        stringFormatter = new StringFormatter(this.getDescription().getName(), translator);
-        stringFormatter.setColorConversion(ColorConversion.RGB);
-        stringFormatter.setNamePrefix("#546EED[&r&l");
-        stringFormatter.setNameSuffix("#546EED]");
-        stringFormatter.setErrorColor(ChatColor.RED);
-        stringFormatter.setSuccessColor(ChatColor.GREEN);
-    }
-
-    /**
-     * Sets up Vault by getting plugins from their providers
-     */
-    private void setupVault() {
-        ServicesManager servicesManager = this.getServer().getServicesManager();
-        RegisteredServiceProvider<Permission> permissionProvider = servicesManager.getRegistration(Permission.class);
-        RegisteredServiceProvider<Economy> economyProvider = servicesManager.getRegistration(Economy.class);
-
-        if (permissionProvider != null) {
-            PermissionManager.initialize(permissionProvider.getProvider());
-        } else {
-            log(Level.WARNING, "No Vault permission provider found. Permission rewards are unavailable.");
-        }
-
-        if (economyProvider != null) {
-            EconomyManager.initialize(economyProvider.getProvider());
-        } else {
-            log(Level.WARNING, "No Vault economy provider found. Economy rewards are unavailable.");
-        }
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/AbstractArenaPlayerRegistry.java

@@ -1,114 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.util.ArenaStorageHelper;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.logging.Level;
-
-/**
- * A player registry to keep track of currently playing players
- *
- * @param <K> <p>The type of arena stored</p>
- */
-public abstract class AbstractArenaPlayerRegistry<K extends Arena> implements ArenaPlayerRegistry<K> {
-
-    private final Map<UUID, ArenaSession> arenaPlayers = new HashMap<>();
-    private final Map<UUID, PlayerEntryState> entryStates = new HashMap<>();
-
-    /**
-     * Instantiates a new arena player registry
-     */
-    public AbstractArenaPlayerRegistry() {
-        loadEntryStates();
-    }
-
-    @Override
-    public @NotNull Set<UUID> getPlayingPlayers() {
-        return arenaPlayers.keySet();
-    }
-
-    @Override
-    public @Nullable PlayerEntryState getEntryState(@NotNull UUID playerId) {
-        return this.entryStates.get(playerId);
-    }
-
-    @Override
-    public void registerPlayer(@NotNull UUID playerId, @NotNull ArenaSession arenaSession) {
-        this.arenaPlayers.put(playerId, arenaSession);
-        this.entryStates.put(playerId, arenaSession.getEntryState());
-        this.saveEntryStates();
-    }
-
-    @Override
-    public boolean removePlayer(@NotNull UUID playerId, boolean restoreState) {
-        // Try and restore the state. If it cannot be restored, retain the entry state
-        PlayerEntryState entryState = this.entryStates.remove(playerId);
-        if (restoreState) {
-            if (entryState.restore()) {
-                this.saveEntryStates();
-            } else {
-                this.entryStates.put(playerId, entryState);
-            }
-        } else {
-            this.saveEntryStates();
-        }
-
-        return this.arenaPlayers.remove(playerId) != null;
-    }
-
-    @Override
-    public @Nullable ArenaSession getArenaSession(@NotNull UUID playerId) {
-        return this.arenaPlayers.getOrDefault(playerId, null);
-    }
-
-    @Override
-    public void removeForArena(K arena, boolean immediately) {
-        Set<UUID> removed = new HashSet<>();
-        for (Map.Entry<UUID, ArenaSession> entry : this.arenaPlayers.entrySet()) {
-            if (entry.getValue().getArena() == arena) {
-                // Kick the player gracefully
-                entry.getValue().triggerQuit(immediately, false);
-                removed.add(entry.getKey());
-            }
-        }
-        removed.forEach(this.arenaPlayers::remove);
-    }
-
-    /**
-     * Gets a string key unique to this type of player registry
-     *
-     * @return <p>A unique key used for entry state storage</p>
-     */
-    protected abstract String getEntryStateStorageKey();
-
-    /**
-     * Saves all entry states to disk
-     */
-    private void saveEntryStates() {
-        ArenaStorageHelper.storeArenaPlayerEntryStates(getEntryStateStorageKey(), new HashSet<>(entryStates.values()));
-    }
-
-    /**
-     * Loads all entry states from disk
-     */
-    private void loadEntryStates() {
-        this.entryStates.clear();
-        Set<PlayerEntryState> entryStates = ArenaStorageHelper.getArenaPlayerEntryStates(getEntryStateStorageKey());
-        for (PlayerEntryState entryState : entryStates) {
-            this.entryStates.put(entryState.getPlayerId(), entryState);
-        }
-        if (!this.entryStates.isEmpty()) {
-            MiniGames.log(Level.WARNING, entryStates.size() + " un-exited sessions found. This happens if " +
-                    "players leave in the middle of a game, or if the server crashes. MiniGames will do its best " +
-                    "to fix the players' states.");
-        }
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/AbstractArenaSession.java

@@ -1,152 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.property.RecordResult;
-import net.knarcraft.minigames.property.RecordType;
-import net.knarcraft.minigames.util.PlayerTeleporter;
-import net.knarcraft.minigames.util.RewardHelper;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-public abstract class AbstractArenaSession implements ArenaSession {
-
-    private final @NotNull Arena arena;
-    private final @NotNull ArenaGameMode gameMode;
-    private final @NotNull Player player;
-    protected int deaths;
-    protected long startTime;
-    protected PlayerEntryState entryState;
-
-    /**
-     * Instantiates a new abstract arena session
-     *
-     * @param arena    <p>The arena that's being played in</p>
-     * @param player   <p>The player playing the arena</p>
-     * @param gameMode <p>The game-mode</p>
-     */
-    public AbstractArenaSession(@NotNull Arena arena, @NotNull Player player, @NotNull ArenaGameMode gameMode) {
-        this.arena = arena;
-        this.player = player;
-        this.gameMode = gameMode;
-        this.deaths = 0;
-        this.startTime = System.currentTimeMillis();
-    }
-
-    @Override
-    public void triggerQuit(boolean immediately, boolean removeSession) {
-        // Stop this session
-        if (removeSession) {
-            removeSession();
-        }
-        // Teleport the player out of the arena
-        teleportToExit(immediately);
-        // Make the player visible to everyone
-        MiniGames.getInstance().getPlayerVisibilityManager().showPlayersFor(player);
-
-        MiniGames.getInstance().getStringFormatter().displaySuccessMessage(player, MiniGameMessage.SUCCESS_ARENA_QUIT);
-    }
-
-    @Override
-    public void reset() {
-        this.deaths = 0;
-        this.startTime = System.currentTimeMillis();
-        PlayerTeleporter.teleportPlayer(this.player, this.arena.getSpawnLocation(), false, false);
-        this.entryState.setArenaState();
-    }
-
-    /**
-     * Announces a record set by this player
-     *
-     * @param recordResult <p>The result of the record</p>
-     * @param recordType   <p>The type of record set (time or deaths)</p>
-     */
-    protected void announceRecord(@NotNull RecordResult recordResult, @NotNull RecordType recordType) {
-        if (recordResult == RecordResult.NONE) {
-            return;
-        }
-
-        // Gets a string representation of the played game-mode
-        String gameModeString = getGameModeString();
-
-        MiniGameMessage recordInfoMiniGameMessage = switch (recordResult) {
-            case WORLD_RECORD -> MiniGameMessage.RECORD_ACHIEVED_GLOBAL;
-            case PERSONAL_BEST -> MiniGameMessage.RECORD_ACHIEVED_PERSONAL;
-            default -> throw new IllegalStateException("Unexpected value: " + recordResult);
-        };
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        String recordInfo = stringFormatter.replacePlaceholder(recordInfoMiniGameMessage, "{recordType}",
-                recordType.name().toLowerCase().replace("_", " "));
-
-        stringFormatter.displaySuccessMessage(player, stringFormatter.replacePlaceholders(
-                MiniGameMessage.SUCCESS_RECORD_ACHIEVED, new String[]{"{gameMode}", "{recordInfo}"},
-                new String[]{gameModeString, recordInfo}));
-
-        // Reward the player
-        rewardRecord(recordResult, recordType);
-    }
-
-    /**
-     * Registers the player's record if necessary, and prints record information to the player
-     */
-    protected void registerRecord() {
-        ArenaRecordsRegistry recordsRegistry = this.arena.getData().getRecordRegistries().get(this.gameMode);
-        long timeElapsed = System.currentTimeMillis() - this.startTime;
-        announceRecord(recordsRegistry.registerTimeRecord(this.player.getUniqueId(), timeElapsed), RecordType.TIME);
-        announceRecord(recordsRegistry.registerDeathRecord(this.player.getUniqueId(), this.deaths), RecordType.DEATHS);
-    }
-
-    /**
-     * Rewards the specified achieved record
-     *
-     * @param recordResult <p>The result of the record achieved</p>
-     * @param recordType   <p>The type of record achieved</p>
-     */
-    protected void rewardRecord(RecordResult recordResult, RecordType recordType) {
-        RewardCondition condition = null;
-        if (recordResult == RecordResult.WORLD_RECORD) {
-            if (recordType == RecordType.DEATHS) {
-                condition = RewardCondition.GLOBAL_DEATH_RECORD;
-            } else if (recordType == RecordType.TIME) {
-                condition = RewardCondition.GLOBAL_TIME_RECORD;
-            }
-        } else if (recordResult == RecordResult.PERSONAL_BEST) {
-            if (recordType == RecordType.DEATHS) {
-                condition = RewardCondition.PERSONAL_DEATH_RECORD;
-            } else if (recordType == RecordType.TIME) {
-                condition = RewardCondition.PERSONAL_TIME_RECORD;
-            }
-        }
-        RewardHelper.grantRewards(this.player, this.arena.getRewards(condition));
-    }
-
-    /**
-     * Teleports the playing player out of the arena
-     */
-    protected void teleportToExit(boolean immediately) {
-        // Teleport the player out of the arena
-        Location exitLocation;
-        if (this.arena.getExitLocation() != null) {
-            exitLocation = this.arena.getExitLocation();
-        } else {
-            exitLocation = this.entryState.getEntryLocation();
-        }
-        PlayerTeleporter.teleportPlayer(this.player, exitLocation, true, immediately);
-    }
-
-    /**
-     * Gets the string representation of the session's game-mode
-     *
-     * @return <p>The string representation</p>
-     */
-    protected abstract String getGameModeString();
-
-    /**
-     * Removes this session from current sessions
-     */
-    protected abstract void removeSession();
-
-}

src/main/java/net/knarcraft/minigames/arena/AbstractPlayerEntryState.java

@@ -1,178 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.property.PersistentDataKey;
-import org.bukkit.Bukkit;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.NamespacedKey;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.persistence.PersistentDataType;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-import java.util.logging.Level;
-
-/**
- * An abstract representation of a player's entry state
- */
-public abstract class AbstractPlayerEntryState implements PlayerEntryState {
-
-    protected final UUID playerId;
-    private final Location entryLocation;
-    private final boolean originalIsFlying;
-    private final GameMode originalGameMode;
-    private final boolean originalAllowFlight;
-    private final boolean originalInvulnerable;
-    private final boolean originalIsSwimming;
-    private final boolean originalCollideAble;
-
-    /**
-     * Instantiates a new abstract player entry state
-     *
-     * @param player <p>The player whose state this should keep track of</p>
-     */
-    public AbstractPlayerEntryState(@NotNull Player player) {
-        this.playerId = player.getUniqueId();
-        this.entryLocation = player.getLocation().clone();
-        this.originalIsFlying = player.isFlying();
-        this.originalGameMode = player.getGameMode();
-        this.originalAllowFlight = player.getAllowFlight();
-        this.originalInvulnerable = player.isInvulnerable();
-        this.originalIsSwimming = player.isSwimming();
-        this.originalCollideAble = player.isCollidable();
-    }
-
-    /**
-     * Instantiates a new abstract player entry state
-     *
-     * @param playerId             <p>The id of the player whose state this should keep track of</p>
-     * @param entryLocation        <p>The location the player entered from</p>
-     * @param originalIsFlying     <p>Whether the player was flying before entering the arena</p>
-     * @param originalGameMode     <p>The game-mode of the player before entering the arena</p>
-     * @param originalAllowFlight  <p>Whether the player was allowed flight before entering the arena</p>
-     * @param originalInvulnerable <p>Whether the player was invulnerable before entering the arena</p>
-     * @param originalIsSwimming   <p>Whether the player was swimming before entering the arena</p>
-     * @param originalCollideAble  <p>Whether the player was collide-able before entering the arena</p>
-     */
-    public AbstractPlayerEntryState(@NotNull UUID playerId, Location entryLocation,
-                                    boolean originalIsFlying, GameMode originalGameMode, boolean originalAllowFlight,
-                                    boolean originalInvulnerable, boolean originalIsSwimming,
-                                    boolean originalCollideAble) {
-        this.playerId = playerId;
-        this.entryLocation = entryLocation;
-        this.originalIsFlying = originalIsFlying;
-        this.originalGameMode = originalGameMode;
-        this.originalAllowFlight = originalAllowFlight;
-        this.originalInvulnerable = originalInvulnerable;
-        this.originalIsSwimming = originalIsSwimming;
-        this.originalCollideAble = originalCollideAble;
-    }
-
-    @Override
-    public @NotNull UUID getPlayerId() {
-        return this.playerId;
-    }
-
-    @Override
-    public boolean restore() {
-        Player player = getPlayer();
-        if (player == null) {
-            return false;
-        }
-        restore(player);
-        return true;
-    }
-
-    @Override
-    public void restore(@NotNull Player player) {
-        player.setCollidable(this.originalCollideAble);
-        player.setAllowFlight(this.originalAllowFlight);
-        player.setFlying(player.getAllowFlight() && this.originalIsFlying);
-        player.setGameMode(this.originalGameMode);
-        player.setInvulnerable(this.originalInvulnerable);
-        player.setSwimming(this.originalIsSwimming);
-        removeMenuItem(player);
-    }
-
-    @Override
-    public Location getEntryLocation() {
-        return this.entryLocation;
-    }
-
-    /**
-     * Gets the player this entry state belongs to
-     *
-     * @return <p>The player, or null if not currently online</p>
-     */
-    protected Player getPlayer() {
-        Player player = Bukkit.getOfflinePlayer(this.playerId).getPlayer();
-        if (player == null) {
-            MiniGames.log(Level.WARNING, "Unable to change state for player with id " + this.playerId +
-                    " because the player was not found on the server.");
-        }
-        return player;
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("playerId", new SerializableUUID(this.playerId));
-        data.put("entryLocation", this.entryLocation);
-        data.put("originalIsFlying", this.originalIsFlying);
-        data.put("originalGameMode", this.originalGameMode.name());
-        data.put("originalAllowFlight", this.originalAllowFlight);
-        data.put("originalInvulnerable", this.originalInvulnerable);
-        data.put("originalIsSwimming", this.originalIsSwimming);
-        data.put("originalCollideAble", this.originalCollideAble);
-        return data;
-    }
-
-    /**
-     * Removes the menu item from the given player's inventory
-     *
-     * @param player <p>The player to remove the menu item from</p>
-     */
-    private void removeMenuItem(Player player) {
-        Set<ItemStack> itemsToRemove = new HashSet<>();
-        player.getInventory().forEach((item) -> {
-            if (item == null) {
-                return;
-            }
-            ItemMeta meta = item.getItemMeta();
-            if (meta == null) {
-                return;
-            }
-            Integer persistentData = meta.getPersistentDataContainer().get(new NamespacedKey(MiniGames.getInstance(),
-                    PersistentDataKey.MENU_ITEM.getKeyName()), PersistentDataType.INTEGER);
-            if (persistentData != null && persistentData == PersistentDataKey.MENU_ITEM.getDataValue()) {
-                itemsToRemove.add(item);
-            }
-        });
-        for (ItemStack toRemove : itemsToRemove) {
-            player.getInventory().remove(toRemove);
-        }
-    }
-
-    /**
-     * Gets a boolean value from a serialization map
-     *
-     * @param data <p>The serialization data to look through</p>
-     * @param key  <p>The key to get</p>
-     * @return <p>The boolean value of the key</p>
-     */
-    protected static boolean getBoolean(Map<String, Object> data, String key) {
-        Boolean value = (Boolean) data.get(key);
-        return Objects.requireNonNullElse(value, false);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/Arena.java

@@ -1,120 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.minigames.arena.reward.Reward;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import org.bukkit.Location;
-import org.bukkit.block.Block;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * An interface describing an arena
- */
-public interface Arena {
-
-    /**
-     * Gets the name of this arena
-     *
-     * @return <p>The name of this arena</p>
-     */
-    @NotNull String getArenaName();
-
-    /**
-     * Gets the data stored for this arena
-     *
-     * @return <p>The stored data</p>
-     */
-    @NotNull ArenaData getData();
-
-    /**
-     * Gets the id of this arena
-     *
-     * @return <p>This arena's identifier</p>
-     */
-    @NotNull UUID getArenaId();
-
-    /**
-     * Gets this arena's sanitized name
-     *
-     * @return <p>This arena's sanitized name</p>
-     */
-    @NotNull String getArenaNameSanitized();
-
-    /**
-     * Removes the data file belonging to this arena
-     *
-     * @return <p>True if successfully removed</p>
-     */
-    boolean removeData();
-
-    /**
-     * Saves this arena's data
-     *
-     * @return <p>True if successfully saved</p>
-     */
-    boolean saveData();
-
-    /**
-     * Gets whether standing on the given block should cause a win
-     *
-     * @param block <p>The block to check</p>
-     * @return <p>True if standing on the block will cause a win</p>
-     */
-    boolean willCauseWin(Block block);
-
-    /**
-     * Gets whether standing on the given block should cause a loss
-     *
-     * @param block <p>The block to check</p>
-     * @return <p>True if standing on the block will cause a loss</p>
-     */
-    boolean willCauseLoss(Block block);
-
-    /**
-     * Gets whether the win location is a solid block
-     *
-     * @return <p>True if the location is a solid block</p>
-     */
-    boolean winLocationIsSolid();
-
-    /**
-     * Gets the location of this arena's spawn
-     *
-     * @return <p>This arena's spawn location</p>
-     */
-    @NotNull Location getSpawnLocation();
-
-    /**
-     * Gets this arena's exit location
-     *
-     * @return <p>This arena's exit location, or null if no such location is set.</p>
-     */
-    @Nullable Location getExitLocation();
-
-    /**
-     * Adds a reward to this arena
-     *
-     * @param rewardCondition <p>The condition for the reward to be granted</p>
-     * @param reward          <p>The reward to be granted</p>
-     */
-    void addReward(@NotNull RewardCondition rewardCondition, @NotNull Reward reward);
-
-    /**
-     * Clears this arena's rewards for the given condition
-     *
-     * @param rewardCondition <p>The reward condition to clear all rewards for</p>
-     */
-    void clearRewards(@NotNull RewardCondition rewardCondition);
-
-    /**
-     * Gets all rewards for the given reward condition
-     *
-     * @param rewardCondition <p>The condition to get the rewards for</p>
-     * @return <p>All rewards</p>
-     */
-    @NotNull Set<Reward> getRewards(RewardCondition rewardCondition);
-
-}

src/main/java/net/knarcraft/minigames/arena/ArenaData.java

@@ -1,108 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.minigames.container.SerializableContainer;
-import net.knarcraft.minigames.container.SerializableUUID;
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-import static net.knarcraft.minigames.util.SerializableConverter.makeSerializable;
-
-/**
- * An interface describing generic arena data
- */
-public abstract class ArenaData implements ConfigurationSerializable {
-
-    protected final @NotNull UUID arenaId;
-    private final @NotNull Map<ArenaGameMode, ArenaRecordsRegistry> recordRegistries;
-    private final @NotNull Map<ArenaGameMode, Set<UUID>> playersCompleted;
-
-    /**
-     * Instantiates arena data
-     *
-     * @param arenaId          <p>The id of the arena this data belongs to</p>
-     * @param recordRegistries <p>The registry storing records for this arena</p>
-     * @param playersCompleted <p>The players that have completed this arena</p>
-     */
-    public ArenaData(@NotNull UUID arenaId, @NotNull Map<ArenaGameMode, ArenaRecordsRegistry> recordRegistries,
-                     @NotNull Map<ArenaGameMode, Set<UUID>> playersCompleted) {
-        this.arenaId = arenaId;
-        this.recordRegistries = recordRegistries;
-        this.playersCompleted = playersCompleted;
-    }
-
-    /**
-     * Gets the id of this arena
-     *
-     * @return <p>The id of this arena</p>
-     */
-    public @NotNull UUID getArenaId() {
-        return this.arenaId;
-    }
-
-    /**
-     * Gets all record registries
-     *
-     * @return <p>All record registries</p>
-     */
-    public @NotNull Map<ArenaGameMode, ArenaRecordsRegistry> getRecordRegistries() {
-        return new HashMap<>(this.recordRegistries);
-    }
-
-    /**
-     * Gets whether the given player has cleared this arena
-     *
-     * @param arenaGameMode <p>The game-mode to check for</p>
-     * @param player        <p>The player to check</p>
-     * @return <p>True if the player has cleared the arena this data belongs to</p>
-     */
-    public boolean hasNotCompleted(@NotNull ArenaGameMode arenaGameMode, @NotNull Player player) {
-        return !this.playersCompleted.getOrDefault(arenaGameMode, new HashSet<>()).contains(player.getUniqueId());
-    }
-
-    /**
-     * Registers the given player as having completed this arena
-     *
-     * @param arenaGameMode <p>The game-mode the player completed</p>
-     * @param player        <p>The player that completed this data's arena</p>
-     */
-    public boolean setCompleted(@NotNull ArenaGameMode arenaGameMode, @NotNull Player player) {
-        // Make sure to add an empty set to prevent a NullPointerException
-        if (!this.playersCompleted.containsKey(arenaGameMode)) {
-            this.playersCompleted.put(arenaGameMode, new HashSet<>());
-        }
-
-        boolean added = this.playersCompleted.get(arenaGameMode).add(player.getUniqueId());
-        // Persistently save the completion
-        if (added) {
-            saveData();
-        }
-        return added;
-    }
-
-    /**
-     * Saves this data to disk
-     */
-    public abstract void saveData();
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("arenaId", new SerializableUUID(this.arenaId));
-        data.put("recordsRegistry", this.recordRegistries);
-
-        // Convert normal UUIDs to serializable UUIDs
-        Map<ArenaGameMode, Set<SerializableContainer<UUID>>> serializablePlayersCompleted = new HashMap<>();
-        makeSerializable(this.playersCompleted, serializablePlayersCompleted, new SerializableUUID(null));
-        data.put("playersCompleted", serializablePlayersCompleted);
-        return data;
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/ArenaGameMode.java

@@ -1,24 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import org.jetbrains.annotations.NotNull;
-
-/**
- * An interface describing any arena game-mode
- */
-public interface ArenaGameMode {
-
-    /**
-     * Gets the name of this game-mode
-     *
-     * @return <p>The name of this game-mode</p>
-     */
-    @NotNull String name();
-
-    /**
-     * Gets a set of all available arena game-modes in the type definition of this game-mode
-     *
-     * @return <p>All game-modes in this game-mode's class</p>
-     */
-    @NotNull ArenaGameMode[] getValues();
-
-}

src/main/java/net/knarcraft/minigames/arena/ArenaPlayerRegistry.java

@@ -1,63 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * A registry keeping track of all player sessions for some arenas
- *
- * @param <K> <p>The type of arena this registry stores</p>
- */
-public interface ArenaPlayerRegistry<K extends Arena> {
-
-    /**
-     * Gets the ids of the players currently playing
-     *
-     * @return <p>The ids of the playing players</p>
-     */
-    @NotNull Set<UUID> getPlayingPlayers();
-
-    /**
-     * Gets the current entry state for the given player
-     *
-     * @param playerId <p>The id of the player to get an entry state for</p>
-     * @return <p>The entry state of the player, or null if not found</p>
-     */
-    @Nullable PlayerEntryState getEntryState(@NotNull UUID playerId);
-
-    /**
-     * Registers that the given player has started playing the given dropper arena session
-     *
-     * @param playerId     <p>The id of the player that started playing</p>
-     * @param arenaSession <p>The arena session to register</p>
-     */
-    void registerPlayer(@NotNull UUID playerId, @NotNull ArenaSession arenaSession);
-
-    /**
-     * Removes this player from players currently playing
-     *
-     * @param playerId     <p>The id of the player to remove</p>
-     * @param restoreState <p>Whether to restore the state of the player as part of the removal</p>
-     */
-    boolean removePlayer(@NotNull UUID playerId, boolean restoreState);
-
-    /**
-     * Gets the player's active dropper arena session
-     *
-     * @param playerId <p>The id of the player to get arena for</p>
-     * @return <p>The player's active arena session, or null if not currently playing</p>
-     */
-    @Nullable ArenaSession getArenaSession(@NotNull UUID playerId);
-
-    /**
-     * Removes all active sessions for the given arena
-     *
-     * @param arena       <p>The arena to remove sessions for</p>
-     * @param immediately <p>Whether to immediately teleport the player</p>
-     */
-    void removeForArena(K arena, boolean immediately);
-
-}

src/main/java/net/knarcraft/minigames/arena/ArenaSession.java

@@ -1,55 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.minigames.gui.ArenaGUI;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A player's session while in an arena
- */
-public interface ArenaSession {
-
-    /**
-     * Gets the state of the player when they joined the session
-     *
-     * @return <p>The player's entry state</p>
-     */
-    @NotNull PlayerEntryState getEntryState();
-
-    /**
-     * Triggers a win for the player playing in this session
-     */
-    void triggerWin();
-
-    /**
-     * Triggers a loss for the player playing in this session
-     */
-    void triggerLoss();
-
-    /**
-     * Triggers a quit for the player playing in this session
-     *
-     * @param immediately   <p>Whether to to the teleportation immediately, not using any timers</p>
-     * @param removeSession <p>Whether to also remove the session. Should usually be true.</p>
-     */
-    void triggerQuit(boolean immediately, boolean removeSession);
-
-    /**
-     * Gets the arena this session is being played in
-     *
-     * @return <p>The session's arena</p>
-     */
-    @NotNull Arena getArena();
-
-    /**
-     * Gets the GUI with this arena's options
-     *
-     * @return <p>This arena's GUI</p>
-     */
-    @NotNull ArenaGUI getGUI();
-
-    /**
-     * Resets the session to allow a player to try again
-     */
-    void reset();
-
-}

src/main/java/net/knarcraft/minigames/arena/EditablePropertyType.java

@@ -1,48 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-/**
- * The type of one editable property
- */
-public enum EditablePropertyType {
-
-    /**
-     * The property is a location
-     */
-    LOCATION,
-
-    /**
-     * The property is an arena name
-     */
-    ARENA_NAME,
-
-    /**
-     * The property is a horizontal velocity
-     */
-    HORIZONTAL_VELOCITY,
-
-    /**
-     * The property is a vertical velocity (fly speed)
-     */
-    VERTICAL_VELOCITY,
-
-    /**
-     * The property is a material that specifies a block
-     */
-    BLOCK_TYPE,
-
-    /**
-     * The property clears a checkpoint
-     */
-    CHECKPOINT_CLEAR,
-
-    /**
-     * The property is a comma-separated list of materials
-     */
-    MATERIAL_LIST,
-
-    /**
-     * The property is any double value
-     */
-    DOUBLE,
-
-}

src/main/java/net/knarcraft/minigames/arena/PlayerEntryState.java

@@ -1,45 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import org.bukkit.Location;
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.bukkit.entity.Player;
-
-import java.util.UUID;
-
-/**
- * The stored state of a player
- */
-public interface PlayerEntryState extends ConfigurationSerializable {
-
-    /**
-     * Sets the state of the stored player to the state used by the arena
-     */
-    void setArenaState();
-
-    /**
-     * Restores the stored state for the stored player
-     */
-    boolean restore();
-
-    /**
-     * Restores the stored state for the given player
-     *
-     * @param player <p>A player object that's refers to the same player as the stored player</p>
-     */
-    void restore(Player player);
-
-    /**
-     * Gets the id of the player this state belongs to
-     *
-     * @return <p>The player the state belongs to</p>
-     */
-    UUID getPlayerId();
-
-    /**
-     * Gets the location the player entered from
-     *
-     * @return <p>The location the player entered from</p>
-     */
-    Location getEntryLocation();
-
-}

src/main/java/net/knarcraft/minigames/arena/PlayerVisibilityManager.java

@@ -1,109 +0,0 @@
-package net.knarcraft.minigames.arena;
-
-import net.knarcraft.minigames.MiniGames;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * A manager for keeping track of which players have set other players as hidden
- */
-public class PlayerVisibilityManager {
-
-    private final Set<UUID> displayingEnabledFor = new HashSet<>();
-
-    /**
-     * Toggles whether players should be hidden for the player with the given id
-     *
-     * @param player <p>The the player to update</p>
-     */
-    public void toggleHidePlayers(@NotNull ArenaPlayerRegistry<?> playerRegistry, @NotNull Player player) {
-        if (displayingEnabledFor.contains(player.getUniqueId())) {
-            displayingEnabledFor.remove(player.getUniqueId());
-            // Make all other players hidden
-            changeVisibilityFor(playerRegistry, player, true);
-        } else {
-            displayingEnabledFor.add(player.getUniqueId());
-            // Make all other players visible again
-            changeVisibilityFor(playerRegistry, player, false);
-        }
-
-    }
-
-    /**
-     * Gets whether the given player is currently hiding other players
-     *
-     * @param player <p>The player to check</p>
-     * @return <p>True if currently hiding other players</p>
-     */
-    public boolean isHidingPlayers(Player player) {
-        return !this.displayingEnabledFor.contains(player.getUniqueId());
-    }
-
-    /**
-     * Updates which players are seen as hidden
-     *
-     * @param playerRegistry <p>The registry containing all playing players</p>
-     * @param player         <p>The player that joined the arena</p>
-     */
-    public void updateHiddenPlayers(@NotNull ArenaPlayerRegistry<?> playerRegistry, @NotNull Player player) {
-        boolean hideForPlayer = !displayingEnabledFor.contains(player.getUniqueId());
-        for (UUID playerId : playerRegistry.getPlayingPlayers()) {
-            Player otherPlayer = Bukkit.getPlayer(playerId);
-            if (otherPlayer == null) {
-                continue;
-            }
-            // Hide the arena player from the newly joined player
-            if (hideForPlayer) {
-                player.hidePlayer(MiniGames.getInstance(), otherPlayer);
-            }
-            // Hide the newly joined player from this player
-            if (!displayingEnabledFor.contains(playerId)) {
-                otherPlayer.hidePlayer(MiniGames.getInstance(), player);
-            }
-        }
-    }
-
-    /**
-     * Makes all players visible to the given player
-     *
-     * @param player <p>The player to update visibility for</p>
-     */
-    public void showPlayersFor(@NotNull Player player) {
-        for (Player otherPlayer : Bukkit.getOnlinePlayers()) {
-            player.showPlayer(MiniGames.getInstance(), otherPlayer);
-            otherPlayer.showPlayer(MiniGames.getInstance(), player);
-        }
-    }
-
-    /**
-     * Changes whether the given player can see the other players in the arena
-     *
-     * @param playerRegistry <p>The player registry containing other players</p>
-     * @param player         <p>The player to change the visibility for</p>
-     * @param hide           <p>Whether to hide the players or show the players</p>
-     */
-    private void changeVisibilityFor(@Nullable ArenaPlayerRegistry<?> playerRegistry, @NotNull Player player, boolean hide) {
-        if (playerRegistry == null) {
-            return;
-        }
-        for (UUID playerId : playerRegistry.getPlayingPlayers()) {
-            Player otherPlayer = Bukkit.getPlayer(playerId);
-            if (otherPlayer == null) {
-                continue;
-            }
-
-            if (hide) {
-                player.hidePlayer(MiniGames.getInstance(), otherPlayer);
-            } else {
-                player.showPlayer(MiniGames.getInstance(), otherPlayer);
-            }
-        }
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperArenaData.java

@@ -1,72 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaData;
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.container.SerializableContainer;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.util.SerializableConverter;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Data stored for an arena
- */
-public class DropperArenaData extends ArenaData {
-
-    /**
-     * Instantiates a new dropper arena data object
-     *
-     * @param arenaId          <p>The id of the arena this data belongs to</p>
-     * @param recordRegistries <p>The registries of this arena's records</p>
-     * @param playersCompleted <p>The set of the players that have cleared this arena for each game-mode</p>
-     */
-    public DropperArenaData(@NotNull UUID arenaId,
-                            @NotNull Map<ArenaGameMode, ArenaRecordsRegistry> recordRegistries,
-                            @NotNull Map<ArenaGameMode, Set<UUID>> playersCompleted) {
-        super(arenaId, recordRegistries, playersCompleted);
-    }
-
-    @Override
-    public void saveData() {
-        MiniGames.getInstance().getDropperArenaHandler().saveData(this.arenaId);
-    }
-
-    /**
-     * Deserializes a dropper arena data from the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized dropper arena data</p>
-     */
-    @SuppressWarnings({"unused", "unchecked"})
-    public static @NotNull DropperArenaData deserialize(@NotNull Map<String, Object> data) {
-        SerializableUUID serializableUUID = (SerializableUUID) data.get("arenaId");
-        Map<ArenaGameMode, ArenaRecordsRegistry> recordsRegistry =
-                (Map<ArenaGameMode, ArenaRecordsRegistry>) data.get("recordsRegistry");
-        Map<ArenaGameMode, Set<SerializableContainer<UUID>>> playersCompletedData =
-                (Map<ArenaGameMode, Set<SerializableContainer<UUID>>>) data.get("playersCompleted");
-
-        if (recordsRegistry == null) {
-            recordsRegistry = new HashMap<>();
-        } else if (playersCompletedData == null) {
-            playersCompletedData = new HashMap<>();
-        }
-
-        // Convert the serializable UUIDs to normal UUIDs
-        Map<ArenaGameMode, Set<UUID>> allPlayersCompleted = new HashMap<>();
-        SerializableConverter.getRawValue(playersCompletedData, allPlayersCompleted);
-
-        for (ArenaGameMode arenaGameMode : playersCompletedData.keySet()) {
-            if (!recordsRegistry.containsKey(arenaGameMode) || recordsRegistry.get(arenaGameMode) == null) {
-                recordsRegistry.put(arenaGameMode, new DropperArenaRecordsRegistry(serializableUUID.getRawValue()));
-            }
-        }
-        return new DropperArenaData(serializableUUID.getRawValue(), recordsRegistry, allPlayersCompleted);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperArenaGroup.java

@@ -1,56 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaGroup;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.util.SerializableConverter;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * A sorted group of arenas that must be completed in sequence
- */
-public class DropperArenaGroup extends ArenaGroup<DropperArena, DropperArenaGroup> {
-
-    /**
-     * Instantiates a new dropper arena group
-     *
-     * @param groupName <p>The name of this group</p>
-     */
-    public DropperArenaGroup(@NotNull String groupName) {
-        super(groupName, MiniGames.getInstance().getDropperArenaHandler());
-    }
-
-    /**
-     * Instantiates a new dropper arena group
-     *
-     * @param groupId   <p>The unique id of this group</p>
-     * @param groupName <p>The name of this group</p>
-     * @param arenas    <p>The arenas in this group</p>
-     */
-    private DropperArenaGroup(@NotNull UUID groupId, @NotNull String groupName, @NotNull List<UUID> arenas) {
-        super(groupId, groupName, arenas, MiniGames.getInstance().getDropperArenaHandler());
-    }
-
-    /**
-     * Deserializes the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized arena group</p>
-     */
-    @SuppressWarnings({"unused", "unchecked"})
-    public static @NotNull DropperArenaGroup deserialize(@NotNull Map<String, Object> data) {
-        UUID id = ((SerializableUUID) data.get("groupId")).getRawValue();
-        String name = (String) data.get("groupName");
-        List<SerializableUUID> serializableArenas = (List<SerializableUUID>) data.get("arenas");
-        List<UUID> arenas = new ArrayList<>();
-
-        SerializableConverter.getRawValue(new ArrayList<>(serializableArenas), arenas);
-        return new DropperArenaGroup(id, name, arenas);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperArenaHandler.java

@@ -1,77 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaHandler;
-import net.knarcraft.minigames.arena.ArenaPlayerRegistry;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.DropperArenaStorageHelper;
-
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.logging.Level;
-
-/**
- * A handler that keeps track of all dropper arenas
- */
-public class DropperArenaHandler extends ArenaHandler<DropperArena, DropperArenaGroup> {
-
-    /**
-     * Instantiates a new arena handler
-     *
-     * @param playerRegistry <p>The registry keeping track of player sessions</p>
-     */
-    public DropperArenaHandler(ArenaPlayerRegistry<DropperArena> playerRegistry) {
-        super(playerRegistry);
-    }
-
-    @Override
-    public void saveGroups() {
-        try {
-            DropperArenaStorageHelper.saveDropperArenaGroups(new HashSet<>(this.arenaGroups.values()));
-        } catch (IOException exception) {
-            MiniGames.log(Level.SEVERE, MiniGames.getInstance().getTranslator().getTranslatedMessage(
-                    MiniGameMessage.ERROR_CANNOT_SAVE_ARENA_GROUPS));
-            MiniGames.log(Level.SEVERE, exception.getMessage());
-        }
-    }
-
-    @Override
-    protected void loadGroups() {
-        Set<DropperArenaGroup> arenaGroups = DropperArenaStorageHelper.loadDropperArenaGroups();
-        Map<UUID, DropperArenaGroup> arenaGroupMap = new HashMap<>();
-        for (DropperArenaGroup arenaGroup : arenaGroups) {
-            for (UUID arenaId : arenaGroup.getArenas()) {
-                arenaGroupMap.put(arenaId, arenaGroup);
-            }
-        }
-        this.arenaGroups = arenaGroupMap;
-    }
-
-    @Override
-    public void saveArenas() {
-        try {
-            DropperArenaStorageHelper.saveDropperArenas(this.arenas);
-        } catch (IOException exception) {
-            MiniGames.log(Level.SEVERE, "Unable to save current arenas! " +
-                    "Data loss can occur!");
-            MiniGames.log(Level.SEVERE, exception.getMessage());
-        }
-    }
-
-    @Override
-    protected void loadArenas() {
-        this.arenas = DropperArenaStorageHelper.loadDropperArenas();
-
-        // Save a map from arena name to arena id for improved performance
-        this.arenaNameLookup = new HashMap<>();
-        for (Map.Entry<UUID, DropperArena> arena : this.arenas.entrySet()) {
-            String sanitizedName = arena.getValue().getArenaNameSanitized();
-            this.arenaNameLookup.put(sanitizedName, arena.getKey());
-        }
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperArenaPlayerRegistry.java

@@ -1,15 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.minigames.arena.AbstractArenaPlayerRegistry;
-
-/**
- * A registry to keep track of which players are playing in which arenas
- */
-public class DropperArenaPlayerRegistry extends AbstractArenaPlayerRegistry<DropperArena> {
-
-    @Override
-    protected String getEntryStateStorageKey() {
-        return "dropper";
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperArenaRecordsRegistry.java

@@ -1,65 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.record.IntegerRecord;
-import net.knarcraft.minigames.arena.record.LongRecord;
-import net.knarcraft.minigames.container.SerializableUUID;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * A registry keeping track of all records
- */
-public class DropperArenaRecordsRegistry extends ArenaRecordsRegistry {
-
-    /**
-     * Instantiates a new empty records registry
-     */
-    public DropperArenaRecordsRegistry(@NotNull UUID arenaId) {
-        super(arenaId);
-    }
-
-    /**
-     * Instantiates a new records registry
-     *
-     * @param leastDeaths              <p>The existing least death records to use</p>
-     * @param shortestTimeMilliSeconds <p>The existing leash time records to use</p>
-     */
-    private DropperArenaRecordsRegistry(@NotNull UUID arenaId, @NotNull Set<IntegerRecord> leastDeaths,
-                                        @NotNull Set<LongRecord> shortestTimeMilliSeconds) {
-        super(arenaId, leastDeaths, shortestTimeMilliSeconds);
-    }
-
-    /**
-     * Saves changed records
-     */
-    protected void save() {
-        MiniGames.getInstance().getDropperArenaHandler().saveData(this.arenaId);
-    }
-
-    /**
-     * Deserializes the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized records registry</p>
-     */
-    @SuppressWarnings({"unused", "unchecked"})
-    public static DropperArenaRecordsRegistry deserialize(Map<String, Object> data) {
-        UUID arenaId = ((SerializableUUID) data.get("arenaId")).getRawValue();
-        Set<IntegerRecord> leastDeaths =
-                (Set<IntegerRecord>) data.getOrDefault("leastDeaths", new HashMap<>());
-        Set<LongRecord> shortestTimeMilliseconds =
-                (Set<LongRecord>) data.getOrDefault("shortestTime", new HashMap<>());
-
-        leastDeaths.removeIf(Objects::isNull);
-        shortestTimeMilliseconds.removeIf(Objects::isNull);
-        return new DropperArenaRecordsRegistry(arenaId, leastDeaths, shortestTimeMilliseconds);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperArenaSession.java

@@ -1,156 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.AbstractArenaSession;
-import net.knarcraft.minigames.arena.PlayerEntryState;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.gui.ArenaGUI;
-import net.knarcraft.minigames.gui.DropperGUI;
-import net.knarcraft.minigames.util.PlayerTeleporter;
-import net.knarcraft.minigames.util.RewardHelper;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.logging.Level;
-
-/**
- * A representation of a player's current session in a dropper arena
- */
-public class DropperArenaSession extends AbstractArenaSession {
-
-    private final @NotNull DropperArena arena;
-    private final @NotNull Player player;
-    private final @NotNull DropperArenaGameMode gameMode;
-    private boolean startedMoving = false;
-
-    /**
-     * Instantiates a new dropper arena session
-     *
-     * @param dropperArena <p>The arena that's being played in</p>
-     * @param player       <p>The player playing the arena</p>
-     * @param gameMode     <p>The game-mode</p>
-     */
-    public DropperArenaSession(@NotNull DropperArena dropperArena, @NotNull Player player,
-                               @NotNull DropperArenaGameMode gameMode) {
-        super(dropperArena, player, gameMode);
-        this.arena = dropperArena;
-        this.player = player;
-        this.gameMode = gameMode;
-
-        this.entryState = new DropperPlayerEntryState(player, gameMode, dropperArena.getPlayerHorizontalVelocity());
-        this.entryState.setArenaState();
-    }
-
-    /**
-     * Marks that this arena's player has started moving
-     */
-    public void setStartedMoving() {
-        this.startedMoving = true;
-    }
-
-    /**
-     * Gets whether the player of this session has started moving in the arena
-     *
-     * @return <p>True if the player has started moving</p>
-     */
-    public boolean getStartedMoving() {
-        return this.startedMoving;
-    }
-
-    /**
-     * Gets the player playing in this session
-     *
-     * @return <p>This session's player</p>
-     */
-    public @NotNull Player getPlayer() {
-        return this.player;
-    }
-
-    /**
-     * Gets the game-mode the player is playing in this session
-     *
-     * @return <p>The game-mode for this session</p>
-     */
-    public @NotNull DropperArenaGameMode getGameMode() {
-        return this.gameMode;
-    }
-
-    @Override
-    public @NotNull PlayerEntryState getEntryState() {
-        return this.entryState;
-    }
-
-    @Override
-    public void triggerWin() {
-        // Stop this session
-        removeSession();
-
-        // Check for, and display, records
-        MiniGames miniGames = MiniGames.getInstance();
-        boolean ignore = miniGames.getDropperConfiguration().ignoreRecordsUntilGroupBeatenOnce();
-        DropperArenaGroup group = miniGames.getDropperArenaHandler().getGroup(this.arena.getArenaId());
-        if (!ignore || group == null || group.hasBeatenAll(this.gameMode, this.player)) {
-            registerRecord();
-        }
-
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-
-        // Mark the arena as cleared
-        if (this.arena.getData().setCompleted(this.gameMode, this.player)) {
-            stringFormatter.displaySuccessMessage(this.player, MiniGameMessage.SUCCESS_ARENA_FIRST_CLEAR);
-            RewardHelper.grantRewards(this.player, this.arena.getRewards(RewardCondition.FIRST_WIN));
-        }
-        stringFormatter.displaySuccessMessage(this.player, MiniGameMessage.SUCCESS_ARENA_WIN);
-        RewardHelper.grantRewards(this.player, this.arena.getRewards(RewardCondition.WIN));
-
-        // Teleport the player out of the arena
-        teleportToExit(false);
-    }
-
-    @Override
-    public void triggerLoss() {
-        this.deaths++;
-        //Teleport the player back to the top
-        PlayerTeleporter.teleportPlayer(this.player, this.arena.getSpawnLocation(), true, false);
-        this.entryState.setArenaState();
-    }
-
-    @Override
-    public @NotNull DropperArena getArena() {
-        return this.arena;
-    }
-
-    @Override
-    public @NotNull ArenaGUI getGUI() {
-        return new DropperGUI(player);
-    }
-
-    @Override
-    public void reset() {
-        this.startedMoving = false;
-        super.reset();
-    }
-
-    @Override
-    protected void removeSession() {
-        // Remove this session for game sessions to stop listeners from fiddling more with the player
-        boolean removedSession = MiniGames.getInstance().getDropperArenaPlayerRegistry().removePlayer(
-                player.getUniqueId(), true);
-        if (!removedSession) {
-            MiniGames.log(Level.SEVERE, "Unable to remove dropper arena session for " + player.getName() + ". " +
-                    "This will have unintended consequences.");
-        }
-    }
-
-    @Override
-    protected String getGameModeString() {
-        return switch (this.gameMode) {
-            case DEFAULT -> "default";
-            case INVERTED -> "inverted";
-            case RANDOM_INVERTED -> "random";
-        };
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/dropper/DropperPlayerEntryState.java

@@ -1,130 +0,0 @@
-package net.knarcraft.minigames.arena.dropper;
-
-import net.knarcraft.minigames.arena.AbstractPlayerEntryState;
-import net.knarcraft.minigames.container.SerializableUUID;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * The state of a player before entering a dropper arena
- */
-public class DropperPlayerEntryState extends AbstractPlayerEntryState {
-
-    private final float originalFlySpeed;
-    private final float horizontalVelocity;
-    private final DropperArenaGameMode arenaGameMode;
-
-    /**
-     * Instantiates a new player state
-     *
-     * @param player <p>The player whose state should be stored</p>
-     */
-    public DropperPlayerEntryState(@NotNull Player player, @NotNull DropperArenaGameMode arenaGameMode,
-                                   float horizontalVelocity) {
-        super(player);
-        this.originalFlySpeed = player.getFlySpeed();
-        this.arenaGameMode = arenaGameMode;
-        this.horizontalVelocity = horizontalVelocity;
-    }
-
-    /**
-     * Instantiates a new parkour player entry state
-     *
-     * @param playerId             <p>The id of the player whose state this should keep track of</p>
-     * @param entryLocation        <p>The location the player entered from</p>
-     * @param originalIsFlying     <p>Whether the player was flying before entering the arena</p>
-     * @param originalGameMode     <p>The game-mode of the player before entering the arena</p>
-     * @param originalAllowFlight  <p>Whether the player was allowed flight before entering the arena</p>
-     * @param originalInvulnerable <p>Whether the player was invulnerable before entering the arena</p>
-     * @param originalIsSwimming   <p>Whether the player was swimming before entering the arena</p>
-     * @param originalFlySpeed     <p>The fly-speed of the player before entering the arena</p>
-     * @param horizontalVelocity   <p>The horizontal velocity of the player before entering the arena</p>
-     * @param originalCollideAble  <p>Whether the player was collide-able before entering the arena</p>
-     */
-    public DropperPlayerEntryState(@NotNull UUID playerId, Location entryLocation,
-                                   boolean originalIsFlying, GameMode originalGameMode, boolean originalAllowFlight,
-                                   boolean originalInvulnerable, boolean originalIsSwimming,
-                                   float originalFlySpeed, float horizontalVelocity,
-                                   DropperArenaGameMode arenaGameMode, boolean originalCollideAble) {
-        super(playerId, entryLocation, originalIsFlying, originalGameMode, originalAllowFlight,
-                originalInvulnerable, originalIsSwimming, originalCollideAble);
-        this.originalFlySpeed = originalFlySpeed;
-        this.horizontalVelocity = horizontalVelocity;
-        this.arenaGameMode = arenaGameMode;
-    }
-
-    @Override
-    public void setArenaState() {
-        Player player = getPlayer();
-        if (player == null) {
-            return;
-        }
-        player.setAllowFlight(true);
-        player.setFlying(true);
-        player.setGameMode(GameMode.ADVENTURE);
-        player.setSwimming(false);
-
-        // If playing on the inverted game-mode, negate the horizontal velocity to swap the controls
-        if (this.arenaGameMode == DropperArenaGameMode.INVERTED) {
-            player.setFlySpeed(-this.horizontalVelocity);
-        } else {
-            player.setFlySpeed(this.horizontalVelocity);
-        }
-    }
-
-    @Override
-    public boolean restore() {
-        Player player = getPlayer();
-        if (player == null) {
-            return false;
-        }
-        this.restore(player);
-        return true;
-    }
-
-    @Override
-    public void restore(@NotNull Player player) {
-        super.restore(player);
-        player.setFlySpeed(this.originalFlySpeed);
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = super.serialize();
-        data.put("originalFlySpeed", this.originalFlySpeed);
-        data.put("horizontalVelocity", this.horizontalVelocity);
-        data.put("arenaGameMode", this.arenaGameMode);
-        return data;
-    }
-
-    /**
-     * Deserializes a ParkourPlayerEntryState from the given data
-     *
-     * @return <p>The data to deserialize</p>
-     */
-    @SuppressWarnings("unused")
-    public static DropperPlayerEntryState deserialize(Map<String, Object> data) {
-        UUID playerId = ((SerializableUUID) data.get("playerId")).getRawValue();
-        Location entryLocation = (Location) data.get("entryLocation");
-        boolean originalIsFlying = getBoolean(data, "originalIsFlying");
-        GameMode originalGameMode = GameMode.valueOf((String) data.get("originalGameMode"));
-        boolean originalAllowFlight = getBoolean(data, "originalAllowFlight");
-        boolean originalInvulnerable = getBoolean(data, "originalInvulnerable");
-        boolean originalIsSwimming = getBoolean(data, "originalIsSwimming");
-        float originalFlySpeed = ((Number) data.get("originalFlySpeed")).floatValue();
-        float horizontalVelocity = ((Number) data.get("horizontalVelocity")).floatValue();
-        DropperArenaGameMode arenaGameMode = (DropperArenaGameMode) data.get("arenaGameMode");
-        boolean originalCollideAble = getBoolean(data, "originalCollideAble");
-
-        return new DropperPlayerEntryState(playerId, entryLocation, originalIsFlying,
-                originalGameMode, originalAllowFlight, originalInvulnerable, originalIsSwimming,
-                originalFlySpeed, horizontalVelocity, arenaGameMode, originalCollideAble);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArena.java

@@ -1,526 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.knarlib.util.MaterialHelper;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.Arena;
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.reward.Reward;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.util.ParkourArenaStorageHelper;
-import net.knarcraft.minigames.util.StringSanitizer;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.logging.Level;
-
-import static net.knarcraft.minigames.util.InputValidationHelper.isInvalid;
-
-/**
- * A representation of one parkour arena
- */
-public class ParkourArena implements Arena {
-
-    /**
-     * An unique and persistent identifier for this arena
-     */
-    private final @NotNull UUID arenaId;
-
-    /**
-     * A name used when listing and storing this arena.
-     */
-    private @NotNull String arenaName;
-
-    /**
-     * The location players are teleported to when joining this arena.
-     */
-    private @NotNull Location spawnLocation;
-
-    /**
-     * The location players will be sent to when they win or lose the arena. If not set, their entry location should be
-     * used instead.
-     */
-    private @Nullable Location exitLocation;
-
-    /**
-     * The material of the block players have to hit to win this parkour arena
-     */
-    private @NotNull Material winBlockType;
-
-    /**
-     * The location the player has to reach to win. If not set, winBlockType is used instead
-     */
-    private @Nullable Location winLocation;
-
-    /**
-     * The names of the block types constituting this arena's kill plane
-     */
-    private @Nullable Set<String> killPlaneBlockNames;
-
-    /**
-     * The block types constituting this arena's kill plane
-     */
-    private @Nullable Set<Material> killPlaneBlocks;
-
-    /**
-     * The names of the block types serving as obstacles for this arena
-     */
-    private @Nullable Set<String> obstacleBlockNames;
-
-    /**
-     * The block types serving as obstacles for this arena
-     */
-    private @Nullable Set<Material> obstacleBlocks;
-
-    /**
-     * The checkpoints for this arena. Entering a checkpoint overrides the player's spawn location.
-     */
-    private final @NotNull List<Location> checkpoints;
-
-    /**
-     * The arena data for this arena
-     */
-    private final @NotNull ParkourArenaData parkourArenaData;
-
-    private final @NotNull ParkourArenaHandler parkourArenaHandler;
-
-    private Map<RewardCondition, Set<Reward>> rewards = new HashMap<>();
-
-    /**
-     * Instantiates a new parkour arena
-     *
-     * @param arenaId             <p>The id of the arena</p>
-     * @param arenaName           <p>The name of the arena</p>
-     * @param spawnLocation       <p>The location players spawn in when entering the arena</p>
-     * @param exitLocation        <p>The location the players are teleported to when exiting the arena, or null</p>
-     * @param winBlockType        <p>The material of the block players have to hit to win this parkour arena</p>
-     * @param winLocation         <p>The location a player has to reach to win this arena</p>
-     * @param killPlaneBlockNames <p>The names of the types of blocks that trigger a loss when stepped on</p>
-     * @param obstacleBlockNames  <p>The names of the types of blocks that trigger a loss when touched</p>
-     * @param checkpoints         <p>The checkpoints set for this arena</p>
-     * @param rewards             <p>The rewards given by this arena</p>
-     * @param parkourArenaData    <p>The arena data keeping track of which players have done what in this arena</p>
-     * @param arenaHandler        <p>The arena handler used for saving any changes</p>
-     */
-    public ParkourArena(@NotNull UUID arenaId, @NotNull String arenaName, @NotNull Location spawnLocation,
-                        @Nullable Location exitLocation, @NotNull Material winBlockType, @Nullable Location winLocation,
-                        @Nullable Set<String> killPlaneBlockNames, @Nullable Set<String> obstacleBlockNames,
-                        @NotNull List<Location> checkpoints,
-                        @NotNull Map<RewardCondition, Set<Reward>> rewards,
-                        @NotNull ParkourArenaData parkourArenaData, @NotNull ParkourArenaHandler arenaHandler) {
-        this.arenaId = arenaId;
-        this.arenaName = arenaName;
-        this.spawnLocation = spawnLocation;
-        this.exitLocation = exitLocation;
-        this.winBlockType = winBlockType;
-        this.winLocation = winLocation;
-        this.killPlaneBlockNames = killPlaneBlockNames;
-        this.killPlaneBlocks = this.killPlaneBlockNames == null ? null : MaterialHelper.loadMaterialList(
-                new ArrayList<>(killPlaneBlockNames), "+", MiniGames.getInstance().getLogger());
-        this.obstacleBlockNames = obstacleBlockNames;
-        this.obstacleBlocks = this.obstacleBlockNames == null ? null : MaterialHelper.loadMaterialList(
-                new ArrayList<>(obstacleBlockNames), "+", MiniGames.getInstance().getLogger());
-        this.checkpoints = checkpoints;
-        this.parkourArenaData = parkourArenaData;
-        this.parkourArenaHandler = arenaHandler;
-        this.rewards = rewards;
-    }
-
-    /**
-     * Instantiates a new parkour arena
-     *
-     * <p>Note that this minimal constructor can be used to quickly create a new parkour arena at the player's given
-     * location, simply by them giving an arena name.</p>
-     *
-     * @param arenaName     <p>The name of the arena</p>
-     * @param spawnLocation <p>The location players spawn in when entering the arena</p>
-     * @param arenaHandler  <p>The arena handler used for saving any changes</p>
-     */
-    public ParkourArena(@NotNull String arenaName, @NotNull Location spawnLocation,
-                        @NotNull ParkourArenaHandler arenaHandler) {
-        this.arenaId = UUID.randomUUID();
-        this.arenaName = arenaName;
-        this.spawnLocation = spawnLocation;
-        this.exitLocation = null;
-        this.winLocation = null;
-
-        Map<ArenaGameMode, ArenaRecordsRegistry> recordRegistries = new HashMap<>();
-        for (ParkourArenaGameMode arenaGameMode : ParkourArenaGameMode.values()) {
-            recordRegistries.put(arenaGameMode, new ParkourArenaRecordsRegistry(this.arenaId));
-        }
-
-        this.parkourArenaData = new ParkourArenaData(this.arenaId, recordRegistries, new HashMap<>());
-        this.winBlockType = Material.EMERALD_BLOCK;
-        this.killPlaneBlocks = null;
-        this.obstacleBlocks = null;
-        this.checkpoints = new ArrayList<>();
-        this.parkourArenaHandler = arenaHandler;
-    }
-
-    @Override
-    public @NotNull ParkourArenaData getData() {
-        return this.parkourArenaData;
-    }
-
-    @Override
-    public @NotNull UUID getArenaId() {
-        return this.arenaId;
-    }
-
-    @Override
-    public @NotNull String getArenaName() {
-        return this.arenaName;
-    }
-
-    @Override
-    public @NotNull Location getSpawnLocation() {
-        return this.spawnLocation;
-    }
-
-    @Override
-    public @Nullable Location getExitLocation() {
-        return this.exitLocation;
-    }
-
-    @Override
-    public void addReward(@NotNull RewardCondition rewardCondition, @NotNull Reward reward) {
-        this.rewards.computeIfAbsent(rewardCondition, k -> new HashSet<>());
-        this.rewards.get(rewardCondition).add(reward);
-        this.saveArena();
-    }
-
-    @Override
-    public void clearRewards(@NotNull RewardCondition rewardCondition) {
-        this.rewards.remove(rewardCondition);
-        this.saveArena();
-    }
-
-    @Override
-    public @NotNull Set<Reward> getRewards(RewardCondition rewardCondition) {
-        if (this.rewards.containsKey(rewardCondition)) {
-            return this.rewards.get(rewardCondition);
-        } else {
-            return new HashSet<>();
-        }
-    }
-
-    /**
-     * Gets the type of block a player has to hit to win this arena
-     *
-     * @return <p>The kind of block players must hit</p>
-     */
-    public @NotNull Material getWinBlockType() {
-        return this.winBlockType;
-    }
-
-    /**
-     * The location a player has to reach to win this arena
-     *
-     * <p></p>
-     *
-     * @return <p>The win trigger's location</p>
-     */
-    public @Nullable Location getWinLocation() {
-        return this.winLocation != null ? this.winLocation.clone() : null;
-    }
-
-    /**
-     * Gets the block types used for this parkour arena's kill plane
-     *
-     * @return <p>The types of blocks that cause a loss</p>
-     */
-    public @NotNull Set<Material> getKillPlaneBlocks() {
-        if (this.killPlaneBlocks != null) {
-            return new HashSet<>(this.killPlaneBlocks);
-        } else {
-            return MiniGames.getInstance().getParkourConfiguration().getKillPlaneBlocks();
-        }
-    }
-
-    /**
-     * Gets the names of the block types used for this parkour arena's kill plane
-     *
-     * @return <p>The names of the types of blocks that cause a loss</p>
-     */
-    public @Nullable Set<String> getKillPlaneBlockNames() {
-        return this.killPlaneBlockNames;
-    }
-
-    /**
-     * Gets the block types used for this parkour arena's obstacle blocks
-     *
-     * @return <p>The types of blocks used as obstacles</p>
-     */
-    public @NotNull Set<Material> getObstacleBlocks() {
-        if (this.obstacleBlocks != null) {
-            return new HashSet<>(this.obstacleBlocks);
-        } else {
-            return MiniGames.getInstance().getParkourConfiguration().getObstacleBlocks();
-        }
-    }
-
-    /**
-     * Gets the names of the blocks used as this arena's obstacle blocks
-     *
-     * @return <p>The names of the blocks used as this arena's obstacle blocks</p>
-     */
-    public @Nullable Set<String> getObstacleBlockNames() {
-        return this.obstacleBlockNames;
-    }
-
-    /**
-     * Gets all checkpoint locations for this arena
-     *
-     * @return <p>All checkpoint locations for this arena</p>
-     */
-    public List<Location> getCheckpoints() {
-        List<Location> copy = new ArrayList<>(this.checkpoints.size());
-        for (Location location : this.checkpoints) {
-            copy.add(location.clone());
-        }
-        return copy;
-    }
-
-    /**
-     * Gets whether this arena has no checkpoints
-     *
-     * @return <p>True if this arena has no checkpoints</p>
-     */
-    public boolean hasNoCheckpoints() {
-        return this.checkpoints.isEmpty();
-    }
-
-    /**
-     * Gets this arena's sanitized name
-     *
-     * @return <p>This arena's sanitized name</p>
-     */
-    public @NotNull String getArenaNameSanitized() {
-        return StringSanitizer.sanitizeArenaName(this.getArenaName());
-    }
-
-    @Override
-    public boolean removeData() {
-        return ParkourArenaStorageHelper.removeParkourArenaData(getArenaId());
-    }
-
-    @Override
-    public boolean saveData() {
-        try {
-            ParkourArenaStorageHelper.saveParkourArenaData(getData());
-            return true;
-        } catch (IOException exception) {
-            return false;
-        }
-    }
-
-    @Override
-    public boolean willCauseWin(Block block) {
-        return (this.winLocation != null && this.winLocation.getBlock().equals(block)) ||
-                (this.winLocation == null && this.winBlockType == block.getType());
-    }
-
-    @Override
-    public boolean willCauseLoss(Block block) {
-        return this.getKillPlaneBlocks().contains(block.getType()) || this.getObstacleBlocks().contains(block.getType());
-    }
-
-    @Override
-    public boolean winLocationIsSolid() {
-        return (this.winLocation != null && this.winLocation.getBlock().getType().isSolid()) ||
-                this.winBlockType.isSolid();
-    }
-
-    /**
-     * Sets the spawn location for this arena
-     *
-     * @param newLocation <p>The new spawn location</p>
-     * @return <p>True if successfully updated</p>
-     */
-    public boolean setSpawnLocation(@NotNull Location newLocation) {
-        if (isInvalid(newLocation)) {
-            return false;
-        } else {
-            this.spawnLocation = newLocation;
-            this.saveArena();
-            return true;
-        }
-    }
-
-    /**
-     * Sets the exit location for this arena
-     *
-     * @param newLocation <p>The new exit location</p>
-     * @return <p>True if successfully updated</p>
-     */
-    public boolean setExitLocation(@NotNull Location newLocation) {
-        if (isInvalid(newLocation)) {
-            return false;
-        } else {
-            this.exitLocation = newLocation;
-            this.saveArena();
-            return true;
-        }
-    }
-
-    /**
-     * Sets the name of this arena
-     *
-     * @param arenaName <p>The new name</p>
-     * @return <p>True if successfully updated</p>
-     */
-    public boolean setName(@NotNull String arenaName) {
-        if (!arenaName.isBlank()) {
-            String oldName = this.getArenaNameSanitized();
-            this.arenaName = arenaName;
-            // Update the arena lookup map to make sure the new name can be used immediately
-            this.parkourArenaHandler.updateLookupName(oldName, this.getArenaNameSanitized());
-            this.saveArena();
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    /**
-     * Sets the material of the win block type
-     *
-     * <p>The win block type is the type of block a player must hit to win in this arena</p>
-     *
-     * @param material <p>The material to set for the win block type</p>
-     * @return <p>True if successfully updated</p>
-     */
-    public boolean setWinBlockType(@NotNull Material material) {
-        if (material.isAir() || !material.isBlock()) {
-            return false;
-        } else {
-            this.winBlockType = material;
-            this.saveArena();
-            return true;
-        }
-    }
-
-    /**
-     * Sets the location players need to reach to win this arena
-     *
-     * @param newLocation <p>The location players have to reach</p>
-     * @return <p>True if successfully changed</p>
-     */
-    public boolean setWinLocation(@NotNull Location newLocation) {
-        if (isInvalid(newLocation)) {
-            return false;
-        } else {
-            this.winLocation = newLocation.clone();
-            this.saveArena();
-            return true;
-        }
-    }
-
-    /**
-     * Sets the type of blocks constituting this arena's kill plane
-     *
-     * @param killPlaneBlockNames <p>The names of the blocks that will cause players to lose</p>
-     */
-    public boolean setKillPlaneBlocks(@NotNull Set<String> killPlaneBlockNames) {
-        if (killPlaneBlockNames.isEmpty()) {
-            this.killPlaneBlockNames = null;
-            this.killPlaneBlocks = null;
-        } else {
-            Set<Material> parsed = MaterialHelper.loadMaterialList(new ArrayList<>(killPlaneBlockNames), "+",
-                    MiniGames.getInstance().getLogger());
-            if (parsed.isEmpty()) {
-                return false;
-            }
-            this.killPlaneBlockNames = killPlaneBlockNames;
-            this.killPlaneBlocks = parsed;
-        }
-        this.saveArena();
-        return true;
-    }
-
-    /**
-     * Sets the type of blocks used as obstacle blocks
-     *
-     * @param obstacleBlockNames <p>The names of the obstacle blocks</p>
-     */
-    public boolean setObstacleBlocks(@NotNull Set<String> obstacleBlockNames) {
-        if (obstacleBlockNames.isEmpty()) {
-            this.obstacleBlockNames = null;
-            this.obstacleBlocks = null;
-        } else {
-            Set<Material> parsed = MaterialHelper.loadMaterialList(new ArrayList<>(obstacleBlockNames), "+",
-                    MiniGames.getInstance().getLogger());
-            if (parsed.isEmpty()) {
-                return false;
-            }
-            this.obstacleBlockNames = obstacleBlockNames;
-            this.obstacleBlocks = parsed;
-        }
-        this.saveArena();
-        return true;
-    }
-
-    /**
-     * Adds a checkpoint to this arena
-     *
-     * @param checkpoint <p>The checkpoint to add</p>
-     * @return <p>True if successfully added</p>
-     */
-    public boolean addCheckpoint(@NotNull Location checkpoint) {
-        if (isInvalid(checkpoint)) {
-            return false;
-        }
-
-        this.checkpoints.add(checkpoint.clone());
-        this.saveArena();
-        return true;
-    }
-
-    /**
-     * Clears all checkpoints from this arena
-     *
-     * @return <p>True if successfully cleared</p>
-     */
-    public boolean clearCheckpoints() {
-        if (checkpoints.isEmpty()) {
-            return false;
-        }
-
-        this.checkpoints.clear();
-        this.saveArena();
-        return true;
-    }
-
-    /**
-     * Saves this arena to disk
-     */
-    public void saveArena() {
-        try {
-            ParkourArenaStorageHelper.saveSingleParkourArena(this);
-        } catch (IOException exception) {
-            MiniGames.log(Level.SEVERE, "Unable to save arena! " +
-                    "Data loss can occur!");
-            MiniGames.log(Level.SEVERE, exception.getMessage());
-        }
-    }
-
-    @Override
-    public boolean equals(Object other) {
-        if (!(other instanceof ParkourArena otherArena)) {
-            return false;
-        }
-        return this.getArenaNameSanitized().equals(otherArena.getArenaNameSanitized());
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaData.java

@@ -1,72 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaData;
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.container.SerializableContainer;
-import net.knarcraft.minigames.container.SerializableUUID;
-import net.knarcraft.minigames.util.SerializableConverter;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * Data stored for an arena
- */
-public class ParkourArenaData extends ArenaData {
-
-    /**
-     * Instantiates a new parkour arena data object
-     *
-     * @param arenaId          <p>The id of the arena this data belongs to</p>
-     * @param recordRegistries <p>The registry of this arena's records</p>
-     * @param playersCompleted <p>The set of the players that have cleared this arena</p>
-     */
-    public ParkourArenaData(@NotNull UUID arenaId,
-                            @NotNull Map<ArenaGameMode, ArenaRecordsRegistry> recordRegistries,
-                            @NotNull Map<ArenaGameMode, Set<UUID>> playersCompleted) {
-        super(arenaId, recordRegistries, playersCompleted);
-    }
-
-    @Override
-    public void saveData() {
-        MiniGames.getInstance().getParkourArenaHandler().saveData(this.arenaId);
-    }
-
-    /**
-     * Deserializes a parkour arena data from the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized parkour arena data</p>
-     */
-    @SuppressWarnings({"unused", "unchecked"})
-    public static @NotNull ParkourArenaData deserialize(@NotNull Map<String, Object> data) {
-        SerializableUUID serializableUUID = (SerializableUUID) data.get("arenaId");
-        Map<ArenaGameMode, ArenaRecordsRegistry> recordsRegistry =
-                (Map<ArenaGameMode, ArenaRecordsRegistry>) data.get("recordsRegistry");
-        Map<ArenaGameMode, Set<SerializableContainer<UUID>>> playersCompletedData =
-                (Map<ArenaGameMode, Set<SerializableContainer<UUID>>>) data.get("playersCompleted");
-
-        if (recordsRegistry == null) {
-            recordsRegistry = new HashMap<>();
-        } else if (playersCompletedData == null) {
-            playersCompletedData = new HashMap<>();
-        }
-
-        // Convert the serializable UUIDs to normal UUIDs
-        Map<ArenaGameMode, Set<UUID>> allPlayersCompleted = new HashMap<>();
-        SerializableConverter.getRawValue(playersCompletedData, allPlayersCompleted);
-
-        for (ArenaGameMode arenaGameMode : playersCompletedData.keySet()) {
-            if (!recordsRegistry.containsKey(arenaGameMode) || recordsRegistry.get(arenaGameMode) == null) {
-                recordsRegistry.put(arenaGameMode, new ParkourArenaRecordsRegistry(serializableUUID.getRawValue()));
-            }
-        }
-        return new ParkourArenaData(serializableUUID.getRawValue(), recordsRegistry, allPlayersCompleted);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaEditableProperty.java

@@ -1,133 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.arena.EditablePropertyType;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.function.Function;
-
-/**
- * All editable properties of a parkour arena
- */
-public enum ParkourArenaEditableProperty {
-
-    /**
-     * The name of the arena
-     */
-    NAME("name", ParkourArena::getArenaName, EditablePropertyType.ARENA_NAME),
-
-    /**
-     * The arena's spawn location
-     */
-    SPAWN_LOCATION("spawnLocation", (arena) -> String.valueOf(arena.getSpawnLocation()),
-            EditablePropertyType.LOCATION),
-
-    /**
-     * The arena's exit location
-     */
-    EXIT_LOCATION("exitLocation", (arena) -> String.valueOf(arena.getExitLocation()),
-            EditablePropertyType.LOCATION),
-
-    /**
-     * The arena's win block type
-     */
-    WIN_BLOCK_TYPE("winBlockType", (arena) -> arena.getWinBlockType().toString(),
-            EditablePropertyType.BLOCK_TYPE),
-
-    /**
-     * The arena's win location (overrides the win block type)
-     */
-    WIN_LOCATION("winLocation", (arena) -> {
-        if (arena.getWinLocation() != null) {
-            return arena.getWinLocation().toString();
-        } else {
-            return "null";
-        }
-    }, EditablePropertyType.LOCATION),
-
-    /**
-     * The arena's check points. Specifically used for adding.
-     */
-    CHECKPOINT_ADD("checkpointAdd", (arena) -> String.valueOf(arena.getCheckpoints()),
-            EditablePropertyType.LOCATION),
-
-    /**
-     * The arena's check points. Specifically used for clearing.
-     */
-    CHECKPOINT_CLEAR("checkpointClear", (arena) -> String.valueOf(arena.getCheckpoints()),
-            EditablePropertyType.CHECKPOINT_CLEAR),
-
-    /**
-     * The blocks constituting the arena's lethal blocks
-     */
-    KILL_PLANE_BLOCKS("killPlaneBlocks", (arena) -> String.valueOf(arena.getKillPlaneBlockNames()),
-            EditablePropertyType.MATERIAL_LIST),
-
-    /**
-     * The blocks used as this arena's obstacle blocks
-     */
-    OBSTACLE_BLOCKS("obstacleBlocks", (arena) -> String.valueOf(arena.getObstacleBlockNames()),
-            EditablePropertyType.MATERIAL_LIST),
-
-    ;
-
-    private final @NotNull String argumentString;
-    private final Function<ParkourArena, String> currentValueProvider;
-    private final EditablePropertyType propertyType;
-
-    /**
-     * Instantiates a new arena editable property
-     *
-     * @param argumentString <p>The argument string used to specify this property</p>
-     */
-    ParkourArenaEditableProperty(@NotNull String argumentString, Function<ParkourArena, String> currentValueProvider,
-                                 EditablePropertyType propertyType) {
-        this.argumentString = argumentString;
-        this.currentValueProvider = currentValueProvider;
-        this.propertyType = propertyType;
-    }
-
-    /**
-     * Gets the type of property this editable property represents
-     *
-     * @return <p>The type of this property</p>
-     */
-    public EditablePropertyType getPropertyType() {
-        return this.propertyType;
-    }
-
-    /**
-     * Gets the string representation of this property's current value
-     *
-     * @param arena <p>The arena to check the value for</p>
-     * @return <p>The current value as a string</p>
-     */
-    public String getCurrentValueAsString(ParkourArena arena) {
-        return this.currentValueProvider.apply(arena);
-    }
-
-    /**
-     * Gets the argument string used to specify this property
-     *
-     * @return <p>The argument string</p>
-     */
-    public @NotNull String getArgumentString() {
-        return this.argumentString;
-    }
-
-    /**
-     * Gets the editable property corresponding to the given argument string
-     *
-     * @param argumentString <p>The argument string used to specify an editable property</p>
-     * @return <p>The corresponding editable property, or null if not found</p>
-     */
-    public static @Nullable ParkourArenaEditableProperty getFromArgumentString(String argumentString) {
-        for (ParkourArenaEditableProperty property : ParkourArenaEditableProperty.values()) {
-            if (property.argumentString.equalsIgnoreCase(argumentString)) {
-                return property;
-            }
-        }
-        return null;
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaGameMode.java

@@ -1,64 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.arena.ArenaGameMode;
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A representation of possible arena game-modes
- */
-public enum ParkourArenaGameMode implements ConfigurationSerializable, ArenaGameMode {
-
-    /**
-     * The default game-mode. Failing once throws the player out.
-     */
-    DEFAULT,
-
-    /**
-     * A hardcore game mode where no checkpoints are allowed
-     */
-    HARDCORE,
-    ;
-
-    /**
-     * Tries to match the correct game-mode according to the given string
-     *
-     * @param gameMode <p>The game-mode string to match</p>
-     * @return <p>The specified arena game-mode</p>
-     */
-    public static @NotNull ParkourArenaGameMode matchGamemode(@NotNull String gameMode) {
-        try {
-            return ParkourArenaGameMode.valueOf(gameMode.toUpperCase());
-        } catch (IllegalArgumentException exception) {
-            return ParkourArenaGameMode.DEFAULT;
-        }
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("name", this.name());
-        return data;
-    }
-
-    /**
-     * Deserializes the arena game-mode specified by the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized arena game-mode</p>
-     */
-    @SuppressWarnings("unused")
-    public static ParkourArenaGameMode deserialize(Map<String, Object> data) {
-        return ParkourArenaGameMode.valueOf((String) data.get("name"));
-    }
-
-    @Override
-    public @NotNull ParkourArenaGameMode[] getValues() {
-        return ParkourArenaGameMode.values();
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaGroup.java

@@ -1,56 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaGroup;
-import net.knarcraft.minigames.container.SerializableUUID;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * A sorted group of arenas that must be completed in sequence
- */
-public class ParkourArenaGroup extends ArenaGroup<ParkourArena, ParkourArenaGroup> {
-
-    /**
-     * Instantiates a new parkour arena group
-     *
-     * @param groupName <p>The name of this group</p>
-     */
-    public ParkourArenaGroup(@NotNull String groupName) {
-        super(groupName, MiniGames.getInstance().getParkourArenaHandler());
-    }
-
-    /**
-     * Instantiates a new parkour arena group
-     *
-     * @param groupId   <p>The unique id of this group</p>
-     * @param groupName <p>The name of this group</p>
-     * @param arenas    <p>The arenas in this group</p>
-     */
-    private ParkourArenaGroup(@NotNull UUID groupId, @NotNull String groupName, @NotNull List<UUID> arenas) {
-        super(groupId, groupName, arenas, MiniGames.getInstance().getParkourArenaHandler());
-    }
-
-    /**
-     * Deserializes the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized arena group</p>
-     */
-    @SuppressWarnings({"unused", "unchecked"})
-    public static @NotNull ParkourArenaGroup deserialize(@NotNull Map<String, Object> data) {
-        UUID id = ((SerializableUUID) data.get("groupId")).getRawValue();
-        String name = (String) data.get("groupName");
-        List<SerializableUUID> serializableArenas = (List<SerializableUUID>) data.get("arenas");
-        List<UUID> arenas = new ArrayList<>();
-        for (SerializableUUID arenaId : serializableArenas) {
-            arenas.add(arenaId.getRawValue());
-        }
-        return new ParkourArenaGroup(id, name, arenas);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaHandler.java

@@ -1,77 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaHandler;
-import net.knarcraft.minigames.arena.ArenaPlayerRegistry;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.ParkourArenaStorageHelper;
-
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.UUID;
-import java.util.logging.Level;
-
-/**
- * A handler that keeps track of all parkour arenas
- */
-public class ParkourArenaHandler extends ArenaHandler<ParkourArena, ParkourArenaGroup> {
-
-    /**
-     * Instantiates a new arena handler
-     *
-     * @param playerRegistry <p>The registry keeping track of player sessions</p>
-     */
-    public ParkourArenaHandler(ArenaPlayerRegistry<ParkourArena> playerRegistry) {
-        super(playerRegistry);
-    }
-
-    @Override
-    public void saveGroups() {
-        try {
-            ParkourArenaStorageHelper.saveParkourArenaGroups(new HashSet<>(this.arenaGroups.values()));
-        } catch (IOException exception) {
-            MiniGames.log(Level.SEVERE, MiniGames.getInstance().getTranslator().getTranslatedMessage(
-                    MiniGameMessage.ERROR_CANNOT_SAVE_ARENA_GROUPS));
-            MiniGames.log(Level.SEVERE, exception.getMessage());
-        }
-    }
-
-    @Override
-    protected void loadGroups() {
-        Set<ParkourArenaGroup> arenaGroups = ParkourArenaStorageHelper.loadParkourArenaGroups();
-        Map<UUID, ParkourArenaGroup> arenaGroupMap = new HashMap<>();
-        for (ParkourArenaGroup arenaGroup : arenaGroups) {
-            for (UUID arenaId : arenaGroup.getArenas()) {
-                arenaGroupMap.put(arenaId, arenaGroup);
-            }
-        }
-        this.arenaGroups = arenaGroupMap;
-    }
-
-    @Override
-    public void saveArenas() {
-        try {
-            ParkourArenaStorageHelper.saveParkourArenas(this.arenas);
-        } catch (IOException exception) {
-            MiniGames.log(Level.SEVERE, "Unable to save current arenas! " +
-                    "Data loss can occur!");
-            MiniGames.log(Level.SEVERE, exception.getMessage());
-        }
-    }
-
-    @Override
-    protected void loadArenas() {
-        this.arenas = ParkourArenaStorageHelper.loadParkourArenas();
-
-        // Save a map from arena name to arena id for improved performance
-        this.arenaNameLookup = new HashMap<>();
-        for (Map.Entry<UUID, ParkourArena> arena : this.arenas.entrySet()) {
-            String sanitizedName = arena.getValue().getArenaNameSanitized();
-            this.arenaNameLookup.put(sanitizedName, arena.getKey());
-        }
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaPlayerRegistry.java

@@ -1,15 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.arena.AbstractArenaPlayerRegistry;
-
-/**
- * A registry to keep track of which players are playing in which arenas
- */
-public class ParkourArenaPlayerRegistry extends AbstractArenaPlayerRegistry<ParkourArena> {
-
-    @Override
-    protected String getEntryStateStorageKey() {
-        return "parkour";
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaRecordsRegistry.java

@@ -1,66 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaRecordsRegistry;
-import net.knarcraft.minigames.arena.record.IntegerRecord;
-import net.knarcraft.minigames.arena.record.LongRecord;
-import net.knarcraft.minigames.container.SerializableUUID;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-
-/**
- * A registry keeping track of all records
- */
-public class ParkourArenaRecordsRegistry extends ArenaRecordsRegistry {
-
-    /**
-     * Instantiates a new empty records registry
-     */
-    public ParkourArenaRecordsRegistry(@NotNull UUID arenaId) {
-        super(arenaId);
-    }
-
-    /**
-     * Instantiates a new records registry
-     *
-     * @param leastDeaths              <p>The existing least death records to use</p>
-     * @param shortestTimeMilliSeconds <p>The existing leash time records to use</p>
-     */
-    private ParkourArenaRecordsRegistry(@NotNull UUID arenaId, @NotNull Set<IntegerRecord> leastDeaths,
-                                        @NotNull Set<LongRecord> shortestTimeMilliSeconds) {
-        super(arenaId, leastDeaths, shortestTimeMilliSeconds);
-    }
-
-    /**
-     * Saves changed records
-     */
-    @Override
-    protected void save() {
-        MiniGames.getInstance().getParkourArenaHandler().saveData(this.arenaId);
-    }
-
-    /**
-     * Deserializes the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized records registry</p>
-     */
-    @SuppressWarnings({"unused", "unchecked"})
-    public static ParkourArenaRecordsRegistry deserialize(Map<String, Object> data) {
-        UUID arenaId = ((SerializableUUID) data.get("arenaId")).getRawValue();
-        Set<IntegerRecord> leastDeaths =
-                (Set<IntegerRecord>) data.getOrDefault("leastDeaths", new HashMap<>());
-        Set<LongRecord> shortestTimeMilliseconds =
-                (Set<LongRecord>) data.getOrDefault("shortestTime", new HashMap<>());
-
-        leastDeaths.removeIf(Objects::isNull);
-        shortestTimeMilliseconds.removeIf(Objects::isNull);
-        return new ParkourArenaRecordsRegistry(arenaId, leastDeaths, shortestTimeMilliseconds);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaSession.java

@@ -1,151 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.AbstractArenaSession;
-import net.knarcraft.minigames.arena.PlayerEntryState;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.gui.ArenaGUI;
-import net.knarcraft.minigames.gui.ParkourGUI;
-import net.knarcraft.minigames.util.PlayerTeleporter;
-import net.knarcraft.minigames.util.RewardHelper;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.logging.Level;
-
-/**
- * A representation of a player's current session in a parkour arena
- */
-public class ParkourArenaSession extends AbstractArenaSession {
-
-    private final @NotNull ParkourArena arena;
-    private final @NotNull Player player;
-    private final @NotNull ParkourArenaGameMode gameMode;
-    private Location reachedCheckpoint = null;
-
-    /**
-     * Instantiates a new parkour arena session
-     *
-     * @param parkourArena <p>The arena that's being played in</p>
-     * @param player       <p>The player playing the arena</p>
-     * @param gameMode     <p>The game-mode</p>
-     */
-    public ParkourArenaSession(@NotNull ParkourArena parkourArena, @NotNull Player player,
-                               @NotNull ParkourArenaGameMode gameMode) {
-        super(parkourArena, player, gameMode);
-        this.arena = parkourArena;
-        this.player = player;
-        this.gameMode = gameMode;
-
-        this.entryState = new ParkourPlayerEntryState(player);
-        this.entryState.setArenaState();
-    }
-
-    /**
-     * Gets the game-mode the player is playing in this session
-     *
-     * @return <p>The game-mode for this session</p>
-     */
-    public @NotNull ParkourArenaGameMode getGameMode() {
-        return this.gameMode;
-    }
-
-    /**
-     * Registers the checkpoint this session's player has reached
-     *
-     * @param location <p>The location of the checkpoint</p>
-     */
-    public void registerCheckpoint(@NotNull Location location) {
-        this.reachedCheckpoint = location;
-    }
-
-    /**
-     * Gets the checkpoint currently registered as the player's spawn location
-     *
-     * @return <p>The registered checkpoint, or null if not set</p>
-     */
-    public @Nullable Location getRegisteredCheckpoint() {
-        return this.reachedCheckpoint;
-    }
-
-    @Override
-    public @NotNull PlayerEntryState getEntryState() {
-        return this.entryState;
-    }
-
-    @Override
-    public void triggerWin() {
-        // Stop this session
-        removeSession();
-
-        // Check for, and display, records
-        MiniGames miniGames = MiniGames.getInstance();
-        boolean ignore = miniGames.getParkourConfiguration().ignoreRecordsUntilGroupBeatenOnce();
-        ParkourArenaGroup group = miniGames.getParkourArenaHandler().getGroup(this.arena.getArenaId());
-        if (!ignore || group == null || group.hasBeatenAll(this.gameMode, this.player)) {
-            registerRecord();
-        }
-
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-
-        // Mark the arena as cleared
-        if (this.arena.getData().setCompleted(this.gameMode, this.player)) {
-            stringFormatter.displaySuccessMessage(this.player, MiniGameMessage.SUCCESS_ARENA_FIRST_CLEAR);
-            RewardHelper.grantRewards(this.player, this.arena.getRewards(RewardCondition.FIRST_WIN));
-        }
-        stringFormatter.displaySuccessMessage(this.player, MiniGameMessage.SUCCESS_ARENA_WIN);
-        RewardHelper.grantRewards(this.player, this.arena.getRewards(RewardCondition.WIN));
-
-        // Teleport the player out of the arena
-        teleportToExit(false);
-    }
-
-    @Override
-    public void triggerLoss() {
-        this.deaths++;
-        //Teleport the player back to the top
-        Location spawnLocation = this.reachedCheckpoint != null ? this.reachedCheckpoint : this.arena.getSpawnLocation();
-        PlayerTeleporter.teleportPlayer(this.player, spawnLocation, true, false);
-        this.entryState.setArenaState();
-    }
-
-    @Override
-    public @NotNull ParkourArena getArena() {
-        return this.arena;
-    }
-
-    @Override
-    public @NotNull ArenaGUI getGUI() {
-        return new ParkourGUI(player);
-    }
-
-    @Override
-    public void reset() {
-        this.reachedCheckpoint = null;
-        super.reset();
-    }
-
-    @Override
-    protected void removeSession() {
-        // Remove this session for game sessions to stop listeners from fiddling more with the player
-        boolean removedSession = MiniGames.getInstance().getParkourArenaPlayerRegistry().removePlayer(
-                player.getUniqueId(), true);
-        if (!removedSession) {
-            MiniGames.log(Level.SEVERE, "Unable to remove parkour arena session for " + player.getName() + ". " +
-                    "This will have unintended consequences.");
-        }
-    }
-
-    @Override
-    protected String getGameModeString() {
-        return switch (this.gameMode) {
-            case DEFAULT -> "default";
-            case HARDCORE -> "hardcore";
-        };
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourArenaStorageKey.java

@@ -1,86 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A representation of each key used for storing arena data
- */
-public enum ParkourArenaStorageKey {
-
-    /**
-     * The key for an arena's id
-     */
-    ID("arenaId"),
-
-    /**
-     * The key for an arena's name
-     */
-    NAME("arenaName"),
-
-    /**
-     * The key for an arena's spawn location
-     */
-    SPAWN_LOCATION("arenaSpawnLocation"),
-
-    /**
-     * The key for an arena's exit location
-     */
-    EXIT_LOCATION("arenaExitLocation"),
-
-    /**
-     * The key for the type of this arena's win block
-     */
-    WIN_BLOCK_TYPE("winBlockType"),
-
-    /**
-     * The key for this arena's win location (overrides win block type)
-     */
-    WIN_LOCATION("winLocation"),
-
-    /**
-     * The key for this arena's kill plane blocks (overrides the config)
-     */
-    KILL_PLANE_BLOCKS("killPlaneBlocks"),
-
-    /**
-     * The key for this arena's obstacle blocks (overrides the config)
-     */
-    OBSTACLE_BLOCKS("obstacleBlocks"),
-
-    /**
-     * The key for this arena's checkpoint locations
-     */
-    CHECKPOINTS("checkpoints"),
-
-    /**
-     * The hey for this arena's data
-     */
-    DATA("arenaData"),
-
-    /**
-     * The key for this arena's rewards
-     */
-    REWARDS("rewards"),
-    ;
-
-    private final @NotNull String key;
-
-    /**
-     * Instantiates a new arena storage key
-     *
-     * @param key <p>The string path of the configuration key this value represents.</p>
-     */
-    ParkourArenaStorageKey(@NotNull String key) {
-        this.key = key;
-    }
-
-    /**
-     * Gets the configuration key this enum represents
-     *
-     * @return <p>The string key representation.</p>
-     */
-    public @NotNull String getKey() {
-        return this.key;
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/parkour/ParkourPlayerEntryState.java

@@ -1,78 +0,0 @@
-package net.knarcraft.minigames.arena.parkour;
-
-import net.knarcraft.minigames.arena.AbstractPlayerEntryState;
-import net.knarcraft.minigames.container.SerializableUUID;
-import org.bukkit.GameMode;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Map;
-import java.util.UUID;
-
-/**
- * The state of a player before entering a parkour arena
- */
-public class ParkourPlayerEntryState extends AbstractPlayerEntryState {
-
-    /**
-     * Instantiates a new player state
-     *
-     * @param player <p>The player whose state should be stored</p>
-     */
-    public ParkourPlayerEntryState(@NotNull Player player) {
-        super(player);
-    }
-
-    /**
-     * Instantiates a new parkour player entry state
-     *
-     * @param playerId             <p>The id of the player whose state this should keep track of</p>
-     * @param entryLocation        <p>The location the player entered from</p>
-     * @param originalIsFlying     <p>Whether the player was flying before entering the arena</p>
-     * @param originalGameMode     <p>The game-mode of the player before entering the arena</p>
-     * @param originalAllowFlight  <p>Whether the player was allowed flight before entering the arena</p>
-     * @param originalInvulnerable <p>Whether the player was invulnerable before entering the arena</p>
-     * @param originalIsSwimming   <p>Whether the player was swimming before entering the arena</p>
-     * @param originalCollideAble  <p>Whether the player was collide-able before entering the arena</p>
-     */
-    public ParkourPlayerEntryState(@NotNull UUID playerId, Location entryLocation,
-                                   boolean originalIsFlying, GameMode originalGameMode, boolean originalAllowFlight,
-                                   boolean originalInvulnerable, boolean originalIsSwimming, boolean originalCollideAble) {
-        super(playerId, entryLocation, originalIsFlying, originalGameMode, originalAllowFlight,
-                originalInvulnerable, originalIsSwimming, originalCollideAble);
-    }
-
-    @Override
-    public void setArenaState() {
-        Player player = getPlayer();
-        if (player == null) {
-            return;
-        }
-        player.setAllowFlight(false);
-        player.setFlying(false);
-        player.setGameMode(GameMode.ADVENTURE);
-        player.setSwimming(false);
-    }
-
-    /**
-     * Deserializes a ParkourPlayerEntryState from the given data
-     *
-     * @return <p>The data to deserialize</p>
-     */
-    @SuppressWarnings("unused")
-    public static ParkourPlayerEntryState deserialize(Map<String, Object> data) {
-        UUID playerId = ((SerializableUUID) data.get("playerId")).getRawValue();
-        Location entryLocation = (Location) data.get("entryLocation");
-        boolean originalIsFlying = getBoolean(data, "originalIsFlying");
-        GameMode originalGameMode = GameMode.valueOf((String) data.get("originalGameMode"));
-        boolean originalAllowFlight = getBoolean(data, "originalAllowFlight");
-        boolean originalInvulnerable = getBoolean(data, "originalInvulnerable");
-        boolean originalIsSwimming = getBoolean(data, "originalIsSwimming");
-        boolean originalCollideAble = getBoolean(data, "originalCollideAble");
-
-        return new ParkourPlayerEntryState(playerId, entryLocation, originalIsFlying,
-                originalGameMode, originalAllowFlight, originalInvulnerable, originalIsSwimming, originalCollideAble);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/CommandReward.java

@@ -1,69 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A reward that executes a specified command when it's granted
- */
-public class CommandReward implements Reward {
-
-    private final @NotNull String command;
-
-    /**
-     * Instantiates a new command reward
-     *
-     * @param command <p>The command to execute when granting this reward</p>
-     */
-    public CommandReward(@NotNull String command) {
-        this.command = command;
-    }
-
-    @Override
-    public boolean grant(@NotNull Player player) {
-        return Bukkit.dispatchCommand(Bukkit.getServer().getConsoleSender(), replaceNamePlaceholder(player, command));
-    }
-
-    @Override
-    public @NotNull String getGrantMessage() {
-        return MiniGames.getInstance().getStringFormatter().replacePlaceholder(
-                MiniGameMessage.SUCCESS_COMMAND_REWARDED, "{command}", command);
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("command", command);
-        return data;
-    }
-
-    /**
-     * Replaces the name placeholder in the given input with the given player's name
-     *
-     * @param player <p>The player whose name should be used</p>
-     * @param input  <p>The input containing a name placeholder</p>
-     * @return <p>The input with the placeholder replaced</p>
-     */
-    private String replaceNamePlaceholder(@NotNull Player player, @NotNull String input) {
-        return input.replaceAll("[<%(\\[{]player[_\\-]?(name)?[>%)\\]}]", player.getName());
-    }
-
-    /**
-     * Deserializes the command reward defined in the given data
-     *
-     * @param data <p>The data to deserialize from</p>
-     * @return <p>The deserialized data</p>
-     */
-    @SuppressWarnings("unused")
-    public static CommandReward deserialize(Map<String, Object> data) {
-        return new CommandReward((String) data.get("command"));
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/EconomyReward.java

@@ -1,65 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.manager.EconomyManager;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.logging.Level;
-
-/**
- * A reward that gives an amount of currency when it's granted
- */
-public class EconomyReward implements Reward {
-
-    private final double amount;
-
-    /**
-     * Instantiates a new economy reward
-     *
-     * @param amount <p>The amount of currency granted</p>
-     */
-    public EconomyReward(double amount) {
-        this.amount = amount;
-    }
-
-    @Override
-    public boolean grant(@NotNull Player player) {
-        if (!EconomyManager.isInitialized()) {
-            MiniGames.log(Level.SEVERE, "An economy reward has been set, but no Vault-compatible economy" +
-                    " plugin has been initialized.");
-            return false;
-        }
-        EconomyManager.deposit(player, amount);
-        return true;
-    }
-
-    @Override
-    public @NotNull String getGrantMessage() {
-        return MiniGames.getInstance().getStringFormatter().replacePlaceholder(MiniGameMessage.SUCCESS_ECONOMY_REWARDED,
-                "{currency}", EconomyManager.format(amount));
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("amount", amount);
-        return data;
-    }
-
-    /**
-     * Deserializes the economy reward defined in the given data
-     *
-     * @param data <p>The data to deserialize from</p>
-     * @return <p>The deserialized data</p>
-     */
-    @SuppressWarnings("unused")
-    public static EconomyReward deserialize(Map<String, Object> data) {
-        return new EconomyReward((Double) data.get("amount"));
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/ItemReward.java

@@ -1,108 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.HashMap;
-import java.util.Map;
-
-/**
- * A reward that gives an item stack when granted
- */
-public class ItemReward implements Reward {
-
-    private final ItemStack item;
-
-    /**
-     * Instantiates a new item reward
-     *
-     * @param item <p>The item rewarded</p>
-     */
-    public ItemReward(@NotNull ItemStack item) {
-        if (item.getAmount() > item.getMaxStackSize()) {
-            throw new IllegalArgumentException("Item stack exceeds the maximum stack size");
-        }
-        this.item = item;
-    }
-
-    @Override
-    public boolean grant(@NotNull Player player) {
-        Inventory inventory = player.getInventory();
-        if (canFitItem(inventory)) {
-            inventory.addItem(item);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public @NotNull String getGrantMessage() {
-        return MiniGames.getInstance().getStringFormatter().replacePlaceholders(MiniGameMessage.SUCCESS_ITEM_REWARDED,
-                new String[]{"{amount}", "{item}"}, new String[]{String.valueOf(item.getAmount()),
-                        item.getType().getKey().getKey().replace("_", " ")});
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("item", item);
-        return data;
-    }
-
-    /**
-     * Deserializes the item reward defined in the given data
-     *
-     * @param data <p>The data to deserialize from</p>
-     * @return <p>The deserialized data</p>
-     */
-    @SuppressWarnings("unused")
-    public static ItemReward deserialize(Map<String, Object> data) {
-        return new ItemReward((ItemStack) data.get("item"));
-    }
-
-    /**
-     * Checks whether the given inventory is able to fit this item reward
-     *
-     * @param inventory <p>The inventory to check</p>
-     * @return <p>True if the inventory can fit the item</p>
-     */
-    private boolean canFitItem(Inventory inventory) {
-        // If a slot is available, there is no problem
-        if (inventory.firstEmpty() != -1) {
-            return true;
-        }
-
-        // If the inventory doesn't contain the correct type of item, stacking is impossible
-        if (!inventory.contains(item.getType())) {
-            return false;
-        }
-
-        // Check if the item stack can fit in the inventory if stacked with existing items
-        int availableSlots = 0;
-        for (ItemStack itemStack : inventory.getStorageContents()) {
-            ItemMeta itemMeta = itemStack.getItemMeta();
-            ItemMeta targetMeta = item.getItemMeta();
-            // Skip items of a different type, or with metadata that would prevent stacking
-            if (itemStack.getType() != item.getType() ||
-                    (itemMeta != null && targetMeta != null && !itemMeta.equals(targetMeta))) {
-                continue;
-            }
-
-            availableSlots += itemStack.getMaxStackSize() - itemStack.getAmount();
-
-            if (availableSlots < item.getAmount()) {
-                return true;
-            }
-        }
-
-        return false;
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/PermissionReward.java

@@ -1,85 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.manager.PermissionManager;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.logging.Level;
-
-/**
- * A reward that grants a specified permission when granted
- */
-public class PermissionReward implements Reward {
-
-    private final @NotNull String permission;
-    private final @Nullable World world;
-
-    /**
-     * Instantiates a new permission reward
-     *
-     * @param world      <p>The world to grant the permission for, or null</p>
-     * @param permission <p>The permission to grant</p>
-     */
-    public PermissionReward(@Nullable World world, @NotNull String permission) {
-        this.world = world;
-        this.permission = permission;
-    }
-
-    @Override
-    public boolean grant(@NotNull Player player) {
-        if (!PermissionManager.isInitialized()) {
-            MiniGames.log(Level.SEVERE, "A permission reward has been set, but no Vault-compatible permission" +
-                    " plugin has been initialized.");
-            return false;
-        }
-        if (PermissionManager.hasPermission(player, this.permission, this.world != null ? this.world.getName() : null)) {
-            return false;
-        } else {
-            PermissionManager.addPermission(player, this.permission, this.world);
-            return true;
-        }
-    }
-
-    @Override
-    public @NotNull String getGrantMessage() {
-        if (world == null) {
-            return MiniGames.getInstance().getStringFormatter().replacePlaceholder(
-                    MiniGameMessage.SUCCESS_PERMISSION_REWARDED, "{permission}", permission);
-        } else {
-            return MiniGames.getInstance().getStringFormatter().replacePlaceholders(
-                    MiniGameMessage.SUCCESS_PERMISSION_REWARDED_WORLD, new String[]{"{permission}", "{world}"},
-                    new String[]{permission, world.getName()});
-        }
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        if (world != null) {
-            data.put("world", world);
-        }
-        data.put("permission", permission);
-        return data;
-    }
-
-    /**
-     * Deserializes the permission reward defined in the given data
-     *
-     * @param data <p>The data to deserialize from</p>
-     * @return <p>The deserialized data</p>
-     */
-    @SuppressWarnings("unused")
-    public static PermissionReward deserialize(Map<String, Object> data) {
-        World world = (World) data.getOrDefault("world", null);
-        String permission = (String) data.get("permission");
-        return new PermissionReward(world, permission);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/Reward.java

@@ -1,27 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A reward a player can be awarded
- */
-public interface Reward extends ConfigurationSerializable {
-
-    /**
-     * Grants this reward to the given player
-     *
-     * @param player <p>The player this reward should be granted to</p>
-     * @return <p>True if the item was granted. False if not possible.</p>
-     */
-    boolean grant(@NotNull Player player);
-
-    /**
-     * Gets the message to display to a user when granting this reward
-     *
-     * @return <p>The message to display when this reward is granted</p>
-     */
-    @NotNull String getGrantMessage();
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/RewardCondition.java

@@ -1,83 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Objects;
-
-/**
- * The condition for granting a reward
- */
-public enum RewardCondition implements ConfigurationSerializable {
-
-    /**
-     * The reward is granted each time the player wins/clears the arena
-     */
-    WIN,
-
-    /**
-     * The reward is granted the first time the player wins/clears the arena
-     */
-    FIRST_WIN,
-
-    /**
-     * The reward is granted if the player beats their personal least deaths record
-     */
-    PERSONAL_DEATH_RECORD,
-
-    /**
-     * The reward is granted if the player beats their personal least time record
-     */
-    PERSONAL_TIME_RECORD,
-
-    /**
-     * The reward is granted if the player beats the global least deaths record
-     */
-    GLOBAL_DEATH_RECORD,
-
-    /**
-     * The reward is granted if the player beats the global least time record
-     */
-    GLOBAL_TIME_RECORD,
-    ;
-
-    /**
-     * Gets a reward condition from the given string
-     *
-     * @param condition <p>The string specifying a reward condition</p>
-     * @return <p>The matching reward condition, or null if not found</p>
-     */
-    public static @Nullable RewardCondition getFromString(@NotNull String condition) {
-        for (RewardCondition rewardCondition : RewardCondition.values()) {
-            if (rewardCondition.name().equalsIgnoreCase(condition.replace("-", "_"))) {
-                return rewardCondition;
-            }
-        }
-
-        return null;
-    }
-
-    @NotNull
-    @Override
-    public Map<String, Object> serialize() {
-        Map<String, Object> data = new HashMap<>();
-        data.put("condition", this.name());
-        return data;
-    }
-
-    /**
-     * Deserializes a reward condition from the given data
-     *
-     * @param data <p>The data to deserialize</p>
-     * @return <p>The deserialized reward condition</p>
-     */
-    @SuppressWarnings({"unused"})
-    public static @NotNull RewardCondition deserialize(@NotNull Map<String, Object> data) {
-        RewardCondition rewardCondition = getFromString(String.valueOf(data.get("condition")));
-        return Objects.requireNonNullElse(rewardCondition, RewardCondition.FIRST_WIN);
-    }
-
-}

src/main/java/net/knarcraft/minigames/arena/reward/RewardType.java

@@ -1,47 +0,0 @@
-package net.knarcraft.minigames.arena.reward;
-
-import org.jetbrains.annotations.NotNull;
-
-/**
- * The type of a specific reward
- */
-public enum RewardType {
-
-    /**
-     * A command reward
-     */
-    COMMAND,
-
-    /**
-     * An economy reward
-     */
-    ECONOMY,
-
-    /**
-     * An item reward
-     */
-    ITEM,
-
-    /**
-     * A permission reward
-     */
-    PERMISSION,
-    ;
-
-    /**
-     * Gets a reward type from the given string
-     *
-     * @param condition <p>The string specifying a reward type</p>
-     * @return <p>The matching reward type, or null if not found</p>
-     */
-    public static RewardType getFromString(@NotNull String condition) {
-        for (RewardType rewardType : RewardType.values()) {
-            if (rewardType.name().equalsIgnoreCase(condition.replace("-", "_"))) {
-                return rewardType;
-            }
-        }
-
-        return null;
-    }
-
-}

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

@@ -1,51 +0,0 @@
-package net.knarcraft.minigames.command;
-
-import net.knarcraft.minigames.arena.ArenaGameMode;
-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;
-import java.util.function.Supplier;
-
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
-/**
- * An abstract class for an arena joining tab-completer
- */
-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 filterMatchingContains(arenaNameSupplier.get(), arguments[0]);
-        } else if (arguments.length == 2) {
-            List<String> gameModes = new ArrayList<>();
-            for (ArenaGameMode gameMode : gameMode.getValues()) {
-                gameModes.add(gameMode.name().toLowerCase());
-            }
-            return filterMatchingContains(gameModes, arguments[1]);
-        } else {
-            return new ArrayList<>();
-        }
-    }
-
-}

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

@@ -1,41 +0,0 @@
-package net.knarcraft.minigames.command;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.GUIHelper;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.command.TabExecutor;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.ArrayList;
-import java.util.List;
-
-/**
- * The command for opening up an arena's menu
- */
-public class MenuCommand implements TabExecutor {
-
-    @Override
-    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
-                             @NotNull String[] arguments) {
-        if (!(commandSender instanceof Player player)) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_PLAYER_ONLY);
-            return false;
-        }
-
-        GUIHelper.openGUI(player);
-        return true;
-    }
-
-    @Nullable
-    @Override
-    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
-                                      @NotNull String[] strings) {
-        return new ArrayList<>();
-    }
-
-}

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

@@ -1,90 +0,0 @@
-package net.knarcraft.minigames.command;
-
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.Arena;
-import net.knarcraft.minigames.arena.reward.Reward;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.RewardHelper;
-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.Arrays;
-
-/**
- * The command used for setting arena rewards
- */
-public class SetArenaRewardCommand implements CommandExecutor {
-
-    @Override
-    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
-                             @NotNull String[] arguments) {
-        if (!(commandSender instanceof Player player)) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_PLAYER_ONLY);
-            return false;
-        }
-
-        if (arguments.length < 4) {
-            return false;
-        }
-        
-        /*
-        
-        /MiniGamesReward add dropper <name> <condition> <type> [data]
-        /MiniGamesReward add parkour <name> <condition> <type> [data]
-        /MiniGamesReward clear dropper <name> <condition>
-        /MiniGamesReward clear parkour <name> <condition>
-        
-         */
-
-        Arena arena = null;
-        if (arguments[1].equalsIgnoreCase("dropper")) {
-            arena = MiniGames.getInstance().getDropperArenaHandler().getArena(arguments[2]);
-        } else if (arguments[1].equalsIgnoreCase("parkour")) {
-            arena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[2]);
-        }
-        if (arena == null) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(commandSender,
-                    MiniGameMessage.ERROR_ARENA_NOT_FOUND);
-            return false;
-        }
-
-        RewardCondition condition = RewardCondition.getFromString(arguments[3]);
-        if (condition == null) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(player,
-                    MiniGameMessage.ERROR_REWARD_CONDITION_INVALID);
-            return false;
-        }
-
-        if (arguments[0].equalsIgnoreCase("clear")) {
-            arena.clearRewards(condition);
-            MiniGames.getInstance().getStringFormatter().displaySuccessMessage(player,
-                    MiniGameMessage.SUCCESS_REWARDS_CLEARED);
-            return true;
-        }
-
-        if (!arguments[0].equalsIgnoreCase("add") || arguments.length < 5) {
-            return false;
-        }
-
-        String firstArgument = arguments.length > 5 ? arguments[5] : null;
-        String secondArgument = arguments.length > 6 ? arguments[6] : null;
-
-        Reward reward = RewardHelper.parseRewardInput(player, arguments[4], firstArgument, secondArgument,
-                Arrays.copyOfRange(arguments, 5, arguments.length));
-
-        if (reward != null) {
-            arena.addReward(condition, reward);
-            MiniGames.getInstance().getStringFormatter().displaySuccessMessage(player,
-                    MiniGameMessage.SUCCESS_REWARD_ADDED);
-            return true;
-        } else {
-            return false;
-        }
-    }
-
-}

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

@@ -1,168 +0,0 @@
-package net.knarcraft.minigames.command;
-
-import net.knarcraft.knarlib.util.MaterialHelper;
-import net.knarcraft.knarlib.util.TabCompletionHelper;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.Arena;
-import net.knarcraft.minigames.arena.reward.RewardCondition;
-import net.knarcraft.minigames.arena.reward.RewardType;
-import net.knarcraft.minigames.util.TabCompleteHelper;
-import org.bukkit.Material;
-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.Arrays;
-import java.util.EnumSet;
-import java.util.List;
-import java.util.Set;
-
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingStartsWith;
-
-/**
- * The tab completer for the reward setting command
- */
-public class SetArenaRewardTabCompleter implements TabCompleter {
-
-    private static final List<String> materials = getMaterials();
-
-    @Nullable
-    @Override
-    public List<String> onTabComplete(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
-                                      @NotNull String[] arguments) {
-        if (arguments.length == 1) {
-            // The first argument is either clear or add
-            return TabCompletionHelper.filterMatchingStartsWith(Arrays.asList("add", "clear"), arguments[0]);
-        }
-        if (arguments.length >= 2) {
-            // If the first argument is invalid, stop further tab completion
-            if (!arguments[0].equalsIgnoreCase("add") && !arguments[0].equalsIgnoreCase("clear")) {
-                return new ArrayList<>();
-            }
-        }
-        if (arguments.length == 2) {
-            // The second argument is the type of arena to change rewards for
-            return TabCompletionHelper.filterMatchingStartsWith(Arrays.asList("dropper", "parkour"), arguments[1]);
-        } else if (arguments.length == 3) {
-            // The third argument is the name of the arena to change rewards for
-            if (arguments[1].equalsIgnoreCase("dropper")) {
-                return filterMatchingContains(TabCompleteHelper.getDropperArenas(), arguments[2]);
-            } else if (arguments[1].equalsIgnoreCase("parkour")) {
-                return filterMatchingContains(TabCompleteHelper.getParkourArenas(), arguments[2]);
-            }
-        }
-        if (arguments.length >= 4) {
-            // Make sure a valid dropper or arena name has been given
-            Arena arena = null;
-            if (arguments[1].equalsIgnoreCase("dropper")) {
-                arena = MiniGames.getInstance().getDropperArenaHandler().getArena(arguments[2]);
-            } else if (arguments[1].equalsIgnoreCase("parkour")) {
-                arena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[2]);
-            }
-            if (arena == null) {
-                return new ArrayList<>();
-            }
-        }
-        if (arguments.length == 4) {
-            // The fourth argument is the condition to change the reward for
-            return filterMatchingContains(getRewardConditions(), arguments[3]);
-        }
-        if (arguments.length >= 5) {
-            // If the condition is invalid, or it's the clear action, stop tab-completion
-            if (RewardCondition.getFromString(arguments[3]) == null ||
-                    arguments[0].equalsIgnoreCase("clear")) {
-                return new ArrayList<>();
-            }
-        }
-        if (arguments.length == 5) {
-            // The fifth argument is the type of reward to grant
-            return filterMatchingContains(getRewardTypes(), arguments[4]);
-        }
-        if (arguments.length >= 6) {
-            // Make sure a valid reward type has been given
-            RewardType rewardType = RewardType.getFromString(arguments[4]);
-            if (rewardType == null) {
-                return new ArrayList<>();
-            }
-
-            if (arguments.length == 6) {
-                return switch (rewardType) {
-                    case ITEM -> filterMatchingContains(materials, arguments[5]);
-                    case PERMISSION -> TabCompleteHelper.tabCompletePermission(arguments[5]);
-                    case ECONOMY -> filterMatchingStartsWith(Arrays.asList("1", "5", "10", "25", "50"), arguments[5]);
-                    case COMMAND -> filterMatchingStartsWith(getCommands(), arguments[5]);
-                };
-            }
-
-            if (rewardType == RewardType.ITEM && arguments.length == 7) {
-                // If a valid item material has been given, give potential amounts
-                if (MaterialHelper.loadMaterialString(arguments[5], MiniGames.getInstance().getLogger()) == null) {
-                    return new ArrayList<>();
-                }
-                return Arrays.asList("1", "5", "10", "16", "32", "48", "64");
-            }
-        }
-        return new ArrayList<>();
-    }
-
-    /**
-     * Gets example command rewards
-     *
-     * @return <p>Example command rewards</p>
-     */
-    private static List<String> getCommands() {
-        List<String> commands = new ArrayList<>();
-        commands.add("f powerboost player add %player% 1");
-        commands.add("minecraft:xp give (player_name) 1000");
-        return commands;
-    }
-
-    /**
-     * Gets all materials grant-able as item rewards
-     *
-     * @return <p>All grant-able materials</p>
-     */
-    private static List<String> getMaterials() {
-        List<String> materials = new ArrayList<>();
-        Set<Material> invalid = EnumSet.of(Material.WATER, Material.LAVA, Material.POWDER_SNOW);
-        for (Material material : Material.values()) {
-            if (material.isAir() || invalid.contains(material) || (material.isBlock() &&
-                    (material.getHardness() == -1 || material.getHardness() == Double.MAX_VALUE))) {
-                continue;
-            }
-            materials.add(material.name());
-        }
-        return materials;
-    }
-
-    /**
-     * Gets a list of all reward types
-     *
-     * @return <p>All reward types</p>
-     */
-    private List<String> getRewardTypes() {
-        List<String> types = new ArrayList<>();
-        for (RewardType rewardType : RewardType.values()) {
-            types.add(rewardType.name());
-        }
-        return types;
-    }
-
-    /**
-     * Gets a list of all reward conditions
-     *
-     * @return <p>All reward conditions</p>
-     */
-    private List<String> getRewardConditions() {
-        List<String> conditions = new ArrayList<>();
-        for (RewardCondition rewardCondition : RewardCondition.values()) {
-            conditions.add(rewardCondition.name());
-        }
-        return conditions;
-    }
-
-}

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

@@ -1,40 +0,0 @@
-package net.knarcraft.minigames.command.dropper;
-
-import net.knarcraft.minigames.arena.dropper.DropperArenaEditableProperty;
-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;
-
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
-/**
- * The tab-completer for the edit arena command
- */
-public class EditDropperArenaTabCompleter implements TabCompleter {
-
-    @Override
-    public @Nullable List<String> onTabComplete(@NotNull CommandSender sender, @NotNull Command command,
-                                                @NotNull String label, @NotNull String[] arguments) {
-        if (arguments.length == 1) {
-            return filterMatchingContains(TabCompleteHelper.getDropperArenas(), arguments[0]);
-        } else if (arguments.length == 2) {
-            return filterMatchingContains(TabCompleteHelper.getDropperArenaProperties(), arguments[1]);
-        } else if (arguments.length == 3) {
-            DropperArenaEditableProperty property = DropperArenaEditableProperty.getFromArgumentString(arguments[1]);
-            if (property == null) {
-                return new ArrayList<>();
-            }
-            return filterMatchingContains(TabCompleteHelper.getTabCompleteSuggestions(property.getPropertyType()),
-                    arguments[2]);
-        } else {
-            return new ArrayList<>();
-        }
-    }
-
-}

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

@@ -1,145 +0,0 @@
-package net.knarcraft.minigames.command.dropper;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaPlayerRegistry;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGameMode;
-import net.knarcraft.minigames.arena.dropper.DropperArenaGroup;
-import net.knarcraft.minigames.arena.dropper.DropperArenaSession;
-import net.knarcraft.minigames.config.DropperConfiguration;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.util.GUIHelper;
-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 dropper arena
- */
-public class JoinDropperArenaCommand implements CommandExecutor {
-
-    @Override
-    public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
-                             @NotNull String[] arguments) {
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        if (!(commandSender instanceof Player player)) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_PLAYER_ONLY);
-            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) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ALREADY_PLAYING);
-            return true;
-        }
-
-        // Make sure the arena exists
-        DropperArena specifiedArena = MiniGames.getInstance().getDropperArenaHandler().getArena(arguments[0]);
-        if (specifiedArena == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_NOT_FOUND);
-            return false;
-        }
-
-        // Deny vehicles as allowing this is tricky, and will cause problems in some cases
-        if (player.isInsideVehicle() || !player.getPassengers().isEmpty()) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_JOIN_IN_VEHICLE_OR_PASSENGER);
-            return true;
-        }
-
-        joinArena(specifiedArena, player, arguments);
-        return true;
-    }
-
-    /**
-     * 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>
-     */
-    private void joinArena(DropperArena specifiedArena, Player player, String[] arguments) {
-        // Find the specified game-mode
-        DropperArenaGameMode gameMode;
-        if (arguments.length > 1) {
-            gameMode = DropperArenaGameMode.matchGameMode(arguments[1]);
-        } else {
-            gameMode = DropperArenaGameMode.DEFAULT;
-        }
-
-        // Make sure the player has beaten the necessary levels
-        DropperArenaGroup arenaGroup = MiniGames.getInstance().getDropperArenaHandler().getGroup(specifiedArena.getArenaId());
-        if (arenaGroup != null && !doGroupChecks(specifiedArena, arenaGroup, gameMode, player)) {
-            return;
-        }
-
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-
-        // Make sure the player has beaten the arena once in normal mode before playing another mode
-        if (MiniGames.getInstance().getDropperConfiguration().mustDoNormalModeFirst() &&
-                gameMode != DropperArenaGameMode.DEFAULT &&
-                specifiedArena.getData().hasNotCompleted(DropperArenaGameMode.DEFAULT, player)) {
-            stringFormatter.displayErrorMessage(player, MiniGameMessage.ERROR_NORMAL_MODE_REQUIRED);
-            return;
-        }
-
-        // Register the player's session
-        DropperArenaSession newSession = new DropperArenaSession(specifiedArena, player, gameMode);
-        ArenaPlayerRegistry<DropperArena> playerRegistry = MiniGames.getInstance().getDropperArenaPlayerRegistry();
-        playerRegistry.registerPlayer(player.getUniqueId(), newSession);
-
-        // Update visibility and hit-box for the player
-        MiniGames.getInstance().getPlayerVisibilityManager().updateHiddenPlayers(playerRegistry, player);
-
-        // Try to teleport the player to the arena
-        boolean teleported = PlayerTeleporter.teleportPlayer(player, specifiedArena.getSpawnLocation(), false, false);
-        if (!teleported) {
-            stringFormatter.displayErrorMessage(player, MiniGameMessage.ERROR_ARENA_TELEPORT_FAILED);
-            newSession.triggerQuit(false, true);
-        } else {
-            // Update the player's state to follow the arena's rules
-            newSession.getEntryState().setArenaState();
-
-            player.getInventory().addItem(GUIHelper.getGUIOpenItem());
-            stringFormatter.displaySuccessMessage(player, MiniGameMessage.SUCCESS_ARENA_JOINED);
-        }
-    }
-
-    /**
-     * Performs necessary check for the given arena's group
-     *
-     * @param dropperArena  <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 DropperArena dropperArena, @NotNull DropperArenaGroup arenaGroup,
-                                  @NotNull DropperArenaGameMode arenaGameMode, @NotNull Player player) {
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        DropperConfiguration configuration = MiniGames.getInstance().getDropperConfiguration();
-        // Require that players beat all arenas in the group in the normal game-mode before trying challenge modes
-        if (configuration.mustDoNormalModeFirst() && arenaGameMode != DropperArenaGameMode.DEFAULT &&
-                !arenaGroup.hasBeatenAll(DropperArenaGameMode.DEFAULT, player)) {
-            stringFormatter.displayErrorMessage(player, MiniGameMessage.ERROR_GROUP_NORMAL_MODE_REQUIRED);
-            return false;
-        }
-
-        // Require that the player has beaten the previous arena on the same game-mode before trying this one
-        if (configuration.mustDoGroupedInSequence() &&
-                arenaGroup.cannotPlay(arenaGameMode, player, dropperArena.getArenaId())) {
-            stringFormatter.displayErrorMessage(player, MiniGameMessage.ERROR_PREVIOUS_ARENA_REQUIRED);
-            return false;
-        }
-
-        return true;
-    }
-
-}

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

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

@@ -1,40 +0,0 @@
-package net.knarcraft.minigames.command.dropper;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.dropper.DropperArena;
-import net.knarcraft.minigames.config.MiniGameMessage;
-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 RemoveDropperArenaCommand 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;
-        }
-
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-
-        // Get the specified arena
-        DropperArena targetArena = MiniGames.getInstance().getDropperArenaHandler().getArena(arguments[0]);
-        if (targetArena == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_NOT_FOUND);
-            return false;
-        }
-
-        // Remove the arena
-        MiniGames.getInstance().getDropperArenaHandler().removeArena(targetArena);
-        stringFormatter.displaySuccessMessage(commandSender, MiniGameMessage.SUCCESS_ARENA_REMOVED);
-        return true;
-    }
-
-}

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

@@ -1,31 +0,0 @@
-package net.knarcraft.minigames.command.dropper;
-
-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;
-
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
-/**
- * The tab-completer for the remove arena command
- */
-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 filterMatchingContains(TabCompleteHelper.getDropperArenas(), arguments[0]);
-        } else {
-            return new ArrayList<>();
-        }
-    }
-
-}

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

@@ -1,55 +0,0 @@
-package net.knarcraft.minigames.command.parkour;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.parkour.ParkourArena;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaHandler;
-import net.knarcraft.minigames.config.MiniGameMessage;
-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) {
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        if (!(commandSender instanceof Player player)) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_PLAYER_ONLY);
-            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) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_NAME_COLLISION);
-            return false;
-        }
-
-        ParkourArena arena = new ParkourArena(arenaName, player.getLocation(), arenaHandler);
-        arenaHandler.addArena(arena);
-        stringFormatter.displaySuccessMessage(commandSender, MiniGameMessage.SUCCESS_ARENA_CREATED);
-        return true;
-    }
-
-}

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

@@ -1,139 +0,0 @@
-package net.knarcraft.minigames.command.parkour;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.parkour.ParkourArena;
-import net.knarcraft.minigames.arena.parkour.ParkourArenaEditableProperty;
-import net.knarcraft.minigames.config.MiniGameMessage;
-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) {
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        if (!(commandSender instanceof Player player)) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_PLAYER_ONLY);
-            return false;
-        }
-
-        if (arguments.length < 2) {
-            return false;
-        }
-
-        ParkourArena specifiedArena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[0]);
-        if (specifiedArena == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_NOT_FOUND);
-            return false;
-        }
-
-        ParkourArenaEditableProperty editableProperty = ParkourArenaEditableProperty.getFromArgumentString(arguments[1]);
-        if (editableProperty == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_UNKNOWN_PROPERTY);
-            return false;
-        }
-
-        if (arguments.length < 3) {
-            // Print the current value of the property
-            String value = editableProperty.getCurrentValueAsString(specifiedArena);
-            stringFormatter.displaySuccessMessage(commandSender, stringFormatter.replacePlaceholders(
-                    MiniGameMessage.SUCCESS_CURRENT_VALUE, new String[]{"{property}", "{value}"},
-                    new String[]{editableProperty.getArgumentString(), value}));
-            return true;
-        } else {
-            boolean successful;
-            try {
-                successful = changeValue(specifiedArena, editableProperty, arguments[2], player);
-            } catch (NumberFormatException exception) {
-                successful = false;
-            }
-            if (successful) {
-                stringFormatter.displaySuccessMessage(player, stringFormatter.replacePlaceholder(
-                        MiniGameMessage.SUCCESS_PROPERTY_CHANGED, "{property}",
-                        editableProperty.getArgumentString()));
-            } else {
-                stringFormatter.displayErrorMessage(player, MiniGameMessage.ERROR_PROPERTY_INPUT_INVALID);
-            }
-            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>
-     * @throws NumberFormatException <p>If unable to parse a given numeric value</p>
-     */
-    private boolean changeValue(@NotNull ParkourArena arena, @NotNull ParkourArenaEditableProperty property,
-                                @NotNull String value, @NotNull Player player) throws NumberFormatException {
-        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(","))));
-            case OBSTACLE_BLOCKS -> arena.setObstacleBlocks(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

@@ -1,40 +0,0 @@
-package net.knarcraft.minigames.command.parkour;
-
-import net.knarcraft.minigames.arena.parkour.ParkourArenaEditableProperty;
-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;
-
-import static net.knarcraft.knarlib.util.TabCompletionHelper.filterMatchingContains;
-
-/**
- * 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[] arguments) {
-        if (arguments.length == 1) {
-            return filterMatchingContains(TabCompleteHelper.getParkourArenas(), arguments[0]);
-        } else if (arguments.length == 2) {
-            return filterMatchingContains(TabCompleteHelper.getParkourArenaProperties(), arguments[1]);
-        } else if (arguments.length == 3) {
-            ParkourArenaEditableProperty property = ParkourArenaEditableProperty.getFromArgumentString(arguments[1]);
-            if (property == null) {
-                return new ArrayList<>();
-            }
-            return filterMatchingContains(TabCompleteHelper.getTabCompleteSuggestions(property.getPropertyType()),
-                    arguments[2]);
-        } else {
-            return new ArrayList<>();
-        }
-    }
-
-}

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

@@ -1,138 +0,0 @@
-package net.knarcraft.minigames.command.parkour;
-
-import net.knarcraft.knarlib.formatting.StringFormatter;
-import net.knarcraft.minigames.MiniGames;
-import net.knarcraft.minigames.arena.ArenaPlayerRegistry;
-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.ParkourArenaSession;
-import net.knarcraft.minigames.config.MiniGameMessage;
-import net.knarcraft.minigames.config.ParkourConfiguration;
-import net.knarcraft.minigames.util.GUIHelper;
-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) {
-        StringFormatter stringFormatter = MiniGames.getInstance().getStringFormatter();
-        if (!(commandSender instanceof Player player)) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_PLAYER_ONLY);
-            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) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ALREADY_PLAYING);
-            return true;
-        }
-
-        // Make sure the arena exists
-        ParkourArena specifiedArena = MiniGames.getInstance().getParkourArenaHandler().getArena(arguments[0]);
-        if (specifiedArena == null) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_ARENA_NOT_FOUND);
-            return false;
-        }
-
-        // Deny vehicles as allowing this is tricky, and will cause problems in some cases
-        if (player.isInsideVehicle() || !player.getPassengers().isEmpty()) {
-            stringFormatter.displayErrorMessage(commandSender, MiniGameMessage.ERROR_JOIN_IN_VEHICLE_OR_PASSENGER);
-            return true;
-        }
-
-        joinArena(specifiedArena, player, arguments);
-        return true;
-    }
-
-    /**
-     * 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>
-     */
-    private void 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;
-        }
-
-        // Don't allow joining the hardcore game-mode if there are no checkpoints to skip
-        if (specifiedArena.hasNoCheckpoints() && gameMode == ParkourArenaGameMode.HARDCORE) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(player,
-                    MiniGameMessage.ERROR_HARDCORE_NO_CHECKPOINTS);
-            return;
-        }
-
-        // 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;
-        }
-
-        // Register the player's session
-        ParkourArenaSession newSession = new ParkourArenaSession(specifiedArena, player, gameMode);
-        ArenaPlayerRegistry<ParkourArena> playerRegistry = MiniGames.getInstance().getParkourArenaPlayerRegistry();
-        playerRegistry.registerPlayer(player.getUniqueId(), newSession);
-
-        // Update visibility and hit-box for the player
-        MiniGames.getInstance().getPlayerVisibilityManager().updateHiddenPlayers(playerRegistry, player);
-
-        // Try to teleport the player to the arena
-        boolean teleported = PlayerTeleporter.teleportPlayer(player, specifiedArena.getSpawnLocation(), false, false);
-        if (!teleported) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(player,
-                    MiniGameMessage.ERROR_ARENA_TELEPORT_FAILED);
-            newSession.triggerQuit(false, true);
-        } else {
-            // Update the player's state to follow the arena's rules
-            newSession.getEntryState().setArenaState();
-
-            player.getInventory().addItem(GUIHelper.getGUIOpenItem());
-            MiniGames.getInstance().getStringFormatter().displaySuccessMessage(player,
-                    MiniGameMessage.SUCCESS_ARENA_JOINED);
-        }
-    }
-
-    /**
-     * 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.cannotPlay(arenaGameMode, player, parkourArena.getArenaId())) {
-            MiniGames.getInstance().getStringFormatter().displayErrorMessage(player,
-                    MiniGameMessage.ERROR_PREVIOUS_ARENA_REQUIRED);
-            return false;
-        }
-
-        return true;
-    }
-
-}