SelectorEntityArgBase can now select a list of entities, a single ent…

…ity, a list of players, or a single player

core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/SelectorPlayerArgBase.kt → core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/SelectorEntityArgBase.kt

@@ -8,15 +8,18 @@ import com.github.spigotbasics.core.messages.Message
 import com.github.spigotbasics.core.permission.CorePermissions
 import org.bukkit.Bukkit
 import org.bukkit.command.CommandSender
+import org.bukkit.entity.Entity
 import org.bukkit.entity.Player
 
-abstract class SelectorPlayerArgBase<T>(name: String) : CommandArgument<T>(name) {
+abstract class SelectorEntityArgBase<T>(name: String) : CommandArgument<T>(name) {
     protected enum class ErrorType {
         NOT_FOUND,
         NO_PERMISSION_SELECTORS,
         SELECTOR_INCLUDES_ENTITIES,
         MULTIPLE_PLAYERS_FOUND,
+        MULTIPLE_ENTITIES_FOUND,
         COULD_NOT_PARSE_SELECTOR,
+        NOT_FOUND_ENTITY,
     }
 
     protected val selectorPermission = CorePermissions.useSelectors
@@ -38,8 +41,9 @@ abstract class SelectorPlayerArgBase<T>(name: String) : CommandArgument<T>(name)
     protected fun get(
         sender: CommandSender,
         value: String,
-        allowMultiplePlayers: Boolean,
-    ): Either<ErrorType, List<Player>> {
+        allowMultiple: Boolean,
+        allowEntities: Boolean,
+    ): Either<ErrorType, List<Entity>> {
         val onePlayer = Bukkit.getPlayer(value)
         if (onePlayer != null) {
             return Either.Right(listOf(onePlayer))
@@ -56,29 +60,32 @@ abstract class SelectorPlayerArgBase<T>(name: String) : CommandArgument<T>(name)
             } catch (e: IllegalArgumentException) {
                 return Either.Left(ErrorType.COULD_NOT_PARSE_SELECTOR)
             }
-        val players = selected.filterIsInstance<Player>()
-        if (selected.size != players.size) {
+        val entities = if (!allowEntities) selected.filterIsInstance<Player>() else selected
+        if (!allowEntities && selected.size != entities.size) {
             return Either.Left(ErrorType.SELECTOR_INCLUDES_ENTITIES)
         }
-        if (!allowMultiplePlayers && players.size > 1) {
-            return Either.Left(ErrorType.MULTIPLE_PLAYERS_FOUND)
+        if (!allowMultiple && entities.size > 1) {
+            return Either.Left(if (allowEntities) ErrorType.MULTIPLE_ENTITIES_FOUND else ErrorType.MULTIPLE_PLAYERS_FOUND)
         }
-        if (players.isEmpty()) {
-            return Either.Left(ErrorType.NOT_FOUND)
+        if (entities.isEmpty()) {
+            return Either.Left(if (allowEntities) ErrorType.NOT_FOUND_ENTITY else ErrorType.NOT_FOUND)
         }
-        return Either.Right(players)
+        return Either.Right(entities)
     }
 
     protected fun errorMessage0(
         sender: CommandSender,
         value: String,
-        allowMultiplePlayers: Boolean,
+        allowMultiple: Boolean,
+        allowEntities: Boolean,
     ): Message {
-        return when (get(sender, value, allowMultiplePlayers).leftOrNull()) {
+        return when (get(sender, value, allowMultiple, allowEntities).leftOrNull()) {
             ErrorType.NOT_FOUND -> Basics.messages.playerNotFound(value)
+            ErrorType.NOT_FOUND_ENTITY -> Basics.messages.selectorMatchesNoEntities(name, value)
             ErrorType.NO_PERMISSION_SELECTORS -> Basics.messages.noPermission(selectorPermission)
             ErrorType.SELECTOR_INCLUDES_ENTITIES -> Basics.messages.selectorIncludesEntities(name, value)
             ErrorType.MULTIPLE_PLAYERS_FOUND -> Basics.messages.selectorMatchesMultiplePlayers(name, value)
+            ErrorType.MULTIPLE_ENTITIES_FOUND -> Basics.messages.selectorMatchesMultipleEntities(name, value)
             ErrorType.COULD_NOT_PARSE_SELECTOR -> Basics.messages.selectorCouldNotParse(name, value)
             else -> super.errorMessage(sender, value)
         }

core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/SelectorMultiPlayerArg.kt

@@ -4,21 +4,21 @@ import com.github.spigotbasics.core.messages.Message
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
 
-class SelectorMultiPlayerArg(name: String) : SelectorPlayerArgBase<List<Player>>(name) {
+class SelectorMultiPlayerArg(name: String) : SelectorEntityArgBase<List<Player>>(name) {
     override fun parse(
         sender: CommandSender,
         value: String,
     ): List<Player>? {
-        return get(sender, value, true).fold(
+        return get(sender, value, allowMultiple = true, allowEntities = false).fold(
             { _ -> null },
             { it },
-        )
+        )?.map { it as Player }
     }
 
     override fun errorMessage(
         sender: CommandSender,
         value: String,
     ): Message {
-        return errorMessage0(sender, value, true)
+        return errorMessage0(sender, value, allowMultiple = true, allowEntities = false)
     }
 }

core/src/main/kotlin/com/github/spigotbasics/core/command/parsed/arguments/SelectorSinglePlayerArg.kt

@@ -5,18 +5,18 @@ import com.github.spigotbasics.core.messages.Message
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
 
-class SelectorSinglePlayerArg(name: String) : SelectorPlayerArgBase<Player>(name) {
+class SelectorSinglePlayerArg(name: String) : SelectorEntityArgBase<Player>(name) {
     override fun parse(
         sender: CommandSender,
         value: String,
     ): Player? {
-        return get(sender, value, false).rightOrNull()?.singleOrNull()
+        return get(sender, value, allowMultiple = false, allowEntities = false).rightOrNull()?.singleOrNull() as Player?
     }
 
     override fun errorMessage(
         sender: CommandSender,
         value: String,
     ): Message {
-        return errorMessage0(sender, value, false)
+        return errorMessage0(sender, value, allowMultiple = false, allowEntities = false)
     }
 }

core/src/main/kotlin/com/github/spigotbasics/core/messages/CoreMessages.kt

@@ -44,13 +44,27 @@ class CoreMessages(context: ConfigInstantiationContext) : SavedConfig(context) {
         .tagParsed("argument", argumentName)
         .tagUnparsed("value", selector)
 
+    fun selectorMatchesNoEntities(
+        argumentName: String,
+        selector: String,
+    ) = getMessage("selector-matches-no-entities")
+        .tagParsed("argument", argumentName)
+        .tagUnparsed("value", selector)
+
     fun selectorMatchesMultiplePlayers(
         argumentName: String,
         selector: String,
     ) = getMessage("selector-matches-multiple-players")
         .tagParsed("argument", argumentName)
         .tagUnparsed("value", selector)
 
+    fun selectorMatchesMultipleEntities(
+        argumentName: String,
+        selector: String,
+    ) = getMessage("selector-matches-multiple-entities")
+        .tagParsed("argument", argumentName)
+        .tagUnparsed("value", selector)
+
     fun selectorCouldNotParse(
         argumentName: String,
         selector: String,

core/src/main/resources/messages.yml

@@ -12,6 +12,8 @@ invalid-value-for-argument: "<error><red>Invalid value for <bright_red><#argumen
 invalid-value-for-argument-must-be-integer: "<error><red>Invalid value for <bright_red><#argument></bright_red>: Must be an integer, was <dark_red><#value></dark_red>!</red>"
 selector-includes-entities: "<error><red>Only players may be selected for argument <bright_red><#argument></bright_red>, but the provided selector <bright_red><#value></bright_red> includes entities!</red>"
 selector-matches-multiple-players: "<error><red>Only one player may be selected for argument <bright_red><#argument></bright_red>, but the provided selector <bright_red><#value></bright_red> matches multiple players!</red>"
+selector-matches-multiple-entities: "<error><red>Only one entity may be selected for argument <bright_red><#argument></bright_red>, but the provided selector <bright_red><#value></bright_red> matches multiple entities!</red>"
+selector-matches-no-entities: "<error><red>The given selector <bright_red><#value></bright_red> does not match any entities for argument <bright_red><#argument></bright_red>!</red>"
 selector-could-not-parse: "<error><red>Could not parse selector <bright_red><#value></bright_red> for argument <bright_red><#argument></bright_red>!</red>"
 
 # Tags: <#argument> <#value> <#min> <#max>

modules/basics-tp/src/main/kotlin/com/github/spigotbasics/modules/basicstp/BasicsTpModule.kt

@@ -1,21 +1,34 @@
 package com.github.spigotbasics.modules.basicstp
 
+import com.github.spigotbasics.core.command.parsed.arguments.SelectorMultiPlayerArg
 import com.github.spigotbasics.core.command.parsed.arguments.XYZCoordsArg
 import com.github.spigotbasics.core.module.AbstractBasicsModule
 import com.github.spigotbasics.core.module.loader.ModuleInstantiationContext
 
 class BasicsTpModule(context: ModuleInstantiationContext) : AbstractBasicsModule(context) {
     private val permission = permissionManager.createSimplePermission("basics.tp", "Allows teleporting")
+    private val permissionOthers = permissionManager.createSimplePermission("basics.tp.others", "Allows teleporting other players")
 
     override fun onEnable() {
         commandFactory.parsedCommandBuilder("tp", permission).mapContext {
-            usage = "<x y z>"
+            usage = "[player] <x y z | entity>"
+
+            // x y z
             path {
                 playerOnly()
                 arguments {
                     named("coords", XYZCoordsArg("Target Coordinates"))
                 }
             }
+
+            path {
+                arguments {
+                    named("player", SelectorMultiPlayerArg("Player"))
+                    named("coords", XYZCoordsArg("Target Coordinates"))
+                }
+                permissions(permissionOthers)
+            }
+
             executor(TeleportCommand(this@BasicsTpModule))
         }.register()
     }