com.mojang.brigadier.Command Java Examples

public static <T> void registerCommands(CommandDispatcher<T> dispatcher, Command<T> executor, SuggestionProvider<T> suggestor, String... aliases) {
    if (aliases.length == 0) {
        return;
    }

    String mainName = aliases[0];
    LiteralArgumentBuilder<T> command = LiteralArgumentBuilder.<T>literal(mainName)
            .executes(executor)
            .then(RequiredArgumentBuilder.<T, String>argument("args", StringArgumentType.greedyString())
                    .suggests(suggestor)
                    .executes(executor)
            );

    LiteralCommandNode<T> node = dispatcher.register(command);
    for (int i = 1; i < aliases.length; i++) {
        dispatcher.register(LiteralArgumentBuilder.<T>literal(aliases[i]).redirect(node));
    }
}
 

@SuppressWarnings("unchecked")
@Test
public void testEquals() throws Exception {
    final Object otherSource = new Object();
    final Command<Object> command = mock(Command.class);
    final Command<Object> otherCommand = mock(Command.class);
    final CommandNode<Object> rootNode = mock(CommandNode.class);
    final CommandNode<Object> otherRootNode = mock(CommandNode.class);
    final CommandNode<Object> node = mock(CommandNode.class);
    final CommandNode<Object> otherNode = mock(CommandNode.class);
    new EqualsTester()
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, rootNode, 0).build(""), new CommandContextBuilder<>(dispatcher, source, rootNode, 0).build(""))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, otherRootNode, 0).build(""), new CommandContextBuilder<>(dispatcher, source, otherRootNode, 0).build(""))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, otherSource, rootNode, 0).build(""), new CommandContextBuilder<>(dispatcher, otherSource, rootNode, 0).build(""))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withCommand(command).build(""), new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withCommand(command).build(""))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withCommand(otherCommand).build(""), new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withCommand(otherCommand).build(""))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withArgument("foo", new ParsedArgument<>(0, 1, 123)).build("123"), new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withArgument("foo", new ParsedArgument<>(0, 1, 123)).build("123"))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withNode(node, StringRange.between(0, 3)).withNode(otherNode, StringRange.between(4, 6)).build("123 456"), new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withNode(node, StringRange.between(0, 3)).withNode(otherNode, StringRange.between(4, 6)).build("123 456"))
        .addEqualityGroup(new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withNode(otherNode, StringRange.between(0, 3)).withNode(node, StringRange.between(4, 6)).build("123 456"), new CommandContextBuilder<>(dispatcher, source, rootNode, 0).withNode(otherNode, StringRange.between(0, 3)).withNode(node, StringRange.between(4, 6)).build("123 456"))
        .testEquals();
}
 

private void checkCommandRegistered() {
    CommandDispatcher<CommandSource> dispatcher = getPlayerCommandDispatcher();
    if (dispatcher == null) {
        return;
    }

    try {
        if (dispatcher != this.dispatcher) {
            this.dispatcher = dispatcher;
            registerCommands(this.dispatcher, c -> Command.SINGLE_SUCCESS, this, "sparkc", "sparkclient");
            FabricSparkGameHooks.INSTANCE.setChatSendCallback(this::onClientChat);
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

public static <T> void registerCommands(CommandDispatcher<T> dispatcher, Command<T> executor, SuggestionProvider<T> suggestor, String... aliases) {
    if (aliases.length == 0) {
        return;
    }

    String mainName = aliases[0];
    LiteralArgumentBuilder<T> command = LiteralArgumentBuilder.<T>literal(mainName)
            .executes(executor)
            .then(RequiredArgumentBuilder.<T, String>argument("args", StringArgumentType.greedyString())
                    .suggests(suggestor)
                    .executes(executor)
            );

    LiteralCommandNode<T> node = dispatcher.register(command);
    for (int i = 1; i < aliases.length; i++) {
        dispatcher.register(LiteralArgumentBuilder.<T>literal(aliases[i]).redirect(node));
    }
}
 

@Override
public int run(CommandContext<ServerCommandSource> context) throws CommandSyntaxException {
    String[] args = processArgs(context);
    if (args == null) {
        return 0;
    }

    this.platform.executeCommand(new FabricCommandSender(context.getSource().getPlayer(), this), args);
    return Command.SINGLE_SUCCESS;
}
 

private void checkCommandRegistered() {
    CommandDispatcher<ISuggestionProvider> dispatcher = getPlayerCommandDispatcher();
    if (dispatcher == null) {
        return;
    }

    try {
        if (dispatcher != this.dispatcher) {
            this.dispatcher = dispatcher;
            registerCommands(this.dispatcher, context -> Command.SINGLE_SUCCESS, this, "sparkc", "sparkclient");
        }
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

@Override
public int run(CommandContext<CommandSource> context) throws CommandSyntaxException {
    String[] args = processArgs(context);
    if (args == null)
        return 0;
    this.platform.executeCommand(new ForgeCommandSender(context.getSource().source, this), args);
    return Command.SINGLE_SUCCESS;
}
 

@Test
public void testEquals() throws Exception {
    @SuppressWarnings("unchecked") final Command<Object> command = (Command<Object>) mock(Command.class);

    new EqualsTester()
        .addEqualityGroup(
            argument("foo", integer()).build(),
            argument("foo", integer()).build()
        )
        .addEqualityGroup(
            argument("foo", integer()).executes(command).build(),
            argument("foo", integer()).executes(command).build()
        )
        .addEqualityGroup(
            argument("bar", integer(-100, 100)).build(),
            argument("bar", integer(-100, 100)).build()
        )
        .addEqualityGroup(
            argument("foo", integer(-100, 100)).build(),
            argument("foo", integer(-100, 100)).build()
        )
        .addEqualityGroup(
            argument("foo", integer()).then(
                argument("bar", integer())
            ).build(),
            argument("foo", integer()).then(
                argument("bar", integer())
            ).build()
        )
        .testEquals();
}
 

@Test
public void testEquals() throws Exception {
    @SuppressWarnings("unchecked") final Command<Object> command = mock(Command.class);

    new EqualsTester()
        .addEqualityGroup(
            literal("foo").build(),
            literal("foo").build()
        )
        .addEqualityGroup(
            literal("bar").executes(command).build(),
            literal("bar").executes(command).build()
        )
        .addEqualityGroup(
            literal("bar").build(),
            literal("bar").build()
        )
        .addEqualityGroup(
            literal("foo").then(
                literal("bar")
            ).build(),
            literal("foo").then(
                literal("bar")
            ).build()
        )
        .testEquals();
}
 

public VariableResolver(Environment environment) {
    super(environment);
    command = specialize(Command.class, sender);
    argumentType = types.erasure(elements.getTypeElement(ArgumentType.class.getName()).asType());
    requirement = specialize(Predicate.class, sender);
    suggestions = specialize(SuggestionProvider.class, sender);
}
 

@ParameterizedTest
@MethodSource("mutables")
void setCommand(Mutable<CommandSender> mutable) {
    Command command = val -> 0;
    
    mutable.setCommand(command);
    
    assertEquals(command, ((CommandNode<?>) mutable).getCommand());
    if (mutable instanceof Aliasable<?>) {
        assertEquals(command, ((Aliasable<CommandSender>) mutable).aliases().get(0).getCommand());
    }
}
 

private static <T> void buildSetSettingCommand(LiteralArgumentBuilder<CommandSource> command,
                                               Setting<T> setting, ArgumentType<T> argument, Class<T> clazz) {
    Command<CommandSource> setSettingCommand = context -> {
        setting.set(context.getArgument(VALUE, clazz));
        if (CommandHelper.lastNodeIsLiteral(context, SAVE)) {
            ConfigManager.saveConfig();
        }
        return 0;
    };
    command.then(Commands.argument(VALUE, argument)
            .executes(setSettingCommand)
            .then(Commands.literal(SAVE)
                    .executes(setSettingCommand)));
}
 

protected CommandNode(final Command<S> command, final Predicate<S> requirement, final CommandNode<S> redirect, final RedirectModifier<S> modifier, final boolean forks) {
    this.command = command;
    this.requirement = requirement;
    this.redirect = redirect;
    this.modifier = modifier;
    this.forks = forks;
}
 

public CommandContext(final S source, final String input, final Map<String, ParsedArgument<S, ?>> arguments, final Command<S> command, final CommandNode<S> rootNode, final List<ParsedCommandNode<S>> nodes, final StringRange range, final CommandContext<S> child, final RedirectModifier<S> modifier, boolean forks) {
    this.source = source;
    this.input = input;
    this.arguments = arguments;
    this.command = command;
    this.rootNode = rootNode;
    this.nodes = nodes;
    this.range = range;
    this.child = child;
    this.modifier = modifier;
    this.forks = forks;
}
 

private static Command<ServerCommandSource> manipulation(Consumer<EntityPlayerActionPack> action)
{
    return c -> manipulate(c, action);
}
 

public Command<S> getCommand() {
    return command;
}
 

public T executes(final Command<S> command) {
    this.command = command;
    return getThis();
}
 

public Command<S> getCommand() {
    return command;
}
 

public Command<S> getCommand() {
    return command;
}
 

public CommandContextBuilder<S> withCommand(final Command<S> command) {
    this.command = command;
    return this;
}
 

public ArgumentCommandNode(final String name, final ArgumentType<T> type, final Command<S> command, final Predicate<S> requirement, final CommandNode<S> redirect, final RedirectModifier<S> modifier, final boolean forks, final SuggestionProvider<S> customSuggestions) {
    super(command, requirement, redirect, modifier, forks);
    this.name = name;
    this.type = type;
    this.customSuggestions = customSuggestions;
}
 

public LiteralCommandNode(final String literal, final Command<S> command, final Predicate<S> requirement, final CommandNode<S> redirect, final RedirectModifier<S> modifier, final boolean forks) {
    super(command, requirement, redirect, modifier, forks);
    this.literal = literal;
}
 

public Command<S> getCommand() {
    return command;
}
 

@VisibleForOverride
protected Command<R> execution(CommandNode<T> command) {
    return (Command<R>) NONE;
}
 

public B executes(Execution<T> command) {
    return executes((Command<T>) command);
}
 

protected void fixPermissions() {
	/*
	 * Makes permission checks more "Bukkit" like and less "Vanilla Minecraft" like
	 */
	try {

		// Get the command map to find registered commands
		SimpleCommandMap map = nms.getSimpleCommandMap();
		Field f = getField(SimpleCommandMap.class, "knownCommands");
		Map<String, org.bukkit.command.Command> knownCommands = (Map<String, org.bukkit.command.Command>) f
				.get(map);

		CommandAPIMain.getLog().info("Linking permissions to commands:");
		permissionsToFix.forEach((cmdName, perm) -> {

			if (perm.equals(CommandPermission.NONE)) {
				if (CommandAPIMain.getConfiguration().hasVerboseOutput()) {
					CommandAPIMain.getLog().info("NONE -> /" + cmdName);
				}
				// Set the command permission to empty string (Minecraft standard for "no
				// permission required")
				if (nms.isVanillaCommandWrapper(knownCommands.get(cmdName))) {
					knownCommands.get(cmdName).setPermission("");
				}
				if (nms.isVanillaCommandWrapper(knownCommands.get("minecraft:" + cmdName))) {
					knownCommands.get(cmdName).setPermission("");
				}
			} else {
				if (perm.getPermission() != null) {
					if (CommandAPIMain.getConfiguration().hasVerboseOutput()) {
						CommandAPIMain.getLog().info(perm.getPermission() + " -> /" + cmdName);
					}
					// Set the command permission to the (String) permission node
					if (nms.isVanillaCommandWrapper(knownCommands.get(cmdName))) {
						knownCommands.get(cmdName).setPermission(perm.getPermission());
					}
					if (nms.isVanillaCommandWrapper(knownCommands.get("minecraft:" + cmdName))) {
						knownCommands.get(cmdName).setPermission(perm.getPermission());
					}
				} else {
					// Dafaq?
				}
			}
		});
	} catch (IllegalAccessException | IllegalArgumentException e) {
		e.printStackTrace();
	}
}
 

public void setCommand(Command<T> command); 

public Command<T> getCommand();