Beispiel #1
0
        static void build_template_grand_melee()
        {
            EncounterTemplateGroup group = new EncounterTemplateGroup("Grand Melee", "Entire Party");

            EncounterTemplate gm1 = new EncounterTemplate(Difficulty.Easy);

            gm1.Slots.Add(new EncounterTemplateSlot(4, -2, RoleType.Brute));
            gm1.Slots.Add(new EncounterTemplateSlot(11, -4, true));
            group.Templates.Add(gm1);

            EncounterTemplate gm2 = new EncounterTemplate(Difficulty.Moderate);

            gm2.Slots.Add(new EncounterTemplateSlot(2, -1, RoleType.Soldier));
            gm2.Slots.Add(new EncounterTemplateSlot(4, -2, RoleType.Brute));
            gm2.Slots.Add(new EncounterTemplateSlot(12, -4, true));
            group.Templates.Add(gm2);

            EncounterTemplate gm3 = new EncounterTemplate(Difficulty.Hard);

            gm3.Slots.Add(new EncounterTemplateSlot(2, 0, RoleType.Soldier));
            gm3.Slots.Add(new EncounterTemplateSlot(4, -1, RoleType.Brute));
            gm3.Slots.Add(new EncounterTemplateSlot(17, -2, true));
            group.Templates.Add(gm3);

            fTemplateGroups.Add(group);
        }
Beispiel #2
0
        static void build_template_dragons_den()
        {
            EncounterTemplateGroup group = new EncounterTemplateGroup("Dragon's Den", "Entire Party");

            EncounterTemplate dd1 = new EncounterTemplate(Difficulty.Easy);

            dd1.Slots.Add(new EncounterTemplateSlot(1, -2, RoleFlag.Solo));
            group.Templates.Add(dd1);

            EncounterTemplate dd2 = new EncounterTemplate(Difficulty.Moderate);

            dd2.Slots.Add(new EncounterTemplateSlot(1, 0, RoleFlag.Solo));
            group.Templates.Add(dd2);

            EncounterTemplate dd3 = new EncounterTemplate(Difficulty.Moderate);

            dd3.Slots.Add(new EncounterTemplateSlot(1, 1, RoleFlag.Solo));
            group.Templates.Add(dd3);

            EncounterTemplate dd4 = new EncounterTemplate(Difficulty.Hard);

            dd4.Slots.Add(new EncounterTemplateSlot(1, 3, RoleFlag.Solo));
            group.Templates.Add(dd4);

            EncounterTemplate dd5 = new EncounterTemplate(Difficulty.Hard);

            dd5.Slots.Add(new EncounterTemplateSlot(1, 1, RoleFlag.Solo));
            dd5.Slots.Add(new EncounterTemplateSlot(1, 0, RoleFlag.Elite));
            group.Templates.Add(dd5);

            fTemplateGroups.Add(group);
        }
Beispiel #3
0
        private static void build_template_wolf_pack()
        {
            EncounterTemplateGroup encounterTemplateGroup = new EncounterTemplateGroup("Wolf Pack", "Entire Party");
            EncounterTemplate      encounterTemplate      = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate.Slots.Add(new EncounterTemplateSlot(7, -4, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate encounterTemplate1 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(7, -2, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate encounterTemplate2 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(5, 0, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterTemplate encounterTemplate3 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate3.Slots.Add(new EncounterTemplateSlot(3, 5, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate3);
            EncounterTemplate encounterTemplate4 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(4, 5, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate4);
            EncounterTemplate encounterTemplate5 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate5.Slots.Add(new EncounterTemplateSlot(6, 2, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate5);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
        }
Beispiel #4
0
        static void build_template_commander_and_troops()
        {
            EncounterTemplateGroup group = new EncounterTemplateGroup("Commander and Troops", "Entire Party");

            EncounterTemplate ct1 = new EncounterTemplate(Difficulty.Easy);

            ct1.Slots.Add(new EncounterTemplateSlot(1, 0, new RoleType[] { RoleType.Controller, RoleType.Soldier, RoleType.Lurker, RoleType.Skirmisher }));
            ct1.Slots.Add(new EncounterTemplateSlot(4, -3, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group.Templates.Add(ct1);

            EncounterTemplate ct2 = new EncounterTemplate(Difficulty.Moderate);

            ct2.Slots.Add(new EncounterTemplateSlot(1, 3, new RoleType[] { RoleType.Controller, RoleType.Soldier, RoleType.Lurker, RoleType.Skirmisher }));
            ct2.Slots.Add(new EncounterTemplateSlot(5, -2, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group.Templates.Add(ct2);

            EncounterTemplate ct3 = new EncounterTemplate(Difficulty.Hard);

            ct3.Slots.Add(new EncounterTemplateSlot(1, 5, new RoleType[] { RoleType.Controller, RoleType.Soldier, RoleType.Lurker, RoleType.Skirmisher }));
            ct3.Slots.Add(new EncounterTemplateSlot(3, 1, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            ct3.Slots.Add(new EncounterTemplateSlot(2, 1, new RoleType[] { RoleType.Artillery }));
            group.Templates.Add(ct3);

            fTemplateGroups.Add(group);
        }
Beispiel #5
0
        private static void build_template_dragons_den()
        {
            EncounterTemplateGroup encounterTemplateGroup = new EncounterTemplateGroup("Dragon's Den", "Entire Party");
            EncounterTemplate      encounterTemplate      = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate.Slots.Add(new EncounterTemplateSlot(1, -2, RoleFlag.Solo));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate encounterTemplate1 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(1, 0, RoleFlag.Solo));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate encounterTemplate2 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(1, 1, RoleFlag.Solo));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterTemplate encounterTemplate3 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate3.Slots.Add(new EncounterTemplateSlot(1, 3, RoleFlag.Solo));
            encounterTemplateGroup.Templates.Add(encounterTemplate3);
            EncounterTemplate encounterTemplate4 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(1, 1, RoleFlag.Solo));
            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(1, 0, RoleFlag.Elite));
            encounterTemplateGroup.Templates.Add(encounterTemplate4);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
        }
Beispiel #6
0
        private static void build_template_double_line()
        {
            EncounterTemplateGroup       encounterTemplateGroup = new EncounterTemplateGroup("Double Line", "Entire Party");
            EncounterTemplate            encounterTemplate      = new EncounterTemplate(Difficulty.Easy);
            List <EncounterTemplateSlot> slots = encounterTemplate.Slots;

            RoleType[] roleTypeArray = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots.Add(new EncounterTemplateSlot(3, -4, roleTypeArray));
            List <EncounterTemplateSlot> encounterTemplateSlots = encounterTemplate.Slots;

            RoleType[] roleTypeArray1 = new RoleType[] { RoleType.Artillery, RoleType.Controller };
            encounterTemplateSlots.Add(new EncounterTemplateSlot(2, -2, roleTypeArray1));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate            encounterTemplate1 = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> slots1             = encounterTemplate1.Slots;

            RoleType[] roleTypeArray2 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots1.Add(new EncounterTemplateSlot(3, 0, roleTypeArray2));
            List <EncounterTemplateSlot> encounterTemplateSlots1 = encounterTemplate1.Slots;

            RoleType[] roleTypeArray3 = new RoleType[] { RoleType.Artillery, RoleType.Controller };
            encounterTemplateSlots1.Add(new EncounterTemplateSlot(2, 0, roleTypeArray3));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate            encounterTemplate2 = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> slots2             = encounterTemplate2.Slots;

            RoleType[] roleTypeArray4 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots2.Add(new EncounterTemplateSlot(3, -2, roleTypeArray4));
            List <EncounterTemplateSlot> encounterTemplateSlots2 = encounterTemplate2.Slots;

            RoleType[] roleTypeArray5 = new RoleType[] { RoleType.Artillery, RoleType.Controller };
            encounterTemplateSlots2.Add(new EncounterTemplateSlot(2, 3, roleTypeArray5));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterTemplate            encounterTemplate3 = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> slots3             = encounterTemplate3.Slots;

            RoleType[] roleTypeArray6 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots3.Add(new EncounterTemplateSlot(3, 2, roleTypeArray6));
            encounterTemplate3.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Controller));
            List <EncounterTemplateSlot> encounterTemplateSlots3 = encounterTemplate3.Slots;

            RoleType[] roleTypeArray7 = new RoleType[] { RoleType.Artillery, RoleType.Lurker };
            encounterTemplateSlots3.Add(new EncounterTemplateSlot(1, 4, roleTypeArray7));
            encounterTemplateGroup.Templates.Add(encounterTemplate3);
            EncounterTemplate            encounterTemplate4 = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> slots4             = encounterTemplate4.Slots;

            RoleType[] roleTypeArray8 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots4.Add(new EncounterTemplateSlot(3, 0, roleTypeArray8));
            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(2, 1, RoleType.Artillery));
            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Controller));
            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Lurker));
            encounterTemplateGroup.Templates.Add(encounterTemplate4);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
        }
Beispiel #7
0
        private static void build_template_battlefield_control()
        {
            EncounterTemplateGroup encounterTemplateGroup = new EncounterTemplateGroup("Battlefield Control", "Entire Party");
            EncounterTemplate      encounterTemplate      = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate.Slots.Add(new EncounterTemplateSlot(1, -2, RoleType.Controller));
            encounterTemplate.Slots.Add(new EncounterTemplateSlot(6, -4, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate encounterTemplate1 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(1, 1, RoleType.Controller));
            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(6, -2, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate encounterTemplate2 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(1, 5, RoleType.Controller));
            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(5, 1, RoleType.Skirmisher));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
        }
Beispiel #8
0
        static void build_template_double_line()
        {
            EncounterTemplateGroup group = new EncounterTemplateGroup("Double Line", "Entire Party");

            EncounterTemplate dl1 = new EncounterTemplate(Difficulty.Easy);

            dl1.Slots.Add(new EncounterTemplateSlot(3, -4, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            dl1.Slots.Add(new EncounterTemplateSlot(2, -2, new RoleType[] { RoleType.Artillery, RoleType.Controller }));
            group.Templates.Add(dl1);

            EncounterTemplate dl2 = new EncounterTemplate(Difficulty.Moderate);

            dl2.Slots.Add(new EncounterTemplateSlot(3, 0, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            dl2.Slots.Add(new EncounterTemplateSlot(2, 0, new RoleType[] { RoleType.Artillery, RoleType.Controller }));
            group.Templates.Add(dl2);

            EncounterTemplate dl3 = new EncounterTemplate(Difficulty.Moderate);

            dl3.Slots.Add(new EncounterTemplateSlot(3, -2, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            dl3.Slots.Add(new EncounterTemplateSlot(2, 3, new RoleType[] { RoleType.Artillery, RoleType.Controller }));
            group.Templates.Add(dl3);

            EncounterTemplate dl4 = new EncounterTemplate(Difficulty.Hard);

            dl4.Slots.Add(new EncounterTemplateSlot(3, 2, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            dl4.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Controller));
            dl4.Slots.Add(new EncounterTemplateSlot(1, 4, new RoleType[] { RoleType.Artillery, RoleType.Lurker }));
            group.Templates.Add(dl4);

            EncounterTemplate dl5 = new EncounterTemplate(Difficulty.Hard);

            dl5.Slots.Add(new EncounterTemplateSlot(3, 0, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            dl5.Slots.Add(new EncounterTemplateSlot(2, 1, RoleType.Artillery));
            dl5.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Controller));
            dl5.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Lurker));
            group.Templates.Add(dl5);

            fTemplateGroups.Add(group);
        }
Beispiel #9
0
        private static void build_template_grand_melee()
        {
            EncounterTemplateGroup encounterTemplateGroup = new EncounterTemplateGroup("Grand Melee", "Entire Party");
            EncounterTemplate      encounterTemplate      = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate.Slots.Add(new EncounterTemplateSlot(4, -2, RoleType.Brute));
            encounterTemplate.Slots.Add(new EncounterTemplateSlot(11, -4, true));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate encounterTemplate1 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(2, -1, RoleType.Soldier));
            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(4, -2, RoleType.Brute));
            encounterTemplate1.Slots.Add(new EncounterTemplateSlot(12, -4, true));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate encounterTemplate2 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(2, 0, RoleType.Soldier));
            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(4, -1, RoleType.Brute));
            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(17, -2, true));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
        }
Beispiel #10
0
        static void build_template_wolf_pack()
        {
            EncounterTemplateGroup group = new EncounterTemplateGroup("Wolf Pack", "Entire Party");

            EncounterTemplate wp1 = new EncounterTemplate(Difficulty.Easy);

            wp1.Slots.Add(new EncounterTemplateSlot(7, -4, RoleType.Skirmisher));
            group.Templates.Add(wp1);

            EncounterTemplate wp2 = new EncounterTemplate(Difficulty.Moderate);

            wp2.Slots.Add(new EncounterTemplateSlot(7, -2, RoleType.Skirmisher));
            group.Templates.Add(wp2);

            EncounterTemplate wp3 = new EncounterTemplate(Difficulty.Moderate);

            wp3.Slots.Add(new EncounterTemplateSlot(5, 0, RoleType.Skirmisher));
            group.Templates.Add(wp3);

            EncounterTemplate wp4 = new EncounterTemplate(Difficulty.Hard);

            wp4.Slots.Add(new EncounterTemplateSlot(3, 5, RoleType.Skirmisher));
            group.Templates.Add(wp4);

            EncounterTemplate wp5 = new EncounterTemplate(Difficulty.Hard);

            wp5.Slots.Add(new EncounterTemplateSlot(4, 5, RoleType.Skirmisher));
            group.Templates.Add(wp5);

            EncounterTemplate wp6 = new EncounterTemplate(Difficulty.Hard);

            wp6.Slots.Add(new EncounterTemplateSlot(6, 2, RoleType.Skirmisher));
            group.Templates.Add(wp6);

            fTemplateGroups.Add(group);
        }
Beispiel #11
0
        static void build_template_battlefield_control()
        {
            EncounterTemplateGroup group = new EncounterTemplateGroup("Battlefield Control", "Entire Party");

            EncounterTemplate bc1 = new EncounterTemplate(Difficulty.Easy);

            bc1.Slots.Add(new EncounterTemplateSlot(1, -2, RoleType.Controller));
            bc1.Slots.Add(new EncounterTemplateSlot(6, -4, RoleType.Skirmisher));
            group.Templates.Add(bc1);

            EncounterTemplate bc2 = new EncounterTemplate(Difficulty.Moderate);

            bc2.Slots.Add(new EncounterTemplateSlot(1, 1, RoleType.Controller));
            bc2.Slots.Add(new EncounterTemplateSlot(6, -2, RoleType.Skirmisher));
            group.Templates.Add(bc2);

            EncounterTemplate bc3 = new EncounterTemplate(Difficulty.Hard);

            bc3.Slots.Add(new EncounterTemplateSlot(1, 5, RoleType.Controller));
            bc3.Slots.Add(new EncounterTemplateSlot(5, 1, RoleType.Skirmisher));
            group.Templates.Add(bc3);

            fTemplateGroups.Add(group);
        }
Beispiel #12
0
        private static void build_template_commander_and_troops()
        {
            EncounterTemplateGroup       encounterTemplateGroup = new EncounterTemplateGroup("Commander and Troops", "Entire Party");
            EncounterTemplate            encounterTemplate      = new EncounterTemplate(Difficulty.Easy);
            List <EncounterTemplateSlot> slots = encounterTemplate.Slots;

            RoleType[] roleTypeArray = new RoleType[] { RoleType.Controller, RoleType.Soldier, RoleType.Lurker, RoleType.Skirmisher };
            slots.Add(new EncounterTemplateSlot(1, 0, roleTypeArray));
            List <EncounterTemplateSlot> encounterTemplateSlots = encounterTemplate.Slots;

            RoleType[] roleTypeArray1 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            encounterTemplateSlots.Add(new EncounterTemplateSlot(4, -3, roleTypeArray1));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate            encounterTemplate1 = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> slots1             = encounterTemplate1.Slots;

            RoleType[] roleTypeArray2 = new RoleType[] { RoleType.Controller, RoleType.Soldier, RoleType.Lurker, RoleType.Skirmisher };
            slots1.Add(new EncounterTemplateSlot(1, 3, roleTypeArray2));
            List <EncounterTemplateSlot> encounterTemplateSlots1 = encounterTemplate1.Slots;

            RoleType[] roleTypeArray3 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            encounterTemplateSlots1.Add(new EncounterTemplateSlot(5, -2, roleTypeArray3));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate            encounterTemplate2 = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> slots2             = encounterTemplate2.Slots;

            RoleType[] roleTypeArray4 = new RoleType[] { RoleType.Controller, RoleType.Soldier, RoleType.Lurker, RoleType.Skirmisher };
            slots2.Add(new EncounterTemplateSlot(1, 5, roleTypeArray4));
            List <EncounterTemplateSlot> encounterTemplateSlots2 = encounterTemplate2.Slots;

            RoleType[] roleTypeArray5 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            encounterTemplateSlots2.Add(new EncounterTemplateSlot(3, 1, roleTypeArray5));
            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(2, 1, new RoleType[1]));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
        }
Beispiel #13
0
        static void build_template_duel()
        {
            #region Controller

            EncounterTemplateGroup group_controller = new EncounterTemplateGroup("Duel vs Controller", "Individual PC");

            EncounterTemplate c1 = new EncounterTemplate(Difficulty.Easy);
            c1.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Artillery));
            group_controller.Templates.Add(c1);

            EncounterTemplate c2 = new EncounterTemplate(Difficulty.Easy);
            c2.Slots.Add(new EncounterTemplateSlot(1, -1, new RoleType[] { RoleType.Controller, RoleType.Skirmisher }));
            group_controller.Templates.Add(c2);

            EncounterTemplate c3 = new EncounterTemplate(Difficulty.Moderate);
            c3.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Artillery));
            group_controller.Templates.Add(c3);

            EncounterTemplate c4 = new EncounterTemplate(Difficulty.Moderate);
            c4.Slots.Add(new EncounterTemplateSlot(1, 1, new RoleType[] { RoleType.Controller, RoleType.Skirmisher }));
            group_controller.Templates.Add(c4);

            EncounterTemplate c5 = new EncounterTemplate(Difficulty.Hard);
            c5.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Artillery));
            group_controller.Templates.Add(c5);

            EncounterTemplate c6 = new EncounterTemplate(Difficulty.Hard);
            c6.Slots.Add(new EncounterTemplateSlot(1, 3, new RoleType[] { RoleType.Controller, RoleType.Skirmisher }));
            group_controller.Templates.Add(c6);

            fTemplateGroups.Add(group_controller);

            #endregion

            #region Defender

            EncounterTemplateGroup group_defender = new EncounterTemplateGroup("Duel vs Defender", "Individual PC");

            EncounterTemplate d1 = new EncounterTemplate(Difficulty.Easy);
            d1.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Skirmisher));
            group_defender.Templates.Add(d1);

            EncounterTemplate d2 = new EncounterTemplate(Difficulty.Easy);
            d2.Slots.Add(new EncounterTemplateSlot(1, -1, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group_defender.Templates.Add(d2);

            EncounterTemplate d3 = new EncounterTemplate(Difficulty.Moderate);
            d3.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Skirmisher));
            group_defender.Templates.Add(d3);

            EncounterTemplate d4 = new EncounterTemplate(Difficulty.Moderate);
            d4.Slots.Add(new EncounterTemplateSlot(1, 1, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group_defender.Templates.Add(d4);

            EncounterTemplate d5 = new EncounterTemplate(Difficulty.Hard);
            d5.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Skirmisher));
            group_defender.Templates.Add(d5);

            EncounterTemplate d6 = new EncounterTemplate(Difficulty.Hard);
            d6.Slots.Add(new EncounterTemplateSlot(1, 3, new RoleType[] { RoleType.Controller, RoleType.Skirmisher }));
            group_defender.Templates.Add(d6);

            fTemplateGroups.Add(group_defender);

            #endregion

            #region Leader

            EncounterTemplateGroup group_leader = new EncounterTemplateGroup("Duel vs Leader", "Individual PC");

            EncounterTemplate l1 = new EncounterTemplate(Difficulty.Easy);
            l1.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Skirmisher));
            group_leader.Templates.Add(l1);

            EncounterTemplate l2 = new EncounterTemplate(Difficulty.Easy);
            l2.Slots.Add(new EncounterTemplateSlot(1, -1, new RoleType[] { RoleType.Controller, RoleType.Soldier }));
            group_leader.Templates.Add(l2);

            EncounterTemplate l3 = new EncounterTemplate(Difficulty.Moderate);
            l3.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Skirmisher));
            group_leader.Templates.Add(l3);

            EncounterTemplate l4 = new EncounterTemplate(Difficulty.Moderate);
            l4.Slots.Add(new EncounterTemplateSlot(1, 1, new RoleType[] { RoleType.Controller, RoleType.Soldier }));
            group_leader.Templates.Add(l4);

            EncounterTemplate l5 = new EncounterTemplate(Difficulty.Hard);
            l5.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Skirmisher));
            group_leader.Templates.Add(l5);

            EncounterTemplate l6 = new EncounterTemplate(Difficulty.Hard);
            l6.Slots.Add(new EncounterTemplateSlot(1, 3, new RoleType[] { RoleType.Controller, RoleType.Soldier }));
            group_leader.Templates.Add(l6);

            fTemplateGroups.Add(group_leader);

            #endregion

            #region Striker

            EncounterTemplateGroup group_striker = new EncounterTemplateGroup("Duel vs Striker", "Individual PC");

            EncounterTemplate s1 = new EncounterTemplate(Difficulty.Easy);
            s1.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Skirmisher));
            group_striker.Templates.Add(s1);

            EncounterTemplate s2 = new EncounterTemplate(Difficulty.Easy);
            s2.Slots.Add(new EncounterTemplateSlot(1, -1, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group_striker.Templates.Add(s2);

            EncounterTemplate s3 = new EncounterTemplate(Difficulty.Moderate);
            s3.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Skirmisher));
            group_striker.Templates.Add(s3);

            EncounterTemplate s4 = new EncounterTemplate(Difficulty.Moderate);
            s4.Slots.Add(new EncounterTemplateSlot(1, 1, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group_striker.Templates.Add(s4);

            EncounterTemplate s5 = new EncounterTemplate(Difficulty.Hard);
            s5.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Skirmisher));
            group_striker.Templates.Add(s5);

            EncounterTemplate s6 = new EncounterTemplate(Difficulty.Hard);
            s6.Slots.Add(new EncounterTemplateSlot(1, 3, new RoleType[] { RoleType.Brute, RoleType.Soldier }));
            group_striker.Templates.Add(s6);

            fTemplateGroups.Add(group_striker);

            #endregion
        }
Beispiel #14
0
        public static bool Build(AutoBuildData data, Encounter enc, bool include_individual)
        {
            int min_level = Math.Max(data.Level - 4, 1);
            int max_level = data.Level + 5;

            build_creature_list(min_level, max_level, data.Categories, data.Keywords, true);

            if (fCreatures.Count == 0)
            {
                return(false);
            }

            build_template_list(data.Type, data.Difficulty, data.Level, include_individual);
            if (fTemplateGroups.Count == 0)
            {
                return(false);
            }

            build_trap_list(data.Level);
            build_challenge_list(data.Level);

            int attempts = 0;

            while (attempts < TRIES)
            {
                attempts += 1;

                // Pick a template
                int group_index = Session.Random.Next() % fTemplateGroups.Count;
                EncounterTemplateGroup group = fTemplateGroups[group_index];
                int template_index           = Session.Random.Next() % group.Templates.Count;
                EncounterTemplate template   = group.Templates[template_index];

                bool ok = true;
                List <EncounterSlot> slots = new List <EncounterSlot>();
                foreach (EncounterTemplateSlot template_slot in template.Slots)
                {
                    // Attempt to populate the slot
                    List <EncounterCard> candidates = new List <EncounterCard>();
                    foreach (EncounterCard card in fCreatures)
                    {
                        if (template_slot.Match(card, data.Level))
                        {
                            candidates.Add(card);
                        }
                    }

                    if (candidates.Count == 0)
                    {
                        ok = false;
                        break;
                    }

                    // Choose a candidate
                    int           creature_index = Session.Random.Next() % candidates.Count;
                    EncounterCard candidate      = candidates[creature_index];

                    // Build the slot
                    EncounterSlot slot = new EncounterSlot();
                    slot.Card = candidate;
                    for (int n = 0; n != template_slot.Count; ++n)
                    {
                        CombatData ccd = new CombatData();
                        slot.CombatData.Add(ccd);
                    }

                    slots.Add(slot);
                }

                if (ok)
                {
                    enc.Slots = slots;
                    enc.Traps.Clear();
                    enc.SkillChallenges.Clear();

                    // Random modification
                    switch (Session.Random.Next(12))
                    {
                    case 4:
                    case 5:
                    {
                        // Replace a creature with a trap / hazard
                        if (add_trap(enc))
                        {
                            remove_creature(enc);
                        }
                    }
                    break;

                    case 6:
                    {
                        // Replace a creature with a skill challenge
                        if (add_challenge(enc))
                        {
                            remove_creature(enc);
                        }
                    }
                    break;

                    case 7:
                    {
                        // Replace a creature with a lurker
                        if (add_lurker(enc))
                        {
                            remove_creature(enc);
                        }
                    }
                    break;

                    case 8:
                    case 9:
                    {
                        // Add a trap / hazard
                        add_trap(enc);
                        Difficulty diff = enc.GetDifficulty(data.Level, data.Size);
                        if ((diff == Difficulty.Hard) || (diff == Difficulty.Extreme))
                        {
                            remove_creature(enc);
                        }
                    }
                    break;

                    case 10:
                    {
                        // Add a skill challenge
                        Difficulty diff = enc.GetDifficulty(data.Level, data.Size);
                        if ((diff == Difficulty.Hard) || (diff == Difficulty.Extreme))
                        {
                            remove_creature(enc);
                        }
                        add_challenge(enc);
                    }
                    break;

                    case 11:
                    {
                        // Add a lurker
                        add_lurker(enc);
                        Difficulty diff = enc.GetDifficulty(data.Level, data.Size);
                        if ((diff == Difficulty.Hard) || (diff == Difficulty.Extreme))
                        {
                            remove_creature(enc);
                        }
                    }
                    break;
                    }

                    while ((enc.GetDifficulty(data.Level, data.Size) == Difficulty.Extreme) && (enc.Count > 1))
                    {
                        remove_creature(enc);
                    }

                    foreach (EncounterSlot slot in enc.Slots)
                    {
                        slot.SetDefaultDisplayNames();
                    }

                    return(true);
                }
            }

            // We were unable to build the encounter
            return(false);
        }
Beispiel #15
0
        private static void build_template_duel()
        {
            EncounterTemplateGroup encounterTemplateGroup = new EncounterTemplateGroup("Duel vs Controller", "Individual PC");
            EncounterTemplate      encounterTemplate      = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Artillery));
            encounterTemplateGroup.Templates.Add(encounterTemplate);
            EncounterTemplate            encounterTemplate1 = new EncounterTemplate(Difficulty.Easy);
            List <EncounterTemplateSlot> slots = encounterTemplate1.Slots;

            RoleType[] roleTypeArray = new RoleType[] { RoleType.Controller, RoleType.Skirmisher };
            slots.Add(new EncounterTemplateSlot(1, -1, roleTypeArray));
            encounterTemplateGroup.Templates.Add(encounterTemplate1);
            EncounterTemplate encounterTemplate2 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate2.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Artillery));
            encounterTemplateGroup.Templates.Add(encounterTemplate2);
            EncounterTemplate            encounterTemplate3     = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> encounterTemplateSlots = encounterTemplate3.Slots;

            RoleType[] roleTypeArray1 = new RoleType[] { RoleType.Controller, RoleType.Skirmisher };
            encounterTemplateSlots.Add(new EncounterTemplateSlot(1, 1, roleTypeArray1));
            encounterTemplateGroup.Templates.Add(encounterTemplate3);
            EncounterTemplate encounterTemplate4 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate4.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Artillery));
            encounterTemplateGroup.Templates.Add(encounterTemplate4);
            EncounterTemplate            encounterTemplate5 = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> slots1             = encounterTemplate5.Slots;

            RoleType[] roleTypeArray2 = new RoleType[] { RoleType.Controller, RoleType.Skirmisher };
            slots1.Add(new EncounterTemplateSlot(1, 3, roleTypeArray2));
            encounterTemplateGroup.Templates.Add(encounterTemplate5);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup);
            EncounterTemplateGroup encounterTemplateGroup1 = new EncounterTemplateGroup("Duel vs Defender", "Individual PC");
            EncounterTemplate      encounterTemplate6      = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate6.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Skirmisher));
            encounterTemplateGroup1.Templates.Add(encounterTemplate6);
            EncounterTemplate            encounterTemplate7      = new EncounterTemplate(Difficulty.Easy);
            List <EncounterTemplateSlot> encounterTemplateSlots1 = encounterTemplate7.Slots;

            RoleType[] roleTypeArray3 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            encounterTemplateSlots1.Add(new EncounterTemplateSlot(1, -1, roleTypeArray3));
            encounterTemplateGroup1.Templates.Add(encounterTemplate7);
            EncounterTemplate encounterTemplate8 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate8.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Skirmisher));
            encounterTemplateGroup1.Templates.Add(encounterTemplate8);
            EncounterTemplate            encounterTemplate9 = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> slots2             = encounterTemplate9.Slots;

            RoleType[] roleTypeArray4 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots2.Add(new EncounterTemplateSlot(1, 1, roleTypeArray4));
            encounterTemplateGroup1.Templates.Add(encounterTemplate9);
            EncounterTemplate encounterTemplate10 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate10.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Skirmisher));
            encounterTemplateGroup1.Templates.Add(encounterTemplate10);
            EncounterTemplate            encounterTemplate11     = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> encounterTemplateSlots2 = encounterTemplate11.Slots;

            RoleType[] roleTypeArray5 = new RoleType[] { RoleType.Controller, RoleType.Skirmisher };
            encounterTemplateSlots2.Add(new EncounterTemplateSlot(1, 3, roleTypeArray5));
            encounterTemplateGroup1.Templates.Add(encounterTemplate11);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup1);
            EncounterTemplateGroup encounterTemplateGroup2 = new EncounterTemplateGroup("Duel vs Leader", "Individual PC");
            EncounterTemplate      encounterTemplate12     = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate12.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Skirmisher));
            encounterTemplateGroup2.Templates.Add(encounterTemplate12);
            EncounterTemplate            encounterTemplate13 = new EncounterTemplate(Difficulty.Easy);
            List <EncounterTemplateSlot> slots3 = encounterTemplate13.Slots;

            RoleType[] roleTypeArray6 = new RoleType[] { RoleType.Controller, RoleType.Soldier };
            slots3.Add(new EncounterTemplateSlot(1, -1, roleTypeArray6));
            encounterTemplateGroup2.Templates.Add(encounterTemplate13);
            EncounterTemplate encounterTemplate14 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate14.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Skirmisher));
            encounterTemplateGroup2.Templates.Add(encounterTemplate14);
            EncounterTemplate            encounterTemplate15     = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> encounterTemplateSlots3 = encounterTemplate15.Slots;

            RoleType[] roleTypeArray7 = new RoleType[] { RoleType.Controller, RoleType.Soldier };
            encounterTemplateSlots3.Add(new EncounterTemplateSlot(1, 1, roleTypeArray7));
            encounterTemplateGroup2.Templates.Add(encounterTemplate15);
            EncounterTemplate encounterTemplate16 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate16.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Skirmisher));
            encounterTemplateGroup2.Templates.Add(encounterTemplate16);
            EncounterTemplate            encounterTemplate17 = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> slots4 = encounterTemplate17.Slots;

            RoleType[] roleTypeArray8 = new RoleType[] { RoleType.Controller, RoleType.Soldier };
            slots4.Add(new EncounterTemplateSlot(1, 3, roleTypeArray8));
            encounterTemplateGroup2.Templates.Add(encounterTemplate17);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup2);
            EncounterTemplateGroup encounterTemplateGroup3 = new EncounterTemplateGroup("Duel vs Striker", "Individual PC");
            EncounterTemplate      encounterTemplate18     = new EncounterTemplate(Difficulty.Easy);

            encounterTemplate18.Slots.Add(new EncounterTemplateSlot(1, 0, RoleType.Skirmisher));
            encounterTemplateGroup3.Templates.Add(encounterTemplate18);
            EncounterTemplate            encounterTemplate19     = new EncounterTemplate(Difficulty.Easy);
            List <EncounterTemplateSlot> encounterTemplateSlots4 = encounterTemplate19.Slots;

            RoleType[] roleTypeArray9 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            encounterTemplateSlots4.Add(new EncounterTemplateSlot(1, -1, roleTypeArray9));
            encounterTemplateGroup3.Templates.Add(encounterTemplate19);
            EncounterTemplate encounterTemplate20 = new EncounterTemplate(Difficulty.Moderate);

            encounterTemplate20.Slots.Add(new EncounterTemplateSlot(1, 2, RoleType.Skirmisher));
            encounterTemplateGroup3.Templates.Add(encounterTemplate20);
            EncounterTemplate            encounterTemplate21 = new EncounterTemplate(Difficulty.Moderate);
            List <EncounterTemplateSlot> slots5 = encounterTemplate21.Slots;

            RoleType[] roleTypeArray10 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            slots5.Add(new EncounterTemplateSlot(1, 1, roleTypeArray10));
            encounterTemplateGroup3.Templates.Add(encounterTemplate21);
            EncounterTemplate encounterTemplate22 = new EncounterTemplate(Difficulty.Hard);

            encounterTemplate22.Slots.Add(new EncounterTemplateSlot(1, 4, RoleType.Skirmisher));
            encounterTemplateGroup3.Templates.Add(encounterTemplate22);
            EncounterTemplate            encounterTemplate23     = new EncounterTemplate(Difficulty.Hard);
            List <EncounterTemplateSlot> encounterTemplateSlots5 = encounterTemplate23.Slots;

            RoleType[] roleTypeArray11 = new RoleType[] { RoleType.Brute, RoleType.Soldier };
            encounterTemplateSlots5.Add(new EncounterTemplateSlot(1, 3, roleTypeArray11));
            encounterTemplateGroup3.Templates.Add(encounterTemplate23);
            EncounterBuilder.fTemplateGroups.Add(encounterTemplateGroup3);
        }
Beispiel #16
0
        public static bool Build(AutoBuildData data, Encounter enc, bool include_individual)
        {
            int num   = Math.Max(data.Level - 4, 1);
            int level = data.Level + 5;

            EncounterBuilder.build_creature_list(num, level, data.Categories, data.Keywords, true);
            if (EncounterBuilder.fCreatures.Count == 0)
            {
                return(false);
            }
            EncounterBuilder.build_template_list(data.Type, data.Difficulty, data.Level, include_individual);
            if (EncounterBuilder.fTemplateGroups.Count == 0)
            {
                return(false);
            }
            EncounterBuilder.build_trap_list(data.Level);
            EncounterBuilder.build_challenge_list(data.Level);
            int num1 = 0;

            while (num1 < 100)
            {
                num1++;
                int num2 = Session.Random.Next() % EncounterBuilder.fTemplateGroups.Count;
                EncounterTemplateGroup item = EncounterBuilder.fTemplateGroups[num2];
                int num3 = Session.Random.Next() % item.Templates.Count;
                EncounterTemplate encounterTemplate = item.Templates[num3];
                bool flag = true;
                List <EncounterSlot> encounterSlots = new List <EncounterSlot>();
                foreach (EncounterTemplateSlot slot in encounterTemplate.Slots)
                {
                    List <EncounterCard> encounterCards = new List <EncounterCard>();
                    foreach (EncounterCard fCreature in EncounterBuilder.fCreatures)
                    {
                        if (!slot.Match(fCreature, data.Level))
                        {
                            continue;
                        }
                        encounterCards.Add(fCreature);
                    }
                    if (encounterCards.Count != 0)
                    {
                        int           num4          = Session.Random.Next() % encounterCards.Count;
                        EncounterSlot encounterSlot = new EncounterSlot()
                        {
                            Card = encounterCards[num4]
                        };
                        for (int i = 0; i != slot.Count; i++)
                        {
                            CombatData combatDatum = new CombatData();
                            encounterSlot.CombatData.Add(combatDatum);
                        }
                        encounterSlots.Add(encounterSlot);
                    }
                    else
                    {
                        flag = false;
                        break;
                    }
                }
                if (!flag)
                {
                    continue;
                }
                enc.Slots = encounterSlots;
                enc.Traps.Clear();
                enc.SkillChallenges.Clear();
                switch (Session.Random.Next(12))
                {
                case 4:
                case 5:
                {
                    if (!EncounterBuilder.add_trap(enc))
                    {
                        break;
                    }
                    EncounterBuilder.remove_creature(enc);
                    break;
                }

                case 6:
                {
                    if (!EncounterBuilder.add_challenge(enc))
                    {
                        break;
                    }
                    EncounterBuilder.remove_creature(enc);
                    break;
                }

                case 7:
                {
                    if (!EncounterBuilder.add_lurker(enc))
                    {
                        break;
                    }
                    EncounterBuilder.remove_creature(enc);
                    break;
                }

                case 8:
                case 9:
                {
                    EncounterBuilder.add_trap(enc);
                    Difficulty difficulty = enc.GetDifficulty(data.Level, data.Size);
                    if (difficulty != Difficulty.Hard && difficulty != Difficulty.Extreme)
                    {
                        break;
                    }
                    EncounterBuilder.remove_creature(enc);
                    break;
                }

                case 10:
                {
                    Difficulty difficulty1 = enc.GetDifficulty(data.Level, data.Size);
                    if (difficulty1 == Difficulty.Hard || difficulty1 == Difficulty.Extreme)
                    {
                        EncounterBuilder.remove_creature(enc);
                    }
                    EncounterBuilder.add_challenge(enc);
                    break;
                }

                case 11:
                {
                    EncounterBuilder.add_lurker(enc);
                    Difficulty difficulty2 = enc.GetDifficulty(data.Level, data.Size);
                    if (difficulty2 != Difficulty.Hard && difficulty2 != Difficulty.Extreme)
                    {
                        break;
                    }
                    EncounterBuilder.remove_creature(enc);
                    break;
                }
                }
                while (enc.GetDifficulty(data.Level, data.Size) == Difficulty.Extreme && enc.Count > 1)
                {
                    EncounterBuilder.remove_creature(enc);
                }
                foreach (EncounterSlot slot1 in enc.Slots)
                {
                    slot1.SetDefaultDisplayNames();
                }
                return(true);
            }
            return(false);
        }