From f26916a86f2e5bc7aaf4d5b4704fd661eb2d6f81 Mon Sep 17 00:00:00 2001 From: Martin Sulikowski Date: Sat, 18 Oct 2025 00:34:45 +0200 Subject: [PATCH 1/6] Remove usage of panda-utilities and panda expressible. --- buildSrc/src/main/kotlin/Versions.kt | 4 +- .../core/feature/jail/JailService.java | 2 +- eternalcore-core/build.gradle.kts | 5 +-- .../FullServerBypassController.java | 38 +++++++++---------- .../core/feature/jail/JailServiceImpl.java | 2 +- .../playerinfo/OnlinePlayersListCommand.java | 8 ++-- .../PlayerQuitMessageController.java | 1 - .../core/feature/teleport/TeleportTask.java | 12 +++--- .../injector/bean/BeanCandidateContainer.java | 8 +--- .../argument/GameModeArgument.java | 22 +++++++---- .../core/user/UserClientBukkitSettings.java | 11 +++--- .../eternalcode/core/util/MaterialUtil.java | 33 +++++++++++++++- eternalcore-docs-generate/build.gradle.kts | 2 - 13 files changed, 85 insertions(+), 63 deletions(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 427ba5328..96d73667f 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -1,7 +1,7 @@ object Versions { - const val SPIGOT_API = "1.21.3-R0.1-SNAPSHOT" - const val PAPER_API = "1.21.3-R0.1-SNAPSHOT" + const val SPIGOT_API = "1.21.10-R0.1-SNAPSHOT" + const val PAPER_API = "1.21.10-R0.1-SNAPSHOT" const val ETERNALCODE_COMMONS = "1.3.1" const val MULTIFICATION = "1.2.2" diff --git a/eternalcore-api/src/main/java/com/eternalcode/core/feature/jail/JailService.java b/eternalcore-api/src/main/java/com/eternalcode/core/feature/jail/JailService.java index 43e855812..64f172121 100644 --- a/eternalcore-api/src/main/java/com/eternalcode/core/feature/jail/JailService.java +++ b/eternalcore-api/src/main/java/com/eternalcode/core/feature/jail/JailService.java @@ -3,13 +3,13 @@ import java.time.Duration; import java.util.Collection; import java.util.UUID; -import javax.annotation.Nullable; import org.bukkit.Location; import java.util.Optional; import org.bukkit.command.CommandSender; import org.bukkit.entity.Player; import org.jetbrains.annotations.Blocking; +import org.jetbrains.annotations.Nullable; public interface JailService { diff --git a/eternalcore-core/build.gradle.kts b/eternalcore-core/build.gradle.kts index 3fb9ae09a..6ff44aec0 100644 --- a/eternalcore-core/build.gradle.kts +++ b/eternalcore-core/build.gradle.kts @@ -92,12 +92,9 @@ eternalShadow { ) // common libraries - library("org.panda-lang:expressible:${Versions.EXPRESSIBLE}") - library("org.panda-lang:panda-utilities:${Versions.PANDA_UTILITIES}") + library("commons-io:commons-io:${Versions.APACHE_COMMONS}") libraryRelocate( - "panda.std", - "panda.utilities", "org.apache.commons.io", ) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java index dc9b388d7..841c244f4 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java @@ -14,8 +14,8 @@ import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerLoginEvent; -import panda.utilities.text.Joiner; +import java.util.List; import java.util.Optional; @PermissionDocs( @@ -27,6 +27,7 @@ class FullServerBypassController implements Listener { static final String SLOT_BYPASS = "eternalcore.slot.bypass"; + private static final String LINE_SEPARATOR = "\n"; private final TranslationManager translationManager; private final UserManager userManager; @@ -41,35 +42,30 @@ class FullServerBypassController implements Listener { @EventHandler void onLogin(PlayerLoginEvent event) { - if (event.getResult() == PlayerLoginEvent.Result.KICK_FULL) { - Player player = event.getPlayer(); + if (event.getResult() != PlayerLoginEvent.Result.KICK_FULL) { + return; + } - if (player.hasPermission(SLOT_BYPASS)) { - event.allow(); + Player player = event.getPlayer(); - return; - } + if (player.hasPermission(SLOT_BYPASS)) { + event.allow(); + return; + } - String serverFullMessage = this.getServerFullMessage(player); - Component serverFullMessageComponent = this.miniMessage.deserialize(serverFullMessage); + String serverFullMessage = this.getServerFullMessage(player); + Component serverFullMessageComponent = this.miniMessage.deserialize(serverFullMessage); - event.disallow(PlayerLoginEvent.Result.KICK_FULL, AdventureUtil.SECTION_SERIALIZER.serialize(serverFullMessageComponent)); - } + event.disallow(PlayerLoginEvent.Result.KICK_FULL, AdventureUtil.SECTION_SERIALIZER.serialize(serverFullMessageComponent)); } private String getServerFullMessage(Player player) { Optional userOption = this.userManager.getUser(player.getUniqueId()); - if (userOption.isEmpty()) { - return Joiner.on("\n") - .join(this.translationManager.getMessages().player().fullServerSlots()) - .toString(); - } - - User user = userOption.get(); + List messages = userOption + .map(user -> this.translationManager.getMessages(user.getUniqueId()).player().fullServerSlots()) + .orElseGet(() -> this.translationManager.getMessages().player().fullServerSlots()); - return Joiner.on("\n") - .join(this.translationManager.getMessages(user.getUniqueId()).player().fullServerSlots()) - .toString(); + return String.join(LINE_SEPARATOR, messages); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/jail/JailServiceImpl.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/jail/JailServiceImpl.java index a5a36155e..8cc0303bf 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/jail/JailServiceImpl.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/jail/JailServiceImpl.java @@ -18,7 +18,6 @@ import java.util.HashMap; import java.util.Map; import java.util.UUID; -import javax.annotation.Nullable; import org.bukkit.Location; import org.bukkit.Server; import org.bukkit.command.CommandSender; @@ -26,6 +25,7 @@ import org.jetbrains.annotations.Blocking; import java.util.Optional; +import org.jetbrains.annotations.Nullable; @Service class JailServiceImpl implements JailService { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/playerinfo/OnlinePlayersListCommand.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/playerinfo/OnlinePlayersListCommand.java index f708a7512..ba5f4430b 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/playerinfo/OnlinePlayersListCommand.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/playerinfo/OnlinePlayersListCommand.java @@ -11,10 +11,10 @@ import dev.rollczi.litecommands.annotations.execute.Execute; import dev.rollczi.litecommands.annotations.permission.Permission; import java.util.Collection; +import java.util.stream.Collectors; import org.bukkit.Server; import org.bukkit.entity.HumanEntity; import org.bukkit.entity.Player; -import panda.utilities.text.Joiner; @Command(name = "list") @Permission("eternalcore.list") @@ -43,9 +43,9 @@ void execute(@Sender Viewer viewer) { .toList(); String onlineCount = String.valueOf(online.size()); - String players = Joiner.on(this.config.format.separator) - .join(online, HumanEntity::getName) - .toString(); + String players = online.stream() + .map(HumanEntity::getName) + .collect(Collectors.joining(this.config.format.separator)); this.noticeService.create() .notice(translation -> translation.player().onlinePlayersMessage()) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java index b364b59df..d9778bb6b 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/quitmessage/PlayerQuitMessageController.java @@ -10,7 +10,6 @@ import org.bukkit.event.EventHandler; import org.bukkit.event.Listener; import org.bukkit.event.player.PlayerQuitEvent; -import panda.utilities.StringUtils; @Controller class PlayerQuitMessageController implements Listener { diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/teleport/TeleportTask.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/teleport/TeleportTask.java index 4ae426094..3e94790e1 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/teleport/TeleportTask.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/teleport/TeleportTask.java @@ -14,12 +14,13 @@ import org.bukkit.Location; import org.bukkit.Server; import org.bukkit.entity.Player; -import panda.utilities.StringUtils; @Task(delay = 1L, period = 1L, unit = TimeUnit.SECONDS) class TeleportTask implements Runnable { private static final int SECONDS_OFFSET = 1; + private static final double MOVEMENT_THRESHOLD = 0.5; + private static final String EMPTY_STRING = ""; private final NoticeService noticeService; private final TeleportTaskService teleportTaskService; @@ -58,7 +59,7 @@ public void run() { teleport.completeResult(TeleportResult.MOVED_DURING_TELEPORT); this.noticeService.create() - .notice(translation -> Notice.actionbar(StringUtils.EMPTY)) + .notice(translation -> Notice.actionbar(EMPTY_STRING)) .notice(translation -> translation.teleport().teleportTaskCanceled()) .player(player.getUniqueId()) .send(); @@ -102,11 +103,12 @@ private void completeTeleport(Player player, Teleport teleport) { private boolean hasPlayerMovedDuringTeleport(Player player, Teleport teleport) { Location startLocation = PositionAdapter.convert(teleport.getStartLocation()); Location currentLocation = player.getLocation(); + if (!currentLocation.getWorld().equals(startLocation.getWorld())) { - return true; + return true; } - return currentLocation.distance(startLocation) > 0.5; + + return currentLocation.distance(startLocation) > MOVEMENT_THRESHOLD; } } - diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/injector/bean/BeanCandidateContainer.java b/eternalcore-core/src/main/java/com/eternalcode/core/injector/bean/BeanCandidateContainer.java index 0ab8557b0..f1c59f680 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/injector/bean/BeanCandidateContainer.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/injector/bean/BeanCandidateContainer.java @@ -1,14 +1,9 @@ package com.eternalcode.core.injector.bean; import dev.rollczi.litecommands.priority.MutablePrioritizedList; -import dev.rollczi.litecommands.priority.Prioritized; -import dev.rollczi.litecommands.priority.PrioritizedList; import dev.rollczi.litecommands.priority.PriorityLevel; -import java.util.HashSet; -import java.util.Iterator; -import java.util.Set; import java.util.function.Function; -import javax.annotation.Nullable; +import org.jetbrains.annotations.Nullable; class BeanCandidateContainer { @@ -66,5 +61,4 @@ BeanCandidate nextCandidate() { return candidate; } } - } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java index cd86f5969..34fc3766e 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java @@ -10,11 +10,9 @@ import dev.rollczi.litecommands.invocation.Invocation; import dev.rollczi.litecommands.suggestion.SuggestionContext; import dev.rollczi.litecommands.suggestion.SuggestionResult; +import java.util.Optional; import org.bukkit.GameMode; import org.bukkit.command.CommandSender; -import panda.std.Option; - -import java.util.Optional; @LiteArgument(type = GameMode.class) class GameModeArgument extends AbstractViewerArgument { @@ -29,7 +27,14 @@ class GameModeArgument extends AbstractViewerArgument { @Override public ParseResult parse(Invocation invocation, String argument, Translation translation) { - Option gameMode = Option.supplyThrowing(IllegalArgumentException.class, () -> GameMode.valueOf(argument.toUpperCase())); + Optional gameMode; + + try { + gameMode = Optional.of(GameMode.valueOf(argument.toUpperCase())); + } + catch (IllegalArgumentException exception) { + gameMode = Optional.empty(); + } if (gameMode.isPresent()) { return ParseResult.success(gameMode.get()); @@ -38,15 +43,18 @@ public ParseResult parse(Invocation invocation, String Optional alias = this.gameModeArgumentSettings.getByAlias(argument); return alias - .map(parsed -> ParseResult.success(parsed)) + .map(ParseResult::success) .orElseGet(() -> ParseResult.failure(translation.player().gameModeNotCorrect())); } @Override - public SuggestionResult suggest(Invocation invocation, Argument argument, SuggestionContext context) { + public SuggestionResult suggest( + Invocation invocation, + Argument argument, + SuggestionContext context + ) { return this.gameModeArgumentSettings.getAvailableAliases() .stream() .collect(SuggestionResult.collector()); } - } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/user/UserClientBukkitSettings.java b/eternalcore-core/src/main/java/com/eternalcode/core/user/UserClientBukkitSettings.java index 088e4698e..2a45d8aae 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/user/UserClientBukkitSettings.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/user/UserClientBukkitSettings.java @@ -2,10 +2,9 @@ import org.bukkit.Server; import org.bukkit.entity.Player; -import panda.std.Option; import java.lang.ref.WeakReference; -import java.util.Locale; +import java.util.Optional; import java.util.UUID; class UserClientBukkitSettings implements UserClientSettings { @@ -25,21 +24,21 @@ public boolean isOnline() { return this.getPlayer().isPresent(); } - private Option getPlayer() { + private Optional getPlayer() { Player player = this.playerReference.get(); if (player == null) { Player playerFromServer = this.server.getPlayer(this.uuid); if (playerFromServer == null) { - return Option.none(); + return Optional.empty(); } this.playerReference = new WeakReference<>(playerFromServer); - return Option.of(playerFromServer); + return Optional.of(playerFromServer); } - return Option.of(player); + return Optional.of(player); } } diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java b/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java index 5ae39fb6d..e866c737e 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java @@ -1,15 +1,44 @@ package com.eternalcode.core.util; import org.bukkit.Material; -import panda.utilities.StringUtils; public final class MaterialUtil { + private static final String UNDERSCORE = "_"; + private static final String SPACE = " "; + private MaterialUtil() { throw new UnsupportedOperationException("This is a utility class and cannot be instantiated"); } public static String format(Material material) { - return StringUtils.capitalize(material.name().toLowerCase().replace("_", " ")); + String formattedName = material.name().toLowerCase().replace(UNDERSCORE, SPACE); + return capitalize(formattedName); + } + + private static String capitalize(String text) { + if (text == null || text.isEmpty()) { + return text; + } + + String[] words = text.split(SPACE); + StringBuilder result = new StringBuilder(); + + for (int i = 0; i < words.length; i++) { + String word = words[i]; + + if (!word.isEmpty()) { + result.append(Character.toUpperCase(word.charAt(0))); + if (word.length() > 1) { + result.append(word.substring(1)); + } + } + + if (i < words.length - 1) { + result.append(SPACE); + } + } + + return result.toString(); } } diff --git a/eternalcore-docs-generate/build.gradle.kts b/eternalcore-docs-generate/build.gradle.kts index 12ae56845..d1c567833 100644 --- a/eternalcore-docs-generate/build.gradle.kts +++ b/eternalcore-docs-generate/build.gradle.kts @@ -20,8 +20,6 @@ dependencies { runtimeOnly("com.j256.ormlite:ormlite-jdbc:${Versions.ORMLITE}") runtimeOnly("com.zaxxer:HikariCP:${Versions.HIKARI_CP}") runtimeOnly("dev.rollczi:liteskullapi:${Versions.LITE_SKULL_API}") - runtimeOnly("org.panda-lang:expressible:${Versions.EXPRESSIBLE}") - runtimeOnly("org.panda-lang:panda-utilities:${Versions.PANDA_UTILITIES}") runtimeOnly("commons-io:commons-io:${Versions.APACHE_COMMONS}") runtimeOnly("dev.triumphteam:triumph-gui:${Versions.TRIUMPH_GUI}") runtimeOnly("org.bstats:bstats-bukkit:${Versions.BSTATS}") From 44c1e841ec5456e0db3dfb01ac0617739a6fb914 Mon Sep 17 00:00:00 2001 From: Martin Sulikowski Date: Sat, 18 Oct 2025 00:40:45 +0200 Subject: [PATCH 2/6] Simplify game mode parsing by removing Optional usage and directly handling exceptions --- .../argument/GameModeArgument.java | 20 +++++-------------- 1 file changed, 5 insertions(+), 15 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java index 34fc3766e..481f5cbe5 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java @@ -10,7 +10,6 @@ import dev.rollczi.litecommands.invocation.Invocation; import dev.rollczi.litecommands.suggestion.SuggestionContext; import dev.rollczi.litecommands.suggestion.SuggestionResult; -import java.util.Optional; import org.bukkit.GameMode; import org.bukkit.command.CommandSender; @@ -27,24 +26,15 @@ class GameModeArgument extends AbstractViewerArgument { @Override public ParseResult parse(Invocation invocation, String argument, Translation translation) { - Optional gameMode; - try { - gameMode = Optional.of(GameMode.valueOf(argument.toUpperCase())); + GameMode gameMode = GameMode.valueOf(argument.toUpperCase()); + return ParseResult.success(gameMode); } catch (IllegalArgumentException exception) { - gameMode = Optional.empty(); - } - - if (gameMode.isPresent()) { - return ParseResult.success(gameMode.get()); + return this.gameModeArgumentSettings.getByAlias(argument) + .map(ParseResult::success) + .orElseGet(() -> ParseResult.failure(translation.player().gameModeNotCorrect())); } - - Optional alias = this.gameModeArgumentSettings.getByAlias(argument); - - return alias - .map(ParseResult::success) - .orElseGet(() -> ParseResult.failure(translation.player().gameModeNotCorrect())); } @Override From 69ef1e6bfae7f56907136171548f3e712d1bca0c Mon Sep 17 00:00:00 2001 From: Martin Sulikowski Date: Sat, 18 Oct 2025 00:40:54 +0200 Subject: [PATCH 3/6] Refactor text capitalization method to use streams for improved readability --- .../eternalcode/core/util/MaterialUtil.java | 25 +++++-------------- 1 file changed, 6 insertions(+), 19 deletions(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java b/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java index e866c737e..45aff6235 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/util/MaterialUtil.java @@ -1,5 +1,7 @@ package com.eternalcode.core.util; +import java.util.Arrays; +import java.util.stream.Collectors; import org.bukkit.Material; public final class MaterialUtil { @@ -21,24 +23,9 @@ private static String capitalize(String text) { return text; } - String[] words = text.split(SPACE); - StringBuilder result = new StringBuilder(); - - for (int i = 0; i < words.length; i++) { - String word = words[i]; - - if (!word.isEmpty()) { - result.append(Character.toUpperCase(word.charAt(0))); - if (word.length() > 1) { - result.append(word.substring(1)); - } - } - - if (i < words.length - 1) { - result.append(SPACE); - } - } - - return result.toString(); + return Arrays.stream(text.split(SPACE)) + .filter(word -> !word.isEmpty()) + .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1)) + .collect(Collectors.joining(SPACE)); } } From 33ac56eb58789b642485c7f868f7e78f880f107d Mon Sep 17 00:00:00 2001 From: Martin Sulikowski Date: Sat, 18 Oct 2025 00:42:15 +0200 Subject: [PATCH 4/6] revert --- buildSrc/src/main/kotlin/Versions.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/buildSrc/src/main/kotlin/Versions.kt b/buildSrc/src/main/kotlin/Versions.kt index 96d73667f..427ba5328 100644 --- a/buildSrc/src/main/kotlin/Versions.kt +++ b/buildSrc/src/main/kotlin/Versions.kt @@ -1,7 +1,7 @@ object Versions { - const val SPIGOT_API = "1.21.10-R0.1-SNAPSHOT" - const val PAPER_API = "1.21.10-R0.1-SNAPSHOT" + const val SPIGOT_API = "1.21.3-R0.1-SNAPSHOT" + const val PAPER_API = "1.21.3-R0.1-SNAPSHOT" const val ETERNALCODE_COMMONS = "1.3.1" const val MULTIFICATION = "1.2.2" From 5f65256961748696d56716f7f2f92b830d0d2366 Mon Sep 17 00:00:00 2001 From: Martin Sulikowski Date: Mon, 20 Oct 2025 20:13:16 +0200 Subject: [PATCH 5/6] Follow @noyzys review. --- .../litecommand/argument/ArgumentParser.java | 52 +++++++++++++++++++ .../argument/GameModeArgument.java | 41 +++++++++++---- 2 files changed, 84 insertions(+), 9 deletions(-) create mode 100644 eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/ArgumentParser.java diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/ArgumentParser.java b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/ArgumentParser.java new file mode 100644 index 000000000..4df9062bf --- /dev/null +++ b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/ArgumentParser.java @@ -0,0 +1,52 @@ +package com.eternalcode.core.litecommand.argument; + +import dev.rollczi.litecommands.argument.parser.ParseResult; +import java.util.function.Function; +import java.util.function.Predicate; +import java.util.function.Supplier; + +final class ArgumentParser { + + private final Function> parser; + + private ArgumentParser(Function> parser) { + this.parser = parser; + } + + public static ArgumentParser of() { + return new ArgumentParser<>(input -> ParseResult.failure(new Object())); + } + + public ArgumentParser thenTry(Function> nextParser) { + return new ArgumentParser<>(input -> this.parser.apply(input) + .mapFailure(ignored -> nextParser.apply(input))); + } + + public ArgumentParser thenTryIf( + Predicate condition, + Function> nextParser + ) { + return new ArgumentParser<>(input -> this.parser.apply(input) + .mapFailure(ignored -> { + if (condition.test(input)) { + return nextParser.apply(input); + } + return ParseResult.failure(new Object()); + })); + } + + public Function> build() { + return this.parser; + } + + public Function> buildWithFinalFailure(Function> finalFailure) { + return input -> this.parser.apply(input) + .mapFailure(ignored -> finalFailure.apply(input)); + } + + public Function> buildWithFinalFailure(Supplier> finalFailure) { + return input -> this.parser.apply(input) + .mapFailure(ignored -> finalFailure.get()); + } +} + diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java index ed5d383d1..45c507540 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/litecommand/argument/GameModeArgument.java @@ -10,6 +10,8 @@ import dev.rollczi.litecommands.invocation.Invocation; import dev.rollczi.litecommands.suggestion.SuggestionContext; import dev.rollczi.litecommands.suggestion.SuggestionResult; +import java.util.Locale; +import java.util.function.Function; import org.bukkit.GameMode; import org.bukkit.command.CommandSender; @@ -17,24 +19,23 @@ class GameModeArgument extends AbstractViewerArgument { private final GameModeArgumentSettings gameModeArgumentSettings; + private final ArgumentParser gameModeArgumentParser; @Inject GameModeArgument(TranslationManager translationManager, GameModeArgumentSettings gameModeArgumentSettings) { super(translationManager); this.gameModeArgumentSettings = gameModeArgumentSettings; + this.gameModeArgumentParser = createGameModeArgumentParser(); } @Override public ParseResult parse(Invocation invocation, String argument, Translation translation) { - try { - GameMode gameMode = GameMode.valueOf(argument.toUpperCase()); - return ParseResult.success(gameMode); - } - catch (IllegalArgumentException exception) { - return this.gameModeArgumentSettings.getByAlias(argument) - .map(ParseResult::success) - .orElseGet(() -> ParseResult.failure(translation.gamemode().gamemodeTypeInvalid())); - } + String normalizedInput = argument.trim().toUpperCase(Locale.ROOT); + + Function> finalParser = this.gameModeArgumentParser + .buildWithFinalFailure(input -> ParseResult.failure(translation.gamemode().gamemodeTypeInvalid())); + + return finalParser.apply(normalizedInput); } @Override @@ -47,4 +48,26 @@ public SuggestionResult suggest( .stream() .collect(SuggestionResult.collector()); } + + private ArgumentParser createGameModeArgumentParser() { + return ArgumentParser.of() + .thenTry(this::parseDirectGameMode) + .thenTry(this::parseFromAliases); + } + + private ParseResult parseDirectGameMode(String normalizedInput) { + try { + GameMode gameMode = GameMode.valueOf(normalizedInput); + return ParseResult.success(gameMode); + } + catch (IllegalArgumentException exception) { + return ParseResult.failure(new Object()); + } + } + + private ParseResult parseFromAliases(String normalizedInput) { + return this.gameModeArgumentSettings.getByAlias(normalizedInput) + .map(ParseResult::success) + .orElseGet(() -> ParseResult.failure(new Object())); + } } From 0ad7406cb5e8c6518b1e3468d642ff00c81b2304 Mon Sep 17 00:00:00 2001 From: Martin Sulikowski Date: Mon, 20 Oct 2025 20:16:42 +0200 Subject: [PATCH 6/6] Fix. --- .../feature/fullserverbypass/FullServerBypassController.java | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java index 06aa9ba00..011232ba3 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/fullserverbypass/FullServerBypassController.java @@ -64,7 +64,7 @@ private String getServerFullMessage(Player player) { List messages = userOption .map(user -> this.translationManager.getMessages(user.getUniqueId()).online().serverFull()) - .orElseGet(() -> this.translationManager.getMessages(user.getUniqueId()).online().serverFull()); + .orElseGet(() -> this.translationManager.getMessages(player.getUniqueId()).online().serverFull()); return String.join(LINE_SEPARATOR, messages); }