Generifies arena records, and prepares for PlaceholderAPI

pom.xml

@@ -58,6 +58,10 @@
             <id>spigot-repo</id>
             <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
         </repository>
+        <repository>
+            <id>placeholderapi</id>
+            <url>https://repo.extendedclip.com/content/repositories/placeholderapi/</url>
+        </repository>
     </repositories>
 
     <dependencies>
@@ -79,5 +83,11 @@
             <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>
     </dependencies>
 </project>

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

@@ -1,5 +1,6 @@
 package net.knarcraft.dropper;
 
+import net.knarcraft.dropper.arena.ArenaRecord;
 import net.knarcraft.dropper.arena.DropperArenaData;
 import net.knarcraft.dropper.arena.DropperArenaGroup;
 import net.knarcraft.dropper.arena.DropperArenaHandler;
@@ -25,7 +26,9 @@ 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.RecordExpansion;
 import net.knarcraft.dropper.property.ArenaGameMode;
+import org.bukkit.Bukkit;
 import org.bukkit.command.CommandExecutor;
 import org.bukkit.command.PluginCommand;
 import org.bukkit.command.TabCompleter;
@@ -94,6 +97,7 @@ public final class Dropper extends JavaPlugin {
         ConfigurationSerialization.registerClass(DropperArenaData.class);
         ConfigurationSerialization.registerClass(DropperArenaGroup.class);
         ConfigurationSerialization.registerClass(ArenaGameMode.class);
+        ConfigurationSerialization.registerClass(ArenaRecord.class);
     }
 
     @Override
@@ -121,6 +125,12 @@ public final class Dropper extends JavaPlugin {
         registerCommand("dropperGroupSet", new GroupSetCommand(), null);
         registerCommand("dropperGroupSwap", new GroupSwapCommand(), null);
         registerCommand("dropperGroupList", new GroupListCommand(), null);
+
+        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
+            if (!new RecordExpansion(this).register()) {
+                getLogger().log(Level.WARNING, "Unable to register PlaceholderAPI expansion!");
+            }
+        }
     }
 
     @Override

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

@@ -0,0 +1,52 @@
+package net.knarcraft.dropper.arena;
+
+import net.knarcraft.dropper.container.SerializableUUID;
+import org.bukkit.configuration.serialization.ConfigurationSerializable;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+/**
+ * A record stored for an arena
+ *
+ * @param userId <p>The id of the player that achieved the record</p>
+ * @param record <p>The record achieved</p>
+ * @param <K>    <p>The comparable type of the record</p>
+ */
+public record ArenaRecord<K extends Comparable<K>>(UUID userId, K record) implements Comparable<ArenaRecord<K>>,
+        ConfigurationSerializable {
+
+    @Override
+    public boolean equals(Object other) {
+        return other instanceof ArenaRecord<?> && userId.equals(((ArenaRecord<?>) other).userId);
+    }
+
+    @Override
+    public int compareTo(@NotNull ArenaRecord<K> other) {
+        return record.compareTo(other.record);
+    }
+
+    @NotNull
+    @Override
+    public Map<String, Object> serialize() {
+        Map<String, Object> data = new HashMap<>();
+        data.put("userId", new SerializableUUID(userId()));
+        data.put("record", record);
+        return data;
+    }
+
+    /**
+     * Deserializes the saved arena record
+     *
+     * @param data <p>The data to deserialize</p>
+     * @param <K>  <p>The type of the deserialized record</p>
+     * @return <p>The deserialized data</p>
+     */
+    @SuppressWarnings({"unused", "unchecked"})
+    public static <K extends Comparable<K>> ArenaRecord<K> deserialize(@NotNull Map<String, Object> data) {
+        return new ArenaRecord<>(((SerializableUUID) data.get("userId")).uuid(), (K) data.get("record"));
+    }
+
+}

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

@@ -7,9 +7,11 @@ import org.bukkit.configuration.serialization.ConfigurationSerializable;
 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 java.util.stream.Stream;
+import java.util.concurrent.atomic.AtomicReference;
 
 /**
  * A registry keeping track of all records
@@ -17,16 +19,16 @@ import java.util.stream.Stream;
 public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
 
     private final UUID arenaId;
-    private final @NotNull Map<UUID, Number> leastDeaths;
+    private final @NotNull Set<ArenaRecord<Integer>> leastDeaths;
-    private final @NotNull Map<UUID, Number> shortestTimeMilliSeconds;
+    private final @NotNull Set<ArenaRecord<Long>> shortestTimeMilliSeconds;
 
     /**
      * Instantiates a new empty records registry
      */
     public DropperArenaRecordsRegistry(@NotNull UUID arenaId) {
         this.arenaId = arenaId;
-        this.leastDeaths = new HashMap<>();
+        this.leastDeaths = new HashSet<>();
-        this.shortestTimeMilliSeconds = new HashMap<>();
+        this.shortestTimeMilliSeconds = new HashSet<>();
     }
 
     /**
@@ -35,11 +37,11 @@ public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
      * @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 Map<UUID, Integer> leastDeaths,
+    private DropperArenaRecordsRegistry(@NotNull UUID arenaId, @NotNull Set<ArenaRecord<Integer>> leastDeaths,
-                                        @NotNull Map<UUID, Long> shortestTimeMilliSeconds) {
+                                        @NotNull Set<ArenaRecord<Long>> shortestTimeMilliSeconds) {
         this.arenaId = arenaId;
-        this.leastDeaths = new HashMap<>(leastDeaths);
+        this.leastDeaths = new HashSet<>(leastDeaths);
-        this.shortestTimeMilliSeconds = new HashMap<>(shortestTimeMilliSeconds);
+        this.shortestTimeMilliSeconds = new HashSet<>(shortestTimeMilliSeconds);
     }
 
     /**
@@ -47,12 +49,8 @@ public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
      *
      * @return <p>Existing death records</p>
      */
-    public Map<UUID, Integer> getLeastDeathsRecords() {
+    public Set<ArenaRecord<Integer>> getLeastDeathsRecords() {
-        Map<UUID, Integer> leastDeathRecords = new HashMap<>();
+        return new HashSet<>(this.leastDeaths);
-        for (Map.Entry<UUID, Number> entry : this.leastDeaths.entrySet()) {
-            leastDeathRecords.put(entry.getKey(), entry.getValue().intValue());
-        }
-        return leastDeathRecords;
     }
 
     /**
@@ -60,12 +58,8 @@ public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
      *
      * @return <p>Existing time records</p>
      */
-    public Map<UUID, Long> getShortestTimeMilliSecondsRecords() {
+    public Set<ArenaRecord<Long>> getShortestTimeMilliSecondsRecords() {
-        Map<UUID, Long> leastTimeRecords = new HashMap<>();
+        return new HashSet<>(this.shortestTimeMilliSeconds);
-        for (Map.Entry<UUID, Number> entry : this.shortestTimeMilliSeconds.entrySet()) {
-            leastTimeRecords.put(entry.getKey(), entry.getValue().longValue());
-        }
-        return leastTimeRecords;
     }
 
     /**
@@ -105,25 +99,26 @@ public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
      * @param amount          <p>The amount of whatever the player achieved</p>
      * @return <p>The result of the player's record attempt</p>
      */
-    private @NotNull RecordResult registerRecord(@NotNull Map<UUID, Number> existingRecords, @NotNull UUID playerId,
+    private <T extends Comparable<T>> @NotNull RecordResult registerRecord(@NotNull Set<ArenaRecord<T>> existingRecords,
-                                                 Number amount) {
+                                                                           @NotNull UUID playerId, T amount) {
         RecordResult result;
-        Stream<Map.Entry<UUID, Number>> records = existingRecords.entrySet().stream();
+        if (existingRecords.stream().allMatch((entry) -> amount.compareTo(entry.record()) < 0)) {
-        long amountLong = amount.longValue();
-
-        if (records.allMatch((entry) -> amountLong < entry.getValue().longValue())) {
             // If the given value is less than all other values, that's a world record!
             result = RecordResult.WORLD_RECORD;
-            existingRecords.put(playerId, amount);
+            existingRecords.add(new ArenaRecord<>(playerId, amount));
             save();
-        } else if (existingRecords.containsKey(playerId) && amountLong < existingRecords.get(playerId).longValue()) {
+            return result;
+        }
+
+        ArenaRecord<T> playerRecord = getRecord(existingRecords, playerId);
+        if (playerRecord != null && amount.compareTo(playerRecord.record()) < 0) {
             // If the given value is less than the player's previous value, that's a personal best!
             result = RecordResult.PERSONAL_BEST;
-            existingRecords.put(playerId, amount);
+            existingRecords.add(new ArenaRecord<>(playerId, amount));
             save();
         } else {
             // Make sure to save the record if this is the user's first attempt
-            if (!existingRecords.containsKey(playerId)) {
+            if (playerRecord == null) {
                 save();
             }
             result = RecordResult.NONE;
@@ -132,23 +127,24 @@ public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
         return result;
     }
 
+    private <T extends Comparable<T>> ArenaRecord<T> getRecord(@NotNull Set<ArenaRecord<T>> existingRecords,
+                                                               @NotNull UUID playerId) {
+        AtomicReference<ArenaRecord<T>> record = new AtomicReference<>();
+        existingRecords.forEach((item) -> {
+            if (item.userId().equals(playerId)) {
+                record.set(item);
+            }
+        });
+        return record.get();
+    }
+
     @NotNull
     @Override
     public Map<String, Object> serialize() {
         Map<String, Object> data = new HashMap<>();
         data.put("arenaId", new SerializableUUID(this.arenaId));
-
+        data.put("leastDeaths", this.leastDeaths);
-        Map<SerializableUUID, Number> leastDeaths = new HashMap<>();
+        data.put("shortestTime", this.shortestTimeMilliSeconds);
-        for (Map.Entry<UUID, Number> entry : this.leastDeaths.entrySet()) {
-            leastDeaths.put(new SerializableUUID(entry.getKey()), entry.getValue());
-        }
-        data.put("leastDeaths", leastDeaths);
-
-        Map<SerializableUUID, Number> shortestTimeMilliSeconds = new HashMap<>();
-        for (Map.Entry<UUID, Number> entry : this.shortestTimeMilliSeconds.entrySet()) {
-            shortestTimeMilliSeconds.put(new SerializableUUID(entry.getKey()), entry.getValue());
-        }
-        data.put("shortestTime", shortestTimeMilliSeconds);
         return data;
     }
 
@@ -161,20 +157,10 @@ public class DropperArenaRecordsRegistry implements ConfigurationSerializable {
     @SuppressWarnings({"unused", "unchecked"})
     public static DropperArenaRecordsRegistry deserialize(Map<String, Object> data) {
         UUID arenaId = ((SerializableUUID) data.get("arenaId")).uuid();
-        Map<SerializableUUID, Integer> leastDeathsData =
+        Set<ArenaRecord<Integer>> leastDeaths =
-                (Map<SerializableUUID, Integer>) data.getOrDefault("leastDeaths", new HashMap<>());
+                (Set<ArenaRecord<Integer>>) data.getOrDefault("leastDeaths", new HashMap<>());
-        Map<UUID, Integer> leastDeaths = new HashMap<>();
+        Set<ArenaRecord<Long>> shortestTimeMilliseconds =
-        for (Map.Entry<SerializableUUID, Integer> entry : leastDeathsData.entrySet()) {
+                (Set<ArenaRecord<Long>>) data.getOrDefault("shortestTime", new HashMap<>());
-            leastDeaths.put(entry.getKey().uuid(), entry.getValue());
-        }
-
-        Map<SerializableUUID, Number> shortestTimeMillisecondsData =
-                (Map<SerializableUUID, Number>) data.getOrDefault("shortestTime", new HashMap<>());
-        Map<UUID, Long> shortestTimeMilliseconds = new HashMap<>();
-        for (Map.Entry<SerializableUUID, Number> entry : shortestTimeMillisecondsData.entrySet()) {
-            shortestTimeMilliseconds.put(entry.getKey().uuid(), entry.getValue().longValue());
-        }
-
         return new DropperArenaRecordsRegistry(arenaId, leastDeaths, shortestTimeMilliseconds);
     }
 

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

@@ -21,7 +21,7 @@ public class PlayerEntryState {
     private final boolean originalAllowFlight;
     private final boolean originalInvulnerable;
     private final boolean originalIsSwimming;
-    private final boolean originalCollidable;
+    private final boolean originalCollideAble;
     private final ArenaGameMode arenaGameMode;
 
     /**
@@ -39,7 +39,7 @@ public class PlayerEntryState {
         this.originalInvulnerable = player.isInvulnerable();
         this.originalIsSwimming = player.isSwimming();
         this.arenaGameMode = arenaGameMode;
-        this.originalCollidable = player.isCollidable();
+        this.originalCollideAble = player.isCollidable();
     }
 
     /**
@@ -73,7 +73,7 @@ public class PlayerEntryState {
         this.player.setFlySpeed(this.originalFlySpeed);
         this.player.setInvulnerable(this.originalInvulnerable);
         this.player.setSwimming(this.originalIsSwimming);
-        this.player.setCollidable(this.originalCollidable);
+        this.player.setCollidable(this.originalCollideAble);
         this.player.removePotionEffect(PotionEffectType.INVISIBILITY);
     }
 

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

@@ -0,0 +1,89 @@
+package net.knarcraft.dropper.placeholder;
+
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import me.clip.placeholderapi.expansion.Relational;
+import net.knarcraft.dropper.Dropper;
+import org.bukkit.OfflinePlayer;
+import org.bukkit.entity.Player;
+
+public class RecordExpansion extends PlaceholderExpansion implements Relational {
+
+    private final Dropper plugin;
+
+    public RecordExpansion(Dropper plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public String getIdentifier() {
+        return "dropper";
+    }
+
+    @Override
+    public String getAuthor() {
+        return "EpicKnarvik97";
+    }
+
+    @Override
+    public String getVersion() {
+        return "1.0.0";
+    }
+
+    @Override
+    public boolean persist() {
+        return true;
+    }
+
+    @Override
+    public String onRequest(OfflinePlayer player, String parameters) {
+        /*String[] parts = parameters.split("_");
+        // Record is used as the prefix for all record placeholders in case more placeholder types are added
+        if (parts.length < 7 || !parts[0].equals("record")) {
+            return parameters;
+        }
+        boolean timeRecords = parts[1].equals("time");
+        ArenaGameMode gameMode = ArenaGameMode.matchGamemode(parts[2]);
+        boolean isGroup = parts[3].equalsIgnoreCase("group");
+        String identifier = parts[4];
+        int recordNumber = Integer.parseInt(parts[5]);
+        boolean value = parts[6].equalsIgnoreCase("value");
+
+        DropperArenaHandler arenaHandler = Dropper.getInstance().getArenaHandler();
+        if (isGroup) {
+            DropperArenaGroup group = arenaHandler.getGroup(identifier);
+        } else {
+            DropperArena arena = arenaHandler.getArena(identifier);
+            if (arena == null) {
+                return parameters;
+            }
+            @NotNull Map<ArenaGameMode, DropperArenaRecordsRegistry> registries = arena.getData().recordRegistries();
+            DropperArenaRecordsRegistry recordsRegistry = registries.get(gameMode);
+            if (timeRecords) {
+                recordsRegistry.getShortestTimeMilliSecondsRecords();
+            } else {
+                recordsRegistry.getLeastDeathsRecords();
+            }
+        }*/
+        
+        /*
+        Format:
+        %dropper_record_time_random_arena_arenaname_1_player%
+        %dropper_record_time_random_arena_arenaname_1_value%
+
+        dropper_record: Denotes that it's a placeholder for a dropper record
+        deaths/time: The type of record to get
+        default/inverted/random: The game-mode to get the record for
+        arena/group: Denoting if the following name is the name of an arena or an arena group
+        1,2,3,...: The placing to get: 1 for first place, etc.
+        player/value: Whether to get the name of the player, or the player's record
+         */
+        // TODO: Figure out how placeholders should work. %dropper_group_1% should display the top player of the arena group
+        return parameters;
+    }
+
+    @Override
+    public String onPlaceholderRequest(Player player1, Player player2, String parameters) {
+        return null;
+    }
+
+}

src/main/resources/plugin.yml

@@ -3,6 +3,8 @@ version: '${project.version}'
 main: net.knarcraft.dropper.Dropper
 api-version: 1.19
 description: A plugin for dropper mini-games
+softdepend:
+  - PlaceholderAPI
 
 # Note to self: Aliases must be lowercase!
 commands: