follow Rollczi's suggestion -> refactored placeholder registry

Author: P1otrulla

buildSrc/src/main/kotlin/eternalcombat-java.gradle.kts

@@ -3,7 +3,7 @@ plugins {
 }
 
 group = "com.eternalcode"
-version = "2.2.1-SNAPSHOT"
+version = "2.2.0"
 
 tasks.compileJava {
     options.compilerArgs = listOf("-Xlint:deprecation", "-parameters")

eternalcombat-plugin/src/main/java/com/eternalcode/combat/bridge/BridgeService.java

@@ -69,7 +69,7 @@ public void init(Server server) {
 
         initialize(
             "PlaceholderAPI",
-            () -> new FightTagPlaceholder(this.config.placeholders, this.fightManager, server, this.plugin).register(),
+            () -> new FightTagPlaceholder(this.config, this.fightManager, server, this.plugin).register(),
             () -> this.logger.warning("PlaceholderAPI not found; skipping placeholders.")
         );
     }

eternalcombat-plugin/src/main/java/com/eternalcode/combat/bridge/placeholder/FightTagPlaceholder.java

@@ -1,6 +1,7 @@
 package com.eternalcode.combat.bridge.placeholder;
 
 import com.eternalcode.combat.config.implementation.PlaceholderSettings;
+import com.eternalcode.combat.config.implementation.PluginConfig;
 import com.eternalcode.combat.fight.FightManager;
 import com.eternalcode.combat.fight.FightTag;
 import com.eternalcode.combat.util.DurationUtil;
@@ -16,94 +17,108 @@
 public class FightTagPlaceholder extends PlaceholderExpansion {
 
     private static final String IDENTIFIER = "eternalcombat";
+
     private final PlaceholderSettings placeholderSettings;
     private final FightManager fightManager;
     private final Server server;
     private final Plugin plugin;
 
-    public FightTagPlaceholder(PlaceholderSettings placeholderSettings, FightManager fightManager, Server server, Plugin plugin) {
-        this.placeholderSettings = placeholderSettings;
+    public FightTagPlaceholder(PluginConfig pluginConfig, FightManager fightManager, Server server, Plugin plugin) {
+        this.placeholderSettings = pluginConfig.placeholders;
         this.fightManager = fightManager;
         this.server = server;
         this.plugin = plugin;
     }
 
     @Override
-    public boolean canRegister() {
-        return true;
+    public String onRequest(OfflinePlayer player, String identifier) {
+        return switch (identifier) {
+            case "remaining_millis" -> this.handleRemainingMillis(player);
+            case "remaining_seconds" -> this.handleRemainingSeconds(player);
+            case "opponent" -> this.handleOpponent(player);
+            case "opponent_health" -> this.handleOpponentHealth(player);
+            case "isInCombat" -> this.handleIsInCombat(player);
+            case "isInCombat_formatted" -> this.handleIsInCombatFormatted(player);
+            default -> "";
+        };
     }
 
-    @Override
-    public @NotNull String getIdentifier() {
-        return IDENTIFIER;
+    private String handleRemainingMillis(OfflinePlayer player) {
+        return this.getFightTag(player)
+            .map(tag -> DurationParser.TIME_UNITS.format(tag.getRemainingDuration()))
+            .orElse("");
     }
 
-    @Override
-    public @NotNull String getAuthor() {
-        return this.plugin.getDescription().getAuthors().get(0);
+    private String handleRemainingSeconds(OfflinePlayer player) {
+        return this.getFightTag(player)
+            .map(tag -> DurationUtil.format(tag.getRemainingDuration()))
+            .orElse("");
     }
 
-    @Override
-    public @NotNull String getVersion() {
-        return this.plugin.getDescription().getVersion();
+    private String handleOpponent(OfflinePlayer player) {
+        return this.getTagger(player)
+            .map(Player::getName)
+            .orElse("");
     }
 
-    @Override
-    public String onRequest(OfflinePlayer player, String identifier) {
-        if (identifier.equals("remaining_seconds") || identifier.equals("remaining_millis")) {
-            return this.getFightTag(player)
-                .map(fightTagInter -> identifier.equals("remaining_millis")
-                                      ? DurationParser.TIME_UNITS.format(fightTagInter.getRemainingDuration())
-                                      : DurationUtil.format(fightTagInter.getRemainingDuration()))
-                .orElse("");
-        }
-
-        if (identifier.equals("opponent")) {
-            return this.getTagger(player)
-                .map(tagger -> tagger.getName())
-                .orElse("");
-        }
-
-        if (identifier.equals("opponent_health")) {
-            return this.getTagger(player)
-                .map(tagger -> String.format("%.2f", tagger.getHealth()))
-                .orElse("");
-        }
-
-        if (identifier.equals("isInCombat") || identifier.equals("isInCombat_formatted")) {
-            Player onlinePlayer = player.getPlayer();
-            boolean inCombat = onlinePlayer != null && this.fightManager.isInCombat(onlinePlayer.getUniqueId());
+    private String handleOpponentHealth(OfflinePlayer player) {
+        return this.getTagger(player)
+            .map(tagger -> String.format("%.2f", tagger.getHealth()))
+            .orElse("");
+    }
 
-            if (identifier.equals("isInCombat")) {
-                return String.valueOf(inCombat);
-            }
+    private String handleIsInCombat(OfflinePlayer player) {
+        return String.valueOf(this.isPlayerInCombat(player));
+    }
 
-            return inCombat
-                ? this.placeholderSettings.isInCombatFormattedTrue
-                : this.placeholderSettings.isInCombatFormattedFalse;
-        }
+    private String handleIsInCombatFormatted(OfflinePlayer player) {
+        return this.isPlayerInCombat(player)
+            ? this.placeholderSettings.isInCombatFormattedTrue
+            : this.placeholderSettings.isInCombatFormattedFalse;
+    }
 
-        return null;
+    private boolean isPlayerInCombat(OfflinePlayer player) {
+        Player onlinePlayer = player.getPlayer();
+        return onlinePlayer != null && this.fightManager.isInCombat(onlinePlayer.getUniqueId());
     }
 
     private @NotNull Optional<Player> getTagger(OfflinePlayer player) {
         return this.getFightTag(player)
-            .map(fightTagInter -> fightTagInter.getTagger())
-            .map(taggerId -> this.server.getPlayer(taggerId));
+            .map(FightTag::getTagger)
+            .map(this.server::getPlayer);
     }
 
     private Optional<FightTag> getFightTag(OfflinePlayer player) {
         Player onlinePlayer = player.getPlayer();
 
-        if (onlinePlayer != null) {
-            if (!this.fightManager.isInCombat(onlinePlayer.getUniqueId())) {
-                return Optional.empty();
-            }
+        if (onlinePlayer == null) {
+            return Optional.empty();
+        }
 
-            return Optional.of(this.fightManager.getTag(onlinePlayer.getUniqueId()));
+        if (!this.fightManager.isInCombat(onlinePlayer.getUniqueId())) {
+            return Optional.empty();
         }
 
-        return Optional.empty();
+        return Optional.of(this.fightManager.getTag(onlinePlayer.getUniqueId()));
+    }
+
+    @Override
+    public boolean canRegister() {
+        return true;
+    }
+
+    @Override
+    public @NotNull String getIdentifier() {
+        return IDENTIFIER;
+    }
+
+    @Override
+    public @NotNull String getAuthor() {
+        return this.plugin.getDescription().getAuthors().get(0);
     }
 
+    @Override
+    public @NotNull String getVersion() {
+        return this.plugin.getDescription().getVersion();
+    }
 }