Unterste Ebene der Command API

Das CommandCallable- und Dispatcher-Interface kann benutzt werden, um Befehle zu erstellen. Auch können die Interfaces als Grundlage selbsterstellter Command-APIs dienen.

Es wird empfohlen, die Command Builder API für einfache Befehlsdefinitionen zu benutzen.

Befehle schreiben

Der erste Schritt ist eine neue Klasse für den Befehl zu erstellen. Diese Klasse muss das Interface CommandCallable implementieren:

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();
    }
}

Tipp

Schau dir die Dokumentation des Interfaces CommandCallable an, um einen Eindruck zu bekommen, wann welche Methode aufgerufen wird.

Befehle registrieren

Nun können wir die Klasse in dem CommandManager registrieren. Der CommandService dient als Manager. Dieser Manager achtet darauf, wann welcher Befehl in den Chat geschrieben wird, um ihn an den richtigen CommandHandler weiterzuleiten. Um deinen Befehl zu registrieren musst du die CommandManager#register(Object, CommandCallable, String…) Methode benutzen. Diese Methode erwartet eine Instanz von deinem Plugin und eine Instanz von der Command Klasse und jeden Alias (bzw. Synonym) als weiteren Parameter.

import org.spongepowered.api.command.CommandManager;

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

Bemerkung

Die Argumente, die du nach der Instanz des Befehls an die Methode übergibst, werden als Alias für den registrierten Befehl benutzt. Du kannst so viele Aliase angeben, wie du möchtest, und der erste Alias, der nicht von einem anderen Plugin genutzt wird, wird als primärer Alias genommen. Das bedeutet, dass Aliase, die bereits von anderen Plugins genutzt werden, für deinen Befehl ignoriert werden.

Command Dispatcher (Zuteiler)

Command-Dispatcher können zu Hilfe genommen werden, um eine hierarchische Struktur von Unterbefehlen aufzubauen.

Die Standardimplementierung des Dispatcher-Interfaces ist der SimpleDispatcher.

Ein Dispatcher ist gleichzeitig auch eine CommandCallable. Deswegen kann es auch als Befehl, wie jeder andere, registriert werden.

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