com.mojang.brigadier.builder.RequiredArgumentBuilder 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));
    }
}
 

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 String toString() {
  MoreObjects.ToStringHelper helper = MoreObjects.toStringHelper(this)
      .add("idx", idx)
      .add("flags", flags)
      .add("children", children)
      .add("redirectTo", redirectTo);

  if (args != null) {
    if (args instanceof LiteralArgumentBuilder) {
      helper.add("argsLabel", ((LiteralArgumentBuilder) args).getLiteral());
    } else if (args instanceof RequiredArgumentBuilder) {
      helper.add("argsName", ((RequiredArgumentBuilder) args).getName());
    }
  }

  return helper.toString();
}
 

@Override
public boolean handle(AvailableCommands commands) {
  // Inject commands from the proxy.
  for (String command : server.getCommandManager().getAllRegisteredCommands()) {
    if (!server.getCommandManager().hasPermission(serverConn.getPlayer(), command)) {
      continue;
    }

    LiteralCommandNode<Object> root = LiteralArgumentBuilder.literal(command)
        .then(RequiredArgumentBuilder.argument("args", StringArgumentType.greedyString())
            .suggests(new ProtocolSuggestionProvider("minecraft:ask_server"))
            .build())
        .executes((ctx) -> 0)
        .build();
    commands.getRootNode().addChild(root);
  }
  return false;
}
 

public static <S extends CommandSource> LiteralArgumentBuilder<S> command(String commandName) {
    return LiteralArgumentBuilder.<S>literal(commandName)
            .then(
                    RequiredArgumentBuilder
                            .<S, String>argument("args", StringArgumentType.greedyString())
                            .executes(((VRCommandHandler) Via.getManager().getCommandHandler())::execute)
                            .suggests(((VRCommandHandler) Via.getManager().getCommandHandler())::suggestion)
            )
            .executes(((VRCommandHandler) Via.getManager().getCommandHandler())::execute);
}
 

private static RequiredArgumentBuilder<ServerCommandSource, BlockStateArgument>
drawShape(OptionalBlockSelector drawer)
{
    return argument("block", BlockStateArgumentType.blockState()).
            executes(drawer::apply)
            .then(literal("replace")
                    .then(argument("filter", BlockPredicateArgumentType.blockPredicate())
                            .executes(drawer::apply)));
}
 

private <T> RequiredArgumentBuilder<?, T> getRequiredArgumentBuilderDynamic(String argumentName, Argument type,
		CommandPermission permission) {
	if(type.getOverriddenSuggestions() == null) {
		return RequiredArgumentBuilder.argument(argumentName, (ArgumentType<T>) type.getRawType()).requires(clw -> 
             permissionCheck(nms.getCommandSenderForCLW(clw), permission)
        );
	} else {
		return getRequiredArgumentBuilderWithProvider(argumentName, type.getRawType(), permission,
				(CommandContext context, SuggestionsBuilder builder) -> getSuggestionsBuilder(builder,
						type.getOverriddenSuggestions().apply(nms.getCommandSenderForCLW(context.getSource()))));
	}
}
 

private static WireNode deserializeNode(ByteBuf buf, int idx) {
  byte flags = buf.readByte();
  int[] children = ProtocolUtils.readIntegerArray(buf);
  int redirectTo = -1;
  if ((flags & FLAG_IS_REDIRECT) > 0) {
    redirectTo = ProtocolUtils.readVarInt(buf);
  }

  switch (flags & FLAG_NODE_TYPE) {
    case NODE_TYPE_ROOT:
      return new WireNode(idx, flags, children, redirectTo, null);
    case NODE_TYPE_LITERAL:
      return new WireNode(idx, flags, children, redirectTo, LiteralArgumentBuilder
          .literal(ProtocolUtils.readString(buf)));
    case NODE_TYPE_ARGUMENT:
      String name = ProtocolUtils.readString(buf);
      ArgumentType<?> argumentType = ArgumentPropertyRegistry.deserialize(buf);

      RequiredArgumentBuilder<Object, ?> argumentBuilder = RequiredArgumentBuilder
          .argument(name, argumentType);
      if ((flags & FLAG_HAS_SUGGESTIONS) != 0) {
        argumentBuilder.suggests(new ProtocolSuggestionProvider(ProtocolUtils.readString(buf)));
      }

      return new WireNode(idx, flags, children, redirectTo, argumentBuilder);
    default:
      throw new IllegalArgumentException("Unknown node type " + (flags & FLAG_NODE_TYPE));
  }
}
 

@Override
public RequiredArgumentBuilder<S, T> createBuilder() {
    final RequiredArgumentBuilder<S, T> builder = RequiredArgumentBuilder.argument(name, type);
    builder.requires(getRequirement());
    builder.forward(getRedirect(), getRedirectModifier(), isFork());
    builder.suggests(customSuggestions);
    if (getCommand() != null) {
        builder.executes(getCommand());
    }
    return builder;
}
 

@Test
public void testCreateBuilder() throws Exception {
    final RequiredArgumentBuilder<Object, Integer> builder = node.createBuilder();
    assertThat(builder.getName(), is(node.getName()));
    assertThat(builder.getType(), is(node.getType()));
    assertThat(builder.getRequirement(), is(node.getRequirement()));
    assertThat(builder.getCommand(), is(node.getCommand()));
}
 

private <T> RequiredArgumentBuilder<S, T> argument(String name, ArgumentType<T> type){
	return RequiredArgumentBuilder.<S, T>argument(name, type);
}
 

public static <T> RequiredArgumentBuilder<CommandSource, T> argument(String name, ArgumentType<T> type) {
    return RequiredArgumentBuilder.argument(name, type);
}
 

private <T> RequiredArgumentBuilder<?, T> getRequiredArgumentBuilderWithProvider(String argumentName,
		ArgumentType<T> type, CommandPermission permission, SuggestionProvider provider) {
	return RequiredArgumentBuilder.argument(argumentName, type)
			.requires(clw -> permissionCheck(nms.getCommandSenderForCLW(clw), permission)).suggests(provider);
}