feat: implement worlds and world folders arguments in WorldCommand

TheBjoRedCraft · TheBjoRedCraft · commit e83873ac92f0 · 2025-11-02T16:34:01.000+01:00
diff --git a/src/main/kotlin/dev/slne/surf/essentials/command/WorldCommand.kt b/src/main/kotlin/dev/slne/surf/essentials/command/WorldCommand.kt
@@ -1,6 +1,8 @@
 package dev.slne.surf.essentials.command
 
 import dev.jorel.commandapi.kotlindsl.*
+import dev.slne.surf.essentials.command.argument.world.worldFoldersArgument
+import dev.slne.surf.essentials.command.argument.world.worldsArgument
 import dev.slne.surf.essentials.service.worldService
 import dev.slne.surf.essentials.util.permission.EssentialsPermissionRegistry
 import dev.slne.surf.essentials.util.util.isFolia
@@ -12,7 +14,7 @@ fun worldCommand() = commandTree("world") {
     withPermission(EssentialsPermissionRegistry.WORLD_COMMAND)
 
     literalArgument("lock") {
-        worldArgument("world") {
+        worldsArgument("world") {
             withPermission(EssentialsPermissionRegistry.WORLD_COMMAND_LOCK)
             anyExecutor { executor, args ->
                 val world: World by args
@@ -45,7 +47,7 @@ fun worldCommand() = commandTree("world") {
     }
 
     literalArgument("unlock") {
-        worldArgument("world") {
+        worldsArgument("world") {
             withPermission(EssentialsPermissionRegistry.WORLD_COMMAND_UNLOCK)
             anyExecutor { executor, args ->
                 val world: World by args
@@ -78,7 +80,7 @@ fun worldCommand() = commandTree("world") {
     }
 
     literalArgument("join") {
-        worldArgument("world") {
+        worldsArgument("world") {
             withPermission(EssentialsPermissionRegistry.WORLD_COMMAND_JOIN)
             playerExecutor { player, args ->
                 val world: World by args
@@ -122,7 +124,7 @@ fun worldCommand() = commandTree("world") {
     }
 
     literalArgument("delete") {
-        worldArgument("world") {
+        worldsArgument("world") {
             withPermission(EssentialsPermissionRegistry.WORLD_COMMAND_DELETE)
             anyExecutor { executor, args ->
                 val world: World by args
@@ -141,7 +143,7 @@ fun worldCommand() = commandTree("world") {
     }
 
     literalArgument("load") {
-        stringArgument("name") {
+        worldFoldersArgument("name") {
             withPermission(EssentialsPermissionRegistry.WORLD_COMMAND_LOAD)
             anyExecutor { executor, args ->
                 val name: String by args
@@ -161,7 +163,7 @@ fun worldCommand() = commandTree("world") {
     }
 
     literalArgument("unload") {
-        worldArgument("world") {
+        worldsArgument("world") {
             withPermission(EssentialsPermissionRegistry.WORLD_COMMAND_UNLOAD)
             anyExecutor { executor, args ->
                 val world: World by args
diff --git a/src/main/kotlin/dev/slne/surf/essentials/command/argument/world/WorldFoldersArgument.kt b/src/main/kotlin/dev/slne/surf/essentials/command/argument/world/WorldFoldersArgument.kt
@@ -0,0 +1,60 @@
+package dev.slne.surf.essentials.command.argument.world
+
+import dev.jorel.commandapi.CommandTree
+import dev.jorel.commandapi.arguments.Argument
+import dev.jorel.commandapi.arguments.ArgumentSuggestions
+import dev.jorel.commandapi.arguments.CustomArgument
+import dev.jorel.commandapi.arguments.StringArgument
+import dev.slne.surf.surfapi.core.api.messages.adventure.buildText
+import org.bukkit.Bukkit
+import org.bukkit.command.CommandSender
+import java.io.File
+
+class WorldFoldersArgument(nodeName: String) :
+    CustomArgument<String, String>(StringArgument(nodeName), { info ->
+        if (File(Bukkit.getWorldContainer(), info.input).exists()) {
+            info.input
+        } else {
+            throw CustomArgumentException.fromAdventureComponent {
+                buildText {
+                    appendPrefix()
+                    error("Der Welten-Ordner wurde nicht gefunden.")
+                }
+            }
+        }
+    }) {
+    init {
+        this.replaceSuggestions(
+            ArgumentSuggestions.stringCollection<CommandSender> {
+                Bukkit.getWorldContainer().listFiles().filter { isMinecraftWorldFolder(it) }
+                    .map { it.name }
+            }
+        )
+    }
+}
+
+private fun isMinecraftWorldFolder(folder: File): Boolean {
+    if (!folder.isDirectory) return false
+
+    val levelDat = File(folder, "level.dat")
+    val regionFolder = File(folder, "region")
+
+    return levelDat.exists() && regionFolder.exists() && regionFolder.isDirectory
+}
+
+
+inline fun CommandTree.worldFoldersArgument(
+    nodeName: String,
+    optional: Boolean = false,
+    block: Argument<*>.() -> Unit = {}
+): CommandTree = then(
+    WorldFoldersArgument(nodeName).setOptional(optional).apply(block)
+)
+
+inline fun Argument<*>.worldFoldersArgument(
+    nodeName: String,
+    optional: Boolean = false,
+    block: Argument<*>.() -> Unit = {}
+): Argument<*> = then(
+    WorldFoldersArgument(nodeName).setOptional(optional).apply(block)
+)
diff --git a/src/main/kotlin/dev/slne/surf/essentials/command/argument/world/WorldsArgument.kt b/src/main/kotlin/dev/slne/surf/essentials/command/argument/world/WorldsArgument.kt
@@ -0,0 +1,45 @@
+package dev.slne.surf.essentials.command.argument.world
+
+import dev.jorel.commandapi.CommandTree
+import dev.jorel.commandapi.arguments.Argument
+import dev.jorel.commandapi.arguments.ArgumentSuggestions
+import dev.jorel.commandapi.arguments.CustomArgument
+import dev.jorel.commandapi.arguments.StringArgument
+import dev.slne.surf.surfapi.core.api.messages.adventure.buildText
+import org.bukkit.Bukkit
+import org.bukkit.World
+import org.bukkit.command.CommandSender
+
+class WorldsArgument(nodeName: String) :
+    CustomArgument<World, String>(StringArgument(nodeName), { info ->
+        Bukkit.getWorld(info.input) ?: throw CustomArgumentException.fromAdventureComponent {
+            buildText {
+                appendPrefix()
+                error("Die Welt wurde nicht gefunden.")
+            }
+        }
+    }) {
+    init {
+        this.replaceSuggestions(
+            ArgumentSuggestions.stringCollection<CommandSender> {
+                Bukkit.getWorlds().map { it.name }
+            }
+        )
+    }
+}
+
+inline fun CommandTree.worldsArgument(
+    nodeName: String,
+    optional: Boolean = false,
+    block: Argument<*>.() -> Unit = {}
+): CommandTree = then(
+    WorldsArgument(nodeName).setOptional(optional).apply(block)
+)
+
+inline fun Argument<*>.worldsArgument(
+    nodeName: String,
+    optional: Boolean = false,
+    block: Argument<*>.() -> Unit = {}
+): Argument<*> = then(
+    WorldsArgument(nodeName).setOptional(optional).apply(block)
+)
diff --git a/src/main/kotlin/dev/slne/surf/essentials/service/WorldService.kt b/src/main/kotlin/dev/slne/surf/essentials/service/WorldService.kt
@@ -6,6 +6,7 @@ import dev.slne.surf.surfapi.core.api.messages.adventure.sendText
 import org.bukkit.*
 import org.bukkit.command.CommandSender
 import org.bukkit.persistence.PersistentDataType
+import java.util.concurrent.CompletableFuture
 
 class WorldService {
     private val accessKey = NamespacedKey(plugin, "world_access")
@@ -137,23 +138,37 @@ class WorldService {
             return
         }
 
-        world.players.forEach {
-            it.teleportAsync(overworldSpawn)
+        val futures = mutableListOf<CompletableFuture<Boolean>>()
+
+        sender.sendText {
+            appendPrefix()
+            info("Teleporiere Spieler aus der Welt...")
         }
 
-        if (!Bukkit.unloadWorld(world, true)) {
-            sender.sendText {
-                appendPrefix()
-                error("Die Welt konnte nicht entladen werden.")
-            }
-            return
+        world.players.forEach {
+            futures.add(it.teleportAsync(overworldSpawn))
         }
 
         sender.sendText {
             appendPrefix()
-            success("Die Welt ")
-            variableValue(world.name)
-            success(" wurde entladen.")
+            info("Die Welt wird entladen...")
+        }
+
+        CompletableFuture.allOf(*futures.toTypedArray()).thenRun {
+            if (!Bukkit.unloadWorld(world, true)) {
+                sender.sendText {
+                    appendPrefix()
+                    error("Die Welt konnte nicht entladen werden.")
+                }
+                return@thenRun
+            }
+
+            sender.sendText {
+                appendPrefix()
+                success("Die Welt ")
+                variableValue(world.name)
+                success(" wurde entladen.")
+            }
         }
     }
 
@@ -174,36 +189,40 @@ class WorldService {
             return
         }
 
+        val futures = mutableListOf<CompletableFuture<Boolean>>()
+
         world.players.forEach {
-            it.teleportAsync(overworldSpawn)
+            futures.add(it.teleportAsync(overworldSpawn))
         }
 
-        if (Bukkit.getWorld(world.name) != null) {
-            if (!Bukkit.unloadWorld(world, true)) {
+        CompletableFuture.allOf(*futures.toTypedArray()).thenRun {
+            if (Bukkit.getWorld(world.name) != null) {
+                if (!Bukkit.unloadWorld(world, true)) {
+                    sender.sendText {
+                        appendPrefix()
+                        error("Die Welt konnte nicht entladen werden.")
+                    }
+                    return@thenRun
+                }
+            }
+
+            val file = Bukkit.getWorldContainer().resolve(world.name)
+            if (!file.exists() || !file.isDirectory) {
                 sender.sendText {
                     appendPrefix()
-                    error("Die Welt konnte nicht entladen werden.")
+                    error("Die Welt existiert nicht.")
                 }
-                return
+                return@thenRun
             }
-        }
 
-        val file = Bukkit.getWorldContainer().resolve(world.name)
-        if (!file.exists() || !file.isDirectory) {
+            file.deleteRecursively()
+
             sender.sendText {
                 appendPrefix()
-                error("Die Welt existiert nicht.")
+                success("Die Welt ")
+                variableValue(world.name)
+                success(" wurde gelöscht.")
             }
-            return
-        }
-
-        file.deleteRecursively()
-
-        sender.sendText {
-            appendPrefix()
-            success("Die Welt ")
-            variableValue(world.name)
-            success(" wurde gelöscht.")
         }
     }
 
