Parameter werden in den meisten Befehlen verwendet. Manchmal sind sie optional, das heißt, wenn du diesen Parameter nicht angibst, wird der Befehl dennoch ausgeführt. Ein Knoten kann mehrere Parametertypen haben, aber es ist zu beachten, dass die Möglichkeit einer Mehrdeutigkeit besteht, die vermieden werden sollte.

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 diesem Fall musst du nach dem Befehlstext /command_with_arg eine ganze Zahl eingeben. Wenn du zum Beispiel /command_with_arg 3 ausführst, erhältst du eine Rückmeldungsnachricht:

Aufruf von /command_with_arg mit Wert = 3

Wenn du /command_with_arg ohne Argumente eingibst, kann der Befehl nicht korrekt geparst werden.

Dann fügen wir ein optionales zweites Argument hinzu:

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

Jetzt kannst du eine oder zwei ganze Zahlen eingeben. Wenn du eine ganze Zahl eingibst, wird ein Feedback-Text mit einem einzigen Wert ausgegeben. Wenn du zwei Ganzzahlen angibst, wird ein Feedback-Text mit zwei Werten ausgegeben.

Du kannst es unnötig finden, ähnliche Ausführungen zweimal anzugeben. Daher können wir eine Methode erstellen, die in beiden Ausführungen verwendet wird.

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

Benutzerdefinierte Argumenttypen

Wenn Vanilla nicht den von dir benötigten Argumenttyp verfügt, kannst du deinen eigenen erstellen. Dazu musst du eine Klasse erstellen, die das Interface ArgumentType<T> erbt, wobei T der Typ des Arguments ist.

Du musst die Methode "parse" implementieren, die die Eingabezeichenfolge zu dem gewünschten Typ parst.

Du kannst zum Beispiel einen Argumenttyp erstellen, der eine BlockPos aus einer Zeichenkette mit dem folgenden Format parst: {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}");
		}
	}
}

Benutzerdefinierte Argumenttypen registrieren

WARNING

Du musst den benutzerdefinierten Argumenttyp sowohl im Server als auch im Client registrieren, sonst wird der Befehl nicht funktionieren!

Du kannst deinen benutzerdefinierten Argumenttyp in der Methode onInitialize deines Mod-Initialisierers mit der Klasse ArgumentTypeRegistry registrieren:

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

Benutzerdefinierte Argumenttypen verwenden

Wir können unseren benutzerdefinierten Argumenttyp in einem Befehl verwenden, indem wir eine Instanz davon an die Methode .argument im Builder des Befehls übergeben.

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

Durch das Ausführen des Befehls, können wir testen, ob der Argumenttyp funktioniert oder nicht: