Command Attributes

This page describes the concept of Command Attributes

Command Attributes

Command attributes are objects that enhance the functionality of commands. They come in various forms such as

• Arguments

• Actions

• Properties

• Subcommands

• Etc.

A command can have an unlimited amount of attributes. To make sure Delegate can distinguish between command attributes, each attribute must have a unique identifier associated with it. Normally, these identifiers are assigned automatically (no intervention needed), but in some cases it is useful for the developer to provide these (as we will see later when arguments are covered).

Chaining Command Attributes

As said previously, a command can have an unlimited amount of attributes assigned to it. When creating a command using Delegate.create() , an implementation of an ICommandBuilder is returned. The implementation of this builder depends on your platform. Different platforms will return different types of builders:

• Paper: PaperCommandBuilder

• Bukkit: BukkitCommandBuilder

• Velocity: VelocityCommandBuilder

• ...

Fluent Interface

The ICommandBuilder interface follows the Fluent Interface design pattern. This is a type of design pattern that allows proper chaining. In the case of Delegate, it is used to chain command attributes. In the next sections, we will build up to the following command (which has been deliberately overcomplicated):

Verbose

public class DelegateExample extends JavaPlugin implements Listener {

    @Override
    public void onEnable() {
        //  Event registration
        getServer().getPluginManager().registerEvents(this, this);

        //  Hook Delegate into the plugin
        Delegate.hook(this);
        
        //  Create example with sub-commands
        Delegate.create("math", "Implementation of a arithmetic operations such as addition and  subtraction.")
                .withIgnoreNull()
                .withSubcommand(new SubcommandDefinition(Delegate.create("+", "Adds two numbers together")
                        .withFloat("a", "The first number to add")
                        .withFloat("b", "The second number to add")
                        .withFunctionAction("addition", (sender, context) -> {
                            //  Get the arguments. On purpose, we're not using type-safe methods,
                            //  to demonstrate that the arguments are in fact of the correct type.
                            float a = context.find("a");
                            float b = context.find("b");

                            //  Some command logic
                            float sum = a + b;

                            //  Since this action is a function, we return a result
                            //  which will be captured by Delegate. The type is
                            //  automatically inferred.
                            return sum;
                        })
                ))
                .withSubcommand(new SubcommandDefinition(Delegate.create("-", "Subtracts two numbers from each other")
                        .withFloat("a", "The first number to subtract")
                        .withFloat("b", "The second number to subtract")
                        .withFunctionAction("subtraction", (sender, context) -> {
                            //  Get the arguments. On purpose, we're not using type-safe methods,
                            //  to demonstrate that the arguments are in fact of the correct type.
                            float a = context.find("a");
                            float b = context.find("b");

                            //  Some command logic
                            float difference = a - b;

                            //  Since this action is a function, we return a result
                            //  which will be captured by Delegate. The type is
                            //  automatically inferred.
                            return difference;
                        })
                ))
                .build();
    }

    @EventHandler(priority = EventPriority.MONITOR)
    public void onCommand(DelegateCommandEvent event) {
        //  Get some information from the event such as the sender and the capture.
        CommandSender sender = event.getSender();
        CommandCapture capture = event.getCapture();

        //  From the capture, we can get the result returned by a sub-command or action.
        //  In this case, we retrieve the capture of the most deeply nested sub-command.
        //  For the example, this is "+" or "-".
        // 
        //  Note: If type inference fails, null will be returned!
        Float result = capture.getResultOf("subtraction");

        //  Further processing of the command can be handled.
        if (result != null)
            sender.sendMessage(Component.text("Result: " + result));
    }

}

Please note that this example is drastically overcomplicated. Delegate can achieve the same functionality with cleaner and less nested code. This is example is for illustration purposes only. Please check the second tab for a simplified version of the command.

Simplified

In the next few tutorials, we will go over the four built-in command attributes:

• Arguments

• Actions

• Properties

• Definitions