La maggior parte dei comandi usa i parametri. A volte possono essere opzionali, il che significa che se non viene fornito quel parametri, il comando verrà eseguito comunque. Ogni nodo può avere tipi di parametri multipli, ma ricorda che c'è una possibilità di ambiguità, che dovrebbe essere evitata.

CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
	dispatcher.register(Commands.literal("command_with_arg")
			.then(Commands.argument("value", IntegerArgumentType.integer())
					.executes(ExampleModCommands::executeCommandWithArg)));
});

private static int executeCommandWithArg(CommandContext<CommandSourceStack> context) {
	int value = IntegerArgumentType.getInteger(context, "value");
	context.getSource().sendSuccess(() -> Component.literal("Called /command_with_arg with value = %s".formatted(value)), false);
	return 1;
}

In questo caso, dopo il testo del comando /command_with_arg, dovresti scrivere un intero. Per esempio, se eseguissi /command_with_arg 3, otterresti come risposta il messaggio:

Called /command_with_arg with value = 3

Se scrivessi /command_with_arg senza parametri, non sarebbe possibile fare il parsing del comando correttamente.

Dopo di che aggiungiamo un secondo parametro opzionale:

CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
	dispatcher.register(Commands.literal("command_with_two_args")
			.then(Commands.argument("value_one", IntegerArgumentType.integer())
					.executes(ExampleModCommands::executeWithOneArg)
					.then(Commands.argument("value_two", IntegerArgumentType.integer())
							.executes(ExampleModCommands::executeWithTwoArgs))));
});

private static int executeWithOneArg(CommandContext<CommandSourceStack> context) {
	int value1 = IntegerArgumentType.getInteger(context, "value_one");
	context.getSource().sendSuccess(() -> Component.literal("Called /command_with_two_args with value one = %s".formatted(value1)), false);
	return 1;
}

private static int executeWithTwoArgs(CommandContext<CommandSourceStack> context) {
	int value1 = IntegerArgumentType.getInteger(context, "value_one");
	int value2 = IntegerArgumentType.getInteger(context, "value_two");
	context.getSource().sendSuccess(() -> Component.literal("Called /argtater2 with value one = %s and value two = %s".formatted(value1, value2)),
			false);
	return 1;
}

Ora puoi scrivere uno oppure due interi. Se fornisci un intero, un testo di feedback con un singolo valore verrà stampato. Se fornisci due interi, un testo di feedback con due interi verrà stampato.

Potresti pensare che sia inutile specificare esecuzioni simili due volte. Per cui possiamo creare un metodo che verrà usato in entrambe le esecuzioni.

CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
	dispatcher.register(Commands.literal("command_with_common_exec")
			.then(Commands.argument("value_one", IntegerArgumentType.integer())
					.executes(context -> executeCommon(IntegerArgumentType.getInteger(context, "value_one"), 0, context))
					.then(Commands.argument("value_two", IntegerArgumentType.integer())
							.executes(context -> executeCommon(
									IntegerArgumentType.getInteger(context, "value_one"),
									IntegerArgumentType.getInteger(context, "value_two"),
									context)))));
});

private static int executeCommon(int value1, int value2, CommandContext<CommandSourceStack> context) {
	context.getSource().sendSuccess(() -> Component.literal("Called /command_with_common_exec with value 1 = %s and value 2 = %s".formatted(value1, value2)), false);
	return 1;
}

Tipi di Parametri Personalizzati

Se vanilla non fornisce il tipo di parametro che ti serve, puoi creartene uno. Per fare questo, hai bisogno di creare una classe che implementa l'interfaccia ArgumentType<T> dove T è il tipo del parametro.

Avrai bisogno d'implementare il metodo parse, che farà il parsing della stringa in input nel tipo desiderato.

Per esempio, puoi creare un tipo di parametro che fa il parsing di un BlockPos da una stringa con il formato seguente: {x, y, z}

public class BlockPosArgumentType implements ArgumentType<BlockPos> {
	/**
	 * Parse the BlockPos from the reader in the {x, y, z} format.
	 */
	@Override
	public BlockPos parse(StringReader reader) throws CommandSyntaxException {
		try {
			// This requires the argument to be surrounded by quotation marks.
			// eg: "{1, 2, 3}"
			String string = reader.readString();

			// Remove the { and } from the string using regex.
			string = string.replace("{", "").replace("}", "");

			// Split the string into the x, y, and z values.
			String[] split = string.split(",");

			// Parse the x, y, and z values from the split string.
			int x = Integer.parseInt(split[0].trim());
			int y = Integer.parseInt(split[1].trim());
			int z = Integer.parseInt(split[2].trim());

			// Return the BlockPos.
			return new BlockPos(x, y, z);
		} catch (Exception e) {
			// Throw an exception if anything fails inside the try block.
			throw CommandSyntaxException.BUILT_IN_EXCEPTIONS.dispatcherParseException().create("Invalid BlockPos format. Expected {x, y, z}");
		}
	}
}

Registrare i Tipi di Parametri Personalizzati

WARNING

Avrai bisogno di registrare i tipi di parametri personalizzati sia sul server sia sul client altrimenti il comando non funzionerà!

Puoi registrare il tuo tipo di parametro personalizzato nel metodo onInitialize dell'inizializer della tua mod usando la classe ArgumentTypeRegistry:

ArgumentTypeRegistry.registerArgumentType(
		ResourceLocation.fromNamespaceAndPath("fabric-docs", "block_pos"),
		BlockPosArgumentType.class,
		SingletonArgumentInfo.contextFree(BlockPosArgumentType::new)
);

Usare i Tipi di Parametri Personalizzati

Possiamo usare il nostro tipo di parametro personalizzato in un comando - passando un'istanza di esso nel metodo .argument del costruttore del comando.

CommandRegistrationCallback.EVENT.register((dispatcher, registryAccess, environment) -> {
	dispatcher.register(Commands.literal("command_with_custom_arg").then(
			Commands.argument("block_pos", new BlockPosArgumentType())
					.executes(ExampleModCommands::executeCustomArgCommand)
	));
});

private static int executeCustomArgCommand(CommandContext<CommandSourceStack> context) {
	BlockPos arg = context.getArgument("block_pos", BlockPos.class);
	context.getSource().sendSuccess(() -> Component.literal("Called /command_with_custom_arg with block pos = %s".formatted(arg)), false);
	return 1;
}

Eseguendo il comando possiamo testare se il tipo di parametro funziona o meno: