net.minecraft.command.ISuggestionProvider Java Examples

@Override
public CompletableFuture<Suggestions> getSuggestions(CommandContext<ISuggestionProvider> context, SuggestionsBuilder builder) throws CommandSyntaxException {
    String chat = context.getInput();
    String[] split = chat.split(" ");
    if (split.length == 0 || (!split[0].equals("/sparkc") && !split[0].equals("/sparkclient"))) {
        return Suggestions.empty();
    }

    String[] args = Arrays.copyOfRange(split, 1, split.length);

    return CompletableFuture.supplyAsync(() -> {
        for (String suggestion : this.platform.tabCompleteCommand(new ForgeCommandSender(this.minecraft.player, this), args)) {
            builder.suggest(suggestion);
        }
        return builder.build();
    });
}
 

public static void register(CommandDispatcher<ISuggestionProvider> commandDispatcher) {
    LiteralArgumentBuilder command = Commands.literal(COMMAND)
            .then(buildCommands(GET, ConfigCommand::getCommandForSetting))
            .then(buildCommands(ArgumentNames.SET, ConfigCommand::setCommandForSetting))
            .then(buildCommands(RESET, ConfigCommand::resetCommandForSetting)
                    .executes(context1 -> {
                        ConfigManager.getSettings().forEach(Setting::reset);
                        ConfigManager.saveConfig();
                        return 0;
                    }))
            .then(Commands.literal(SAVE)
                    .executes(context -> {
                        ConfigManager.saveConfig();
                        return 0;
                    }))
            .then(Commands.literal(SHOW_GUI)
                    .executes(context -> {
                        SettingsScreen.show();
                        return 0;
                    }));

    commandDispatcher.register(command);
}
 

public static void register(CommandDispatcher<ISuggestionProvider> commandDispatcher) {
    LiteralArgumentBuilder command = Commands.literal(COMMAND)
            .then(BoxCommandBuilder.build(BOX))
            .then(BeaconCommandBuilder.build(BEACON))
            .then(LineCommandBuilder.build(LINE))
            .then(SphereCommandBuilder.build(SPHERE))
            .then(Commands.literal(ArgumentNames.CLEAR)
                    .executes(context -> {
                        CustomBoxProvider.clear();
                        CustomBeaconProvider.clear();
                        CustomLineProvider.clear();
                        CustomSphereProvider.clear();

                        CommandHelper.feedback(context, "bbor.commands.custom.cleared.all");
                        return 0;
                    }));
    commandDispatcher.register(command);
}
 

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

public static void register(CommandDispatcher<ISuggestionProvider> commandDispatcher) {
    LiteralArgumentBuilder command = Commands.literal(COMMAND)
            .then(Commands.literal(LOAD)
                    .executes(context -> {
                        LoadSavesScreen.show();
                        return 0;
                    }))
            .then(Commands.literal(ArgumentNames.CLEAR)
                    .executes(context -> {
                        ClientInterop.clearStructures();
                        return 0;
                    }));

    commandDispatcher.register(command);
}
 

public static void register(CommandDispatcher<ISuggestionProvider> commandDispatcher) {
    LiteralArgumentBuilder command = Commands.literal(COMMAND)
            .then(Commands.literal(ArgumentNames.SET)
                    .then(Commands.argument(ArgumentNames.POS, Arguments.point())
                            .executes(SpawningSphereCommand::setSphere))
                    .executes(SpawningSphereCommand::setSphere))
            .then(Commands.literal(ArgumentNames.CLEAR)
                    .executes(context -> {
                        boolean cleared = SpawningSphereProvider.clear();

                        String format = cleared ? "bbor.commands.spawningSphere.cleared" : "bbor.commands.spawningSphere.notSet";
                        CommandHelper.feedback(context, format);
                        return 0;
                    }))
            .then(Commands.literal(CALCULATE_SPAWNABLE)
                    .executes(context -> {
                        if (!SpawningSphereProvider.hasSpawningSphereInDimension(Player.getDimensionId())) {
                            CommandHelper.feedback(context, "bbor.commands.spawningSphere.notSet");
                            return 0;
                        }

                        Counts counts = new Counts();
                        World world = Minecraft.getInstance().world;
                        SpawningSphereProvider.calculateSpawnableSpacesCount(pos -> {
                            counts.spawnable++;
                            if (world.getLightFor(LightType.SKY, pos) > 7)
                                counts.nightSpawnable++;
                        });
                        SpawningSphereProvider.setSpawnableSpacesCount(counts.spawnable);

                        CommandHelper.feedback(context, "bbor.commands.spawningSphere.calculated",
                                String.format("%,d", counts.spawnable),
                                String.format("%,d", counts.nightSpawnable));
                        return 0;
                    }));
    commandDispatcher.register(command);
}
 

public static boolean interceptChatMessage(String message) {
    if (message.startsWith("/bbor:")) {
        ClientPlayNetHandler connection = Minecraft.getInstance().getConnection();
        if (connection != null) {
            CommandDispatcher<ISuggestionProvider> commandDispatcher = connection.func_195515_i();
            CommandSource commandSource = Minecraft.getInstance().player.getCommandSource();
            try {
                commandDispatcher.execute(message.substring(1), commandSource);
            } catch (CommandSyntaxException exception) {
                commandSource.sendErrorMessage(TextComponentUtils.toTextComponent(exception.getRawMessage()));
                if (exception.getInput() != null && exception.getCursor() >= 0) {
                    ITextComponent suggestion = new StringTextComponent("")
                            .applyTextStyle(TextFormatting.GRAY)
                            .applyTextStyle(style -> style.setClickEvent(new ClickEvent(ClickEvent.Action.SUGGEST_COMMAND, message)));
                    int textLength = Math.min(exception.getInput().length(), exception.getCursor());
                    if (textLength > 10) {
                        suggestion.appendText("...");
                    }

                    suggestion.appendText(exception.getInput().substring(Math.max(0, textLength - 10), textLength));
                    if (textLength < exception.getInput().length()) {
                        suggestion.appendSibling(new StringTextComponent(exception.getInput().substring(textLength))
                                .applyTextStyles(TextFormatting.RED, TextFormatting.UNDERLINE));
                    }

                    suggestion.appendSibling(new TranslationTextComponent("command.context.here")
                            .applyTextStyles(TextFormatting.RED, TextFormatting.ITALIC));
                    commandSource.sendErrorMessage(suggestion);
                }
            }
        }
        return true;
    }
    return false;
}
 

public static void registerClientCommands(CommandDispatcher<ISuggestionProvider> commandDispatcher) {
    SeedCommand.register(commandDispatcher);
    SpawningSphereCommand.register(commandDispatcher);
    CustomCommand.register(commandDispatcher);
    ConfigCommand.register(commandDispatcher);
    StructuresCommand.register(commandDispatcher);
}
 

private CommandDispatcher<ISuggestionProvider> getPlayerCommandDispatcher() {
    return Optional.ofNullable(this.minecraft.player)
            .map(player -> player.connection)
            .map(ClientPlayNetHandler::getCommandDispatcher)
            .orElse(null);
}