Finishes the edit command #9

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

@@ -1,8 +1,10 @@
 package net.knarcraft.dropper.arena;
 
+import net.knarcraft.dropper.Dropper;
 import net.knarcraft.dropper.util.ArenaStorageHelper;
 import org.bukkit.Location;
 import org.bukkit.Material;
+import org.bukkit.World;
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
@@ -22,42 +24,42 @@ public class DropperArena {
     /**
      * A name used when listing and storing this arena.
      */
-    private final @NotNull String arenaName;
+    private @NotNull String arenaName;
 
     /**
      * The location players are teleported to when joining this arena.
      */
-    private final @NotNull Location spawnLocation;
+    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 final @Nullable Location exitLocation;
+    private @Nullable Location exitLocation;
 
     /**
      * The velocity in the y-direction to apply to all players in this arena.
      */
-    private final double playerVerticalVelocity;
+    private double playerVerticalVelocity;
 
     /**
      * The velocity in the x-direction to apply to all players in this arena
      *
      * <p>This is technically the fly speed</p>
      */
-    private final float playerHorizontalVelocity;
+    private float playerHorizontalVelocity;
 
     /**
      * The material of the block players have to hit to win this dropper arena
      */
-    private final @NotNull Material winBlockType;
+    private @NotNull Material winBlockType;
 
     /**
      * The arena data for this arena
      */
     private final DropperArenaData dropperArenaData;
 
-    //TODO: It should be possible to get records in sorted order (smallest to largest)
+    private static DropperArenaHandler dropperArenaHandler = null;
 
     /**
      * Instantiates a new dropper arena
@@ -82,6 +84,10 @@ public class DropperArena {
         this.playerHorizontalVelocity = playerHorizontalVelocity;
         this.winBlockType = winBlockType;
         this.dropperArenaData = dropperArenaData;
+
+        if (dropperArenaHandler == null) {
+            dropperArenaHandler = Dropper.getInstance().getArenaHandler();
+        }
     }
 
     /**
@@ -193,6 +199,109 @@ public class DropperArena {
         return ArenaStorageHelper.sanitizeArenaName(this.getArenaName());
     }
 
+    /**
+     * 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;
+            dropperArenaHandler.saveArenas();
+            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;
+            dropperArenaHandler.saveArenas();
+            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
+            dropperArenaHandler.updateLookupName(oldName, this.getArenaNameSanitized());
+            dropperArenaHandler.saveArenas();
+            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;
+            dropperArenaHandler.saveArenas();
+            return true;
+        }
+    }
+
+    /**
+     * Sets the horizontal velocity of this arena's players
+     *
+     * <p>Note: It's assumed the given value is already bound-checked! (-1 to 1)</p>
+     *
+     * @param horizontalVelocity <p>The horizontal velocity to use</p>
+     * @return <p>True if successfully updated</p>
+     */
+    public boolean setHorizontalVelocity(float horizontalVelocity) {
+        if (horizontalVelocity < -1 || horizontalVelocity > 1) {
+            return false;
+        } else {
+            this.playerHorizontalVelocity = horizontalVelocity;
+            dropperArenaHandler.saveArenas();
+            return true;
+        }
+    }
+
+    /**
+     * Sets the vertical velocity of this arena's players
+     *
+     * @param verticalVelocity <p>The vertical velocity to use</p>
+     * @return <p>True if successfully updated</p>
+     */
+    public boolean setVerticalVelocity(double verticalVelocity) {
+        if (verticalVelocity <= 0 || verticalVelocity > 100) {
+            return false;
+        } else {
+            this.playerVerticalVelocity = verticalVelocity;
+            dropperArenaHandler.saveArenas();
+            return true;
+        }
+    }
+
     @Override
     public boolean equals(Object other) {
         if (!(other instanceof DropperArena otherArena)) {
@@ -201,4 +310,15 @@ public class DropperArena {
         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/DropperArenaHandler.java

@@ -72,6 +72,19 @@ public class DropperArenaHandler {
         }
     }
 
+    /**
+     * Replaces an arena's lookup name
+     *
+     * @param oldName <p>The arena's old sanitized lookup name</p>
+     * @param newName <p>The arena's new sanitized lookup name</p>
+     */
+    public void updateLookupName(@NotNull String oldName, @NotNull String newName) {
+        UUID arenaId = this.arenaNameLookup.remove(oldName);
+        if (arenaId != null) {
+            this.arenaNameLookup.put(newName, arenaId);
+        }
+    }
+
     /**
      * Adds a new arena
      *

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

@@ -25,7 +25,7 @@ public class PlayerEntryState {
      */
     public PlayerEntryState(Player player) {
         this.player = player;
-        this.entryLocation = player.getLocation();
+        this.entryLocation = player.getLocation().clone();
         this.originalFlySpeed = player.getFlySpeed();
         this.originalIsFlying = player.isFlying();
         this.originalGameMode = player.getGameMode();

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

@@ -3,6 +3,8 @@ package net.knarcraft.dropper.command;
 import net.knarcraft.dropper.Dropper;
 import net.knarcraft.dropper.arena.DropperArena;
 import net.knarcraft.dropper.property.ArenaEditableProperty;
+import org.bukkit.Location;
+import org.bukkit.Material;
 import org.bukkit.command.Command;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.CommandSender;
@@ -17,7 +19,7 @@ public class EditArenaCommand implements CommandExecutor {
     @Override
     public boolean onCommand(@NotNull CommandSender commandSender, @NotNull Command command, @NotNull String s,
                              @NotNull String[] arguments) {
-        if (!(commandSender instanceof Player)) {
+        if (!(commandSender instanceof Player player)) {
             commandSender.sendMessage("This command must be used by a player");
             return false;
         }
@@ -44,10 +46,115 @@ public class EditArenaCommand implements CommandExecutor {
             // Print the current value of the property
             String value = editableProperty.getCurrentValueAsString(specifiedArena);
             commandSender.sendMessage(String.format(currentValueFormat, editableProperty.getArgumentString(), value));
+            return true;
         } else {
-            // TODO: Expect a new value for the option, which needs to be validated, and possibly set
+            boolean successful = changeValue(specifiedArena, editableProperty, arguments[2], player);
+            if (successful) {
+                player.sendMessage(String.format("Property %s changed to: %s", editableProperty, arguments[2]));
+            } else {
+                player.sendMessage("Unable to change the property. Make sure your input is valid!");
+            }
+            return successful;
         }
-        return true;
+    }
+
+    /**
+     * Changes the given property to the given value
+     *
+     * @param arena    <p>The arena to change the property for</p>
+     * @param property <p>The property to change</p>
+     * @param value    <p>The new value of the property</p>
+     * @param player   <p>The player trying to change the value</p>
+     * @return <p>True if the value was successfully changed</p>
+     */
+    private boolean changeValue(@NotNull DropperArena arena, @NotNull ArenaEditableProperty property,
+                                @NotNull String value, @NotNull Player player) {
+        return switch (property) {
+            case WIN_BLOCK_TYPE -> arena.setWinBlockType(parseMaterial(value));
+            case HORIZONTAL_VELOCITY -> arena.setHorizontalVelocity(sanitizeHorizontalVelocity(value));
+            case VERTICAL_VELOCITY -> arena.setVerticalVelocity(sanitizeVerticalVelocity(value));
+            case SPAWN_LOCATION -> arena.setSpawnLocation(parseLocation(player, value));
+            case NAME -> arena.setName(value);
+            case EXIT_LOCATION -> arena.setExitLocation(parseLocation(player, value));
+        };
+    }
+
+    /**
+     * Sanitizes the player's specified vertical velocity
+     *
+     * @param velocityString <p>The string to parse into a velocity</p>
+     * @return <p>The parsed velocity, defaulting to 0.5 if not parse-able</p>
+     */
+    private double sanitizeVerticalVelocity(@NotNull String velocityString) {
+        // Vertical velocity should not be negative, as it would make the player go upwards. There is technically not a
+        // max speed limit, but setting it too high makes the arena unplayable
+        double velocity;
+        try {
+            velocity = Double.parseDouble(velocityString);
+        } catch (NumberFormatException exception) {
+            velocity = 0.5;
+        }
+
+        // Require at least speed of 0.001, and at most 75 blocks/s
+        return Math.min(Math.max(velocity, 0.001), 75);
+    }
+
+    /**
+     * Sanitizes the user's specified horizontal velocity
+     *
+     * @param velocityString <p>The string to parse into a velocity</p>
+     * @return <p>The parsed velocity, defaulting to 1 if not parse-able</p>
+     */
+    private float sanitizeHorizontalVelocity(@NotNull String velocityString) {
+        // Horizontal velocity is valid between -1 and 1, where negative values swaps directions
+        float velocity;
+        try {
+            velocity = Float.parseFloat(velocityString);
+        } catch (NumberFormatException exception) {
+            velocity = 1;
+        }
+
+        // Make sure the velocity isn't exactly 0
+        if (velocity == 0) {
+            velocity = 0.5f;
+        }
+
+        // If outside bonds, choose the most extreme value
+        return Math.min(Math.max(-1, velocity), 1);
+    }
+
+    /**
+     * 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/resources/plugin.yml

@@ -37,7 +37,9 @@ commands:
     aliases:
       - dcreate
     permission: dropper.create
-    usage: /<command> (Details not finalized)
+    usage: |
+      /<command> <arena> <property> [new value]
+      Valid properties: name, spawnLocation, exitLocation, verticalVelocity, horizontalVelocity, winBlockType
     description: Used to create a new dropper arena
   dropperedit:
     aliases: