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 5fb9a3239..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 @@ -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().online().serverFull()) - .toString(); - } - - User user = userOption.get(); + List messages = userOption + .map(user -> this.translationManager.getMessages(user.getUniqueId()).online().serverFull()) + .orElseGet(() -> this.translationManager.getMessages(player.getUniqueId()).online().serverFull()); - return Joiner.on("\n") - .join(this.translationManager.getMessages(user.getUniqueId()).online().serverFull()) - .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/onlineplayers/OnlinePlayersListCommand.java b/eternalcore-core/src/main/java/com/eternalcode/core/feature/onlineplayers/OnlinePlayersListCommand.java index f954c5441..2b54029f2 100644 --- a/eternalcore-core/src/main/java/com/eternalcode/core/feature/onlineplayers/OnlinePlayersListCommand.java +++ b/eternalcore-core/src/main/java/com/eternalcode/core/feature/onlineplayers/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.online().onlinePlayersList()) 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/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 9167ea4bc..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,43 +10,64 @@ 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; -import panda.std.Option; - -import java.util.Optional; @LiteArgument(type = GameMode.class) 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) { - Option gameMode = Option.supplyThrowing(IllegalArgumentException.class, () -> GameMode.valueOf(argument.toUpperCase())); - - if (gameMode.isPresent()) { - return ParseResult.success(gameMode.get()); - } + String normalizedInput = argument.trim().toUpperCase(Locale.ROOT); - Optional alias = this.gameModeArgumentSettings.getByAlias(argument); + Function> finalParser = this.gameModeArgumentParser + .buildWithFinalFailure(input -> ParseResult.failure(translation.gamemode().gamemodeTypeInvalid())); - return alias - .map(parsed -> ParseResult.success(parsed)) - .orElseGet(() -> ParseResult.failure(translation.gamemode().gamemodeTypeInvalid())); + return finalParser.apply(normalizedInput); } @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()); } + 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())); + } } 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..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,15 +1,31 @@ package com.eternalcode.core.util; +import java.util.Arrays; +import java.util.stream.Collectors; 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; + } + + return Arrays.stream(text.split(SPACE)) + .filter(word -> !word.isEmpty()) + .map(word -> word.substring(0, 1).toUpperCase() + word.substring(1)) + .collect(Collectors.joining(SPACE)); } } 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}")