public ReadResults Parse(IStringReader reader, DispatcherResources resources, out Objective result)
        {
            result = default;
            ReadResults readResults;
            string      objective;

            if (UseBedrock)
            {
                readResults = reader.ReadString(out objective);
            }
            else
            {
                readResults = reader.ReadUnquotedString(out objective);
            }

            if (!readResults.Successful)
            {
                return(readResults);
            }
            if (objective.Length > 16)
            {
                return(ReadResults.Failure(CommandError.ObjectiveNameTooLong()));
            }
            result = new Objective(objective);
            return(ReadResults.Success());
        }
        private static ReadResults ReadScores(EntitySelectorParser parser, IStringReader reader)
        {
            ReadResults readResults = reader.Expect('{');

            if (!readResults.Successful)
            {
                return(readResults);
            }

            reader.SkipWhitespace();
            while (reader.CanRead() && reader.Peek() != '}')
            {
                reader.SkipWhitespace();
                readResults = reader.ReadUnquotedString(out _);
                if (!readResults.Successful)
                {
                    return(readResults);
                }

                reader.SkipWhitespace();
                readResults = reader.Expect('=');
                if (!readResults.Successful)
                {
                    return(readResults);
                }

                reader.SkipWhitespace();
                readResults = new RangeParser <int>(reader).Read(int.TryParse, CommandError.InvalidInteger, int.MinValue, int.MaxValue, false, out Range <int> range);
                if (!readResults.Successful)
                {
                    return(readResults);
                }

                parser.AddArgument(new ParsedArgument <Range <int> >(range, false));
                reader.SkipWhitespace();
                if (reader.CanRead())
                {
                    char c = reader.Read();
                    if (c == ',')
                    {
                        continue;
                    }
                    if (c == '}')
                    {
                        return(ReadResults.Success());
                    }
                }
                return(ReadResults.Failure(CommandError.ExpectedCharacter('}').WithContext(reader)));
            }

            reader.SkipWhitespace();
            return(reader.Expect('}'));
        }
Exemple #3
0
 public ReadResults Parse(IStringReader reader, DispatcherResources resources, out string result)
 {
     if (Type == StringType.GREEDY)
     {
         result = reader.GetRemaining();
         reader.SetCursor(reader.GetLength());
         return(ReadResults.Success());
     }
     else if (Type == StringType.WORD)
     {
         return(reader.ReadUnquotedString(out result));
     }
     else
     {
         return(reader.ReadString(out result));
     }
 }
Exemple #4
0
 /// <exception cref="CommandSyntaxException" />
 public override string Parse(IStringReader reader)
 {
     if (Type == StringArgType.GreedyPhrase)
     {
         var text = reader.Remaining;
         reader.Cursor = reader.TotalLength;
         return(text);
     }
     else if (Type == StringArgType.SingleWord)
     {
         return(reader.ReadUnquotedString());
     }
     else
     {
         return(reader.ReadString());
     }
 }
        private static ReadResults ReadAdvancements(EntitySelectorParser parser, IStringReader reader)
        {
            ReadResults readResults = reader.Expect('{');

            if (!readResults.Successful)
            {
                return(readResults);
            }

            reader.SkipWhitespace();
            while (reader.CanRead() && reader.Peek() != '}')
            {
                reader.SkipWhitespace();
                readResults = ResourceLocation.TryRead(reader, out ResourceLocation advancement);
                if (!readResults.Successful)
                {
                    return(readResults);
                }

                reader.SkipWhitespace();
                readResults = reader.Expect('=');
                if (!readResults.Successful)
                {
                    return(readResults);
                }

                reader.SkipWhitespace();
                if (reader.CanRead() && reader.Peek() == '{')
                {
                    reader.Skip();
                    reader.SkipWhitespace();
                    while (reader.CanRead() && reader.Peek() != '}')
                    {
                        reader.SkipWhitespace();
                        readResults = reader.ReadUnquotedString(out _);
                        if (!readResults.Successful)
                        {
                            return(readResults);
                        }

                        reader.SkipWhitespace();
                        readResults = reader.Expect('=');
                        if (!readResults.Successful)
                        {
                            return(readResults);
                        }

                        reader.SkipWhitespace();
                        readResults = reader.ReadBoolean(out _);
                        if (!readResults.Successful)
                        {
                            return(readResults);
                        }

                        reader.SkipWhitespace();
                        if (reader.CanRead())
                        {
                            char c = reader.Read();
                            if (c == ',')
                            {
                                continue;
                            }
                            if (c == '}')
                            {
                                break;
                            }
                        }
                    }
                }
                else
                {
                    readResults = reader.ReadBoolean(out _);
                    if (!readResults.Successful)
                    {
                        return(readResults);
                    }
                }

                parser.AddArgument(new ParsedArgument <Advancement>(new Advancement(advancement), false));
                reader.SkipWhitespace();
                if (reader.CanRead())
                {
                    char c = reader.Read();
                    if (c == ',')
                    {
                        continue;
                    }
                    if (c == '}')
                    {
                        return(ReadResults.Success());
                    }
                }
                return(ReadResults.Failure(CommandError.ExpectedCharacter('}').WithContext(reader)));
            }

            reader.SkipWhitespace();
            return(reader.Expect('}'));
        }