Basic argument-free ComplexCommand

There are actually a lot of scenarios where Lambda Commands are too verbose and also lack functionality, that’s why Catalyst comes with a built-in massive Command Framework.

Let’s say you have a package com.mycompany.catalystexample.commands that has all the commands of your plugin. Create a new class there called ExampleCommand and make it extend the ComplexCommand class

package com.mycompany.catalystexample.commands;

import com.reigindustries.catalyst.command.factory.ComplexCommand;
import com.reigindustries.catalyst.command.factory.annotations.Command;
import com.reigindustries.catalyst.command.factory.annotations.RequiresPlayer;

@Command("examplecommand|example") /* This is mandatory!!! */
@RequiresPlayer /* This is optional */
@Permission("myplugin.command.example") /* This is optional */
public class ExampleCommand extends ComplexCommand {

    @Index
    public void indexMethod() {

				/* Everything inside a method annotated with @Index will run if the command 
           is called without arguments, or if there are no registered subcommands.
           Yes, I was a PHP developer. */

        getPlayer().sendMessage("You just ran the example command.");

    }

}

• The @Command annotation indicates that the class is a command. This is mandatory
  • You must specify a string inside it, that’ll be the command that executes the code.
  • You can specify aliases right there, using “|” separators.
• @RequiresPlayer indicates that this command can only be run by a player, preventing the console from running it. This is optional
• @Permission specifies a permission which a user should have to run the main command. This is optional
• You must create a method annotated with @Index, this will be your command’s entry point, the code that runs if the command is called without subcommands.
• There are pre-defined variables that you can use here, these are inherited from ComplexCommand:
  • getPlayer() → Returns the player who runs the command
  • getSender() → Use this instead of getPlayer() if the console can run the command
  • getCommandName() → Returns the command that called the code, useful if you want to run different code if different aliases has been used
  • getArgs() → Returns the command arguments as an array of Strings. We made this for debug purposes, you probably won’t need this, we’ll talk about it later.

Now it’s cool that we have a ComplexCommand class, but it must be registered.

Registering all ComplexCommands in a package

We have a static method for this, that you must call in your plugin’s onEnable():

Catalyst.commands().load(String package);

Where package stands for the exact path of your package, in our case:

public class CatalystExample extends JavaPlugin {

    @Override
    public void onEnable() {

        Catalyst.init(this);

        Catalyst.commands().load("com.mycompany.catalystexample.commands");

    }

}

This will go through all classes in our package and register the commands for us, even if you have more than one.

Subcommands

Now that we’ve acquired the great knowledge of defining plain commands, let’s find out how can i add subcommands to a command.