Banderas de Comando

Las banderas de comando son útiles para especificar parámetros extra para ser utilizados para el procesamiento de un comando que no pertenece a un argumento de comando.

Para crear una bandera, primero necesitamos un compilador de banderas. Podemos simplemente utilizar el método GenericArguments#flags() proporcionado por GenericArguments para obtener el compilador que necesitamos. Desde ahí, podemos especificar que tipo de bandera nos gustaría crear. Tenga en cuenta, que las banderas son especificadas como un argumento.

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

Esto creará una bandera de comando, así que cuando el jugador ejecute /our-command -s, la bandera para s será verdadera. Tenga en cuenta que compilando con GenericArguments#none() evitará que el comando tenga cualquier argumento. Si desea que el comando tenga argumentos y banderas, necesitará especificar sus argumentos dentro del método CommandFlags.Builder#buildWith(CommandElement).

Ahora que tenemos especificado que nuestro comando puede ser ejecutado con la bandera, podemos obtener luego el valor de la bandera. Para una bandera boolean simple igual a la que especificamos anteriormente, simplemente podemos solo verificar si existe. En el ejemplo siguiente, verificaremos si el CommandContext para el comando tiene un valor para s.

import org.spongepowered.api.text.Text;

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

Banderas de Permiso

Nuestras banderas hasta aquí son grandes, pero ¿y si queremos tenerlo para que un jugador necesite un permiso para utilizar una bandera? Podemos en cambio utilizar el método CommandFlags.Builder#permissionFlag(String, String…) sobre nuestro compilador de bandera. Esto requerirá que el jugador tenga un permiso específico para ejecutar el comando con la bandera. Un ejemplo de esto está a continuación:

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

Si un jugador no tiene el permiso myplugin.command.flag, entonces no se les permitirá ejecutar nuestro comando con la bandera de comando s.

Banderas de Valor

Los booleans pueden ser grandes, pero ¿y si queremos banderas para cosas como cadenas o enteros? Esto es cuando las banderas de valor vienen dentro del juego. Simplemente necesitamos utilizar el método CommandFlags.Builder#valueFlag(CommandElement, String…) en nuestro compilador de bandera. Utilizando el método valueFlag(), podemos especificar el tipo de bandera que queremos crear, como un entero o cadena. La creación de una bandera de valor entero puede ser hecha así:

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

Puede reemplazar GenericArguments#integer(Text) con cualquier otro tipo de bandera que le gustaría especificar, como GenericArguments#string(Text).

Ahora para recuperar el valor de bandera de nuestro comando, podemos simplemente tratarlo como cualquier otro argumento de comando. Simplemente necesitamos verificar si existe antes de recuperarlo:

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

Banderas Largas

Como alternativa a las banderas cortas como las que hemos estado usando anteriormente, también podemos usar banderas largas. Usando una bandera larga, puede especificar un valor junto con la bandera usando el signo de igual en el comando. Para crear una bandera larga, simplemente prefija tu bandera normal con un guión `` -``, así:

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

Podemos recuperar el valor que especificamos con nuestra bandera de manera similar a banderas de valor:

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

Así que si un usuario ejecuta /our-command --myflag=Flag_Value, el Flag_Value será almacenada en la cadena valor.

Comportamiento de Bandera Desconocida

Ahora, ¿que pasaría si no especificamos una bandera determinada para ir con nuestro comando, pero todavía quisiéramos aceptar banderas desconocidas? Podemos establecer el comportamiento de una bandera desconocida de nuestro comando para lograr esto:

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

Utilizando esto, podemos especificar que cualquier bandera corta con un valor determinado será aceptado. Sin esto, intentar utilizar una bandera desconocida generará una excepción. Alguno de los posibles comportamientos de bandera desconocida son ERROR, ACCEPT_NONVALUE, ACCEPT_VALUE y IGNORE. Tenga en cuenta que el comportamiento predeterminado para bandera desconocida es ERROR.