Beispiel #1
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var prefix = p.After("Can Study:").SkipWhitespaces();

            if (!prefix)
            {
                return(Error(prefix));
            }

            List <IReportNode> skills = new List <IReportNode>();

            while (!p.EOF)
            {
                if (skills.Count > 0)
                {
                    if (!Mem(p.After(",").SkipWhitespaces()))
                    {
                        return(Error(LastResult));
                    }
                }

                var skill = skillParser.Parse(p);
                if (!skill)
                {
                    return(Error(skill));
                }

                skills.Add(skill.Value);
            }

            return(Ok(ReportNode.Bag(
                          ReportNode.Key("canStudy", ReportNode.Array(skills))
                          )));
        }
Beispiel #2
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var weight = p.After("Weight:").SkipWhitespaces().Integer();

            if (!weight)
            {
                return(Error(weight));
            }

            return(Ok(ReportNode.Bag(
                          ReportNode.Int("weight", weight)
                          )));
        }
Beispiel #3
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var capacities = p.After("Capacity:").SkipWhitespaces();

            if (!capacities)
            {
                return(Error(capacities));
            }

            var flying = capacities.Integer();

            if (!flying)
            {
                return(Error(flying));
            }

            var riding = capacities.After("/").Integer();

            if (!riding)
            {
                return(Error(riding));
            }

            var walking = capacities.After("/").Integer();

            if (!walking)
            {
                return(Error(walking));
            }

            var swimming = capacities.After("/").Integer();

            if (!swimming)
            {
                return(Error(swimming));
            }

            return(Ok(ReportNode.Bag(
                          ReportNode.Key("capacity", ReportNode.Object(
                                             ReportNode.Int("flying", flying),
                                             ReportNode.Int("riding", riding),
                                             ReportNode.Int("walking", walking),
                                             ReportNode.Int("swimming", swimming)
                                             ))
                          )));
        }
Beispiel #4
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var name = p.Before("(").SkipWhitespacesBackwards().AsString();

            if (!name)
            {
                return(Error(name));
            }

            var num = p.Between("(", ")").Integer();

            if (!num)
            {
                return(Error(num));
            }

            return(Ok(ReportNode.Bag(
                          ReportNode.Str("name", name),
                          ReportNode.Int("number", num)
                          )));
        }
Beispiel #5
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var month = p.Before(",").AsString();

            if (!month)
            {
                return(Error(month));
            }

            var year = p.After("Year").SkipWhitespaces().Integer();

            if (!year)
            {
                return(Error(year));
            }

            return(Ok(ReportNode.Bag(
                          ReportArray.Key("date", ReportNode.Object(
                                              ReportNode.Str("month", month),
                                              ReportNode.Int("year", year)
                                              ))
                          )));
        }
Beispiel #6
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var faction = factionName.Parse(p);

            if (!faction)
            {
                return(Error(faction));
            }

            var args = p.After("(").BeforeBackwards(")").List(",", argumentParser);

            if (!args)
            {
                return(Error(args));
            }

            return(Ok(ReportNode.Bag(
                          ReportNode.Key("faction", ReportNode.Object(
                                             faction.Value,
                                             ReportNode.Key("type", ReportNode.Array(args.Value))
                                             )
                                         )
                          )));
        }
Beispiel #7
0
        protected override Maybe <IReportNode> Execute(TextParser p)
        {
            var terrain = p.Before("(").SkipWhitespacesBackwards().AsString();

            if (!terrain)
            {
                return(Error(terrain));
            }

            var coords = coordsParser.Parse(p);

            if (!coords)
            {
                return(Error(coords));
            }

            var province = p.After("in").SkipWhitespaces().OneOf(
                x => x.Before(","),
                x => x.Before(".")
                ).AsString();

            if (!province)
            {
                return(Error(province));
            }

            var settlement = p.Try(x => {
                var name = p.After(",").After("contains").SkipWhitespaces().Before("[").SkipWhitespacesBackwards().AsString();
                if (!name)
                {
                    return(name.Convert <(string, string)>());
                }

                var size = p.Between("[", "]").AsString();
                if (!size)
                {
                    return(size.Convert <(string, string)>());
                }

                return(new Maybe <(string, string)>((name.Value, size.Value)));
            });

            var population = p.Try(x => {
                var amount = p.After(",").SkipWhitespaces().Integer();
                if (!amount)
                {
                    return(amount.Convert <(int, string)>());
                }

                var race = p.Between("(", ")").AsString();
                if (!race)
                {
                    return(race.Convert <(int, string)>());
                }

                return(new Maybe <(int, string)>((amount.Value, race.Value)));
            });

            var tax = p.Try(x => x.After("$").Integer());

            return(Ok(ReportNode.Bag(
                          ReportNode.Str("terrain", terrain),
                          ReportNode.Key("coords", coords.Value),
                          ReportNode.Str("province", province),
                          settlement ? ReportNode.Key("settlement", ReportNode.Object(
                                                          ReportNode.Str("name", settlement.Value.Item1),
                                                          ReportNode.Str("size", settlement.Value.Item2)
                                                          )) : null,
                          population ? ReportNode.Key("population", ReportNode.Object(
                                                          ReportNode.Int("amount", population.Value.Item1),
                                                          ReportNode.Str("race", population.Value.Item2)
                                                          )) : null,
                          tax ? ReportNode.Int("tax", tax) : null
                          )));
        }