API pour Commandes de Bas Niveau

Les interfaces CommandCallable et Dispatcher peuvent être utilisés pour définir des commandes. Ces interfaces peuvent être utilisées en tant que base pour une API de commandes personnalisées.

Il est recommandé d’utiliser la Command Builder API pour définir des commandes simples.

Écrire une commande

La première étape est de créer une classe pour votre commande. Cette classe doit implémenter l’interface 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, @Nullable Location<World> targetPosition) throws CommandException {
        return Collections.emptyList();
    }
}

Astuce

Voir la JavaDoc pour CommandCallable pour l’application de chaque méthode dans cet exemple.

Enregistrer la commande

Maintenant nous pouvons enregistrer notre classe dans le CommandManager. Le CommandManager sert de gestionnaire pour regarder quellques commandes sont tapés dans le chat, et les rediriger vers le bon gestionnaire de commandes. Pour enregistrer votre commande, utilisez la méthode CommandManager#register(Object, CommandCallable, String…), en passant votre plugin, une instance de votre commande, et tous les alias nécessaires en paramètres.

import org.spongepowered.api.command.CommandManager;

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

Note

Les paramètres qui suivent la nouvelle instance de votre commande sont les alias pour enregistrer la commande. Vous pouvez ajouter autant de chaînes de caractères (String) que vous le souhaitez. Le premier alias qui n’est pas utilisé par une autre commande devient l’alias primaire. Cela signifie que les alias utilisés par une autre commande seront ignorés.

Routeurs de Commandes

Les routeurs de commandes peuvent être utilisés pour créer des structures hiérarchiques de commandes (c’est-à-dire des sous commandes).

L’implémentation par défaut de l’interface Dispatcher est la classe SimpleDispatcher.

L’interface Dispatcher hérite de CommandCallable, et peut donc être ajoutée au registre comme n’importe quelle autre commande.

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");