com.mojang.brigadier.suggestion.SuggestionProvider 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
protected @Nullable SuggestionProvider<CommandListenerWrapper> suggestions(ArgumentCommandNode<CommandSender, ?> command) {
    var type = command.getType();
    var suggestor = command.getCustomSuggestions();
    
    if (!(type instanceof Type<?>) && suggestor == null) {
        return null;
        
    } else if (suggestor == null) {
        return reparse((Type<?>) type);
    }
    
    var client = CLIENT_SIDE.get(suggestor);
    if (client != null) {
        return client;
 
    } else {
        return reparse(suggestor);
    } 
}
 

SuggestionProvider<CommandListenerWrapper> reparse(Type<?> type) {
    return (context, suggestions) -> {
        var sender = context.getSource().getBukkitSender();
        var reparsed = dispatcher.parse(context.getInput(), sender).getContext().build(context.getInput());
        return type.listSuggestions(reparsed, suggestions);
    };
}
 

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

SuggestionProvider<CommandListenerWrapper> reparse(SuggestionProvider<CommandSender> suggestor) {
    return (context, suggestions) -> {
        var sender = context.getSource().getBukkitSender();
        var reparsed = dispatcher.parse(context.getInput(), sender).getContext().build(context.getInput());
        return suggestor.getSuggestions(reparsed, suggestions);
    };
}
 

@Override
public SuggestionProvider getSuggestionProvider(SuggestionProviders provider) {
    switch (provider) {
        case FUNCTION:
            return (context, builder) -> {
                CustomFunctionData functionData = getCLW(context).getServer().getFunctionData();
                ICompletionProvider.a(functionData.h().a(), builder, "#");
                return ICompletionProvider.a(functionData.c().keySet(), builder);
            };
        case RECIPES:
            return CompletionProviders.b;
        case SOUNDS:
            return CompletionProviders.c;
        case ADVANCEMENTS:
            return (cmdCtx, builder) -> {
                Collection<Advancement> advancements = ((CommandListenerWrapper) cmdCtx.getSource()).getServer().getAdvancementData().a();
                return ICompletionProvider.a(advancements.stream().map(Advancement::getName), builder);
            };
        case LOOT_TABLES:
            return (context, builder) -> {
                LootTableRegistry lootTables = getCLW(context).getServer().getLootTableRegistry();
                return ICompletionProvider.a(lootTables.a(), builder);
            };
        case ENTITIES:
			return CompletionProviders.d;
		case BIOMES:
        default:
            return (context, builder) -> Suggestions.empty();
    }
}
 

@Override
public SuggestionProvider getSuggestionProvider(SuggestionProviders provider) {
    switch (provider) {
        case FUNCTION:
            return (context, builder) -> {
                CustomFunctionData functionData = getCLW(context).getServer().getFunctionData();
                ICompletionProvider.a(functionData.h().a(), builder, "#");
                return ICompletionProvider.a(functionData.c().keySet(), builder);
            };
        case RECIPES:
            return CompletionProviders.b;
        case SOUNDS:
            return CompletionProviders.c;
        case ADVANCEMENTS:
            return (cmdCtx, builder) -> {
                Collection<Advancement> advancements = ((CommandListenerWrapper) cmdCtx.getSource()).getServer().getAdvancementData().a();
                return ICompletionProvider.a(advancements.stream().map(Advancement::getName), builder);
            };
        case LOOT_TABLES:
            return (context, builder) -> {
                LootTableRegistry lootTables = getCLW(context).getServer().getLootTableRegistry();
                return ICompletionProvider.a(lootTables.a(), builder);
            };
        case ENTITIES:
			return CompletionProviders.d;
		case BIOMES:
        default:
            return (context, builder) -> Suggestions.empty();
    }
}
 

@Override
public SuggestionProvider getSuggestionProvider(SuggestionProviders provider) {
	switch (provider) {
	case FUNCTION:
		return (context, builder) -> {
			CustomFunctionData functionData = getCLW(context).getServer().getFunctionData();
			ICompletionProvider.a(functionData.h().a(), builder, "#");
			return ICompletionProvider.a(functionData.c().keySet(), builder);
		};
	case RECIPES:
		return CompletionProviders.b;
	case SOUNDS:
		return CompletionProviders.c;
	case ADVANCEMENTS:
		return (cmdCtx, builder) -> {
			Collection<Advancement> advancements = ((CommandListenerWrapper) cmdCtx.getSource()).getServer()
					.getAdvancementData().getAdvancements();
			return ICompletionProvider.a(advancements.stream().map(Advancement::getName), builder);
		};
	case LOOT_TABLES:
		return (context, builder) -> {
			LootTableRegistry lootTables = getCLW(context).getServer().getLootTableRegistry();
			return ICompletionProvider.a(lootTables.a(), builder);
		};
	case ENTITIES:
		return CompletionProviders.d;
	case BIOMES:
	default:
		return (context, builder) -> Suggestions.empty();
	}
}
 

@Override
public SuggestionProvider getSuggestionProvider(SuggestionProviders provider) {
	switch (provider) {
	case FUNCTION:
		return (context, builder) -> {
			CustomFunctionData functionData = getCLW(context).getServer().getFunctionData();
			ICompletionProvider.a(functionData.g().a(), builder, "#");
			return ICompletionProvider.a(functionData.c().keySet(), builder);
		};
	case RECIPES:
		return CompletionProviders.b;
	case SOUNDS:
		return CompletionProviders.c;
	case ADVANCEMENTS:
		return (cmdCtx, builder) -> {
			Collection<Advancement> advancements = ((CommandListenerWrapper) cmdCtx.getSource()).getServer()
					.getAdvancementData().b();
			return ICompletionProvider.a(advancements.stream().map(Advancement::getName), builder);
		};
	case LOOT_TABLES:
		return (context, builder) -> {
			LootTableRegistry lootTables = getCLW(context).getServer().getLootTableRegistry();
			return ICompletionProvider.a(lootTables.a(), builder);
		};
	case ENTITIES:
		return CompletionProviders.d;
	case BIOMES:
	default:
		return (context, builder) -> Suggestions.empty();
	}
}
 

@Override
public SuggestionProvider getSuggestionProvider(SuggestionProviders provider) {
	switch (provider) {
	case FUNCTION:
		return (context, builder) -> {
			CustomFunctionData functionData = getCLW(context).getServer().getFunctionData();
			ICompletionProvider.a(functionData.g(), builder, "#");
			return ICompletionProvider.a(functionData.f(), builder);
		};
	case RECIPES:
		return CompletionProviders.b;
	case SOUNDS:
		return CompletionProviders.c;
	case ADVANCEMENTS:
		return (cmdCtx, builder) -> {
			Collection<Advancement> advancements = ((CommandListenerWrapper) cmdCtx.getSource()).getServer()
					.getAdvancementData().getAdvancements();
			return ICompletionProvider.a(advancements.stream().map(Advancement::getName), builder);
		};
	case LOOT_TABLES:
		return (context, builder) -> {
			LootTableRegistry lootTables = getCLW(context).getServer().getLootTableRegistry();
			return ICompletionProvider.a(lootTables.a(), builder);
		};
	case BIOMES:
		return CompletionProviders.d;
	case ENTITIES:
		return CompletionProviders.e;
	default:
		return (context, builder) -> Suggestions.empty();
	}
}
 

private static void serializeNode(CommandNode<Object> node, ByteBuf buf,
    Object2IntMap<CommandNode<Object>> idMappings) {
  byte flags = 0;
  if (node.getRedirect() != null) {
    flags |= FLAG_IS_REDIRECT;
  }
  if (node.getCommand() != null) {
    flags |= FLAG_EXECUTABLE;
  }

  if (node instanceof RootCommandNode<?>) {
    flags |= NODE_TYPE_ROOT;
  } else if (node instanceof LiteralCommandNode<?>) {
    flags |= NODE_TYPE_LITERAL;
  } else if (node instanceof ArgumentCommandNode<?, ?>) {
    flags |= NODE_TYPE_ARGUMENT;
    if (((ArgumentCommandNode) node).getCustomSuggestions() != null) {
      flags |= FLAG_HAS_SUGGESTIONS;
    }
  } else {
    throw new IllegalArgumentException("Unknown node type " + node.getClass().getName());
  }

  buf.writeByte(flags);
  ProtocolUtils.writeVarInt(buf, node.getChildren().size());
  for (CommandNode<Object> child : node.getChildren()) {
    ProtocolUtils.writeVarInt(buf, idMappings.getInt(child));
  }
  if (node.getRedirect() != null) {
    ProtocolUtils.writeVarInt(buf, idMappings.getInt(node.getRedirect()));
  }

  if (node instanceof ArgumentCommandNode<?, ?>) {
    ProtocolUtils.writeString(buf, node.getName());
    ArgumentPropertyRegistry.serialize(buf, ((ArgumentCommandNode) node).getType());

    if (((ArgumentCommandNode) node).getCustomSuggestions() != null) {
      // The unchecked cast is required, but it is not particularly relevant because we check for
      // a more specific type later. (Even then, we only pull out one field.)
      @SuppressWarnings("unchecked")
      SuggestionProvider<Object> provider = ((ArgumentCommandNode) node).getCustomSuggestions();

      if (!(provider instanceof ProtocolSuggestionProvider)) {
        throw new IllegalArgumentException("Suggestion provider " + provider.getClass().getName()
          + " is not valid.");
      }

      ProtocolUtils.writeString(buf, ((ProtocolSuggestionProvider) provider).name);
    }
  } else if (node instanceof LiteralCommandNode<?>) {
    ProtocolUtils.writeString(buf, node.getName());
  }
}
 

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

public Argument(String name, ArgumentType<V> type, Command<T> command, Predicate<T> requirement, SuggestionProvider<T> suggestions) {
    this(name, type, command, requirement, null, null, false, suggestions);
}
 

public Argument(String name, ArgumentType<V> type, Execution<T> execution, Predicate<T> requirement, SuggestionProvider<T> suggestions) {
    this(name, type, execution, requirement, null, null, false, suggestions);
}
 

public Argument(String name, ArgumentType<V> type, Command<T> command, Predicate<T> requirement, @Nullable CommandNode<T> destination, RedirectModifier<T> modifier, boolean fork, SuggestionProvider<T> suggestions) {
    super(name, type, command, requirement, destination, modifier, fork, suggestions);
    this.destination = destination;
    this.addition = super::addChild;
}
 

public Builder<T, V> suggests(SuggestionProvider<T> suggestions) {
    this.suggestions = suggestions;
    return getThis();
}
 

@VisibleForOverride
protected @Nullable SuggestionProvider<R> suggestions(ArgumentCommandNode<T, ?> command) {
    return null;
}
 

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 SuggestionProvider<S> getCustomSuggestions() {
    return customSuggestions;
}
 

public RequiredArgumentBuilder<S, T> suggests(final SuggestionProvider<S> provider) {
    this.suggestionsProvider = provider;
    return getThis();
}
 

public SuggestionProvider<S> getSuggestionsProvider() {
    return suggestionsProvider;
}
 

/**
 * Retrieve a specific NMS implemented SuggestionProvider
 * @param provider The SuggestionProvider type to retrieve
 * @return A SuggestionProvider that matches the SuggestionProviders input
 */
SuggestionProvider<?> getSuggestionProvider(SuggestionProviders provider);