Java Code Examples for com.mojang.brigadier.StringReader#peek()

@SuppressWarnings("unchecked")
@Override
public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
    if (!(context.getSource() instanceof CommandSource))
        return builder.buildFuture();

    StringReader reader = new StringReader(builder.getInput());
    reader.setCursor(builder.getStart());

    CompletableFuture<Suggestions> playerCompletions;
    if ((reader.canRead() && reader.peek() == '@') || !suggestPlayerNames) {
        playerCompletions = Suggestions.empty();
    } else {
        playerCompletions = ((CommandSource) context.getSource()).getCompletions((CommandContext<CommandSource>) context, builder.restart());
    }

    EntitySelectorParser parser = new EntitySelectorParser(reader, singleTarget, playersOnly);
    try {
        parser.parse();
    } catch (CommandSyntaxException ignore) {
    }
    CompletableFuture<Suggestions> selectorCompletions = parser.suggestor.apply(builder.restart());

    return CompletableFuture.allOf(playerCompletions, selectorCompletions)
            .thenCompose(v -> UnionArgumentType.mergeSuggestions(playerCompletions.join(), selectorCompletions.join()));
}
 

public Collection<? extends CommandNode<S>> getRelevantNodes(final StringReader input) {
    if (literals.size() > 0) {
        final int cursor = input.getCursor();
        while (input.canRead() && input.peek() != ' ') {
            input.skip();
        }
        final String text = input.getString().substring(cursor, input.getCursor());
        input.setCursor(cursor);
        final LiteralCommandNode<S> literal = literals.get(text);
        if (literal != null) {
            return Collections.singleton(literal);
        } else {
            return arguments.values();
        }
    } else {
        return arguments.values();
    }
}
 

private static boolean isCoordinateArg(StringReader reader) {
    if (reader.peek() == '~') {
        reader.skip();
        if (reader.peek() == ' ')
            return true;
    }
    try {
        reader.readDouble();
    } catch (CommandSyntaxException e) {
        return false;
    }
    return reader.peek() == ' ';
}
 

@Override
public Void parse(StringReader reader) throws CommandSyntaxException {
    if (reader.canRead() && reader.peek() == '@') {
        new EntitySelectorParser(reader, singleTarget, playersOnly).parse();
    } else {
        reader.readUnquotedString();
    }
    return null;
}
 

@Override
public Integer parse(StringReader reader) throws CommandSyntaxException {
    int amount = reader.readInt();
    if (reader.canRead() && (reader.peek() == 'l' || reader.peek() == 'L'))
        reader.skip();
    return amount;
}
 

public static String until(StringReader reader, char delimiter) {
    var start = reader.getCursor();
    while (reader.canRead() && reader.peek() != delimiter) {
        reader.skip();
    }
    
    return reader.getString().substring(start, reader.getCursor());
}
 

private int parse(final StringReader reader) {
    final int start = reader.getCursor();
    if (reader.canRead(literal.length())) {
        final int end = start + literal.length();
        if (reader.getString().substring(start, end).equals(literal)) {
            reader.setCursor(end);
            if (!reader.canRead() || reader.peek() == ' ') {
                return end;
            } else {
                reader.setCursor(start);
            }
        }
    }
    return -1;
}
 

@Override
public boolean isValidInput(final String input) {
    try {
        final StringReader reader = new StringReader(input);
        type.parse(reader);
        return !reader.canRead() || reader.peek() == ' ';
    } catch (final CommandSyntaxException ignored) {
        return false;
    }
}
 

@Override
public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
    List<CompletableFuture<Suggestions>> suggestions = new ArrayList<>();

    String[] args = builder.getRemaining().split(" ", -1);
    if (args.length == 1) {
        suggestions.add(blockPos.listSuggestions(context, builder.restart()));
        suggestions.add(victim.listSuggestions(context, builder.restart()));
        suggestions.add(target.listSuggestions(context, builder.restart()));
    } else {
        StringReader reader = new StringReader(builder.getInput());
        reader.setCursor(builder.getStart());

        boolean victimPresent = !isCoordinateArg(reader);
        if (victimPresent) {
            reader.setCursor(builder.getStart());
            try {
                victim.parse(reader);
            } catch (CommandSyntaxException e) {
                return builder.buildFuture();
            }
            if (reader.peek() != ' ')
                return builder.buildFuture();
        }
        reader.skip();
        if (args.length == 2) {
            if (victimPresent) {
                suggestions.add(blockPos.listSuggestions(context, builder.createOffset(reader.getCursor())));
                suggestions.add(target.listSuggestions(context, builder.createOffset(reader.getCursor())));
            } else {
                suggestions.add(blockPos.listSuggestions(context, builder.restart()));
            }
        } else {
            int argStart = victimPresent ? reader.getCursor() : builder.getStart();
            if (!isCoordinateArg(reader))
                return builder.buildFuture();
            if (args.length <= (victimPresent ? 4 : 3)) {
                suggestions.add(blockPos.listSuggestions(context, builder.createOffset(argStart)));
            } else {
                if (victimPresent) {
                    reader.skip();
                    isCoordinateArg(reader);
                }
                reader.skip();
                isCoordinateArg(reader);
                reader.skip();
                suggestions.add(CommandSource.suggestMatching(new String[] {"~", "~ ~"}, builder.createOffset(reader.getCursor())));
            }
        }
    }

    return CompletableFuture.allOf(suggestions.toArray(new CompletableFuture[0]))
            .thenApply(v -> Suggestions.merge(builder.getInput(), suggestions.stream().map(CompletableFuture::join).collect(Collectors.toList())));
}
 

@Override
public Custom_1_12_Argument parse(StringReader reader) throws CommandSyntaxException {
    List<ParsedArgument<?, ?>> result = new ArrayList<>();

    int start = reader.getCursor();
    Identifier id = Identifier.fromCommandInput(reader);
    if (!Registry.BLOCK.containsId(id)) {
        reader.setCursor(start);
        throw BlockArgumentParser.INVALID_BLOCK_ID_EXCEPTION.createWithContext(reader, id);
    }
    Block block = Registry.BLOCK.get(id);
    if (!isValidBlock(block)) {
        reader.setCursor(start);
        throw BlockArgumentParser.INVALID_BLOCK_ID_EXCEPTION.createWithContext(reader, id);
    }

    result.add(new ParsedArgument<>(start, reader.getCursor(), block));
    if (!reader.canRead())
        return new Custom_1_12_Argument(result);

    reader.expect(' ');
    start = reader.getCursor();
    try {
        int meta;
        if (!test && reader.peek() == '*') {
            reader.skip();
            meta = -1;
        } else {
            meta = reader.readInt();
        }
        if (meta >= (test ? -1 : 0) && meta < 16 && (!reader.canRead() || reader.peek() == ' ')) {
            result.add(new ParsedArgument<>(start, reader.getCursor(), meta));
            return new Custom_1_12_Argument(result);
        }
    } catch (CommandSyntaxException ignore) {
    }
    reader.setCursor(start);
    if ("default".equals(reader.readUnquotedString())) {
        result.add(new ParsedArgument<>(start, reader.getCursor(), 0));
        return new Custom_1_12_Argument(result);
    }

    reader.setCursor(start);

    List<String> properties = BlockStateReverseFlattening.OLD_PROPERTIES.getOrDefault(id, Collections.emptyList());
    Set<String> alreadySeen = new HashSet<>();
    while (reader.canRead() && reader.peek() != ' ') {
        int propStart = reader.getCursor();
        String property = reader.readUnquotedString();
        if (alreadySeen.contains(property)) {
            reader.setCursor(propStart);
            throw BlockArgumentParser.DUPLICATE_PROPERTY_EXCEPTION.createWithContext(reader, id, property);
        }
        if (!properties.contains(property)) {
            reader.setCursor(propStart);
            throw BlockArgumentParser.UNKNOWN_PROPERTY_EXCEPTION.createWithContext(reader, id, property);
        }
        alreadySeen.add(property);
        reader.expect('=');
        int valueStart = reader.getCursor();
        String value = reader.readUnquotedString();
        if (!BlockStateReverseFlattening.OLD_PROPERTY_VALUES.get(Pair.of(id, property)).contains(value)) {
            reader.setCursor(valueStart);
            throw BlockArgumentParser.INVALID_PROPERTY_EXCEPTION.createWithContext(reader, id, property, value);
        }
        if (reader.canRead() && reader.peek() != ' ')
            reader.expect(',');
    }

    result.add(new ParsedArgument<>(start, reader.getCursor(), null));
    return new Custom_1_12_Argument(result);
}