complete overhaul

Author: WantToBeeMe

.idea/.gitignore

@@ -52,66 +52,20 @@ If you see `commander` in the source code, you will know that is referencing a p
 
 There are 2 examples in the `examples` folder:
 - [HelloWorldCommand](examples/HelloWorldCommand.kt): This demonstrates how to use CommandTree with a very basic command
-- [GroupCommand](examples/GroupCommand.kt): This provides a more advanced usage scenario.
-```kotlin
-// CommandLeafs
-CommandEmptyLeaf()
-CommandBoolLeaf()
-CommandIntLeaf()
-CommandDoubleLeaf()
-CommandStringLeaf()
-CommandPlayerLeaf()
-CommandLocationLeaf()
-CommandVarargLeaf()
-CommandPairLeaf()
-CommandTripleLeaf()
-
-// CommandBranch
-//   /command examples [first/second/third]
-//  this command is to group a lot of command nodes together under 1 key word ("example" in this case)
-CommandBranch("example", arrayOf( ..., ... ) )
-
-// Usage
-// note that each leaf also has a emptyEffect argument (which is not shown here)
-// Only the Empty leaf is shown doing that, that's because that's the only other argument that this leaf has
-val exampleCommand = CommandBranch("example", arrayOf(
-    CommandEmptyLeaf("emptyArg", { player -> /* empty command logic */ }),
-    CommandBoolLeaf("boolArg", { player, boolValue -> /* bool command logic */ }),
-    CommandLocationLeaf("locationArg", { player, location -> /* location command logic */ }),
-    
-    CommandIntLeaf("intArg1", 1/null, 10/null, { player, intValue -> /* int command logic */ }),
-    CommandIntLeaf("intArg2", intArrayOf(1,3,5,7), { player, intValue -> /* int command logic */ }),
-    CommandIntLeaf("intArg3", 0,  { Teams.count } , { player, intValue -> /* int command logic */ }), 
-    // you can also provide real time inputs, it will be checked what the value is whenever you enter the command
-    
-    CommandDoubleLeaf("doubleArg1", 0.0/null, 1.0/null, { player, doubleValue -> /* double command logic */ }),
-    CommandDoubleLeaf("doubleArg2", 0.0, { Distance.max } , { player, doubleValue -> /* double command logic */ }),
-    // doubles don't have any possibility for a list
-
-    CommandStringLeaf("stringArg1", null, { player, stringValue -> /* string command logic */ }),                          // anything
-    CommandStringLeaf("stringArg2", arrayOf("option1", "option2"), { player, stringValue -> /* string command logic */ }), // only these options
-    CommandStringLeaf("stringArg2", { Teams.teamNames }, { player, stringValue -> /* string command logic */ }),           // real time
-    
-    CommandPlayerLeaf("playerArg1", arrayOf(), { player, targetPlayer -> /* player command logic */ }),                    // fixed
-    CommandPlayerLeaf("playerArg2", { Plugin.onlinePlayers }, { player, targetPlayer -> /* player command logic */ }),     // dynamic
-    
-    // the following 3 leafs need other leafs to operate, the title of the innerLeafs will never be shown, so they can be basicly any name
-    // the vararg is a list of infinite arguments of the type you provided, the effect will return a list
-    // the boolean is if you allow for it to return empty or not (true if it can, false if not)
-    CommandVarargLeaf("varargArg",
-        CommandIntLeaf("innerIntArg", 1, 100, { _, _ -> }), false, { player, varargValues -> /* vararg command logic */ }),
-    // the pair is 2 argument types, grouped under 1 name (here "pairArg")
-    CommandPairLeaf("pairArg", 
-        CommandIntLeaf("innerIntArg", 1, 100, { _, _ -> }),
-        CommandBoolLeaf("innerBoolArg", { _, _ -> })),
-    // the triple is 3 argument types, grouped under 1 name (here "tripleArg")
-    CommandTripleLeaf("tripleArg",
-        CommandIntLeaf("innerIntArg", 1, 100, { _, _ -> }), 
-        CommandBoolLeaf("innerBoolArg", { _, _ -> }), 
-        CommandStringLeaf("innerStringArg", arrayOf("option1", "option2"), { _, _ -> }))
-))
-```
+- [GroupCommand](examples/GroupCommand.kt): This provides a more advanced usage scenario.  
+
+and this is the list of partials that can be used
+-  BranchPartial
+- EmptyPartial 
+- BooleanPartial 
+- StringPartial 
+- PlayerPartial
+- IntPartial
+- DoublePartial
+- LocationPartial
+- VarargPartial
+- PairPartial
+- TriplePartial
 
 ## License
-
 IDK how licenses work. If I ever find the time to assign a license, it will be a license that basically says "do whatever you want with it, Just reference me somewhere in the comments for example"

.idea/misc.xml

@@ -6,7 +6,7 @@ plugins {
 }
 
 group = "com.github.WantToBeeMe"
-version = "1.0.0"
+version = "2.0.0"
 
 repositories {
     mavenCentral()

README.md

@@ -1,43 +1,28 @@
 package me.wanttobee.commandtree.examples
 
-import me.wanttobee.commandtree.ICommandNamespace
-import me.wanttobee.commandtree.ICommandObject
-import me.wanttobee.commandtree.nodes.*
+import me.wanttobee.commandtree.Description
+import me.wanttobee.commandtree.ITreeCommand
+import me.wanttobee.commandtree.partials.*
 import org.bukkit.ChatColor
 
-// to make sure it all works you simply have to do `CommandTreeSystem.createCommand(GroupCommand)`
-//  (and make sure the CommandTreeSystem has been initialized )
-object GroupCommand  : ICommandNamespace {
-    override val commandName: String = "group"
-    override val commandSummary: String = "to show you some more complex commands you can make"
-    override val systemCommands: Array<ICommandObject> = arrayOf(PairTree)
-    override val hasOnlyOneGroupMember: Boolean = false
-    override val isZeroParameterCommand: Boolean = false
+object GroupCommand : ITreeCommand {
+    override val description = Description("to show you some more complex commands you can make",)
+        .addSubDescription(name="pair",        description="This is my cool pair tree",        usage= "/mygroup pair <bool> <int>")
+        .addSubDescription(name="message", description="This is my cool message tree", usage= "/mygroup message <message>")
+        .addSubDescription(name= "more",     description="moreee!!",                              usage= "/mygroup more")
 
-    // each object start with its own name before you can enter the parameters that the command was based on
-    // this is a string command, it would look something like this `/group message [first_option, option_2, other_option]`
-    // where you start with `message` and ofter that you get the 3 options where you can choose between in your complete
-    object SayTree : ICommandObject {
-        override val helpText: String = "This is my cool pair tree"
-        override val baseTree: ICommandNode = CommandStringLeaf("message", arrayOf("first_option", "option_2", "other_option"),
-            {commander, message -> commander.sendMessage("${ChatColor.RED}$message")}
-        )
-    }
+    override val command = BranchPartial("mygroup").setStaticPartials(
+        PairPartial<Boolean,Int>("pair").setPartials(
+            BooleanPartial("bool"),
+            IntPartial("int").setStaticRange(1..10)
+        ).setEffect {commander, value -> commander.sendMessage("${ChatColor.LIGHT_PURPLE}$value")},
+
+        StringPartial("message").setStaticOptions(arrayOf("first_option", "option_2", "other_option"))
+            .setEffect {commander, message -> commander.sendMessage("${ChatColor.LIGHT_PURPLE}$message")},
 
-    // you can also make it so you have multiple options after the group-name
-    // this one would look something like `/group pair [true/false] [1..10]`
-    // where after pair you get the first option of the pair, which is a boolean,
-    // and then you get the second option of the pair, which is a number between 1 and 10
-    // you can stack pairs however you want. (make sure that if you do set a vararg in the pair, that it is the last argument of the pair stack, otherwise the pair will never finish)
-    // There are some default multiple arguments already, for example the CommandLocationLeaf,
-    // if you want 3 arguments, you could stack 2 pairs (so one slot of the first pair will be a new pair, totaling in 3)
-    // byt you could also use the Triple instead
-    object PairTree : ICommandObject {
-        override val helpText: String = "This is my cool pair tree"
-        override val baseTree: ICommandNode = CommandPairLeaf("pair",
-            CommandBoolLeaf("bool", {_,_ -> } ),
-            CommandIntLeaf("int",1,10, {_,_ -> } ),
-            {commander, pair -> commander.sendMessage("${ChatColor.RED}${pair.first}${ChatColor.LIGHT_PURPLE}${pair.second}")}
+        BranchPartial("more").setStaticPartials(
+            EmptyPartial("even_more")
+                .setEffect {commander -> commander.sendMessage("${ChatColor.GOLD}even more")}
         )
-    }
+    )
 }

build.gradle.kts

@@ -1,9 +1,8 @@
 package me.wanttobee.commandtree.examples
 
-import me.wanttobee.commandtree.ICommandNamespace
-import me.wanttobee.commandtree.ICommandObject
-import me.wanttobee.commandtree.nodes.CommandEmptyLeaf
-import me.wanttobee.commandtree.nodes.ICommandNode
+import me.wanttobee.commandtree.Description
+import me.wanttobee.commandtree.ITreeCommand
+import me.wanttobee.commandtree.partials.EmptyPartial
 import org.bukkit.ChatColor
 
 // this example is one of the most simple classes
@@ -20,17 +19,10 @@ import org.bukkit.ChatColor
 
 // to make sure it all works you simply have to do `CommandTreeSystem.createCommand(HelloWorldCommand)`
 //  (and make sure the CommandTreeSystem has been initialized )
-object HelloWorldCommand : ICommandNamespace {
-    override val commandName: String = "helloWorld"
-    override val commandSummary: String = "to say hello world"
-    override val systemCommands: Array<ICommandObject> = arrayOf(HelloWorld)
-    override val hasOnlyOneGroupMember: Boolean = true
-    override val isZeroParameterCommand: Boolean = true
+object HelloWorldCommand : ITreeCommand {
+    override val description = Description("to say hello world")
 
-    object HelloWorld : ICommandObject{
-        override val helpText: String = "says hello world"
-        override val baseTree: ICommandNode = CommandEmptyLeaf("say") { commander ->
-            commander.sendMessage("${ChatColor.YELLOW} Hello World")
-        }
+    override val command = EmptyPartial("helloWorld").setEffect { commander ->
+        commander.sendMessage("${ChatColor.YELLOW} Hello World")
     }
 }

examples/GroupCommand.kt

@@ -1,5 +1,6 @@
 package me.wanttobee.commandtree
 
+import me.wanttobee.commandtree.partials.*
 import org.bukkit.ChatColor
 import org.bukkit.entity.Player
 import org.bukkit.plugin.java.JavaPlugin
@@ -9,21 +10,33 @@ object CommandTreeSystem {
     var title : String? = null
         private set
 
+    val allPartials = arrayOf(
+        BranchPartial::class,
+        EmptyPartial::class,
+        BooleanPartial::class,
+        StringPartial::class,
+        PlayerPartial::class,
+        IntPartial::class,
+        DoublePartial::class,
+        LocationPartial::class,
+        VarargPartial::class,
+        PairPartial::class,
+        TriplePartial::class
+    )
+
     fun initialize(plugin: JavaPlugin, title: String?){
         minecraftPlugin = plugin
-        CommandTreeSystem.title = title
+        this.title = title
     }
 
-    fun createCommand(command : String,  commandObject : IPlayerCommands){
+    fun createCommand(commandObject : ITreeCommand){
+        createCommand(commandObject.command.argName, commandObject)
+    }
+    fun createCommand(command : String,  commandObject : IPlayerCommandExecutor){
         minecraftPlugin.getCommand(command)?.setExecutor(commandObject)
         minecraftPlugin.getCommand(command)?.tabCompleter = commandObject
     }
 
-    fun createCommand(commandObject : ICommandNamespace){
-        minecraftPlugin.getCommand(commandObject.commandName)?.setExecutor(commandObject)
-        minecraftPlugin.getCommand(commandObject.commandName)?.tabCompleter = commandObject
-    }
-
     fun sendErrorToCommander(commander: Player, errorMessage: String, extraInfo : String = ""){
         val titleBit = title ?: ""
         commander.sendMessage("$titleBit ${ChatColor.RED}$errorMessage ${ChatColor.GRAY}$extraInfo")

examples/HelloWorldCommand.kt

@@ -0,0 +1,14 @@
+package me.wanttobee.commandtree
+
+class Description(val summary: String, val usage: String? = null) {
+    val subDescriptions = mutableListOf<Triple<String,String,String?>>()
+
+    fun addSubDescription(
+        name: String,
+        description: String,
+        usage: String? = null
+    ) : Description {
+        subDescriptions.add(Triple(name,description,usage))
+        return this
+    }
+}