Ejemplo n.º 1
0
        private void jellies()
        {
            group("j", meander: 4, speed: -1, tracking: 4, flags: "few fearless");
            breed("green slime", green, 12, new List <object>()
            {
                new Attack("crawl[s] on", 4),
                MoveFactory.spawn(rate: 6)
            });

            breed("frosty slime", white, 14, new List <object>()
            {
                new Attack("crawl[s] on", 5, ElementFactory.Instance.Cold),
                MoveFactory.spawn(rate: 6)
            });

            breed("smoking slime", red, 18, new List <object>()
            {
                new Attack("crawl[s] on", 6, ElementFactory.Instance.Fire),
                MoveFactory.spawn(rate: 6)
            });

            breed("sparkling slime", lightPurple, 22, new List <object>()
            {
                new Attack("crawl[s] on", 8, ElementFactory.Instance.Lightning),
                MoveFactory.spawn(rate: 6)
            });
        }
Ejemplo n.º 2
0
        private void reptiles()
        {
            group("R");
            breed("frog", green, 4, new List <object>()
            {
                new Attack("hop[s] on", 2),
            }, meander: 4, speed: 1);

            // TODO: Drop scales?
            group("R", meander: 1, flags: "fearless");
            breed("lizard guard", yellow, 26, new List <object>()
            {
                new Attack("claw[s]", 8),
                new Attack("bite[s]", 10),
            });

            breed("lizard protector", darkYellow, 30, new List <object>()
            {
                new Attack("claw[s]", 10),
                new Attack("bite[s]", 14),
            });

            breed("armored lizard", gray, 38, new List <object>()
            {
                new Attack("claw[s]", 10),
                new Attack("bite[s]", 15),
            });

            breed("scaled guardian", darkGray, 50, new List <object>()
            {
                new Attack("claw[s]", 10),
                new Attack("bite[s]", 15),
            });

            breed("saurian", orange, 64, new List <object>()
            {
                new Attack("claw[s]", 12),
                new Attack("bite[s]", 17),
            });

            group("R", meander: 3);
            breed("juvenile salamander", lightRed, 24, new List <object>()
            {
                new Attack("bite[s]", 12, ElementFactory.Instance.Fire),
                MoveFactory.fireCone(rate: 16, damage: 18, range: 6)
            });

            breed("salamander", red, 40, new List <object>()
            {
                new Attack("bite[s]", 16, ElementFactory.Instance.Fire),
                MoveFactory.fireCone(rate: 16, damage: 24, range: 8)
            });
        }
Ejemplo n.º 3
0
        private void people()
        {
            group("p", tracking: 14, flags: "open-doors");
            breed("simpering knave", orange, 15, new List <object>()
            {
                new Attack("hit[s]", 2),
                new Attack("stab[s]", 4)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(30, "whip", 1),
                DropFactory.PercentDrop(20, "body", 1),
                DropFactory.PercentDrop(10, "boots", 2),
                DropFactory.PercentDrop(10, "magic", 1),
            }, meander: 3, flags: "cowardly");

            breed("decrepit mage", purple, 16, new List <object>()
            {
                new Attack("hit[s]", 2),
                MoveFactory.sparkBolt(rate: 10, damage: 8)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(30, "magic", 3),
                DropFactory.PercentDrop(15, "dagger", 1),
                DropFactory.PercentDrop(15, "staff", 1),
                DropFactory.PercentDrop(10, "robe", 2),
                DropFactory.PercentDrop(10, "boots", 2)
            }, meander: 2);

            breed("unlucky ranger", green, 20, new List <object>()
            {
                new Attack("slash[es]", 2),
                MoveFactory.arrow(rate: 4, damage: 2)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(15, "potion", 3),
                DropFactory.PercentDrop(10, "bow", 4),
                DropFactory.PercentDrop(5, "sword", 4),
                DropFactory.PercentDrop(8, "body", 3)
            }, meander: 2);

            breed("drunken priest", aqua, 18, new List <object>()
            {
                new Attack("hit[s]", 3),
                MoveFactory.heal(rate: 15, amount: 8)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(15, "scroll", 3),
                DropFactory.PercentDrop(7, "club", 2),
                DropFactory.PercentDrop(7, "robe", 2)
            }, meander: 4, flags: "fearless");
        }
Ejemplo n.º 4
0
        private void insects()
        {
            group("i", tracking: 3, meander: 8, flags: "fearless");
            breed("giant cockroach[es]", darkBrown, 4, new List <object>()
            {
                new Attack("crawl[s] on", 3),
                MoveFactory.spawn(rate: 4)
            }, drop: DropFactory.PercentDrop(10, "Insect Wing"),
                  speed: 3);

            breed("giant centipede", red, 16, new List <object>()
            {
                new Attack("crawl[s] on", 3),
                new Attack("bite[s]", 5),
            }, speed: 3, meander: 0);
        }
Ejemplo n.º 5
0
        private void eyes()
        {
            group("e", flags: "immobile");
            breed("lazy eye", white, 16, new List <object>()
            {
                new Attack("gaze[s] into", 6),
                MoveFactory.sparkBolt(rate: 7, damage: 10, range: 5),
                MoveFactory.teleport(rate: 9, range: 4)
            });

            group("e", flags: "immobile");
            breed("floating eye", yellow, 30, new List <object>()
            {
                new Attack("touch[es]", 4),
                MoveFactory.lightBolt(rate: 5, damage: 16),
                MoveFactory.teleport(rate: 8, range: 7)
            });

            // baleful eye, malevolent eye, murderous eye
        }
Ejemplo n.º 6
0
        private void canines()
        {
            group("c", tracking: 20, meander: 3, flags: "few");
            breed("mangy cur", yellow, 11, new List <object>()
            {
                new Attack("bite[s]", 4),
                MoveFactory.howl(range: 6)
            }, drop: DropFactory.PercentDrop(20, "Fur Pelt"));

            breed("wild dog", gray, 16, new List <object>()
            {
                new Attack("bite[s]", 4),
                MoveFactory.howl(range: 8)
            }, drop: DropFactory.PercentDrop(20, "Fur Pelt"));

            breed("mongrel", orange, 28, new List <object>()
            {
                new Attack("bite[s]", 6),
                MoveFactory.howl(range: 10)
            }, drop: DropFactory.PercentDrop(20, "Fur Pelt"));
        }
Ejemplo n.º 7
0
        private void kobolds()
        {
            group("k", speed: 2, meander: 4, flags: "cowardly");
            breed("forest sprite", lightGreen, 8, new List <object>()
            {
                new Attack("scratch[es]", 4),
                MoveFactory.teleport(range: 6)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(20, "magic", 1)
            });

            breed("house sprite", lightBlue, 15, new List <object>()
            {
                new Attack("poke[s]", 8),
                MoveFactory.teleport(range: 6)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(20, "magic", 6)
            });

            breed("mischievous sprite", lightRed, 24, new List <object>()
            {
                new Attack("stab[s]", 9),
                MoveFactory.sparkBolt(rate: 8, damage: 8),
                MoveFactory.poisonBolt(rate: 15, damage: 10),
                MoveFactory.teleport(range: 8)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(40, "magic", 8)
            });

            breed("scurrilous imp", lightRed, 18, new List <object>()
            {
                new Attack("club[s]", 4),
                MoveFactory.insult(),
                MoveFactory.haste()
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(10, "club", 1),
                DropFactory.PercentDrop(5, "speed", 1),
            }, meander: 4, flags: "cowardly");

            breed("vexing imp", purple, 19, new List <object>()
            {
                new Attack("scratch[es]", 4),
                MoveFactory.insult(),
                MoveFactory.sparkBolt(rate: 5, damage: 6)
            }, drop: DropFactory.PercentDrop(10, "teleportation", 1),
                  meander: 2, speed: 1, flags: "cowardly");

            breed("kobold", red, 16, new List <object>()
            {
                new Attack("poke[s]", 4),
                MoveFactory.teleport(rate: 6, range: 6)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(30, "magic", 7)
            }, meander: 2, flags: "group");

            breed("kobold shaman", blue, 16, new List <object>()
            {
                new Attack("hit[s]", 4),
                MoveFactory.teleport(rate: 5, range: 6),
                MoveFactory.waterBolt(rate: 5, damage: 6)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(40, "magic", 7)
            }, meander: 2);

            breed("kobold trickster", gold, 20, new List <object>()
            {
                new Attack("hit[s]", 5),
                MoveFactory.sparkBolt(rate: 5, damage: 8),
                MoveFactory.teleport(rate: 5, range: 6),
                MoveFactory.haste(rate: 7)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(40, "magic", 7)
            }, meander: 2);

            breed("kobold priest", white, 25, new List <object>()
            {
                new Attack("club[s]", 6),
                MoveFactory.heal(rate: 15, amount: 10),
                MoveFactory.fireBolt(rate: 10, damage: 8),
                MoveFactory.teleport(rate: 5, range: 6),
                MoveFactory.haste(rate: 7)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(30, "club", 10),
                DropFactory.PercentDrop(40, "magic", 7)
            }, meander: 2);

            breed("imp incanter", lightPurple, 18, new List <object>()
            {
                new Attack("scratch[es]", 4),
                MoveFactory.insult(),
                MoveFactory.fireBolt(rate: 5, damage: 10)
            }, drop: DropFactory.PercentDrop(20, "magic", 1),
                  meander: 4, speed: 1, flags: "cowardly");

            breed("imp warlock", darkPurple, 40, new List <object>()
            {
                new Attack("stab[s]", 5),
                MoveFactory.iceBolt(rate: 8, damage: 12),
                MoveFactory.fireBolt(rate: 8, damage: 12)
            }, drop: DropFactory.PercentDrop(20, "magic", 4),
                  meander: 3, speed: 1, flags: "cowardly");

            // TODO: Always drop something good.
            breed("Feng", orange, 60, new List <object>()
            {
                new Attack("stab[s]", 5),
                MoveFactory.teleport(rate: 5, range: 6),
                MoveFactory.teleport(rate: 50, range: 30),
                MoveFactory.insult(),
                MoveFactory.lightningCone(rate: 8, damage: 12)
            }, drop: DropFactory.PercentDrop(20, "magic", 4),
                  meander: 3, speed: 1, flags: "cowardly");

            // homonculous
        }
Ejemplo n.º 8
0
        private void goblins()
        {
            group("g", meander: 1, flags: "open-doors");
            breed("goblin peon", lightBrown, 20, new List <object>()
            {
                new Attack("stab[s]", 5)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(10, "spear", 3),
                DropFactory.PercentDrop(5, "healing", 2),
            }, meander: 2, flags: "few");

            breed("goblin archer", green, 22, new List <object>()
            {
                new Attack("stab[s]", 3),
                MoveFactory.arrow(rate: 3, damage: 4)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(20, "bow", 1),
                DropFactory.PercentDrop(10, "dagger", 2),
                DropFactory.PercentDrop(5, "healing", 3),
            }, flags: "few");

            breed("goblin fighter", brown, 30, new List <object>()
            {
                new Attack("stab[s]", 7)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(15, "spear", 5),
                DropFactory.PercentDrop(10, "armor", 5),
                DropFactory.PercentDrop(5, "resistance", 3),
                DropFactory.PercentDrop(5, "healing", 3),
            });

            breed("goblin warrior", gray, 42, new List <object>()
            {
                new Attack("stab[s]", 10)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(20, "axe", 6),
                DropFactory.PercentDrop(20, "armor", 6),
                DropFactory.PercentDrop(5, "resistance", 3),
                DropFactory.PercentDrop(5, "healing", 3),
            }, flags: "protective");

            breed("goblin mage", blue, 30, new List <object>()
            {
                new Attack("whip[s]", 7),
                MoveFactory.fireBolt(rate: 12, damage: 6),
                MoveFactory.sparkBolt(rate: 12, damage: 8),
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(10, "equipment", 5),
                DropFactory.PercentDrop(10, "whip", 5),
                DropFactory.PercentDrop(20, "magic", 6),
            });

            breed("goblin ranger", darkGreen, 36, new List <object>()
            {
                new Attack("stab[s]", 10),
                MoveFactory.arrow(rate: 3, damage: 8)
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(30, "bow", 11),
                DropFactory.PercentDrop(20, "armor", 8),
                DropFactory.PercentDrop(20, "magic", 8)
            });

            // TODO: Always drop something good.
            breed("Erlkonig, the Goblin Prince", darkGray, 80, new List <object>()
            {
                new Attack("hit[s]", 10),
                new Attack("slash[es]", 14),
                MoveFactory.darkBolt(rate: 20, damage: 10),
            }, drop: new List <Drop>()
            {
                DropFactory.PercentDrop(60, "equipment", 10),
                DropFactory.PercentDrop(60, "equipment", 10),
                DropFactory.PercentDrop(40, "magic", 12),
            }, flags: "protective");
        }