Befehlsoptionen

Befehlsoptionen sind nützlich, um zusätzliche Parameter anzugeben, die bei der Verarbeitung des Befehls verwenden werden, die aber nicht zu Befehls-Argumenten gehören.

Um eine solche Option zu erstellen, müssen wir uns zu allererst einen Builder für Optionen holen. Wir können einfach die GenericArguments#flags() Methode verwenden, die von GenericArguments bereitgestellt wird, um den Builder zu erhalten, den wir brauchen. Von dort aus, können wir spezifizieren, welche Art von Option wir erstellen möchten. Bitte beachte, dass die Optionen wie ein Argument angegeben werden.

import org.spongepowered.api.command.args.GenericArguments;
import org.spongepowered.api.command.spec.CommandSpec;

CommandSpec myCommand = CommandSpec.builder()
    .executor(new MyCommand())
    .arguments(GenericArguments.flags().flag("s").buildWith(GenericArguments.none()))
    .build();

Dies wird eine Befehlsoption erstellen, sodass wenn der Spieler den Befehl /our-command -s ausführt, die Option für s aktiviert ist. Bitte sei dir bewusst, dass das Erstellen durch GenericArguments#none() verhindert, dass der Befehl irgendwelche Argument hat. Wenn du möchtest, dass dein Befehl sowohl Argumente als auch Optionen hat, musst du deine Argumente bei der CommandFlags.Builder#buildWith(CommandElement) Methode angeben.

Nun, da wir unseren Befehl mit der Option spezifiziert haben, können wir uns den Wert der Option holen. Für eine einfache Boolean Option, wie wir sie oben angegeben haben, können wir einfach prüfen, ob sie existiert. In dem folgendem Beispiel prüfen wir, ob der CommandContext des Befehls einen Wert für s enthält.

import org.spongepowered.api.text.Text;

if (args.hasAny("s")) {
    src.sendMessage(Text.of("The command flag s was specified!"));
}

Options Berechtigungen

Unsere Optionen sind soweit so gut, aber was ist, wenn wir möchten, dass der Spieler eine Berechtigung braucht, um unsere Option verwenden zu können? Wir können stattdeseen die Methode CommandFlags.Builder#permissionFlag(String, String…) auf unserem Options-Builder verwenden. Dies verlangt von dem Spieler eine bestimmte Berechtigung für die Ausführung des Befehls mit der Option. An Beispiel hierfür findest du unten:

CommandSpec myCommand = CommandSpec.builder()
        .executor(new MyCommand())
        .arguments(GenericArguments.flags().permissionFlag("myplugin.command.flag",
            "s").buildWith(GenericArguments.none()))
        .build();

Wenn ein Spieler nicht die nötige Berechtigung myplugin.command.flag hat, darf er den Befehl nicht mit unserer Option s ausführen.

Optionen mit Werten

Booleans können großartig sein, aber was ist, wenn wir Optionen für Strings und Integers verwenden möchten? Dies ist der Punkt, wo Optionen mit Werten ins Spiel kommen. Wir brauchen einfach nur die CommandFlags.Builder#valueFlag(CommandElement, String…) Methode auf unserem Options-Builder aufrufen. Durch die Verwendung der valueFlag() Methode können wir angeben, von welche Art von Wert unsere Option, sein soll, beispielsweise Integer oder String. Eine Option für einen Integer zu erstellen, kann wie folgt erreicht werden:

CommandSpec myCommand = CommandSpec.builder()
        .executor(new MyCommand())
        .arguments(GenericArguments.flags().valueFlag(GenericArguments
                .integer(Text.of("value")), "s").buildWith(GenericArguments.none()))
        .build();

Du kannst GenericArguments#integer(Text) mit jeder anderen Art von Optionsart austauschen, die du möchtest, zum Beispiel GenericArguments#string(Text).

Nun, um auf den Wert der Option in unseren Befehl zuzugreifen, können wir es einfach wie jedes andere Befehls-Argument behandeln. Wir müssen vorher nur prüfen, ob es existiert:

import java.util.Optional;

Optional<Integer> optional = args.<Integer>getOne("value");
if (optional.isPresent()) {
    int value = optional.get().intValue();
} else {
    src.sendMessage(Text.of("The value flag was not specified."));
}

Lange Optionen

Als Alternative zu den kurzen Optionen wie die, die wir zuvor verwendet haben, können wir auch lange Optionen verwenden. Wenn du eine lange Option hast, kannst du diese angeben, indem du den Namen der Option, deinen Gleichzeichen = und deinen Wert angibst. Um ein langes Flag zu erstellen, musst du einfach deiner Option ein Minuszeichen - voranstellen, wie hier gezeigt:

CommandSpec myCommand = CommandSpec.builder()
        .executor(new MyCommand())
        .arguments(GenericArguments.flags().flag("-myflag")
            .buildWith(GenericArguments.none()))
        .build();

Wir können den Wert, der mit unserer Option angegeben wurde, genauso abfragen wie jede andere Option auch:

Optional<String> optional = args.<String>getOne("myflag");
if (optional.isPresent()) {
    String value = optional.get();
}

Sodass, wenn der Benutzer den Befehl /our-command --myflag=Flag_Value ausführt, der Wert Flag_Value in dem String value gespeichert wäre.

Verhalten bei unbekannten Optionen

Nun, was ist, wenn wir keine Optionen in unserem Befehl angegeben haben, aber dennoch unbekannte Optionen akzeptieren wollen? In diesem Fall können wir das Verhalten für unbekannte Optionen für unseren Befehl angeben:

import org.spongepowered.api.command.args.CommandFlags;

CommandSpec myCommand = CommandSpec.builder()
            .executor(new MyCommand())
            .arguments(GenericArguments.flags()
                    .setUnknownShortFlagBehavior(
                        CommandFlags.UnknownFlagBehavior.ACCEPT_VALUE)
                    .buildWith(GenericArguments.none()))
            .build();

Hierdurch können wir angeben, dass wir alle Kurzoptionen mit einem Wert akzeptieren. Ohne dies würde die Verwendung einer unbekannten Option einen Fehler werfen. Ein paar der möglichen Verhalten bei unbekannten Optionen sind ERROR, ACCEPT_NONVALUE, ACCEPT_VALUE und IGNORE. Bitte beachte, dass das Standardverhalten für unbekannte Optionen ERROR ist.