Comando de API de Bajo Nivel

Las interfaces CommandCallable y Dispatcher pueden ser usadas para definir comandos. Las interfaces pueden ser usadas como una base para APIs de comando personalizados.

Se recomienda utilizar la API Constructor de Comandos <../creating> _ para definiciones de comandos simples.

Escribiendo un comando

El primer paso es crear una clase para el comando. La clase tiene que implementar la interfaz CommandCallable:

import org.spongepowered.api.Sponge;
import org.spongepowered.api.text.Text;
import org.spongepowered.api.command.CommandCallable;
import org.spongepowered.api.command.CommandException;
import org.spongepowered.api.command.CommandResult;
import org.spongepowered.api.command.CommandSource;

import java.util.Collections;
import java.util.List;
import java.util.Optional;

public class MyBroadcastCommand implements CommandCallable {

    private final Optional<Text> desc = Optional.of(Text.of("Displays a message to all players"));
    private final Optional<Text> help = Optional.of(Text.of("Displays a message to all players. It has no color support!"));
    private final Text usage = Text.of("<message>");

    public CommandResult process(CommandSource source, String arguments) throws CommandException {
        Sponge.getServer().getBroadcastChannel().send(Text.of(arguments));
        return CommandResult.success();
    }

    public boolean testPermission(CommandSource source) {
        return source.hasPermission("myplugin.broadcast");
    }

    public Optional<Text> getShortDescription(CommandSource source) {
        return desc;
    }

    public Optional<Text> getHelp(CommandSource source) {
        return help;
    }

    public Text getUsage(CommandSource source) {
        return usage;
    }

    public List<String> getSuggestions(CommandSource source, String arguments) throws CommandException {
        return Collections.emptyList();
    }
}

Truco

Consulta el JavaDoc para :javadoc:`CommandCallable`para ver los propósitos de cada método en este ejemplo.

Registrando el comando

El CommandManager se erige como el administrador para ver qué comandos se escriben en el chat, y redirigirlos al manejador de comandos correcto. Para registrar tu comando, usa el método CommandManager#register(Object, CommandCallable, String…) pasando tu complemento, una instancia del comando y cualquier alias necesario como parámetro.

import org.spongepowered.api.command.CommandManager;

CommandManager cmdService = Sponge.getCommandManager();
cmdService.register(plugin, new MyBroadcastCommand(), "message", "broadcast");

Nota

Los argumentos después de la nueva instancia de tu comando son los alias para el comando. Puedes añadir tantas cadenas como quieras. El primer alias que no sea utilizado por otro comando se convierte en el alias principal. Esto significa que se omiten los alias utilizados por otro comando.

Despachadores de Comandos

Los despachadores de comandos pueden ser usados para crear estructuras de comandos jerárquicas (subcomandos).

La implementacion por defecto de la interfaz Dispatcher es la clase SimpleDispatcher.

Un Dispatcher también es un CommandCallable, así que puede ser registrado como cualquier otro comando.

import org.spongepowered.api.command.dispatcher.SimpleDispatcher;

CommandCallable subCommand1 = ...;
CommandCallable subCommand2 = ...;

SimpleDispatcher rootCommand = new SimpleDispatcher();

rootCommand.register(subCommand1, "subcommand1", "sub1");
rootCommand.register(subCommand2, "subcommand2", "sub2");

Sponge.getCommandManager().register(this, rootCommand, "root");