Fix/fix broken commands

gradle.properties

@@ -1,4 +1,4 @@
 kotlin.code.style=official
 kotlin.stdlib.default.dependency=false
 org.gradle.parallel=true
-version=1.21.11-2.0.11-SNAPSHOT
+version=1.21.11-2.0.12-SNAPSHOT

src/main/kotlin/dev/slne/surf/essentials/PaperListenerManager.kt

@@ -12,6 +12,5 @@ object PaperListenerManager {
         UnknownCommandListener.register()
         WorldListener.register()
         SpecialItemListener.register()
-        CommandExecutionListener.register()
     }
 }

src/main/kotlin/dev/slne/surf/essentials/command/argument/GameModeArgument.kt

@@ -5,39 +5,54 @@ 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.essentials.util.permission.EssentialsPermissionRegistry
 import dev.slne.surf.surfapi.core.api.messages.adventure.buildText
 import org.bukkit.GameMode
 import org.bukkit.command.CommandSender
 
 class GameModeArgument(nodeName: String) :
     CustomArgument<GameMode, String>(StringArgument(nodeName), { info ->
-        val gameMode = getGameMode(info.input.lowercase())
+        val input = info.input.lowercase()
+        val gameMode = getGameMode(input)
             ?: throw CustomArgumentException.fromAdventureComponent {
                 buildText {
                     appendErrorPrefix()
                     error("Der Spielmodus wurde nicht gefunden.")
                 }
             }
 
-        val permission = "surf.essentials.gameMode.${gameMode.name.lowercase()}"
         val sender = info.sender
+        if (sender != null) {
+            val base = EssentialsPermissionRegistry.GAME_MODE_COMMAND
+            val specific = "$base.${gameMode.name.lowercase()}"
+            val wildcard = "$base.*"
 
-        if (!sender.hasPermission(permission)) {
-            throw CustomArgumentException.fromAdventureComponent {
-                buildText {
-                    appendErrorPrefix()
-                    error("Dazu hast du keine Berechtigung.")
+            if (!sender.hasPermission(specific) &&
+                !sender.hasPermission(wildcard)
+            ) {
+                throw CustomArgumentException.fromAdventureComponent {
+                    buildText {
+                        appendErrorPrefix()
+                        error("Du hast keine Berechtigung für diesen Spielmodus.")
+                    }
                 }
             }
         }
 
         gameMode
     }) {
+
     init {
-        this.replaceSuggestions(
+        replaceSuggestions(
             ArgumentSuggestions.stringCollection<CommandSender> { sender ->
+                val base = EssentialsPermissionRegistry.GAME_MODE_COMMAND
+                val wildcard = "$base.*"
+
                 GameMode.entries
-                    .filter { sender.sender.hasPermission("surf.essentials.gameMode.${it.name.lowercase()}") }
+                    .filter {
+                        sender.sender.hasPermission(wildcard) ||
+                                sender.sender.hasPermission("$base.${it.name.lowercase()}")
+                    }
                     .map { it.name.lowercase() }
             }
         )

src/main/kotlin/dev/slne/surf/essentials/command/minecraft/GiveComamnd.kt

@@ -2,6 +2,7 @@ package dev.slne.surf.essentials.command.minecraft
 
 import dev.jorel.commandapi.kotlindsl.*
 import dev.slne.surf.essentials.util.permission.EssentialsPermissionRegistry
+import dev.slne.surf.essentials.util.util.translatable
 import dev.slne.surf.surfapi.core.api.messages.adventure.sendText
 import org.bukkit.entity.Player
 import org.bukkit.inventory.ItemStack
@@ -19,9 +20,7 @@ fun giveCommand() = commandTree("give") {
                 executor.sendText {
                     appendSuccessPrefix()
                     success("Du hast ")
-                    variableValue(itemStack.amount.toString())
-                    success("x ")
-                    variableValue(itemStack.type.name)
+                    translatable(itemStack.type.translationKey())
                     success(" an ")
                     variableValue(players.size.toString())
                     success(" Spieler vergeben.")
@@ -31,13 +30,44 @@ fun giveCommand() = commandTree("give") {
                     player.sendText {
                         appendSuccessPrefix()
                         success("Du hast ")
-                        variableValue(itemStack.amount.toString())
-                        success("x ")
-                        variableValue(itemStack.type.name)
+                        translatable(itemStack.type.translationKey())
                         success(" erhalten.")
                     }
                 }
             }
+
+            integerArgument("amount") {
+                anyExecutor { executor, args ->
+                    val itemStack: ItemStack by args
+                    val amount: Int by args
+                    val players: Collection<Player> by args
+
+                    itemStack.amount = amount
+                    players.forEach { it.inventory.addItem(itemStack) }
+
+                    executor.sendText {
+                        appendSuccessPrefix()
+                        success("Du hast ")
+                        variableValue(amount.toString())
+                        success("x ")
+                        translatable(itemStack.type.translationKey())
+                        success(" an ")
+                        variableValue(players.size.toString())
+                        success(" Spieler vergeben.")
+                    }
+
+                    players.forEach { player ->
+                        player.sendText {
+                            appendSuccessPrefix()
+                            success("Du hast ")
+                            variableValue(amount.toString())
+                            success("x ")
+                            translatable(itemStack.type.translationKey())
+                            success(" erhalten.")
+                        }
+                    }
+                }
+            }
         }
     }
 }

src/main/kotlin/dev/slne/surf/essentials/command/minecraft/SummonCommand.kt

@@ -3,11 +3,17 @@ package dev.slne.surf.essentials.command.minecraft
 import dev.jorel.commandapi.kotlindsl.*
 import dev.slne.surf.essentials.util.permission.EssentialsPermissionRegistry
 import dev.slne.surf.essentials.util.util.translatable
+import dev.slne.surf.surfapi.bukkit.api.command.args.adventureCompoundBinaryTagArgument
+import dev.slne.surf.surfapi.bukkit.api.nms.NmsUseWithCaution
+import dev.slne.surf.surfapi.bukkit.api.nms.bridges.entityBridge
 import dev.slne.surf.surfapi.core.api.messages.Colors
 import dev.slne.surf.surfapi.core.api.messages.adventure.sendText
+import net.kyori.adventure.nbt.CompoundBinaryTag
 import org.bukkit.Location
 import org.bukkit.entity.EntityType
 
+@Suppress("UnstableApiUsage")
+@NmsUseWithCaution
 fun summonCommand() = commandTree("summon") {
     withPermission(EssentialsPermissionRegistry.SUMMON_COMMAND)
     entityTypeArgument("entityType") {
@@ -23,30 +29,64 @@ fun summonCommand() = commandTree("summon") {
             }
         }
 
-        integerArgument("amount") {
+        locationArgument("location") {
             playerExecutor { player, args ->
                 val entityType: EntityType by args
-                val amount: Int by args
+                val location: Location by args
 
-                repeat(amount) {
-                    player.location.world.spawnEntity(player.location, entityType)
-                }
+                location.world.spawnEntity(location, entityType)
 
                 player.sendText {
                     appendSuccessPrefix()
                     success("Du hast ")
-                    variableValue(amount)
-                    success(" ")
                     translatable(entityType.translationKey()).color(Colors.VARIABLE_VALUE)
                     success(" beschworen.")
                 }
             }
 
-            locationArgument("location") {
+            adventureCompoundBinaryTagArgument("nbt") {
+                playerExecutor { player, args ->
+                    val entityType: EntityType by args
+                    val location: Location by args
+                    val nbt: CompoundBinaryTag by args
+
+                    entityBridge.createEntityByNbt(player.world, entityType, location, nbt)
+
+                    player.sendText {
+                        appendSuccessPrefix()
+                        success("Du hast ")
+                        translatable(entityType.translationKey()).color(Colors.VARIABLE_VALUE)
+                        success(" beschworen.")
+                    }
+                }
+
+                integerArgument("amount") {
+                    playerExecutor { player, args ->
+                        val entityType: EntityType by args
+                        val location: Location by args
+                        val nbt: CompoundBinaryTag by args
+                        val amount: Int by args
+
+                        repeat(amount) {
+                            entityBridge.createEntityByNbt(player.world, entityType, location, nbt)
+                        }
+
+                        player.sendText {
+                            appendSuccessPrefix()
+                            success("Du hast ")
+                            success("$amount ")
+                            translatable(entityType.translationKey()).color(Colors.VARIABLE_VALUE)
+                            success(" beschworen.")
+                        }
+                    }
+                }
+            }
+
+            integerArgument("amount") {
                 playerExecutor { player, args ->
                     val entityType: EntityType by args
-                    val amount: Int by args
                     val location: Location by args
+                    val amount: Int by args
 
                     repeat(amount) {
                         location.world.spawnEntity(location, entityType)
@@ -55,13 +95,12 @@ fun summonCommand() = commandTree("summon") {
                     player.sendText {
                         appendSuccessPrefix()
                         success("Du hast ")
-                        variableValue(amount)
-                        success(" ")
+                        success("$amount ")
                         translatable(entityType.translationKey()).color(Colors.VARIABLE_VALUE)
                         success(" beschworen.")
                     }
                 }
             }
         }
-    }//TODO: add NBT Support
+    }
 }

src/main/kotlin/dev/slne/surf/essentials/command/minecraft/TeleportCommand.kt

@@ -4,14 +4,15 @@ import dev.jorel.commandapi.kotlindsl.*
 import dev.slne.surf.essentials.util.permission.EssentialsPermissionRegistry
 import dev.slne.surf.surfapi.core.api.messages.adventure.sendText
 import org.bukkit.Location
+import org.bukkit.entity.Entity
 import org.bukkit.entity.Player
 
 fun teleportCommand() = commandTree("teleport") {
     withPermission(EssentialsPermissionRegistry.TELEPORT_COMMAND)
     withAliases("tp")
-    entitySelectorArgumentOnePlayer("target") {
+    entitySelectorArgumentOneEntity("target") {
         playerExecutor { player, args ->
-            val target: Player by args
+            val target: Entity by args
 
             player.teleportAsync(target.location)
 
@@ -39,10 +40,10 @@ fun teleportCommand() = commandTree("teleport") {
     }
     entitySelectorArgumentManyPlayers("players") {
         withPermission(EssentialsPermissionRegistry.TELEPORT_COMMAND_OTHERS)
-        entitySelectorArgumentOnePlayer("target") {
+        entitySelectorArgumentOneEntity("target") {
             anyExecutor { executor, args ->
                 val players: Collection<Player> by args
-                val target: Player by args
+                val target: Entity by args
 
                 players.forEach { it.teleportAsync(target.location) }
 

src/main/kotlin/dev/slne/surf/essentials/command/minecraft/TimeCommand.kt

@@ -1,5 +1,6 @@
 package dev.slne.surf.essentials.command.minecraft
 
+import com.github.shynixn.mccoroutine.folia.globalRegionDispatcher
 import com.github.shynixn.mccoroutine.folia.launch
 import dev.jorel.commandapi.kotlindsl.*
 import dev.slne.surf.essentials.command.argument.namedTimeArgument
@@ -102,7 +103,9 @@ fun timeCommand() = commandTree("time") {
                 val time: Int by args
 
                 Bukkit.getWorlds().forEach {
-                    it.fullTime = time.toLong()
+                    plugin.launch(plugin.globalRegionDispatcher) {
+                        it.fullTime = time.toLong()
+                    }
                 }
 
                 executor.sendText {
@@ -130,7 +133,9 @@ fun timeCommand() = commandTree("time") {
                         (24000 - current) + target
                     }
 
-                    world.fullTime += diff
+                    plugin.launch(plugin.globalRegionDispatcher) {
+                        world.fullTime += diff
+                    }
                 }
 
 
@@ -152,10 +157,10 @@ fun timeCommand() = commandTree("time") {
                 val time: Int by args
 
                 Bukkit.getWorlds().forEach {
-                    if (time !in 100..24000) {
-                        it.fullTime += time
-                    } else {
-                        plugin.launch {
+                    plugin.launch(plugin.globalRegionDispatcher) {
+                        if (time !in 100..24000) {
+                            it.fullTime += time
+                        } else {
                             surfBukkitApi.skipTimeSmoothly(it, time.toLong())
                         }
                     }