Initial commit: LoParkour v1.1.0

src/main/java/dev/loki/loparkour/hook/FloodgateHook.java

@@ -0,0 +1,17 @@
+package dev.loki.loparkour.hook;
+
+import org.bukkit.entity.Player;
+import org.geysermc.floodgate.api.FloodgateApi;
+
+public class FloodgateHook {
+
+    /**
+     * Whether this player is a bedrock player.
+     *
+     * @param player The player.
+     * @return True if this player is a bedrock player, false if not.
+     */
+    public static boolean isBedrockPlayer(Player player) {
+        return FloodgateApi.getInstance().isFloodgatePlayer(player.getUniqueId());
+    }
+}

src/main/java/dev/loki/loparkour/hook/HoloHook.java

@@ -0,0 +1,84 @@
+package dev.loki.loparkour.hook;
+
+import dev.loki.loparkour.LoParkour;
+import dev.loki.loparkour.api.Registry;
+import dev.loki.loparkour.leaderboard.Leaderboard;
+import dev.loki.loparkour.leaderboard.Score;
+import dev.loki.loparkour.mode.Mode;
+import me.filoghost.holographicdisplays.api.HolographicDisplaysAPI;
+
+public class HoloHook {
+
+    /**
+     * Initializes this hook.
+     */
+    public static void init() {
+        try {
+            Class.forName("me.filoghost.holographicdisplays.api.HolographicDisplaysAPI");
+        } catch (Exception ex) {
+            LoParkour.logging().warn("##");
+            LoParkour.logging().warn("## LoParkour only supports Holographic Displays v3.0.0 or higher!");
+            LoParkour.logging().warn("## This hook will now be disabled.");
+            LoParkour.logging().warn("##");
+            return;
+        }
+
+        HolographicDisplaysAPI.get(LoParkour.getPlugin()).registerGlobalPlaceholder("ip_leaderboard", 100, argument -> {
+
+            if (argument == null) {
+                return "?";
+            }
+
+            // {ip_leaderboard: default, score, #1}
+            String[] split = argument.replace(" ", "").split(",");
+
+            Mode mode = Registry.getMode(split[0].toLowerCase());
+
+            if (mode == null) {
+                return "?";
+            }
+
+            Leaderboard leaderboard = mode.getLeaderboard();
+
+            if (leaderboard == null) {
+                return "?";
+            }
+
+            String type = split[1].toLowerCase();
+            String rank = split[2].replace("#", "");
+
+            Score score = leaderboard.getScoreAtRank(Integer.parseInt(rank));
+
+            if (score == null) {
+                return "?";
+            }
+
+            return switch (type) {
+                case "score" -> Integer.toString(score.score());
+                case "name" -> score.name();
+                case "time" -> score.time();
+                case "difficulty" -> score.difficulty();
+                case "difficulty_string" -> parseDifficulty(score.difficulty());
+                default -> "?";
+            };
+        });
+    }
+
+    private static String parseDifficulty(String string) {
+        if (string.contains("?")) {
+            return "?";
+        }
+
+        double difficulty = Double.parseDouble(string);
+        if (difficulty <= 0.25) {
+            return "easy";
+        } else if (difficulty <= 0.5) {
+            return "medium";
+        } else if (difficulty <= 0.75) {
+            return "hard";
+        } else if (difficulty <= 1) {
+            return "very hard";
+        }
+        return "?";
+    }
+} 

src/main/java/dev/loki/loparkour/hook/PAPIHook.java

@@ -0,0 +1,200 @@
+package dev.loki.loparkour.hook;
+
+import dev.loki.loparkour.LoParkour;
+import dev.loki.loparkour.api.Registry;
+import dev.loki.loparkour.generator.ParkourGenerator;
+import dev.loki.loparkour.leaderboard.Leaderboard;
+import dev.loki.loparkour.leaderboard.Score;
+import dev.loki.loparkour.mode.Mode;
+import dev.loki.loparkour.mode.Modes;
+import dev.loki.loparkour.player.ParkourPlayer;
+import dev.loki.loparkour.player.ParkourSpectator;
+import dev.loki.loparkour.player.ParkourUser;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.function.Function;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class PAPIHook extends PlaceholderExpansion {
+
+    private static final Pattern INFINITE_REGEX = Pattern.compile("(.+)_(\\d+)");
+
+    @Override
+    public @NotNull String getIdentifier() {
+        return "witp";
+    }
+
+    @Override
+    public @NotNull String getAuthor() {
+        return "loki";
+    }
+
+    @Override
+    public boolean canRegister() {
+        return true;
+    }
+
+    @Override
+    public boolean persist() {
+        return true;
+    }
+
+    @Override
+    public @NotNull String getVersion() {
+        return LoParkour.getPlugin().getDescription().getVersion();
+    }
+
+    @Override
+    public String onPlaceholderRequest(Player player, @NotNull String params) {
+        // placeholders that don't require a player
+        switch (params) {
+            case "version", "ver" -> {
+                return LoParkour.getPlugin().getDescription().getVersion();
+            }
+            case "leader", "record_player" -> {
+                Score score = Modes.DEFAULT.getLeaderboard().getScoreAtRank(1);
+                return score != null ? score.name() : "?";
+            }
+            case "leader_score", "record_score", "record" -> {
+                Score score = Modes.DEFAULT.getLeaderboard().getScoreAtRank(1);
+                return score != null ? Integer.toString(score.score()) : "?";
+            }
+        }
+
+        if (params.contains("player_rank_")) {
+            return getInfiniteScore(params.replace("player_rank_", ""), Score::name);
+        } else if (params.contains("score_rank_")) {
+            return getInfiniteScore(params.replace("score_rank_", ""), Score::score);
+        } else if (params.contains("time_rank_")) {
+            return getInfiniteScore(params.replace("time_rank_", ""), Score::time);
+        } else if (params.contains("difficulty_rank_")) {
+            return getInfiniteScore(params.replace("difficulty_rank_", ""), Score::difficulty);
+        } else if (params.contains("difficulty_string_rank_")) {
+            return getInfiniteScore(params.replace("difficulty_string_rank_", ""),
+                    score -> parseDifficulty(Double.parseDouble(score.difficulty().contains("?") ? "2" : score.difficulty())));
+        }
+
+        // placeholders that require player
+        if (player == null) {
+            return "player doesn't exist";
+        }
+
+        switch (params) {
+            case "rank" -> {
+                return Integer.toString(Modes.DEFAULT.getLeaderboard().getRank(player.getUniqueId()));
+            }
+            case "highscore", "high_score" -> {
+                return Integer.toString(Modes.DEFAULT.getLeaderboard().get(player.getUniqueId()).score());
+            }
+            case "high_score_time" -> {
+                return Modes.DEFAULT.getLeaderboard().get(player.getUniqueId()).time();
+            }
+        }
+
+        ParkourUser user = ParkourUser.getUser(player);
+        ParkourPlayer pp = null;
+        if (user instanceof ParkourPlayer) {
+            pp = (ParkourPlayer) user;
+        } else if (user instanceof ParkourSpectator) {
+            pp = ((ParkourSpectator) user).closest;
+        }
+
+        if (pp != null && pp.session.generator != null) {
+            ParkourGenerator generator = pp.session.generator;
+            switch (params) {
+                case "score", "current_score" -> {
+                    return Integer.toString(generator.score);
+                }
+                case "time", "current_time" -> {
+                    return generator.getFormattedTime();
+                }
+                case "blocklead", "lead" -> {
+                    return Integer.toString(pp.blockLead);
+                }
+                case "style" -> {
+                    return pp.style;
+                }
+                case "time_pref", "time_preference" -> {
+                    return Integer.toString(pp.selectedTime);
+                }
+                case "scoreboard" -> {
+                    return pp.showScoreboard.toString();
+                }
+                case "difficulty" -> {
+                    return Double.toString(pp.schematicDifficulty);
+                }
+                case "difficulty_string" -> {
+                    return parseDifficulty(pp.schematicDifficulty);
+                }
+                default -> {
+                    if (params.contains("score_until_")) {
+                        String replaced = params.replace("score_until_", "");
+                        int interval = Integer.parseInt(replaced);
+                        if (interval > 0) {
+                            return Integer.toString(interval - (generator.totalScore % interval)); // 100 - (5 % 100) = 95
+                        } else {
+                            return "0";
+                        }
+                    }
+                }
+            }
+        }
+
+        return null;
+    }
+
+    private String parseDifficulty(double difficulty) {
+        if (difficulty <= 0.25) {
+            return "easy";
+        } else if (difficulty <= 0.5) {
+            return "medium";
+        } else if (difficulty <= 0.75) {
+            return "hard";
+        } else if (difficulty <= 1) {
+            return "very hard";
+        }
+        return "?";
+    }
+
+
+    private String getInfiniteScore(String rankData, Function<Score, ?> f) {
+        int rank;
+        Leaderboard leaderboard = null;
+        Matcher matcher = INFINITE_REGEX.matcher(rankData);
+
+        // use mode-specific format
+        // x_mode_rank
+        if (matcher.matches()) {
+            String name = matcher.group(1);
+            rank = Integer.parseInt(matcher.group(2));
+
+            Mode mode = Registry.getMode(name);
+            if (mode != null) {
+                leaderboard = mode.getLeaderboard();
+            }
+            // use generic format
+            // x_rank
+        } else {
+            rank = Integer.parseInt(rankData);
+        }
+
+        if (leaderboard == null) {
+            leaderboard = Modes.DEFAULT.getLeaderboard();
+        }
+
+        if (rank > 0) {
+            Score score = leaderboard.getScoreAtRank(rank);
+
+            if (score == null) {
+                return "?";
+            } else {
+                return String.valueOf(f.apply(score));
+            }
+        } else {
+            return "?";
+        }
+    }
+}

src/main/java/dev/loki/loparkour/hook/VaultHook.java

@@ -0,0 +1,39 @@
+package dev.loki.loparkour.hook;
+
+import dev.loki.loparkour.LoParkour;
+import net.milkbowl.vault.economy.Economy;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.RegisteredServiceProvider;
+
+import java.util.NoSuchElementException;
+
+public class VaultHook {
+
+    private static Economy economy;
+
+    /**
+     * Deposits amount to the bal of player.
+     *
+     * @param player The player.
+     * @param amount The amount.
+     */
+    public static void deposit(Player player, double amount) {
+        if (Bukkit.getPluginManager().getPlugin("Vault") == null) {
+            return;
+        }
+
+        if (economy == null) {
+            RegisteredServiceProvider<Economy> service = Bukkit.getServicesManager().getRegistration(Economy.class);
+
+            if (service == null) {
+                LoParkour.logging().stack("Error while trying to fetch the Vault economy", new NoSuchElementException("No economy found"));
+                return;
+            }
+
+            economy = service.getProvider();
+        }
+
+        economy.depositPlayer(player, amount);
+    }
+}