Commands

Commands can be declared using the @Command annotation on a class:

Java

@Command("foo")
public class Foo {}

Kotlin

@Command("foo")
class Foo

Subcommands

You can add a subcommand to a command by annotating a public method with @Command. The annotated method will be invoked whenever the specified subcommand is executed.

Java

@Command("foo")
public class Foo {
    @Command("bar")
    public void bar() {
        System.out.println("bar");
    }
}

This Foo.bar() is invoked when the /foo bar command is executed.

Kotlin

@Command("foo")
class Foo {
    @Command("bar")
    fun bar() {
        println("bar")
    }
}

This will be executed if the /foo bar command is executed.

Default Commands

Default commands are commands that are run without the need for a subcommand. They are declared by annotating a public method with @Command.Default:

Java

@Command("foo")
public class Foo {
    // Normal import
    // e.g. import net.jailgens.enchanted.annotations.Command;
    @Command.Default
    public void foo() {
        System.out.println("foo");
    }
    
    // Import inner class
    // e.g. import net.jailgens.enchanted.annotations.Command.Default;
    @Default
    public void foo() {
        System.out.println("foo");
    }
}

Both methods are invoked upon the execution of /foo.

Kotlin

@Command("foo")
class Foo {
    // Normal import
    // e.g. import net.jailgens.enchanted.annotations.Command
    @Command.Default
    fun foo() {
        println("foo")
    }
    
    // Import inner class
    // e.g. import net.jailgens.enchanted.annotations.Command.Default
    @Default
    fun foo() {
        println("foo")
    }
}

Either command is executed when the /foo command is run.

You can combine default commands and subcommands:

Java

@Command("foo")
public class Foo {
    // /foo
    @Command.Default
    public void foo() {
        System.out.println("foo");
    }
    
    // /foo bar
    @Command("bar")
    public void bar() {
        System.out.println("bar");
    }
    
    // /foo baz
    @Command("baz")
    public void baz() {
        System.out.println("baz");
    }
}

Kotlin

@Command("foo")
class Foo {
    // /foo
    @Command.Default
    fun foo() {
        println("foo")
    }
    
    // /foo bar
    @Command("bar")
    public void bar() {
        println("bar")
    }
    
    // /foo baz
    @Command("baz")
    public void baz() {
        println("baz")
    }
}

Command Executors

Not to be confused with org.bukkit.command.CommandExecutor.

Command executors are simply something that can execute a command. You can obtain it by adding a CommandExecutor parameter to any subcommand or default command. Some platforms such as Paper provide their own additional command executor's like org.bukkit.command.CommandSender.

Java

@Command("foo")
public class Foo {
    // (Paper) anyone can execute /foo bar
    @Command("bar")
    public void bar(CommandSender sender) {}
    
    // (Paper) only players can execute /foo baz
    @Command("baz")
    public void baz(Player sender) {}
    
    // Anyone can execute this /foo qux, reguardless of implementation or platform
    @Command("qux")
    public void qux(CommandExecutor sender) {}
}

Kotlin

@Command("foo")
class Foo {
    // (Paper) anyone can execute /foo bar
    @Command("bar")
    fun bar(sender: org.bukkit.command.CommandSender) {}
    
    // (Paper) only players can execute /foo baz
    @Command("baz")
    fun baz(sender: org.bukkit.entity.Player) {}
    
    // Anyone can execute this /foo qux, regardless of implementation or platform
    @Command("qux")
    fun qux(sender: net.jailgens.enchanted.CommandExecutor) {}
}

As shown in previous sections, if no command executor is specified, the subcommand or default command can be executed by any CommandExecutor.

Arguments

Command arguments are really easy to define. Simply append a parameter to the end of your command method:

Java

@Command("echo")
public class Echo {
    @Command.Default
    public void echo(CommandExecutor sender, String string) {
        sender.sendMessage(string);
    }
}

Kotlin

@Command("echo")
class Echo {
    // echo <message>
    // Example:
    // Command: /echo hello
    // Response: hello
    @Command.Default
    fun echo(sender: CommandExecutor, string: String) {
        sender.sendMessage(string)
    }
}

You can add additional behaviour to several different aspects of how an argument works such as:

• How it is parsed

• How it gets converted into an object

• If it is required

See Arguments for more details.

Command Groups

Command groups are simply nested subcommands. Their behaviour and definition is just what you'd expect:

Java

@Command("foo")
public class Foo {
    @Command("bar")
    public class Bar {
        // foo bar baz
        @Command("baz")
        public void baz() {}
        
        // foo bar qux
        @Command("qux")
        public void qux() {}
    }
}

Kotlin

@Command("foo")
class Foo {
    @Command("bar")
    class Bar {
        // foo bar baz
        @Command("baz")
        fun baz() {}
        
        // foo bar qux
        @Command("qux")
        fun qux() {}
    }
}

Command Metadata

The Enchanted API defines three metadata annotations:

• @Description - adds a description to a command or subcommand.

• @Param - sets the name of a parameter.

• @Usage - sets the usage of a command, subcommand or default command.

Command Aliases

Aliases are a way to add secondary names to a command:

Java

@Command("gamemode")
@Aliases({"gm"})
public class GameMode { ... }

Kotlin

@Command("gamemode")
@Aliases(["gm"])
class GameMode { ... }