feat(abstract-command): add some more commands for flexibility

common/src/main/kotlin/com/undefined/stellar/AbstractStellarCommand.kt

@@ -28,8 +28,14 @@ abstract class AbstractStellarCommand<T>(val name: String, var description: Stri
     @ApiStatus.Internal open val executions: MutableList<StellarExecution<*>> = mutableListOf()
     @ApiStatus.Internal open val runnables: MutableList<StellarRunnable<*>> = mutableListOf()
 
-    fun addAlias(name: String): T {
-        aliases.add(name)
+    fun setAliases(vararg aliases: String): T {
+        this.aliases.clear()
+        for (alias in aliases) this.aliases.add(alias)
+        return this as T
+    }
+
+    fun addAliases(vararg aliases: String): T {
+        for (alias in aliases) this.aliases.add(alias)
         return this as T
     }
 
@@ -43,46 +49,126 @@ abstract class AbstractStellarCommand<T>(val name: String, var description: Stri
         return this as T
     }
 
-    fun addRequirement(permission: String): T {
-        permissionRequirements.add(PermissionStellarRequirement(1, permission))
-        return this as T
+    fun setRequirements(permissions: List<StellarRequirement<*>>): T {
+        this.requirements.clear()
+        return addRequirements(permissions)
+    }
+
+    fun setRequirements(permissions: List<PermissionStellarRequirement>): T {
+        permissionRequirements.clear()
+        return addRequirements(permissions)
+    }
+
+    fun setRequirements(vararg permissions: StellarRequirement<*>): T {
+        this.requirements.clear()
+        return addRequirements(*permissions)
     }
 
-    fun addRequirement(permissionLevel: Int): T {
-        permissionRequirements.add(PermissionStellarRequirement(permissionLevel))
+    fun setRequirements(vararg permissions: PermissionStellarRequirement): T {
+        permissionRequirements.clear()
+        return addRequirements(*permissions)
+    }
+
+    fun addRequirements(permissions: List<StellarRequirement<*>>): T {
+        for (permission in permissions) this.requirements.add(permission)
         return this as T
     }
 
-    inline fun <reified C : CommandSender> addRequirement(noinline requirement: C.() -> Boolean): T {
-        addRequirement(StellarRequirement(requirement))
+    fun addRequirements(permissions: List<PermissionStellarRequirement>): T {
+        for (permission in permissions) permissionRequirements.add(permission)
         return this as T
     }
 
-    fun addRequirement(requirement: StellarRequirement<*>): T {
-        requirements.add(requirement)
+    fun addRequirements(vararg permissions: StellarRequirement<*>): T =
+        addRequirements(permissions.toList())
+
+    fun addRequirements(vararg permissions: PermissionStellarRequirement): T =
+        addRequirements(permissions.toList())
+
+    fun addRequirements(vararg levels: Int): T {
+        for (level in levels) permissionRequirements.add(PermissionStellarRequirement(level))
         return this as T
     }
 
-    fun addFailureMessage(message: String): T {
-        failureMessages.add(MiniMessage.miniMessage().deserialize(message))
+    fun addRequirements(vararg permissions: String): T {
+        for (permission in permissions) permissionRequirements.add(PermissionStellarRequirement(1, permission))
         return this as T
     }
 
-    fun addFailureMessage(message: Component): T {
-        failureMessages.add(message)
+    inline fun <reified C : CommandSender> addRequirement(noinline requirement: C.() -> Boolean): T =
+        addRequirements(StellarRequirement(requirement))
+
+    fun setFailureMessages(messages: List<Component>): T {
+        failureMessages.clear()
+        return addFailureMessages(messages)
+    }
+
+    fun setFailureMessages(messages: List<String>): T =
+        setFailureMessages(messages.map { MiniMessage.miniMessage().deserialize(it) })
+
+    fun setFailureMessages(vararg messages: Component): T =
+        setFailureMessages(messages.toList())
+
+    fun setFailureMessages(vararg messages: String): T =
+        setFailureMessages(messages.toList())
+
+    fun setPlainFailureMessages(messages: List<String>): T {
+        failureMessages.clear()
+        return addFailureMessages(messages.map { Component.text(it) })
+    }
+
+    fun setPlainFailureMessages(vararg messages: String): T =
+        setFailureMessages(messages.toList())
+
+    fun setGlobalFailureMessages(messages: List<Component>): T {
+        globalFailureMessages.clear()
+        for (message in messages) globalFailureMessages.add(message)
         return this as T
     }
 
-    fun addGlobalFailureMessage(message: String): T {
-        globalFailureMessages.add(MiniMessage.miniMessage().deserialize(message))
+    fun setGlobalFailureMessages(messages: List<String>): T =
+        setGlobalFailureMessages(messages.map { MiniMessage.miniMessage().deserialize(it) })
+
+    fun setGlobalFailureMessages(vararg messages: String): T =
+        setGlobalFailureMessages(messages.toList())
+
+    fun setGlobalFailureMessages(vararg messages: Component): T =
+        setGlobalFailureMessages(messages.toList())
+
+    fun addFailureMessages(messages: List<Component>): T {
+        for (message in messages) failureMessages.add(message)
         return this as T
     }
 
-    fun addGlobalFailureMessage(message: Component): T {
-        globalFailureMessages.add(message)
+    fun addFailureMessages(messages: List<String>): T =
+        addFailureMessages(messages.map { MiniMessage.miniMessage().deserialize(it) })
+
+    fun addFailureMessages(vararg messages: String): T =
+        addFailureMessages(messages.toList())
+
+    fun addFailureMessages(vararg messages: Component): T =
+        addFailureMessages(messages.toList())
+
+    fun addPlainFailureMessages(messages: List<String>): T =
+        addFailureMessages(messages.map { Component.text(it) })
+
+    fun addPlainFailureMessages(vararg messages: String): T =
+        addPlainFailureMessages(messages.toList())
+
+    fun addGlobalFailureMessages(messages: List<Component>): T {
+        for (message in messages) globalFailureMessages.add(message)
         return this as T
     }
 
+    fun addGlobalFailureMessages(messages: List<String>): T =
+        addGlobalFailureMessages(messages.map { MiniMessage.miniMessage().deserialize(it) })
+
+    fun addGlobalFailureMessages(vararg messages: String): T =
+        addGlobalFailureMessages(messages.toList())
+
+    fun addGlobalFailureMessages(vararg messages: Component): T =
+        addGlobalFailureMessages(messages.toList())
+
     inline fun <reified C : CommandSender> addFailureExecution(noinline execution: CommandContext<C>.() -> Unit): T {
         failureExecutions.add(StellarExecution(execution))
         return this as T

common/src/main/kotlin/com/undefined/stellar/data/requirement/PermissionStellarRequirement.kt

@@ -1,3 +1,3 @@
 package com.undefined.stellar.data.requirement
 
-data class PermissionStellarRequirement(val permissionLevel: Int, val permission: String = "")
+data class PermissionStellarRequirement(val level: Int, val permission: String = "")

server/src/main/kotlin/com/undefined/stellar/Main.kt

@@ -1,27 +1,12 @@
 package com.undefined.stellar
 
-import org.bukkit.entity.Player
 import org.bukkit.plugin.java.JavaPlugin
 
 class Main : JavaPlugin() {
 
     override fun onEnable() {
-        val main = StellarCommand("test", description = "this is a description", "othertest")
-        main.addIntegerArgument("int")
-            .addGreedyStringArgument("args")
-            .onWord(0) {
-                addExecution<Player> {
-                    source.sendMessage(getArgument(0))
-                }
-                addRunnable<Player> {
-                    source.sendMessage("runnable")
-                    true
-                }
-            }
-            .addWordExecution<Player>(1) {
-                source.sendMessage("Execution")
-                println("execution")
-            }
+        StellarCommand("test", "othertest")
+            .addFailureMessages("")
             .register(this)
     }
 

v1_20_6/src/main/kotlin/com/undefined/stellar/v1_20_6/BrigadierCommandHelper.kt

@@ -30,7 +30,7 @@ object BrigadierCommandHelper {
 
     fun fulfillsRequirements(command: AbstractStellarCommand<*>, source: CommandSourceStack): Boolean {
         val fulfillsExecutionRequirements = command.requirements.all { it(source.bukkitSender) }
-        val fulfillsPermissionRequirements = command.permissionRequirements.all { source.hasPermission(it.permissionLevel, it.permission) }
+        val fulfillsPermissionRequirements = command.permissionRequirements.all { source.hasPermission(it.level, it.permission) }
         return fulfillsExecutionRequirements.and(fulfillsPermissionRequirements)
     }