From e85eb0aeadcf9b1cc9242ae34029ec10bfc22beb Mon Sep 17 00:00:00 2001 From: Miles Holder Date: Sat, 17 Feb 2024 16:57:00 -0600 Subject: [PATCH 1/3] start conversion --- .../core/command/parsed/arguments/WorldArg.kt | 17 +++++++++++ .../modules/basicsworld/BasicsWorldCommand.kt | 27 +++++++++++++++++ .../modules/basicsworld/BasicsWorldModule.kt | 29 ++++++++++++++++++- 3 files changed, 72 insertions(+), 1 deletion(-) create mode 100644 core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt create mode 100644 modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt new file mode 100644 index 00000000..1cac8a85 --- /dev/null +++ b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt @@ -0,0 +1,17 @@ +package com.github.spigotbasics.core.command.parsed.arguments + +import com.github.spigotbasics.core.Basics +import com.github.spigotbasics.core.messages.Message +import org.bukkit.Bukkit +import org.bukkit.World +import org.bukkit.command.CommandSender + +class WorldArg(name: String) : CommandArgument(name) { + override fun parse(sender: CommandSender, value: String): World? { + return Bukkit.getWorld(value) + } + + override fun errorMessage(sender: CommandSender, value: String): Message { + return Basics.messages.getMessage("world-not-found") + } +} diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt new file mode 100644 index 00000000..075f3053 --- /dev/null +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt @@ -0,0 +1,27 @@ +package com.github.spigotbasics.modules.basicsworld + +import com.github.spigotbasics.core.command.parsed.CommandContextExecutor +import com.github.spigotbasics.core.command.parsed.context.MapContext +import com.github.spigotbasics.core.util.TeleportUtils +import org.bukkit.World +import org.bukkit.command.CommandSender +import org.bukkit.entity.Player + +class BasicsWorldCommand(private val module: BasicsWorldModule) : CommandContextExecutor { + + override fun execute(sender: CommandSender, context: MapContext) { + val player = sender as Player + val force: Boolean = context["force"] != null + val world: World = context["world"] as World + + val origin = player.location + + if (world == player.world) { + module.msgAlreadyInWorld(world.name).sendToSender(player) + return + } + + val targetLocation = TeleportUtils.getScaledLocationInOtherWorld(origin, world) + + } +} diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt index f34d1ee0..1bb2d218 100644 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt @@ -1,11 +1,14 @@ package com.github.spigotbasics.modules.basicsworld +import com.github.spigotbasics.core.command.parsed.arguments.StringOptionArg +import com.github.spigotbasics.core.command.parsed.arguments.WorldArg import com.github.spigotbasics.core.module.AbstractBasicsModule import com.github.spigotbasics.core.module.loader.ModuleInstantiationContext import org.bukkit.permissions.Permission class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsModule(context) { - private val permission = permissionManager.createSimplePermission("basics.world", "Allows to switch worlds using /world") + private val permission = + permissionManager.createSimplePermission("basics.world", "Allows to switch worlds using /world") val worldPermissions = mutableMapOf() fun msgAlreadyInWorld(world: String) = messages.getMessage("already-in-world").tagUnparsed("world", world) @@ -20,6 +23,30 @@ class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsMod ).tagUnparsed("world", world) override fun onEnable() { + val worldArg = WorldArg("World") + val forceArg = StringOptionArg("Force", listOf("--force", "-f")) + commandFactory.parsedCommandBuilder("world", permission) + .mapContext { + usage = "[world]" + aliases(listOf("worldtp", "tpworld")) + + description("Teleport to another world") + + path { + playerOnly() + arguments { + named("world", worldArg) + } + } + + path { + playerOnly() + arguments { + named("forced", forceArg) + named("world", worldArg) + } + } + } commandFactory.rawCommandBuilder("world", permission) .usage("") .description("Teleport to another world") From 87106c09eaf0d28d2d2b788423090f6f91dbd474 Mon Sep 17 00:00:00 2001 From: Miles Holder Date: Sat, 17 Feb 2024 17:34:51 -0600 Subject: [PATCH 2/3] convert world teleport to parsed command executor --- .../core/command/parsed/arguments/WorldArg.kt | 17 --- .../modules/basicsworld/BasicsWorldCommand.kt | 43 +++++- .../modules/basicsworld/BasicsWorldModule.kt | 12 +- .../modules/basicsworld/LocationList.kt | 26 ---- .../modules/basicsworld/WorldArg.kt | 33 +++++ .../modules/basicsworld/WorldCommand.kt | 134 ------------------ 6 files changed, 77 insertions(+), 188 deletions(-) delete mode 100644 core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt delete mode 100644 modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/LocationList.kt create mode 100644 modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt delete mode 100644 modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldCommand.kt diff --git a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt b/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt deleted file mode 100644 index 1cac8a85..00000000 --- a/core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/WorldArg.kt +++ /dev/null @@ -1,17 +0,0 @@ -package com.github.spigotbasics.core.command.parsed.arguments - -import com.github.spigotbasics.core.Basics -import com.github.spigotbasics.core.messages.Message -import org.bukkit.Bukkit -import org.bukkit.World -import org.bukkit.command.CommandSender - -class WorldArg(name: String) : CommandArgument(name) { - override fun parse(sender: CommandSender, value: String): World? { - return Bukkit.getWorld(value) - } - - override fun errorMessage(sender: CommandSender, value: String): Message { - return Basics.messages.getMessage("world-not-found") - } -} diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt index 075f3053..51c5337b 100644 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt @@ -1,15 +1,19 @@ package com.github.spigotbasics.modules.basicsworld +import com.github.spigotbasics.core.Spiper import com.github.spigotbasics.core.command.parsed.CommandContextExecutor import com.github.spigotbasics.core.command.parsed.context.MapContext import com.github.spigotbasics.core.util.TeleportUtils import org.bukkit.World import org.bukkit.command.CommandSender import org.bukkit.entity.Player +import java.util.logging.Level class BasicsWorldCommand(private val module: BasicsWorldModule) : CommandContextExecutor { - - override fun execute(sender: CommandSender, context: MapContext) { + override fun execute( + sender: CommandSender, + context: MapContext, + ) { val player = sender as Player val force: Boolean = context["force"] != null val world: World = context["world"] as World @@ -23,5 +27,40 @@ class BasicsWorldCommand(private val module: BasicsWorldModule) : CommandContext val targetLocation = TeleportUtils.getScaledLocationInOtherWorld(origin, world) + if (force) { + Spiper.teleportAsync(player, targetLocation) + } + + val future = TeleportUtils.findSafeLocationInSameChunkAsync(targetLocation, world.minHeight, world.maxHeight) + future.thenAccept { safeLocation -> + if (safeLocation == null) { + module.coreMessages.noSafeLocationFound.sendToSender(player) + return@thenAccept + } + + module.scheduler.runTask { + Spiper.teleportAsync(player, safeLocation).whenComplete { success, throwable -> + module.msgUnsuccessful(world.name).sendToSender(player) + if (throwable != null || !success) { + module.msgUnsuccessful(world.name).sendToSender(player) + throwable?.let { + module.logger.log( + Level.SEVERE, + "Could not teleport player to world ${world.name}", + it, + ) + } + } else if (success) { + module.msgSuccess(world.name).sendToSender(player) + } + } + } + }.exceptionally { throwable -> + module.logger.log(Level.SEVERE, "Could not find safe location for player", throwable) + module.msgUnsuccessful(world.name).sendToSender(player) + null + } + + module.msgStartingTeleport(world.name).sendToPlayerActionBar(player) } } diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt index 1bb2d218..ad657880 100644 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt @@ -1,7 +1,6 @@ package com.github.spigotbasics.modules.basicsworld import com.github.spigotbasics.core.command.parsed.arguments.StringOptionArg -import com.github.spigotbasics.core.command.parsed.arguments.WorldArg import com.github.spigotbasics.core.module.AbstractBasicsModule import com.github.spigotbasics.core.module.loader.ModuleInstantiationContext import org.bukkit.permissions.Permission @@ -23,7 +22,7 @@ class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsMod ).tagUnparsed("world", world) override fun onEnable() { - val worldArg = WorldArg("World") + val worldArg = WorldArg(this, "World") val forceArg = StringOptionArg("Force", listOf("--force", "-f")) commandFactory.parsedCommandBuilder("world", permission) .mapContext { @@ -42,16 +41,11 @@ class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsMod path { playerOnly() arguments { - named("forced", forceArg) named("world", worldArg) + named("forced", forceArg) } } - } - commandFactory.rawCommandBuilder("world", permission) - .usage("") - .description("Teleport to another world") - .executor(WorldCommand(this)) - .register() + }.executor(BasicsWorldCommand(this)).register() server.worlds.forEach { getWorldPermission(it.name) diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/LocationList.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/LocationList.kt deleted file mode 100644 index 764b096d..00000000 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/LocationList.kt +++ /dev/null @@ -1,26 +0,0 @@ -package com.github.spigotbasics.modules.basicsworld - -import com.github.spigotbasics.core.model.SimpleLocation -import org.bukkit.Location -import org.bukkit.World - -class LocationList { - val lastLocations = mutableListOf() - - fun storeLastLocation(loc: SimpleLocation) { - removeLastLocation(loc.world) - lastLocations.add(loc) - } - - fun removeLastLocation(world: String) { - lastLocations.removeIf { it.world == world } - } - - fun getLastLocation(world: String): SimpleLocation? { - return lastLocations.find { it.world == world } - } - - fun getLastLocationOrDefault(world: World): Location { - return getLastLocation(world.name)?.toLocation(world) ?: world.spawnLocation - } -} diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt new file mode 100644 index 00000000..d31dde04 --- /dev/null +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt @@ -0,0 +1,33 @@ +package com.github.spigotbasics.modules.basicsworld + +import com.github.spigotbasics.core.Basics +import com.github.spigotbasics.core.command.parsed.arguments.CommandArgument +import com.github.spigotbasics.core.messages.Message +import org.bukkit.Bukkit +import org.bukkit.World +import org.bukkit.command.CommandSender +import java.util.stream.Collectors + +class WorldArg(private val module: BasicsWorldModule, name: String) : CommandArgument(name) { + override fun parse( + sender: CommandSender, + value: String, + ): World? { + return if (sender.hasPermission("basics.world.$value")) Bukkit.getWorld(value) else null + } + + override fun errorMessage( + sender: CommandSender, + value: String, + ): Message { + return Basics.messages.getMessage("world-not-found").tagUnparsed("argument", value) + } + + override fun tabComplete( + sender: CommandSender, + typing: String, + ): List { + return Bukkit.getWorlds().stream().map { it.name }.filter { sender.hasPermission("basics.world.$it") } + .collect(Collectors.toList()) + } +} diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldCommand.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldCommand.kt deleted file mode 100644 index e5829d47..00000000 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldCommand.kt +++ /dev/null @@ -1,134 +0,0 @@ -package com.github.spigotbasics.modules.basicsworld - -import com.github.spigotbasics.core.Spiper -import com.github.spigotbasics.core.command.common.BasicsCommandExecutor -import com.github.spigotbasics.core.command.common.CommandResult -import com.github.spigotbasics.core.command.raw.RawCommandContext -import com.github.spigotbasics.core.extensions.partialMatches -import com.github.spigotbasics.core.util.TeleportUtils -import com.github.spigotbasics.core.util.WorldUtils -import org.bukkit.Bukkit -import org.bukkit.World -import org.bukkit.permissions.Permissible -import java.util.logging.Level - -class WorldCommand(val module: BasicsWorldModule) : BasicsCommandExecutor(module) { - override fun execute(context: RawCommandContext): CommandResult { - val player = notFromConsole(context.sender) - val args = context.args - if (args.isEmpty()) { - return CommandResult.USAGE - } - - context.readFlags() - val force = (context.popFlag("-f") or context.popFlag("--force")) - - val origin = player.location - val newWorld = getWorld(args[0]) - if (newWorld == null) { - coreMessages.worldNotFound(args[0]).sendToSender(player) - return CommandResult.SUCCESS // TODO: CommandResult.worldNotFound(String) - } - - if (newWorld == origin.world) { - module.msgAlreadyInWorld(newWorld.name).sendToSender(player) - return CommandResult.SUCCESS - } - - val translatedTargetLocation = TeleportUtils.getScaledLocationInOtherWorld(origin, newWorld) - - requirePermission(player, module.getWorldPermission(newWorld.name)) - - if (force) { - Spiper.teleportAsync(player, translatedTargetLocation) - return CommandResult.SUCCESS - } - - val future = - TeleportUtils.findSafeLocationInSameChunkAsync( - translatedTargetLocation, - newWorld.minHeight, - newWorld.maxHeight, - ) - - future.thenAccept { safeLocation -> - - module.messageFactory.createPlainMessage("").sendToPlayerActionBar(player) - - if (safeLocation == null) { - coreMessages.noSafeLocationFound.sendToSender(player) - } else { - module.scheduler.runTask { - Spiper.teleportAsync(player, safeLocation).whenComplete { success, throwable -> - if (throwable != null || !success) { - module.msgUnsuccessful(newWorld.name).sendToSender(player) - throwable?.let { - module.logger.log( - Level.SEVERE, - "Could not teleport player to world ${newWorld.name}", - it, - ) - } - } else if (success) { - module.msgSuccess(newWorld.name).sendToSender(player) - } - } - } - } - }.exceptionally { throwable -> - module.logger.log(Level.SEVERE, "Could not find safe location for player", throwable) - module.msgUnsuccessful(newWorld.name).sendToSender(player) - null - } - - module.msgStartingTeleport(newWorld.name).sendToPlayerActionBar(player) - return CommandResult.SUCCESS - } - - fun getWorld(name: String): World? { - val worlds = Bukkit.getWorlds() - return when (name) { - "0" -> worlds[0] - "1" -> worlds.find { it.environment == World.Environment.NETHER } - "2" -> worlds.find { it.environment == World.Environment.THE_END } - else -> Bukkit.getWorld(name) - } - } - - override fun tabComplete(context: RawCommandContext): List { - val args = context.args - if (args.size == 1) { - return allWorldsAnd012(context.sender).apply { - if (isNotEmpty()) { - add("--force") - add("-f") - } - }.partialMatches(args[0]) - } - if (args.size == 2) { - if (args[0] == "--force" || args[0] == "-f") { - return allWorldsAnd012(context.sender).partialMatches(args[1]) - } - } - return mutableListOf() - } - - private fun allWorldsAnd012(sender: Permissible): MutableList { - val list = - Bukkit.getWorlds().filter { - val hasPerm = sender.hasPermission(module.getWorldPermission(it.name)) - return@filter hasPerm - }.map { it.name }.toMutableList() - - if (list.contains(WorldUtils.defaultWorldName)) { - list.add("0") - } - if (list.contains(WorldUtils.netherWorldName)) { - list.add("1") - } - if (list.contains(WorldUtils.endWorldName)) { - list.add("2") - } - return list - } -} From ba8cf49f1ffe21e9c620fcdc02b161fd683fe01d Mon Sep 17 00:00:00 2001 From: mfnalex Date: Sun, 18 Feb 2024 12:08:09 +0100 Subject: [PATCH 3/3] Fixed /world --- .../modules/basicsworld/BasicsWorldCommand.kt | 20 ++++++-- .../modules/basicsworld/BasicsWorldModule.kt | 8 +-- .../modules/basicsworld/WorldArg.kt | 51 +++++++++++++++++-- 3 files changed, 68 insertions(+), 11 deletions(-) diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt index 51c5337b..d411ed21 100644 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldCommand.kt @@ -3,6 +3,7 @@ package com.github.spigotbasics.modules.basicsworld import com.github.spigotbasics.core.Spiper import com.github.spigotbasics.core.command.parsed.CommandContextExecutor import com.github.spigotbasics.core.command.parsed.context.MapContext +import com.github.spigotbasics.core.logger.BasicsLoggerFactory import com.github.spigotbasics.core.util.TeleportUtils import org.bukkit.World import org.bukkit.command.CommandSender @@ -10,6 +11,8 @@ import org.bukkit.entity.Player import java.util.logging.Level class BasicsWorldCommand(private val module: BasicsWorldModule) : CommandContextExecutor { + private val logger = BasicsLoggerFactory.getModuleLogger(module, BasicsWorldCommand::class) + override fun execute( sender: CommandSender, context: MapContext, @@ -20,28 +23,39 @@ class BasicsWorldCommand(private val module: BasicsWorldModule) : CommandContext val origin = player.location + logger.debug(100, "Teleporting player ${player.name} to world ${world.name}") + if (world == player.world) { module.msgAlreadyInWorld(world.name).sendToSender(player) + logger.debug(100, "Abort: Player already is in target world") return } val targetLocation = TeleportUtils.getScaledLocationInOtherWorld(origin, world) + logger.debug(100, "Scaled target location: $targetLocation") if (force) { + logger.debug(100, "Force-Teleporting player ${player.name} to world ${world.name} now ...") Spiper.teleportAsync(player, targetLocation) + return } + module.msgStartingTeleport(world.name).sendToPlayerActionBar(player) + val future = TeleportUtils.findSafeLocationInSameChunkAsync(targetLocation, world.minHeight, world.maxHeight) + future.thenAccept { safeLocation -> if (safeLocation == null) { + logger.debug(100, "No safe location found.") module.coreMessages.noSafeLocationFound.sendToSender(player) return@thenAccept } module.scheduler.runTask { + logger.debug(100, "Safe location found: $safeLocation") Spiper.teleportAsync(player, safeLocation).whenComplete { success, throwable -> - module.msgUnsuccessful(world.name).sendToSender(player) if (throwable != null || !success) { + logger.debug(100, "Could not teleport player to world ${world.name} - success: $success, throwable: $throwable") module.msgUnsuccessful(world.name).sendToSender(player) throwable?.let { module.logger.log( @@ -51,16 +65,16 @@ class BasicsWorldCommand(private val module: BasicsWorldModule) : CommandContext ) } } else if (success) { + logger.debug(100, "Player ${player.name} teleported to world ${world.name} successfully") module.msgSuccess(world.name).sendToSender(player) } } } }.exceptionally { throwable -> + logger.debug(100, "Exception while finding safe location for player: $throwable") module.logger.log(Level.SEVERE, "Could not find safe location for player", throwable) module.msgUnsuccessful(world.name).sendToSender(player) null } - - module.msgStartingTeleport(world.name).sendToPlayerActionBar(player) } } diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt index ad657880..370a7780 100644 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/BasicsWorldModule.kt @@ -3,6 +3,7 @@ package com.github.spigotbasics.modules.basicsworld import com.github.spigotbasics.core.command.parsed.arguments.StringOptionArg import com.github.spigotbasics.core.module.AbstractBasicsModule import com.github.spigotbasics.core.module.loader.ModuleInstantiationContext +import org.bukkit.World import org.bukkit.permissions.Permission class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsModule(context) { @@ -42,13 +43,13 @@ class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsMod playerOnly() arguments { named("world", worldArg) - named("forced", forceArg) + named("force", forceArg) } } }.executor(BasicsWorldCommand(this)).register() server.worlds.forEach { - getWorldPermission(it.name) + getWorldPermission(it) } } @@ -57,7 +58,8 @@ class BasicsWorldModule(context: ModuleInstantiationContext) : AbstractBasicsMod messages.reload() } - fun getWorldPermission(name: String): Permission { + fun getWorldPermission(world: World): Permission { + val name = world.name return worldPermissions.computeIfAbsent(name.lowercase()) { permissionManager.createSimplePermission( "basics.world.${name.lowercase()}", diff --git a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt index d31dde04..9cbb69c3 100644 --- a/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt +++ b/modules/basics-world/src/main/kotlin/com/github/spigotbasics/modules/basicsworld/WorldArg.kt @@ -3,31 +3,72 @@ package com.github.spigotbasics.modules.basicsworld import com.github.spigotbasics.core.Basics import com.github.spigotbasics.core.command.parsed.arguments.CommandArgument import com.github.spigotbasics.core.messages.Message +import com.github.spigotbasics.core.util.WorldUtils import org.bukkit.Bukkit import org.bukkit.World import org.bukkit.command.CommandSender -import java.util.stream.Collectors +import org.bukkit.permissions.Permissible class WorldArg(private val module: BasicsWorldModule, name: String) : CommandArgument(name) { override fun parse( sender: CommandSender, value: String, ): World? { - return if (sender.hasPermission("basics.world.$value")) Bukkit.getWorld(value) else null + val world = getWorld(value) ?: return null + if (!sender.hasPermission(module.getWorldPermission(world))) { + return null + } + return world + } + + private fun getWorld(name: String): World? { + val worlds = Bukkit.getWorlds() + return when (name) { + "0" -> worlds[0] + "1" -> worlds.find { it.environment == World.Environment.NETHER } + "2" -> worlds.find { it.environment == World.Environment.THE_END } + else -> Bukkit.getWorld(name) + } } override fun errorMessage( sender: CommandSender, value: String, ): Message { - return Basics.messages.getMessage("world-not-found").tagUnparsed("argument", value) + val world = getWorld(value) + if (world == null) { + return Basics.messages.worldNotFound(value) + } + val perm = module.getWorldPermission(world) + if (!sender.hasPermission(perm)) { + return Basics.messages.noPermission(perm) + } + throw IllegalStateException() } override fun tabComplete( sender: CommandSender, typing: String, ): List { - return Bukkit.getWorlds().stream().map { it.name }.filter { sender.hasPermission("basics.world.$it") } - .collect(Collectors.toList()) + return allWorldsAnd012(sender) + } + + private fun allWorldsAnd012(sender: Permissible): MutableList { + val list = + Bukkit.getWorlds().filter { + val hasPerm = sender.hasPermission(module.getWorldPermission(it)) + return@filter hasPerm + }.map { it.name }.toMutableList() + + if (list.contains(WorldUtils.defaultWorldName)) { + list.add("0") + } + if (list.contains(WorldUtils.netherWorldName)) { + list.add("1") + } + if (list.contains(WorldUtils.endWorldName)) { + list.add("2") + } + return list } }