示例#1
0
        public static void FillBank(Mobile m)
        {
            BankBox bank = m.BankBox;

            for (int i = 0; i < PowerScroll.Skills.Count; ++i)
            {
                m.Skills[PowerScroll.Skills[i]].Cap = 120.0;
            }

            m.StatCap = 250;

            Container cont;

            // Begin box of money
            cont        = new WoodenBox();
            cont.ItemID = 0xE7D;
            cont.Hue    = 0x489;

            PlaceItemIn(cont, 16, 51, new BankCheck(500000));
            PlaceItemIn(cont, 28, 51, new BankCheck(250000));
            PlaceItemIn(cont, 40, 51, new BankCheck(100000));
            PlaceItemIn(cont, 52, 51, new BankCheck(100000));
            PlaceItemIn(cont, 64, 51, new BankCheck(50000));

            PlaceItemIn(cont, 34, 115, new Gold(60000));

            PlaceItemIn(bank, 18, 169, cont);
            // End box of money

            // Begin bag of potion kegs
            cont      = new Backpack();
            cont.Name = "Various Potion Kegs";

            PlaceItemIn(cont, 45, 149, MakePotionKeg(PotionEffect.CureGreater, 0x2D));
            PlaceItemIn(cont, 69, 149, MakePotionKeg(PotionEffect.HealGreater, 0x499));
            PlaceItemIn(cont, 93, 149, MakePotionKeg(PotionEffect.PoisonDeadly, 0x46));
            PlaceItemIn(cont, 117, 149, MakePotionKeg(PotionEffect.RefreshTotal, 0x21));
            PlaceItemIn(cont, 141, 149, MakePotionKeg(PotionEffect.ExplosionGreater, 0x74));

            PlaceItemIn(cont, 93, 82, new Bottle(1000));

            PlaceItemIn(bank, 53, 169, cont);
            // End bag of potion kegs

            // Begin bag of tools
            cont      = new Bag();
            cont.Name = "Tool Bag";

            PlaceItemIn(cont, 30, 35, new TinkerTools(1000));
            PlaceItemIn(cont, 60, 35, new HousePlacementTool());
            PlaceItemIn(cont, 90, 35, new DovetailSaw(1000));
            PlaceItemIn(cont, 30, 68, new Scissors());
            PlaceItemIn(cont, 45, 68, new MortarPestle(1000));
            PlaceItemIn(cont, 75, 68, new ScribesPen(1000));
            PlaceItemIn(cont, 90, 68, new SmithHammer(1000));
            PlaceItemIn(cont, 30, 118, new TwoHandedAxe());
            PlaceItemIn(cont, 60, 118, new FletcherTools(1000));
            PlaceItemIn(cont, 90, 118, new SewingKit(1000));

            PlaceItemIn(cont, 36, 51, new RunicHammer(CraftResource.DullCopper, 1000));
            PlaceItemIn(cont, 42, 51, new RunicHammer(CraftResource.ShadowIron, 1000));
            PlaceItemIn(cont, 48, 51, new RunicHammer(CraftResource.Copper, 1000));
            PlaceItemIn(cont, 54, 51, new RunicHammer(CraftResource.Bronze, 1000));
            PlaceItemIn(cont, 61, 51, new RunicHammer(CraftResource.Gold, 1000));
            PlaceItemIn(cont, 67, 51, new RunicHammer(CraftResource.Agapite, 1000));
            PlaceItemIn(cont, 73, 51, new RunicHammer(CraftResource.Verite, 1000));
            PlaceItemIn(cont, 79, 51, new RunicHammer(CraftResource.Valorite, 1000));

            PlaceItemIn(cont, 36, 55, new RunicSewingKit(CraftResource.SpinedLeather, 1000));
            PlaceItemIn(cont, 42, 55, new RunicSewingKit(CraftResource.HornedLeather, 1000));
            PlaceItemIn(cont, 48, 55, new RunicSewingKit(CraftResource.BarbedLeather, 1000));

            PlaceItemIn(bank, 118, 169, cont);
            // End bag of tools

            // Begin bag of archery ammo
            cont      = new Bag();
            cont.Name = "Bag Of Archery Ammo";

            PlaceItemIn(cont, 48, 76, new Arrow(5000));
            PlaceItemIn(cont, 72, 76, new Bolt(5000));

            PlaceItemIn(bank, 118, 124, cont);
            // End bag of archery ammo

            // Begin bag of treasure maps
            cont      = new Bag();
            cont.Name = "Bag Of Treasure Maps";

            PlaceItemIn(cont, 30, 35, new TreasureMap(1, Map.Trammel));
            PlaceItemIn(cont, 45, 35, new TreasureMap(2, Map.Trammel));
            PlaceItemIn(cont, 60, 35, new TreasureMap(3, Map.Trammel));
            PlaceItemIn(cont, 75, 35, new TreasureMap(4, Map.Trammel));
            PlaceItemIn(cont, 90, 35, new TreasureMap(5, Map.Trammel));
            PlaceItemIn(cont, 90, 35, new TreasureMap(6, Map.Trammel));

            PlaceItemIn(cont, 30, 50, new TreasureMap(1, Map.Trammel));
            PlaceItemIn(cont, 45, 50, new TreasureMap(2, Map.Trammel));
            PlaceItemIn(cont, 60, 50, new TreasureMap(3, Map.Trammel));
            PlaceItemIn(cont, 75, 50, new TreasureMap(4, Map.Trammel));
            PlaceItemIn(cont, 90, 50, new TreasureMap(5, Map.Trammel));
            PlaceItemIn(cont, 90, 50, new TreasureMap(6, Map.Trammel));

            PlaceItemIn(cont, 55, 100, new Lockpick(30));
            PlaceItemIn(cont, 60, 100, new Pickaxe());

            PlaceItemIn(bank, 98, 124, cont);
            // End bag of treasure maps

            // Begin bag of raw materials
            cont      = new Bag();
            cont.Hue  = 0x835;
            cont.Name = "Raw Materials Bag";

            PlaceItemIn(cont, 92, 60, new BarbedLeather(5000));
            PlaceItemIn(cont, 92, 68, new HornedLeather(5000));
            PlaceItemIn(cont, 92, 76, new SpinedLeather(5000));
            PlaceItemIn(cont, 92, 84, new Leather(5000));

            PlaceItemIn(cont, 30, 118, new Cloth(5000));
            PlaceItemIn(cont, 30, 84, new Board(5000));
            PlaceItemIn(cont, 57, 80, new BlankScroll(500));

            PlaceItemIn(cont, 30, 35, new DullCopperIngot(5000));
            PlaceItemIn(cont, 37, 35, new ShadowIronIngot(5000));
            PlaceItemIn(cont, 44, 35, new CopperIngot(5000));
            PlaceItemIn(cont, 51, 35, new BronzeIngot(5000));
            PlaceItemIn(cont, 58, 35, new GoldIngot(5000));
            PlaceItemIn(cont, 65, 35, new AgapiteIngot(5000));
            PlaceItemIn(cont, 72, 35, new VeriteIngot(5000));
            PlaceItemIn(cont, 79, 35, new ValoriteIngot(5000));
            PlaceItemIn(cont, 86, 35, new IronIngot(5000));

            PlaceItemIn(cont, 30, 59, new RedScales(5000));
            PlaceItemIn(cont, 36, 59, new YellowScales(5000));
            PlaceItemIn(cont, 42, 59, new BlackScales(5000));
            PlaceItemIn(cont, 48, 59, new GreenScales(5000));
            PlaceItemIn(cont, 54, 59, new WhiteScales(5000));
            PlaceItemIn(cont, 60, 59, new BlueScales(5000));

            PlaceItemIn(bank, 98, 169, cont);
            // End bag of raw materials

            // Begin bag of spell casting stuff
            cont      = new Backpack();
            cont.Hue  = 0x480;
            cont.Name = "Spell Casting Stuff";

            PlaceItemIn(cont, 45, 105, new Spellbook(UInt64.MaxValue));
            PlaceItemIn(cont, 65, 105, new NecromancerSpellbook((UInt64)0xFFFF));
            PlaceItemIn(cont, 85, 105, new BookOfChivalry((UInt64)0x3FF));
            PlaceItemIn(cont, 105, 105, new BookOfBushido());  //Default ctor = full
            PlaceItemIn(cont, 125, 105, new BookOfNinjitsu()); //Default ctor = full

            Runebook runebook = new Runebook(10);

            runebook.CurCharges = runebook.MaxCharges;
            PlaceItemIn(cont, 145, 105, runebook);

            Item toHue = new BagOfAllReagents(150);

            toHue.Hue = 0x2D;
            PlaceItemIn(cont, 45, 150, toHue);

            toHue     = new BagOfNecroReagents(150);
            toHue.Hue = 0x488;
            PlaceItemIn(cont, 65, 150, toHue);

            PlaceItemIn(cont, 140, 150, new BagOfAllReagents(500));

            for (int i = 0; i < 9; ++i)
            {
                PlaceItemIn(cont, 45 + (i * 10), 75, new RecallRune());
            }

            PlaceItemIn(cont, 141, 74, new FireHorn());

            PlaceItemIn(bank, 78, 169, cont);
            // End bag of spell casting stuff

            // Begin bag of ethereals
            cont      = new Backpack();
            cont.Hue  = 0x490;
            cont.Name = "Bag Of Ethy's!";

            PlaceItemIn(cont, 45, 66, new EtherealHorse());
            PlaceItemIn(cont, 69, 82, new EtherealOstard());
            PlaceItemIn(cont, 93, 99, new EtherealLlama());
            PlaceItemIn(cont, 117, 115, new EtherealKirin());
            PlaceItemIn(cont, 45, 132, new EtherealUnicorn());
            PlaceItemIn(cont, 69, 66, new EtherealRidgeback());
            PlaceItemIn(cont, 93, 82, new EtherealSwampDragon());
            PlaceItemIn(cont, 117, 99, new EtherealBeetle());

            PlaceItemIn(bank, 38, 124, cont);
            // End bag of ethereals

            // Begin first bag of artifacts
            cont      = new Backpack();
            cont.Hue  = 0x48F;
            cont.Name = "Bag of Artifacts";

            PlaceItemIn(cont, 45, 66, new TitansHammer());
            PlaceItemIn(cont, 69, 82, new InquisitorsResolution());
            PlaceItemIn(cont, 93, 99, new BladeOfTheRighteous());
            PlaceItemIn(cont, 117, 115, new ZyronicClaw());

            PlaceItemIn(bank, 58, 124, cont);
            // End first bag of artifacts

            // Begin second bag of artifacts
            cont      = new Backpack();
            cont.Hue  = 0x48F;
            cont.Name = "Bag of Artifacts";

            PlaceItemIn(cont, 45, 66, new GauntletsOfNobility());
            PlaceItemIn(cont, 69, 82, new MidnightBracers());
            PlaceItemIn(cont, 93, 99, new VoiceOfTheFallenKing());
            PlaceItemIn(cont, 117, 115, new OrnateCrownOfTheHarrower());
            PlaceItemIn(cont, 45, 132, new HelmOfInsight());
            PlaceItemIn(cont, 69, 66, new HolyKnightsBreastplate());
            PlaceItemIn(cont, 93, 82, new ArmorOfFortune());
            PlaceItemIn(cont, 117, 99, new TunicOfFire());
            PlaceItemIn(cont, 45, 115, new LeggingsOfBane());
            PlaceItemIn(cont, 69, 132, new ArcaneShield());
            PlaceItemIn(cont, 93, 66, new Aegis());
            PlaceItemIn(cont, 117, 82, new RingOfTheVile());
            PlaceItemIn(cont, 45, 99, new BraceletOfHealth());
            PlaceItemIn(cont, 69, 115, new RingOfTheElements());
            PlaceItemIn(cont, 93, 132, new OrnamentOfTheMagician());
            PlaceItemIn(cont, 117, 66, new DivineCountenance());
            PlaceItemIn(cont, 45, 82, new JackalsCollar());
            PlaceItemIn(cont, 69, 99, new HuntersHeaddress());
            PlaceItemIn(cont, 93, 115, new HatOfTheMagi());
            PlaceItemIn(cont, 117, 132, new ShadowDancerLeggings());
            PlaceItemIn(cont, 45, 66, new SpiritOfTheTotem());
            PlaceItemIn(cont, 69, 82, new BladeOfInsanity());
            PlaceItemIn(cont, 93, 99, new AxeOfTheHeavens());
            PlaceItemIn(cont, 117, 115, new TheBeserkersMaul());
            PlaceItemIn(cont, 45, 132, new Frostbringer());
            PlaceItemIn(cont, 69, 66, new BreathOfTheDead());
            PlaceItemIn(cont, 93, 82, new TheDragonSlayer());
            PlaceItemIn(cont, 117, 99, new BoneCrusher());
            PlaceItemIn(cont, 45, 115, new StaffOfTheMagi());
            PlaceItemIn(cont, 69, 132, new SerpentsFang());
            PlaceItemIn(cont, 93, 66, new LegacyOfTheDreadLord());
            PlaceItemIn(cont, 117, 82, new TheTaskmaster());
            PlaceItemIn(cont, 45, 99, new TheDryadBow());

            PlaceItemIn(bank, 78, 124, cont);
            // End second bag of artifacts

            // Begin bag of minor artifacts
            cont      = new Backpack();
            cont.Hue  = 0x48F;
            cont.Name = "Bag of Minor Artifacts";

            PlaceItemIn(cont, 45, 66, new LunaLance());
            PlaceItemIn(cont, 69, 82, new VioletCourage());
            PlaceItemIn(cont, 93, 99, new CavortingClub());
            PlaceItemIn(cont, 117, 115, new CaptainQuacklebushsCutlass());
            PlaceItemIn(cont, 45, 132, new NightsKiss());
            PlaceItemIn(cont, 69, 66, new ShipModelOfTheHMSCape());
            PlaceItemIn(cont, 93, 82, new AdmiralsHeartyRum());
            PlaceItemIn(cont, 117, 99, new CandelabraOfSouls());
            PlaceItemIn(cont, 45, 115, new IolosLute());
            PlaceItemIn(cont, 69, 132, new GwennosHarp());
            PlaceItemIn(cont, 93, 66, new ArcticDeathDealer());
            PlaceItemIn(cont, 117, 82, new EnchantedTitanLegBone());
            PlaceItemIn(cont, 45, 99, new NoxRangersHeavyCrossbow());
            PlaceItemIn(cont, 69, 115, new BlazeOfDeath());
            PlaceItemIn(cont, 93, 132, new DreadPirateHat());
            PlaceItemIn(cont, 117, 66, new BurglarsBandana());
            PlaceItemIn(cont, 45, 82, new GoldBricks());
            PlaceItemIn(cont, 69, 99, new AlchemistsBauble());
            PlaceItemIn(cont, 93, 115, new PhillipsWoodenSteed());
            PlaceItemIn(cont, 117, 132, new PolarBearMask());
            PlaceItemIn(cont, 45, 66, new BowOfTheJukaKing());
            PlaceItemIn(cont, 69, 82, new GlovesOfThePugilist());
            PlaceItemIn(cont, 93, 99, new OrcishVisage());
            PlaceItemIn(cont, 117, 115, new StaffOfPower());
            PlaceItemIn(cont, 45, 132, new ShieldOfInvulnerability());
            PlaceItemIn(cont, 69, 66, new HeartOfTheLion());
            PlaceItemIn(cont, 93, 82, new ColdBlood());
            PlaceItemIn(cont, 117, 99, new GhostShipAnchor());
            PlaceItemIn(cont, 45, 115, new SeahorseStatuette());
            PlaceItemIn(cont, 69, 132, new WrathOfTheDryad());
            PlaceItemIn(cont, 93, 66, new PixieSwatter());

            for (int i = 0; i < 10; i++)
            {
                PlaceItemIn(cont, 117, 128, new MessageInABottle(Utility.RandomBool() ? Map.Trammel : Map.Felucca, 4));
            }

            PlaceItemIn(bank, 18, 124, cont);

            cont      = new Bag();
            cont.Hue  = 0x501;
            cont.Name = "Tokuno Minor Artifacts";

            PlaceItemIn(cont, 42, 70, new Exiler());
            PlaceItemIn(cont, 38, 53, new HanzosBow());
            PlaceItemIn(cont, 45, 40, new TheDestroyer());
            PlaceItemIn(cont, 92, 80, new DragonNunchaku());
            PlaceItemIn(cont, 42, 56, new PeasantsBokuto());
            PlaceItemIn(cont, 44, 71, new TomeOfEnlightenment());
            PlaceItemIn(cont, 35, 35, new ChestOfHeirlooms());
            PlaceItemIn(cont, 29, 0, new HonorableSwords());
            PlaceItemIn(cont, 49, 85, new AncientUrn());
            PlaceItemIn(cont, 51, 58, new FluteOfRenewal());
            PlaceItemIn(cont, 70, 51, new PigmentsOfTokuno());
            PlaceItemIn(cont, 40, 79, new AncientSamuraiDo());
            PlaceItemIn(cont, 51, 61, new LegsOfStability());
            PlaceItemIn(cont, 88, 78, new GlovesOfTheSun());
            PlaceItemIn(cont, 55, 62, new AncientFarmersKasa());
            PlaceItemIn(cont, 55, 83, new ArmsOfTacticalExcellence());
            PlaceItemIn(cont, 50, 85, new DaimyosHelm());
            PlaceItemIn(cont, 52, 78, new BlackLotusHood());
            PlaceItemIn(cont, 52, 79, new DemonForks());
            PlaceItemIn(cont, 33, 49, new PilferedDancerFans());

            PlaceItemIn(bank, 58, 124, cont);

            cont      = new Bag();
            cont.Name = "Bag of Bows";

            PlaceItemIn(cont, 31, 84, new Bow());
            PlaceItemIn(cont, 78, 74, new CompositeBow());
            PlaceItemIn(cont, 53, 71, new Crossbow());
            PlaceItemIn(cont, 56, 39, new HeavyCrossbow());
            PlaceItemIn(cont, 82, 72, new RepeatingCrossbow());
            PlaceItemIn(cont, 49, 45, new Yumi());

            for (int i = 0; i < cont.Items.Count; i++)
            {
                BaseRanged bow = cont.Items[i] as BaseRanged;

                if (bow != null)
                {
                    bow.Attributes.WeaponSpeed  = 35;
                    bow.Attributes.WeaponDamage = 35;
                }
            }

            PlaceItemIn(bank, 108, 135, cont);
        }
示例#2
0
        private static void AddSkillItems(SkillName skill, Mobile m)
        {
            var elf      = (m.Race == Race.Elf);
            var human    = (m.Race == Race.Human);
            var gargoyle = (m.Race == Race.Gargoyle);

            switch (skill)
            {
            case SkillName.Alchemy:
            {
                PackItem(new EmptyBottle(4));
                PackItem(new MortarPestle());

                var hue = Utility.RandomPinkHue();

                if (elf)
                {
                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(hue));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(hue));
                    }
                }
                else
                {
                    EquipItem(new Robe(Utility.RandomPinkHue()));
                }
                break;
            }

            case SkillName.Anatomy:
            {
                PackItem(new Bandage(3));

                var hue = Utility.RandomYellowHue();

                if (elf)
                {
                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(hue));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(hue));
                    }
                }
                else
                {
                    EquipItem(new Robe(hue));
                }
                break;
            }

            case SkillName.AnimalLore:
            {
                var hue = Utility.RandomBlueHue();

                if (elf)
                {
                    EquipItem(new WildStaff());

                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(hue));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(hue));
                    }
                }
                else
                {
                    EquipItem(new ShepherdsCrook());
                    EquipItem(new Robe(hue));
                }
                break;
            }

            case SkillName.Archery:
            {
                PackItem(new Arrow(25));

                if (elf)
                {
                    EquipItem(new ElvenCompositeLongbow());
                }
                else if (human)
                {
                    EquipItem(new Bow());
                }

                break;
            }

            case SkillName.ArmsLore:
            {
                if (elf)
                {
                    switch (Utility.Random(3))
                    {
                    case 0:
                        EquipItem(new Leafblade());
                        break;

                    case 1:
                        EquipItem(new RuneBlade());
                        break;

                    case 2:
                        EquipItem(new DiamondMace());
                        break;
                    }
                }
                else if (human)
                {
                    switch (Utility.Random(3))
                    {
                    case 0:
                        EquipItem(new Kryss());
                        break;

                    case 1:
                        EquipItem(new Katana());
                        break;

                    case 2:
                        EquipItem(new Club());
                        break;
                    }
                }
                else if (gargoyle)
                {
                    switch (Utility.Random(3))
                    {
                    case 0:
                        EquipItem(new BloodBlade());
                        break;

                    case 1:
                        EquipItem(new GlassSword());
                        break;

                    case 2:
                        EquipItem(new DiscMace());
                        break;
                    }
                }

                break;
            }

            case SkillName.Begging:
            {
                if (elf)
                {
                    EquipItem(new WildStaff());
                }
                else if (human)
                {
                    EquipItem(new GnarledStaff());
                }
                else if (gargoyle)
                {
                    EquipItem(new SerpentStoneStaff());
                }

                break;
            }

            case SkillName.Blacksmith:
            {
                PackItem(new Tongs());
                PackItem(new Pickaxe());
                PackItem(new Pickaxe());
                PackItem(new IronIngot(50));

                if (human || elf)
                {
                    EquipItem(new HalfApron(Utility.RandomYellowHue()));
                }

                break;
            }

            case SkillName.Bushido:
            {
                if (human || elf)
                {
                    EquipItem(new Hakama());
                    EquipItem(new Kasa());
                }

                EquipItem(new BookOfBushido());
                break;
            }

            case SkillName.Fletching:
            {
                PackItem(new Board(14));
                PackItem(new Feather(5));
                PackItem(new Shaft(5));
                break;
            }

            case SkillName.Camping:
            {
                PackItem(new Bedroll());
                PackItem(new Kindling(5));
                break;
            }

            case SkillName.Carpentry:
            {
                PackItem(new Board(10));
                PackItem(new Saw());

                if (human || elf)
                {
                    EquipItem(new HalfApron(Utility.RandomYellowHue()));
                }

                break;
            }

            case SkillName.Cartography:
            {
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new Sextant());
                break;
            }

            case SkillName.Cooking:
            {
                PackItem(new Kindling(2));
                PackItem(new RawLambLeg());
                PackItem(new RawChickenLeg());
                PackItem(new RawFishSteak());
                PackItem(new SackFlour());
                PackItem(new Pitcher(BeverageType.Water));
                break;
            }

            case SkillName.Chivalry:
            {
                if (Core.ML)
                {
                    PackItem(new BookOfChivalry((ulong)0x3FF));
                }

                break;
            }

            case SkillName.DetectHidden:
            {
                if (human || elf)
                {
                    EquipItem(new Cloak(0x455));
                }

                break;
            }

            case SkillName.Discordance:
            {
                PackInstrument();
                break;
            }

            case SkillName.Fencing:
            {
                if (elf)
                {
                    EquipItem(new Leafblade());
                }
                else if (human)
                {
                    EquipItem(new Kryss());
                }
                else if (gargoyle)
                {
                    EquipItem(new BloodBlade());
                }

                break;
            }

            case SkillName.Fishing:
            {
                EquipItem(new FishingPole());

                var hue = Utility.RandomYellowHue();

                if (elf)
                {
                    Item i = new Circlet();
                    i.Hue = hue;
                    EquipItem(i);
                }
                else if (human)
                {
                    EquipItem(new FloppyHat(hue));
                }

                break;
            }

            case SkillName.Healing:
            {
                PackItem(new Bandage(50));
                PackItem(new Scissors());
                break;
            }

            case SkillName.Herding:
            {
                if (elf)
                {
                    EquipItem(new WildStaff());
                }
                else
                {
                    EquipItem(new ShepherdsCrook());
                }

                break;
            }

            case SkillName.Hiding:
            {
                if (human || elf)
                {
                    EquipItem(new Cloak(0x455));
                }

                break;
            }

            case SkillName.Inscribe:
            {
                PackItem(new BlankScroll(2));
                PackItem(new BlueBook());
                break;
            }

            case SkillName.ItemID:
            {
                if (elf)
                {
                    EquipItem(new WildStaff());
                }
                else if (human)
                {
                    EquipItem(new GnarledStaff());
                }
                else if (gargoyle)
                {
                    EquipItem(new SerpentStoneStaff());
                }

                break;
            }

            case SkillName.Lockpicking:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.Lumberjacking:
            {
                if (human || elf)
                {
                    EquipItem(new Hatchet());
                }
                else if (gargoyle)
                {
                    EquipItem(new DualShortAxes());
                }

                break;
            }

            case SkillName.Macing:
            {
                if (elf)
                {
                    EquipItem(new DiamondMace());
                }
                else if (human)
                {
                    EquipItem(new Club());
                }
                else if (gargoyle)
                {
                    EquipItem(new DiscMace());
                }

                break;
            }

            case SkillName.Magery:
            {
                var regs = new BagOfReagents(50);

                if (!Core.AOS)
                {
                    foreach (var item in regs.Items)
                    {
                        item.LootType = LootType.Newbied;
                    }
                }

                PackItem(regs);

                regs.LootType = LootType.Regular;

                PackScroll(0);
                PackScroll(1);
                PackScroll(2);

                var book = new Spellbook((ulong)0x382A8C38);
                book.LootType = LootType.Blessed;
                EquipItem(book);

                if (elf)
                {
                    EquipItem(new Circlet());

                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(Utility.RandomBlueHue()));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(Utility.RandomBlueHue()));
                    }
                }
                else
                {
                    if (human)
                    {
                        EquipItem(new WizardsHat());
                    }

                    EquipItem(new Robe(Utility.RandomBlueHue()));
                }

                break;
            }

            case SkillName.Mining:
            {
                PackItem(new Pickaxe());
                break;
            }

            case SkillName.Musicianship:
            {
                PackInstrument();
                break;
            }

            case SkillName.Necromancy:
            {
                if (Core.ML)
                {
                    Container regs = new BagOfNecroReagents(50);

                    PackItem(regs);

                    regs.LootType = LootType.Regular;
                }

                Spellbook
                    book = new NecromancerSpellbook(
                    (ulong)0x8981);             // animate dead, evil omen, pain spike, summon familiar, wraith form
                book.LootType = LootType.Blessed;
                PackItem(book);

                break;
            }

            case SkillName.Ninjitsu:
            {
                if (human || elf)
                {
                    EquipItem(new Hakama(0x2C3));         //Only ninjas get the hued one.
                    EquipItem(new Kasa());
                }

                EquipItem(new BookOfNinjitsu());
                break;
            }

            case SkillName.Parry:
            {
                if (human || elf)
                {
                    EquipItem(new WoodenShield());
                }
                else if (gargoyle)
                {
                    EquipItem(new GargishWoodenShield());
                }

                break;
            }

            case SkillName.Peacemaking:
            {
                PackInstrument();
                break;
            }

            case SkillName.Poisoning:
            {
                PackItem(new LesserPoisonPotion());
                PackItem(new LesserPoisonPotion());
                break;
            }

            case SkillName.Provocation:
            {
                PackInstrument();
                break;
            }

            case SkillName.Snooping:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.SpiritSpeak:
            {
                if (human || elf)
                {
                    EquipItem(new Cloak(0x455));
                }

                break;
            }

            case SkillName.Stealing:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.Swords:
            {
                if (elf)
                {
                    EquipItem(new RuneBlade());
                }
                else if (human)
                {
                    EquipItem(new Katana());
                }
                else if (gargoyle)
                {
                    EquipItem(new GlassSword());
                }

                break;
            }

            case SkillName.Tactics:
            {
                if (elf)
                {
                    EquipItem(new RuneBlade());
                }
                else if (human)
                {
                    EquipItem(new Katana());
                }
                else if (gargoyle)
                {
                    EquipItem(new GlassSword());
                }

                break;
            }

            case SkillName.Tailoring:
            {
                PackItem(new BoltOfCloth());
                PackItem(new SewingKit());
                break;
            }

            case SkillName.Tinkering:
            {
                PackItem(new TinkerTools());
                PackItem(new IronIngot(50));
                PackItem(new Axle());
                PackItem(new AxleGears());
                PackItem(new Springs());
                PackItem(new ClockFrame());
                break;
            }

            case SkillName.Tracking:
            {
                if (human || elf)
                {
                    if (m_Mobile != null)
                    {
                        var shoes = m_Mobile.FindItemOnLayer(Layer.Shoes);

                        if (shoes != null)
                        {
                            shoes.Delete();
                        }
                    }

                    var hue = Utility.RandomYellowHue();

                    if (elf)
                    {
                        EquipItem(new ElvenBoots(hue));
                    }
                    else
                    {
                        EquipItem(new Boots(hue));
                    }

                    EquipItem(new SkinningKnife());
                }
                else if (gargoyle)
                {
                    PackItem(new SkinningKnife());
                }

                break;
            }

            case SkillName.Veterinary:
            {
                PackItem(new Bandage(5));
                PackItem(new Scissors());
                break;
            }

            case SkillName.Wrestling:
            {
                if (elf)
                {
                    EquipItem(new LeafGloves());
                }
                else if (human)
                {
                    EquipItem(new LeatherGloves());
                }
                else if (gargoyle)
                {
                    // Why not give them arm armor?
                    EquipItem(new GargishLeatherArms());
                }

                break;
            }

            case SkillName.Throwing:
            {
                if (gargoyle)
                {
                    EquipItem(new Boomerang());
                }

                break;
            }

            case SkillName.Mysticism:
            {
                PackItem(new MysticBook((ulong)0xAB));
                break;
            }
            }
        }
示例#3
0
        private static void SetSkills(Mobile m, SkillNameValue[] skills, int prof)
        {
            switch (prof)
            {
            case 1:     // Warrior
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Anatomy, 30), new SkillNameValue(SkillName.Healing, 30),
                    new SkillNameValue(SkillName.Swords, 30), new SkillNameValue(SkillName.Tactics, 30)
                };

                break;
            }

            case 2:     // Magician
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.EvalInt, 30), new SkillNameValue(SkillName.Wrestling, 30),
                    new SkillNameValue(SkillName.Magery, 30), new SkillNameValue(SkillName.Meditation, 30)
                };

                break;
            }

            case 3:     // Blacksmith
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Mining, 30), new SkillNameValue(SkillName.ArmsLore, 30),
                    new SkillNameValue(SkillName.Blacksmith, 30), new SkillNameValue(SkillName.Tinkering, 30)
                };

                break;
            }

            case 4:     // Necromancer
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Necromancy, 30),
                    new SkillNameValue(SkillName.SpiritSpeak, 30), new SkillNameValue(SkillName.Swords, 30),
                    new SkillNameValue(SkillName.Meditation, 20)
                };

                break;
            }

            case 5:     // Paladin
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Chivalry, 30), new SkillNameValue(SkillName.Swords, 30),
                    new SkillNameValue(SkillName.Focus, 30), new SkillNameValue(SkillName.Tactics, 30)
                };

                break;
            }

            case 6:     //Samurai
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Bushido, 30), new SkillNameValue(SkillName.Swords, 30),
                    new SkillNameValue(SkillName.Anatomy, 30), new SkillNameValue(SkillName.Healing, 30)
                };
                break;
            }

            case 7:     //Ninja
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Ninjitsu, 30), new SkillNameValue(SkillName.Hiding, 30),
                    new SkillNameValue(SkillName.Fencing, 30), new SkillNameValue(SkillName.Stealth, 30)
                };
                break;
            }

            default:
            {
                if (!ValidSkills(skills))
                {
                    return;
                }

                break;
            }
            }

            var addSkillItems = true;
            var elf           = (m.Race == Race.Elf);
            var human         = (m.Race == Race.Human);
            var gargoyle      = (m.Race == Race.Gargoyle);

            switch (prof)
            {
            case 1:     // Warrior
            {
                if (elf)
                {
                    EquipItem(new LeafChest());
                }
                else if (human)
                {
                    EquipItem(new LeatherChest());
                }
                else if (gargoyle)
                {
                    EquipItem(new GargishLeatherChest());
                }

                break;
            }

            case 4:     // Necromancer
            {
                Container regs = new BagOfNecroReagents(50);

                if (!Core.AOS)
                {
                    foreach (var item in regs.Items)
                    {
                        item.LootType = LootType.Newbied;
                    }
                }

                PackItem(regs);

                regs.LootType = LootType.Regular;

                if (elf || human)
                {
                    EquipItem(new BoneHelm());
                }

                if (elf)
                {
                    EquipItem(new ElvenMachete());
                    EquipItem(NecroHue(new LeafChest()));
                    EquipItem(NecroHue(new LeafArms()));
                    EquipItem(NecroHue(new LeafGloves()));
                    EquipItem(NecroHue(new LeafGorget()));
                    EquipItem(NecroHue(new LeafGorget()));
                    EquipItem(NecroHue(new ElvenPants()));         //TODO: Verify the pants
                    EquipItem(new ElvenBoots());
                }
                else if (human)
                {
                    EquipItem(new BoneHarvester());
                    EquipItem(NecroHue(new LeatherChest()));
                    EquipItem(NecroHue(new LeatherArms()));
                    EquipItem(NecroHue(new LeatherGloves()));
                    EquipItem(NecroHue(new LeatherGorget()));
                    EquipItem(NecroHue(new LeatherLegs()));
                    EquipItem(NecroHue(new Skirt()));
                    EquipItem(new Sandals(0x8FD));
                }
                else if (gargoyle)
                {
                    EquipItem(new GlassSword());
                    EquipItem(NecroHue(new GargishLeatherChest()));
                    EquipItem(NecroHue(new GargishLeatherArms()));
                    EquipItem(NecroHue(new GargishLeatherLegs()));
                    EquipItem(NecroHue(new GargishLeatherKilt()));
                }

                Spellbook
                    book = new NecromancerSpellbook(
                    (ulong)0x8981);             // animate dead, evil omen, pain spike, summon familiar, wraith form

                PackItem(book);

                book.LootType = LootType.Blessed;

                addSkillItems = false;
                break;
            }

            case 5:     // Paladin
            {
                if (elf)
                {
                    EquipItem(new ElvenMachete());
                    EquipItem(new WingedHelm());
                    EquipItem(new LeafGorget());
                    EquipItem(new LeafArms());
                    EquipItem(new LeafChest());
                    EquipItem(new LeafLegs());
                    EquipItem(new ElvenBoots());         //Verify hue
                }
                else if (human)
                {
                    EquipItem(new Broadsword());
                    EquipItem(new Helmet());
                    EquipItem(new PlateGorget());
                    EquipItem(new RingmailArms());
                    EquipItem(new RingmailChest());
                    EquipItem(new RingmailLegs());
                    EquipItem(new ThighBoots(0x748));
                    EquipItem(new Cloak(0xCF));
                    EquipItem(new BodySash(0xCF));
                }
                else if (gargoyle)
                {
                    EquipItem(new DreadSword());
                    EquipItem(new GargishPlateChest());
                    EquipItem(new GargishPlateArms());
                    EquipItem(new GargishPlateLegs());
                    EquipItem(new GargishPlateKilt());
                }

                Spellbook book = new BookOfChivalry((ulong)0x3FF);
                book.LootType = LootType.Blessed;
                PackItem(book);

                addSkillItems = false;
                break;
            }

            case 6:     // Samurai
            {
                if (elf || human)
                {
                    EquipItem(new HakamaShita(0x2C3));
                    EquipItem(new Hakama(0x2C3));
                    EquipItem(new SamuraiTabi(0x2C3));
                    EquipItem(new TattsukeHakama(0x22D));
                    EquipItem(new Bokuto());

                    if (elf)
                    {
                        EquipItem(new RavenHelm());
                    }
                    else
                    {
                        EquipItem(new LeatherJingasa());
                    }
                }
                else if (gargoyle)
                {
                    EquipItem(new GlassSword());
                    EquipItem(new GargishPlateChest());
                    EquipItem(new GargishPlateArms());
                    EquipItem(new GargishPlateLegs());
                    EquipItem(new GargishPlateKilt());
                }

                PackItem(new Scissors());
                PackItem(new Bandage(50));

                Spellbook book = new BookOfBushido();
                PackItem(book);

                addSkillItems = false;
                break;
            }

            case 7:     // Ninja
            {
                var hues = new[] { 0x1A8, 0xEC, 0x99, 0x90, 0xB5, 0x336, 0x89 };
                //TODO: Verify that's ALL the hues for that above.

                if (elf || human)
                {
                    EquipItem(new Kasa());
                    EquipItem(new TattsukeHakama(hues[Utility.Random(hues.Length)]));
                    EquipItem(new HakamaShita(0x2C3));
                    EquipItem(new NinjaTabi(0x2C3));

                    if (elf)
                    {
                        EquipItem(new AssassinSpike());
                    }
                    else
                    {
                        EquipItem(new Tekagi());
                    }
                }
                else if (gargoyle)
                {
                    EquipItem(new GargishDagger());

                    var hue = hues[Utility.Random(hues.Length)];

                    EquipItem(new GargishClothChestArmor(hue));
                    EquipItem(new GargishClothArmsArmor(hue));
                    EquipItem(new GargishClothLegsArmor(hue));
                    EquipItem(new GargishClothKiltArmor(hue));
                }

                PackItem(new SmokeBomb());

                Spellbook book = new BookOfNinjitsu();
                PackItem(book);

                addSkillItems = false;
                break;
            }
            }

            for (var i = 0; i < skills.Length; ++i)
            {
                var snv = skills[i];

                if (snv.Value > 0 && (snv.Name != SkillName.Stealth || prof == 7) && snv.Name != SkillName.RemoveTrap &&
                    snv.Name != SkillName.Spellweaving)
                {
                    var skill = m.Skills[snv.Name];

                    if (skill != null)
                    {
                        skill.BaseFixedPoint = snv.Value * 10;

                        if (addSkillItems)
                        {
                            AddSkillItems(snv.Name, m);
                        }
                    }
                }
            }
        }
示例#4
0
        public override void OnResponse(NetState state, RelayInfo info) //Function for GumpButtonType.Reply Buttons
        {
            Mobile from = state.Mobile;

            switch (info.ButtonID)
            {
            case 0:     //Case uses the ActionIDs defenied above. Case 0 defenies the actions for the button with the action id 0
            {
                //Cancel
                from.SendMessage(33, "You decide you dont need anything.");
                break;
            }

            case 1:     //Magery Reagents
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 500))
                {
                    BagOfReagents BagOfReagents = new BagOfReagents();
                    from.AddToBackpack(BagOfReagents);
                    from.SendMessage(33, "You bought Bag of Reagents and that costs 500 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 2:     //Necro Reagents
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 500))
                {
                    BagOfNecroReagents BagOfNecroReagents = new BagOfNecroReagents();
                    from.AddToBackpack(BagOfNecroReagents);
                    from.SendMessage(33, "You bought Bag of Necromancer Reagents and that costs 500 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 3:     //Bandages
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 150))
                {
                    BagOfBandages BagOfBandages = new BagOfBandages();
                    from.AddToBackpack(BagOfBandages);
                    from.SendMessage(33, "You bought Bag of Bandages and that costs 150 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 4:     //Weapons
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 200))
                {
                    BagOfWeapons BagOfWeapons = new BagOfWeapons();
                    from.AddToBackpack(BagOfWeapons);
                    from.SendMessage(33, "You bought Bag of Weapons and that costs 200 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 5:     //Armors
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 200))
                {
                    BagOfArmors BagOfArmors = new BagOfArmors();
                    from.AddToBackpack(BagOfArmors);
                    from.SendMessage(33, "You bought Bag of Armors and that costs 200 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 6:     //Necro Reagents
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 100))
                {
                    BagOfClothing BagOfClothing = new BagOfClothing();
                    from.AddToBackpack(BagOfClothing);
                    from.SendMessage(33, "You bought Bag of Clothing and that costs 100 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 7:     //Necro Reagents
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 500))
                {
                    BagOfArrowsAndBolts BagOfArrowsAndBolts = new BagOfArrowsAndBolts();
                    from.AddToBackpack(BagOfArrowsAndBolts);
                    from.SendMessage(33, "You bought Bag of Arrows and Bolts, that costs 500 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }

            case 8:     //Hair Restyling
            {
                Item[] Gold = from.Backpack.FindItemsByType(typeof(Gold));
                if (from.Backpack.ConsumeTotal(typeof(Gold), 150))
                {
                    HairRestylingDeed HairRestylingDeed = new HairRestylingDeed();
                    from.AddToBackpack(HairRestylingDeed);
                    from.SendMessage(33, "You bought Hair Restyling Deed and that costs 150 coins");
                }
                else
                {
                    from.SendMessage(33, "You are short the coinage needed.");
                }
                break;
            }
            }
        }
        private static void SetSkills(Mobile m, SkillNameValue[] skills, int prof)
        {
            switch (prof)
            {
            case 1:                     // Warrior
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Anatomy, 30),
                    new SkillNameValue(SkillName.Healing, 45),
                    new SkillNameValue(SkillName.Swords, 35),
                    new SkillNameValue(SkillName.Tactics, 50)
                };

                break;
            }

            case 2:                     // Magician
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.EvalInt, 30),
                    new SkillNameValue(SkillName.Wrestling, 30),
                    new SkillNameValue(SkillName.Magery, 50),
                    new SkillNameValue(SkillName.Meditation, 50)
                };

                break;
            }

            case 3:                     // Blacksmith
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Mining, 30),
                    new SkillNameValue(SkillName.ArmsLore, 30),
                    new SkillNameValue(SkillName.Blacksmith, 50),
                    new SkillNameValue(SkillName.Tinkering, 50)
                };

                break;
            }

            case 4:                     // Necromancer
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Necromancy, 50),
                    new SkillNameValue(SkillName.Focus, 30),
                    new SkillNameValue(SkillName.SpiritSpeak, 30),
                    new SkillNameValue(SkillName.Swords, 30),
                    new SkillNameValue(SkillName.Tactics, 20)
                };

                break;
            }

            case 5:                     // Paladin
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Chivalry, 51),
                    new SkillNameValue(SkillName.Swords, 49),
                    new SkillNameValue(SkillName.Focus, 30),
                    new SkillNameValue(SkillName.Tactics, 30)
                };

                break;
            }

            case 6:                     //Samurai
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Bushido, 50),
                    new SkillNameValue(SkillName.Swords, 50),
                    new SkillNameValue(SkillName.Anatomy, 30),
                    new SkillNameValue(SkillName.Healing, 30),
                };
                break;
            }

            case 7:                     //Ninja
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Ninjitsu, 50),
                    new SkillNameValue(SkillName.Hiding, 50),
                    new SkillNameValue(SkillName.Fencing, 30),
                    new SkillNameValue(SkillName.Stealth, 30),
                };
                break;
            }

            default:
            {
                if (!ValidSkills(skills))
                {
                    return;
                }

                break;
            }
            }

            bool addSkillItems = true;

            switch (prof)
            {
            case 1:                     // Warrior
            {
                EquipItem(new LeatherChest());
                break;
            }

            case 4:                     // Necromancer
            {
                Container regs = new BagOfNecroReagents(50);

                if (!Core.AOS)
                {
                    foreach (Item item in regs.Items)
                    {
                        item.LootType = LootType.Newbied;
                    }
                }

                PackItem(regs);

                regs.LootType = LootType.Regular;

                EquipItem(new BoneHarvester());
                EquipItem(new BoneHelm());

                EquipItem(NecroHue(new LeatherChest()));
                EquipItem(NecroHue(new LeatherArms()));
                EquipItem(NecroHue(new LeatherGloves()));
                EquipItem(NecroHue(new LeatherGorget()));
                EquipItem(NecroHue(new LeatherLegs()));
                EquipItem(NecroHue(new Skirt()));
                EquipItem(new Sandals(0x8FD));

                Spellbook book = new NecromancerSpellbook((ulong)0x8981);                           // animate dead, evil omen, pain spike, summon familiar, wraith form

                PackItem(book);

                book.LootType = LootType.Blessed;

                addSkillItems = false;

                break;
            }

            case 5:                     // Paladin
            {
                EquipItem(new Broadsword());
                EquipItem(new Helmet());
                EquipItem(new PlateGorget());
                EquipItem(new RingmailArms());
                EquipItem(new RingmailChest());
                EquipItem(new RingmailLegs());
                EquipItem(new ThighBoots(0x748));
                EquipItem(new Cloak(0xCF));
                EquipItem(new BodySash(0xCF));

                Spellbook book = new BookOfChivalry((ulong)0x3FF);

                PackItem(book);

                book.LootType = LootType.Blessed;

                break;
            }

            case 6:                     // Samurai
            {
                addSkillItems = false;
                EquipItem(new HakamaShita(0x2C3));
                EquipItem(new Hakama(0x2C3));
                EquipItem(new SamuraiTabi(0x2C3));
                EquipItem(new TattsukeHakama(0x22D));
                EquipItem(new Bokuto());
                EquipItem(new LeatherJingasa());
                EquipItem(new Scissors());
                EquipItem(new Bandage(50));

                Spellbook book = new BookOfBushido();
                PackItem(book);

                break;
            }

            case 7:                     // Ninja
            {
                addSkillItems = false;
                EquipItem(new Kasa());

                int[] hues = new int[] { 0x1A8, 0xEC, 0x99, 0x90, 0xB5, 0x336, 0x89 };
                //TODO: Verify that's ALL the hues for that above.

                EquipItem(new TattsukeHakama(hues[Utility.Random(hues.Length)]));

                EquipItem(new HakamaShita(0x2C3));
                EquipItem(new NinjaTabi(0x2C3));
                EquipItem(new Tekagi());
                //EquipItem( new Smokebomb() );

                Spellbook book = new BookOfNinjitsu( );
                PackItem(book);

                break;
            }
            }

            for (int i = 0; i < skills.Length; ++i)
            {
                SkillNameValue snv = skills[i];

                if (snv.Value > 0 && snv.Name != SkillName.Stealth && snv.Name != SkillName.RemoveTrap)
                {
                    Skill skill = m.Skills[snv.Name];

                    if (skill != null)
                    {
                        skill.BaseFixedPoint = snv.Value * 10;

                        if (addSkillItems)
                        {
                            AddSkillItems(snv.Name);
                        }
                    }
                }
            }
        }
示例#6
0
        public static void FillBank(Mobile m)
        {
            BankBox bank = m.BankBox;

            for (int i = 0; i < PowerScroll.Skills.Count; ++i)
            {
                m.Skills[PowerScroll.Skills[i]].Cap = 120.0;
            }

            m.StatCap = 250;

            var book = new Runebook(9999);

            book.CurCharges = book.MaxCharges;
            book.Entries.Add(new RunebookEntry(new Point3D(1438, 1695, 0), Map.Trammel, "Britain Bank", null));
            book.Entries.Add(new RunebookEntry(new Point3D(1821, 2821, 0), Map.Trammel, "Trinsic Bank", null));
            book.Entries.Add(new RunebookEntry(new Point3D(1492, 1628, 13), Map.Trammel, "Britain Sweet Dreams", null));
            book.Entries.Add(new RunebookEntry(new Point3D(1388, 1507, 10), Map.Trammel, "Britain Graveyard", null));
            book.Entries.Add(new RunebookEntry(new Point3D(1300, 1080, 0), Map.Trammel, "Dungeon Despise", null));
            book.Entries.Add(new RunebookEntry(new Point3D(1171, 2639, 0), Map.Trammel, "Dungeon Destard", null));
            book.Entries.Add(new RunebookEntry(new Point3D(1260, 2296, 0), Map.Trammel, "Hedge Maze", null));

            m.AddToBackpack(book);

            #region Gold
            var account = m.Account as Account;

            if (account != null && account.GetTag("TCGold") == null)
            {
                account.AddTag("TCGold", "Gold Given");

                Banker.Deposit(m, 30000000, false);
            }
            #endregion

            #region Bank Level Items
            bank.DropItem(new Robe(443));
            bank.DropItem(new Dagger());
            bank.DropItem(new Candle());
            bank.DropItem(new FireworksWand()
            {
                Name = "Mininova Fireworks Wand"
            });
            #endregion

            Container cont;

            #region TMaps
            cont      = new Bag();
            cont.Name = "Bag of Treasure Maps";

            for (int i = 0; i < 10; i++)
            {
                PlaceItemIn(cont, 30 + (i * 6), 35, new TreasureMap(Utility.Random(3), Map.Trammel));
            }

            for (int i = 0; i < 10; i++)
            {
                PlaceItemIn(cont, 30 + (i * 6), 51, new TreasureMap(Utility.Random(3), Map.Trammel));
            }

            for (int i = 0; i < 20; i++)
            {
                PlaceItemIn(cont, 76, 91, new MessageInABottle());
            }

            PlaceItemIn(cont, 22, 77, new Shovel(30000));
            PlaceItemIn(cont, 57, 97, new Lockpick(3));

            PlaceItemIn(bank, 98, 124, cont);
            #endregion

            #region Trans Powder
            cont = new Bag();

            PlaceItemIn(cont, 117, 147, new PowderOfTranslocation(100));
            PlaceItemIn(bank, 117, 147, cont);
            #endregion

            #region Magery Items
            cont      = new WoodenBox();
            cont.Hue  = 1195;
            cont.Name = "Magery Items";

            PlaceItemIn(cont, 78, 88, new CrimsonCincture()
            {
                Hue = 232
            });
            PlaceItemIn(cont, 102, 90, new CrystallineRing());

            var brac = new GoldBracelet();
            brac.Name = "Farmer's Bank of Mastery";
            brac.Attributes.CastRecovery = 3;
            brac.Attributes.CastSpeed    = 1;
            PlaceItemIn(cont, 139, 30, brac);

            Container bag = new Backpack();
            bag.Hue  = 1152;
            bag.Name = "Spell Casting Stuff";

            PlaceItemIn(bag, 45, 107, new Spellbook(UInt64.MaxValue));
            PlaceItemIn(bag, 65, 107, new NecromancerSpellbook((UInt64)0xFFFF));
            PlaceItemIn(bag, 85, 107, new BookOfChivalry((UInt64)0x3FF));
            PlaceItemIn(bag, 105, 107, new BookOfBushido());  //Default ctor = full
            PlaceItemIn(bag, 125, 107, new BookOfNinjitsu()); //Default ctor = full

            PlaceItemIn(bag, 102, 122, new SpellweavingBook((1ul << 16) - 1));
            PlaceItemIn(bag, 122, 122, new MysticBook((1ul << 16) - 1));

            Runebook runebook = new Runebook(20);
            runebook.CurCharges = runebook.MaxCharges;
            PlaceItemIn(bag, 145, 105, runebook);

            Item toHue = new BagOfReagents(5000);
            toHue.Hue = 0x2D;
            PlaceItemIn(bag, 45, 128, toHue);

            toHue     = new BagOfNecroReagents(3000);
            toHue.Hue = 0x488;
            PlaceItemIn(bag, 64, 125, toHue);

            toHue     = new BagOfMysticReagents(3000);
            toHue.Hue = 1167;
            PlaceItemIn(bag, 141, 128, toHue);

            for (int i = 0; i < 9; ++i)
            {
                PlaceItemIn(bag, 45 + (i * 10), 74, new RecallRune());
            }

            PlaceItemIn(cont, 47, 91, bag);

            bag      = new Backpack();
            bag.Name = "Various Potion Kegs";

            PlaceItemIn(bag, 45, 149, MakePotionKeg(PotionEffect.CureGreater, 0x2D));
            PlaceItemIn(bag, 69, 149, MakePotionKeg(PotionEffect.HealGreater, 0x499));
            PlaceItemIn(bag, 93, 149, MakePotionKeg(PotionEffect.PoisonDeadly, 0x46));
            PlaceItemIn(bag, 117, 149, MakePotionKeg(PotionEffect.RefreshTotal, 0x21));
            PlaceItemIn(bag, 141, 149, MakePotionKeg(PotionEffect.ExplosionGreater, 0x74));

            PlaceItemIn(bag, 93, 82, new Bottle(1000));

            PlaceItemIn(cont, 53, 169, bag);

            PlaceItemIn(bank, 63, 142, cont);
            #endregion

            #region Silver - No Mas Silver

            /*cont = new WoodenBox();
             * cont.Hue = 1161;
             *
             * PlaceItemIn(cont, 47, 91, new Silver(9000));
             * PlaceItemIn(bank, 38, 142, cont);*/
            #endregion

            #region Ethys
            cont      = new Backpack();
            cont.Hue  = 0x490;
            cont.Name = "Bag Of Ethy's!";

            PlaceItemIn(cont, 45, 66, new EtherealHorse());
            PlaceItemIn(cont, 93, 99, new EtherealLlama());
            PlaceItemIn(cont, 45, 132, new EtherealUnicorn());
            PlaceItemIn(cont, 117, 99, new EtherealBeetle());

            PlaceItemIn(bank, 38, 124, cont);
            #endregion
        }
示例#7
0
        private static void     AddSkillItems(SkillName skill, Mobile m)
        {
            bool elf = (m.Race == Race.Elf);

            switch (skill)
            {
            case SkillName.Alchemy:
            {
                PackItem(new Bottle(4));
                PackItem(new MortarPestle());

                int hue = Utility.RandomPinkHue();

                if (elf)
                {
                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(hue));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(hue));
                    }
                }
                else
                {
                    EquipItem(new Robe(Utility.RandomPinkHue()));
                }
                break;
            }

            case SkillName.Anatomy:
            {
                PackItem(new Bandage(3));

                int hue = Utility.RandomYellowHue();

                if (elf)
                {
                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(hue));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(hue));
                    }
                }
                else
                {
                    EquipItem(new Robe(Utility.RandomPinkHue()));
                }
                break;
            }

            case SkillName.AnimalLore:
            {
                int hue = Utility.RandomBlueHue();

                if (elf)
                {
                    EquipItem(new WildStaff());

                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(hue));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(hue));
                    }
                }
                else
                {
                    EquipItem(new ShepherdsCrook());
                    EquipItem(new Robe(hue));
                }
                break;
            }

            case SkillName.Archery:
            {
                PackItem(new Arrow(25));

                if (elf)
                {
                    EquipItem(new ElvenCompositeLongbow());
                }
                else
                {
                    EquipItem(new Bow());
                }

                break;
            }

            case SkillName.ArmsLore:
            {
                if (elf)
                {
                    switch (Utility.Random(3))
                    {
                    case 0: EquipItem(new Leafblade()); break;

                    case 1: EquipItem(new RuneBlade()); break;

                    case 2: EquipItem(new DiamondMace()); break;
                    }
                }
                else
                {
                    switch (Utility.Random(3))
                    {
                    case 0: EquipItem(new Kryss()); break;

                    case 1: EquipItem(new Katana()); break;

                    case 2: EquipItem(new Club()); break;
                    }
                }

                break;
            }

            case SkillName.Begging:
            {
                if (elf)
                {
                    EquipItem(new WildStaff());
                }
                else
                {
                    EquipItem(new GnarledStaff());
                }
                break;
            }

            case SkillName.Blacksmith:
            {
                PackItem(new Tongs());
                PackItem(new Pickaxe());
                PackItem(new Pickaxe());
                PackItem(new IronIngot(50));
                EquipItem(new HalfApron(Utility.RandomYellowHue()));
                break;
            }

            case SkillName.Bushido:
            {
                EquipItem(new Hakama());
                EquipItem(new Kasa());
                EquipItem(new BookOfBushido());
                break;
            }

            case SkillName.Fletching:
            {
                PackItem(new Board(14));
                PackItem(new Feather(5));
                PackItem(new Shaft(5));
                break;
            }

            case SkillName.Camping:
            {
                PackItem(new Bedroll());
                PackItem(new Kindling(5));
                break;
            }

            case SkillName.Carpentry:
            {
                PackItem(new Board(10));
                PackItem(new Saw());
                EquipItem(new HalfApron(Utility.RandomYellowHue()));
                break;
            }

            case SkillName.Cartography:
            {
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new Sextant());
                break;
            }

            case SkillName.Cooking:
            {
                PackItem(new Kindling(2));
                PackItem(new RawLambLeg());
                PackItem(new RawChickenLeg());
                PackItem(new RawFishSteak());
                PackItem(new SackFlour());
                PackItem(new Pitcher(BeverageType.Water));
                break;
            }

            case SkillName.Chivalry:
            {
                if (Core.ML)
                {
                    PackItem(new BookOfChivalry((ulong)0x3FF));
                }

                break;
            }

            case SkillName.DetectHidden:
            {
                EquipItem(new Cloak(0x455));
                break;
            }

            case SkillName.Discordance:
            {
                PackInstrument();
                break;
            }

            case SkillName.Fencing:
            {
                if (elf)
                {
                    EquipItem(new Leafblade());
                }
                else
                {
                    EquipItem(new Kryss());
                }

                break;
            }

            case SkillName.Fishing:
            {
                EquipItem(new FishingPole());

                int hue = Utility.RandomYellowHue();

                if (elf)
                {
                    Item i = new Circlet();
                    i.Hue = hue;
                    EquipItem(i);
                }
                else
                {
                    EquipItem(new FloppyHat(Utility.RandomYellowHue()));
                }

                break;
            }

            case SkillName.Healing:
            {
                PackItem(new Bandage(50));
                PackItem(new Scissors());
                break;
            }

            case SkillName.Herding:
            {
                if (elf)
                {
                    EquipItem(new WildStaff());
                }
                else
                {
                    EquipItem(new ShepherdsCrook());
                }

                break;
            }

            case SkillName.Hiding:
            {
                EquipItem(new Cloak(0x455));
                break;
            }

            case SkillName.Inscribe:
            {
                PackItem(new BlankScroll(2));
                PackItem(new BlueBook());
                break;
            }

            case SkillName.ItemID:
            {
                if (elf)
                {
                    EquipItem(new WildStaff());
                }
                else
                {
                    EquipItem(new GnarledStaff());
                }
                break;
            }

            case SkillName.Lockpicking:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.Lumberjacking:
            {
                EquipItem(new Hatchet());
                break;
            }

            case SkillName.Macing:
            {
                if (elf)
                {
                    EquipItem(new DiamondMace());
                }
                else
                {
                    EquipItem(new Club());
                }

                break;
            }

            case SkillName.Magery:
            {
                BagOfReagents regs = new BagOfReagents(30);

/*
 *                                      if ( !Core.AOS )
 *                                              foreach ( Item item in regs.Items )
 *                                                      item.LootType = LootType.Newbied;
 */

                PackItem(regs);

                regs.LootType = LootType.Regular;

                PackScroll(0);
                PackScroll(1);
                PackScroll(2);

                Spellbook book = new Spellbook((ulong)0x382A8C38);

                EquipItem(book);

                //book.LootType = LootType.Blessed;

                if (elf)
                {
                    EquipItem(new Circlet());

                    if (m.Female)
                    {
                        EquipItem(new FemaleElvenRobe(Utility.RandomBlueHue()));
                    }
                    else
                    {
                        EquipItem(new MaleElvenRobe(Utility.RandomBlueHue()));
                    }
                }
                else
                {
                    EquipItem(new WizardsHat());
                    EquipItem(new Robe(Utility.RandomBlueHue()));
                }

                break;
            }

            case SkillName.Mining:
            {
                PackItem(new Pickaxe());
                break;
            }

            case SkillName.Musicianship:
            {
                PackInstrument();
                break;
            }

            case SkillName.Necromancy:
            {
                Container regs = new BagOfNecroReagents(50);

                PackItem(regs);

                regs.LootType = LootType.Regular;
                Spellbook book = new NecromancerSpellbook((ulong)0x1CFFF);                           // Silver: All except VE/VS
                PackItem(book);

                break;
            }

            case SkillName.Ninjitsu:
            {
                EquipItem(new Hakama(0x2C3));                                   //Only ninjas get the hued one.
                EquipItem(new Kasa());
                EquipItem(new BookOfNinjitsu());
                break;
            }

            case SkillName.Parry:
            {
                EquipItem(new WoodenShield());
                break;
            }

            case SkillName.Peacemaking:
            {
                PackInstrument();
                break;
            }

            case SkillName.Poisoning:
            {
                PackItem(new LesserPoisonPotion());
                PackItem(new LesserPoisonPotion());
                break;
            }

            case SkillName.Provocation:
            {
                PackInstrument();
                break;
            }

            case SkillName.Snooping:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.SpiritSpeak:
            {
                EquipItem(new Cloak(0x455));
                break;
            }

            case SkillName.Stealing:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.Swords:
            {
                if (elf)
                {
                    EquipItem(new RuneBlade());
                }
                else
                {
                    EquipItem(new Katana());
                }

                break;
            }

            case SkillName.Tactics:
            {
                if (elf)
                {
                    EquipItem(new RuneBlade());
                }
                else
                {
                    EquipItem(new Katana());
                }

                break;
            }

            case SkillName.Tailoring:
            {
                PackItem(new BoltOfCloth());
                PackItem(new SewingKit());
                break;
            }

            case SkillName.Tracking:
            {
                if (m_Mobile != null)
                {
                    Item shoes = m_Mobile.FindItemOnLayer(Layer.Shoes);

                    if (shoes != null)
                    {
                        shoes.Delete();
                    }
                }

                int hue = Utility.RandomYellowHue();

                if (elf)
                {
                    EquipItem(new ElvenBoots(hue));
                }
                else
                {
                    EquipItem(new Boots(hue));
                }

                EquipItem(new SkinningKnife());
                break;
            }

            case SkillName.Veterinary:
            {
                PackItem(new Bandage(5));
                PackItem(new Scissors());
                break;
            }

            case SkillName.Wrestling:
            {
                if (elf)
                {
                    EquipItem(new LeafGloves());
                }
                else
                {
                    EquipItem(new LeatherGloves());
                }

                break;
            }
            }
        }
示例#8
0
        private static void AddSkillItems(SkillName skill, Mobile m)
        {
            switch (skill)
            {
            case SkillName.Alchemy:
            {
                PackItem(new Bottle(4));
                PackItem(new MortarPestle());
                EquipItem(new Robe(Utility.RandomPinkHue()));
                break;
            }

            case SkillName.Anatomy:
            {
                PackItem(new Bandage(3));
                EquipItem(new Robe(Utility.RandomPinkHue()));
                break;
            }

            case SkillName.AnimalLore:
            {
                EquipItem(new ShepherdsCrook());
                int hue = Utility.RandomBlueHue();
                EquipItem(new Robe(hue));
                break;
            }

            case SkillName.Archery:
            {
                PackItem(new Arrow(25));
                EquipItem(new Bow());
                break;
            }

            case SkillName.ArmsLore:
            {
                switch (Utility.Random(2))
                {
                case 0: EquipItem(new Kryss()); break;

                case 1: EquipItem(new Broadsword()); break;

                case 2: EquipItem(new Club()); break;
                }
                break;
            }

            case SkillName.Begging:
            {
                EquipItem(new GnarledStaff());
                break;
            }

            case SkillName.Blacksmith:
            {
                PackItem(new Tongs());
                PackItem(new Pickaxe());
                PackItem(new Pickaxe());
                PackItem(new IronIngot(50));
                EquipItem(new HalfApron(Utility.RandomYellowHue()));
                break;
            }

            case SkillName.Fletching:
            {
                PackItem(new Board(14));
                PackItem(new Feather(5));
                PackItem(new Shaft(5));
                break;
            }

            case SkillName.Camping:
            {
                PackItem(new Bedroll());
                PackItem(new Kindling(5));
                break;
            }

            case SkillName.Carpentry:
            {
                PackItem(new Board(10));
                PackItem(new Saw());
                EquipItem(new HalfApron(Utility.RandomYellowHue()));
                break;
            }

            case SkillName.Cartography:
            {
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new BlankMap());
                PackItem(new Sextant());
                break;
            }

            case SkillName.Cooking:
            {
                PackItem(new Kindling(2));
                PackItem(new RawLambLeg());
                PackItem(new RawChickenLeg());
                PackItem(new RawFishSteak());
                PackItem(new SackFlour());
                PackItem(new Pitcher(BeverageType.Water));
                break;
            }

            case SkillName.Chivalry:
            {
                if (Core.ML)
                {
                    PackItem(new BookOfChivalry((ulong)0x3FF));
                }

                break;
            }

            case SkillName.DetectHidden:
            {
                EquipItem(new Cloak(0x455));
                break;
            }

            case SkillName.Discordance:
            {
                PackInstrument();
                break;
            }

            case SkillName.Fencing:
            {
                EquipItem(new Kryss());
                break;
            }

            case SkillName.Fishing:
            {
                EquipItem(new FishingPole());
                EquipItem(new FloppyHat(Utility.RandomYellowHue()));
                break;
            }

            case SkillName.Healing:
            {
                PackItem(new Bandage(50));
                PackItem(new Scissors());
                break;
            }

            case SkillName.Herding:
            {
                EquipItem(new ShepherdsCrook());
                break;
            }

            case SkillName.Hiding:
            {
                EquipItem(new Cloak(0x455));
                break;
            }

            case SkillName.Inscribe:
            {
                PackItem(new BlankScroll(2));
                PackItem(new BlueBook());
                break;
            }

            case SkillName.ItemID:
            {
                EquipItem(new GnarledStaff());
                break;
            }

            case SkillName.Lockpicking:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.Lumberjacking:
            {
                EquipItem(new Hatchet());
                break;
            }

            case SkillName.Macing:
            {
                EquipItem(new Club());
                break;
            }

            case SkillName.Magery:
            {
                BagOfReagents regs = new BagOfReagents(100);

                PackItem(regs);

                regs.LootType = LootType.Regular;

                PackScroll(0);
                PackScroll(1);
                PackScroll(2);

                Spellbook book = new Spellbook((ulong)0x382A8C38);

                EquipItem(book);

                break;
            }

            case SkillName.Mining:
            {
                PackItem(new Pickaxe());
                break;
            }

            case SkillName.Musicianship:
            {
                PackInstrument();
                break;
            }

            case SkillName.Necromancy:
            {
                Container regs = new BagOfNecroReagents(50);
                PackItem(regs);
                regs.LootType = LootType.Regular;
                break;
            }

            case SkillName.Parry:
            {
                EquipItem(new WoodenShield());
                break;
            }

            case SkillName.Peacemaking:
            {
                PackInstrument();
                break;
            }

            case SkillName.Poisoning:
            {
                PackItem(new LesserPoisonPotion());
                PackItem(new LesserPoisonPotion());
                break;
            }

            case SkillName.Provocation:
            {
                PackInstrument();
                break;
            }

            case SkillName.Snooping:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.SpiritSpeak:
            {
                EquipItem(new Cloak(0x455));
                break;
            }

            case SkillName.Stealing:
            {
                PackItem(new Lockpick(20));
                break;
            }

            case SkillName.Swords:
            {
                EquipItem(new Broadsword());
                break;
            }

            case SkillName.Tactics:
            {
                EquipItem(new Broadsword());
                break;
            }

            case SkillName.Tailoring:
            {
                PackItem(new BoltOfCloth());
                PackItem(new SewingKit());
                break;
            }

            case SkillName.Tracking:
            {
                if (m_Mobile != null)
                {
                    Item shoes = m_Mobile.FindItemOnLayer(Layer.Shoes);

                    if (shoes != null)
                    {
                        shoes.Delete();
                    }
                }

                int hue = Utility.RandomYellowHue();

                EquipItem(new Boots(hue));

                EquipItem(new SkinningKnife());
                break;
            }

            case SkillName.Veterinary:
            {
                PackItem(new Bandage(5));
                PackItem(new Scissors());
                break;
            }

            case SkillName.Wrestling:
            {
                EquipItem(new LeatherGloves());
                break;
            }
            }
        }
示例#9
0
        private static void SetSkills(Mobile m, SkillNameValue[] skills, int prof)
        {
            bool addSkillItems = true;

            switch (prof)
            {
            case 1:                     // Warrior
            {
                EquipItem(new LeatherChest());
                break;
            }

            case 4:                     // Necromancer
            {
                Container regs = new BagOfNecroReagents(50);

                PackItem(regs);

                regs.LootType = LootType.Regular;

                EquipItem(new BoneHelm());

                EquipItem(new BoneHarvester());
                EquipItem(NecroHue(new LeatherChest()));
                EquipItem(NecroHue(new LeatherArms()));
                EquipItem(NecroHue(new LeatherGloves()));
                EquipItem(NecroHue(new LeatherGorget()));
                EquipItem(NecroHue(new LeatherLegs()));
                EquipItem(NecroHue(new Skirt()));
                EquipItem(new Sandals(0x8FD));

                Spellbook book = new NecromancerSpellbook((ulong)0x8981);                           // animate dead, evil omen, pain spike, summon familiar, wraith form

                PackItem(book);

                addSkillItems = false;

                break;
            }

            case 5:                     // Paladin
            {
                EquipItem(new Broadsword());
                EquipItem(new Helmet());
                EquipItem(new PlateGorget());
                EquipItem(new RingmailArms());
                EquipItem(new RingmailChest());
                EquipItem(new RingmailLegs());
                EquipItem(new ThighBoots(0x748));
                EquipItem(new Cloak(0xCF));
                EquipItem(new BodySash(0xCF));

                Spellbook book = new BookOfChivalry((ulong)0x3FF);

                PackItem(book);

                addSkillItems = false;

                break;
            }
            }

            for (int i = 0; i < skills.Length; ++i)
            {
                SkillNameValue snv = skills[i];

                if (snv.Value > 0 && (snv.Name != SkillName.Stealth || prof == 7) && snv.Name != SkillName.RemoveTrap && snv.Name != SkillName.Spellweaving)
                {
                    Skill skill = m.Skills[snv.Name];

                    if (skill != null)
                    {
                        //skill.BaseFixedPoint = snv.Value * 10;

                        if (addSkillItems)
                        {
                            AddSkillItems(snv.Name, m);
                        }
                    }
                }
            }
        }
        private static void FillBankTOL(Mobile m)
        {
            BankBox bank = m.BankBox;

            if (bank == null)
            {
                return;
            }

            bank.MaxItems = int.MaxValue;

            // The new AOS bankboxes don't have powerscrolls, they are automatically 'applied':

            for (int i = 0; i < PowerScroll.Skills.Count; ++i)
            {
                m.Skills[PowerScroll.Skills[i]].Cap = 120.0;
            }

            m.StatCap = 600;

            Container cont;
            Container cont2;

            // Begin box of money
            cont        = new WoodenBox();
            cont.ItemID = 0xE7D;
            cont.Hue    = 0x489;

            PlaceItemIn(cont, 17, 52, new BankCheck(1000000));
            PlaceItemIn(cont, 28, 52, new BankCheck(1000000));

            PlaceItemIn(cont, 17, 91, new Factions.Silver(9000));
            PlaceItemIn(cont, 34, 91, new Gold(60000));

            PlaceItemIn(bank, 38, 142, cont);
            // End box of money

            // Begin box of Magery Items
            cont        = new WoodenBox();
            cont.ItemID = 0xE7D;
            cont.Name   = "Magery Items";
            cont.Hue    = 1195;

            // Begin bag of spell casting stuff
            cont2      = new Backpack();
            cont2.Hue  = 0x480;
            cont2.Name = "Spell Casting Stuff";

            PlaceItemIn(cont2, 45, 107, new Spellbook(UInt64.MaxValue));
            PlaceItemIn(cont2, 64, 107, new NecromancerSpellbook((UInt64)0xFFFF));
            PlaceItemIn(cont2, 83, 107, new BookOfChivalry((UInt64)0x3FF));
            PlaceItemIn(cont2, 102, 107, new BookOfBushido());  //Default ctor = full
            PlaceItemIn(cont2, 121, 107, new BookOfNinjitsu()); //Default ctor = full
            PlaceItemIn(cont2, 102, 149, new SpellweavingBook((UInt64)0xFFFF));
            PlaceItemIn(cont2, 121, 149, new MysticBook((UInt64)0xFFFF));

            Runebook runebook = new Runebook(20);

            runebook.CurCharges = runebook.MaxCharges;
            PlaceItemIn(cont2, 141, 107, runebook);

            Item toHue = new BagOfReagents(5000);

            toHue.Hue = 0x2D;
            PlaceItemIn(cont2, 45, 128, toHue);

            toHue     = new BagOfNecroReagents(3000);
            toHue.Hue = 0x488;
            PlaceItemIn(cont2, 64, 128, toHue);

            toHue     = new BagOfMysticReagents(3000);
            toHue.Hue = 0x48F;
            PlaceItemIn(cont2, 141, 128, toHue);

            for (int i = 0; i < 6; ++i)
            {
                PlaceItemIn(cont2, 45 + (i * 10), 74, new RecallRune());
            }

            PlaceItemIn(cont, 47, 91, cont2);
            // End bag of spell casting stuff

            // Begin bag of potion kegs
            cont2      = new Backpack();
            cont2.Name = "Various Potion Kegs";

            PlaceItemIn(cont2, 45, 149, MakePotionKeg(PotionEffect.CureGreater, 0x2D));
            PlaceItemIn(cont2, 69, 149, MakePotionKeg(PotionEffect.HealGreater, 0x499));
            PlaceItemIn(cont2, 93, 149, MakePotionKeg(PotionEffect.PoisonDeadly, 0x46));
            PlaceItemIn(cont2, 117, 149, MakePotionKeg(PotionEffect.RefreshTotal, 0x21));
            PlaceItemIn(cont2, 141, 149, MakePotionKeg(PotionEffect.ExplosionGreater, 0x74));

            PlaceItemIn(cont2, 93, 82, new Bottle(1000));

            PlaceItemIn(cont, 78, 91, cont2);
            // End bag of potion kegs

            GoldRing ring = new GoldRing();

            ring.Name = "Ring Of Arcane Tactics";
            ring.Attributes.CastRecovery = 3;
            ring.Attributes.CastSpeed    = 1;
            PlaceItemIn(cont, 109, 90, ring);

            GoldBracelet bracelet = new GoldBracelet();

            bracelet.Name = "Farmer's Band Of Mastery";
            bracelet.Attributes.CastRecovery = 3;
            bracelet.Attributes.CastSpeed    = 1;
            PlaceItemIn(cont, 139, 95, bracelet);

            PlaceItemIn(bank, 63, 142, cont);
            // End box of Magery Items

            // Begin bag of ethereals
            cont      = new Backpack();
            cont.Hue  = 0x490;
            cont.Name = "Bag Of Ethy's!";

            cont.DropItem(new EtherealHorse());
            cont.DropItem(new EtherealOstard());
            cont.DropItem(new EtherealLlama());
            cont.DropItem(new EtherealKirin());
            cont.DropItem(new EtherealUnicorn());
            cont.DropItem(new EtherealRidgeback());
            cont.DropItem(new EtherealSwampDragon());
            cont.DropItem(new EtherealBeetle());

            PlaceItemIn(bank, 43, 124, cont);
            // End bag of ethereals

            // Begin box of Artifacts
            cont        = new WoodenBox();
            cont.ItemID = 0xE7D;
            cont.Hue    = 1170;
            cont.Name   = "Artifacts";

            // Begin bag of minor artifacts
            cont2      = new Bag();
            cont2.Hue  = 1167;
            cont2.Name = "Minor Artifacts";

            cont2.DropItem(new LunaLance());
            cont2.DropItem(new VioletCourage());
            cont2.DropItem(new CavortingClub());
            cont2.DropItem(new CaptainQuacklebushsCutlass());
            cont2.DropItem(new NightsKiss());
            cont2.DropItem(new ShipModelOfTheHMSCape());
            cont2.DropItem(new AdmiralHeartyRum());
            cont2.DropItem(new CandelabraOfSouls());
            cont2.DropItem(new IolosLute());
            cont2.DropItem(new GwennosHarp());
            cont2.DropItem(new ArcticDeathDealer());
            cont2.DropItem(new EnchantedTitanLegBone());
            cont2.DropItem(new NoxRangersHeavyCrossbow());
            cont2.DropItem(new BlazeOfDeath());
            cont2.DropItem(new DreadPirateHat());
            cont2.DropItem(new BurglarsBandana());
            cont2.DropItem(new GoldBricks());
            cont2.DropItem(new AlchemistsBauble());
            cont2.DropItem(new PhillipsWoodenSteed());
            cont2.DropItem(new PolarBearMask());
            cont2.DropItem(new BowOfTheJukaKing());
            cont2.DropItem(new GlovesOfThePugilist());
            cont2.DropItem(new OrcishVisage());
            cont2.DropItem(new StaffOfPower());
            cont2.DropItem(new ShieldOfInvulnerability());
            cont2.DropItem(new HeartOfTheLion());
            cont2.DropItem(new ColdBlood());
            cont2.DropItem(new GhostShipAnchor());
            cont2.DropItem(new SeahorseStatuette());
            cont2.DropItem(new WrathOfTheDryad());
            cont2.DropItem(new PixieSwatter());

            PlaceItemIn(cont, 17, 83, cont2);
            // End bag of minor artifacts

            // Begin Bag of Major Artifacts
            cont2      = new Bag();
            cont2.Hue  = 1266;
            cont2.Name = "Major Artifacts";

            cont2.DropItem(new GauntletsOfNobility());
            cont2.DropItem(new MidnightBracers());
            cont2.DropItem(new VoiceOfTheFallenKing());
            cont2.DropItem(new OrnateCrownOfTheHarrower());
            cont2.DropItem(new HelmOfInsight());
            cont2.DropItem(new HolyKnightsBreastplate());
            cont2.DropItem(new ArmorOfFortune());
            cont2.DropItem(new TunicOfFire());
            cont2.DropItem(new LeggingsOfBane());
            cont2.DropItem(new ArcaneShield());
            cont2.DropItem(new Aegis());
            cont2.DropItem(new RingOfTheVile());
            cont2.DropItem(new BraceletOfHealth());
            cont2.DropItem(new RingOfTheElements());
            cont2.DropItem(new OrnamentOfTheMagician());
            cont2.DropItem(new DivineCountenance());
            cont2.DropItem(new JackalsCollar());
            cont2.DropItem(new HuntersHeaddress());
            cont2.DropItem(new HatOfTheMagi());
            cont2.DropItem(new ShadowDancerLeggings());
            cont2.DropItem(new SpiritOfTheTotem());
            cont2.DropItem(new BladeOfInsanity());
            cont2.DropItem(new AxeOfTheHeavens());
            cont2.DropItem(new TheBeserkersMaul());
            cont2.DropItem(new Frostbringer());
            cont2.DropItem(new BreathOfTheDead());
            cont2.DropItem(new TheDragonSlayer());
            cont2.DropItem(new BoneCrusher());
            cont2.DropItem(new StaffOfTheMagi());
            cont2.DropItem(new SerpentsFang());
            cont2.DropItem(new LegacyOfTheDreadLord());
            cont2.DropItem(new TheTaskmaster());
            cont2.DropItem(new TheDryadBow());
            cont2.DropItem(new TitansHammer());
            cont2.DropItem(new InquisitorsResolution());
            cont2.DropItem(new BladeOfTheRighteous());
            cont2.DropItem(new ZyronicClaw());

            PlaceItemIn(cont, 90, 83, cont2);
            // End Bag of Major Artifacts

            // Begin bag of Tokuno minor artifacts
            cont2      = new Bag();
            cont2.Hue  = 1281;
            cont2.Name = "Tokuno Minor Artifacts";

            cont2.DropItem(new PeasantsBokuto());
            cont2.DropItem(new DragonNunchaku());
            cont2.DropItem(new TheDestroyer());
            cont2.DropItem(new HanzosBow());
            cont2.DropItem(new Exiler());
            cont2.DropItem(new PilferedDancerFans());
            cont2.DropItem(new DemonForks());
            cont2.DropItem(new BlackLotusHood());
            cont2.DropItem(new DaimyosHelm());
            cont2.DropItem(new ArmsOfTacticalExcellence());
            cont2.DropItem(new AncientFarmersKasa());
            cont2.DropItem(new GlovesOfTheSun());
            cont2.DropItem(new LegsOfStability());
            cont2.DropItem(new AncientSamuraiDo());
            cont2.DropItem(new PigmentsOfTokuno());
            cont2.DropItem(new FluteOfRenewal());
            cont2.DropItem(new AncientUrn());
            cont2.DropItem(new HonorableSwords());
            cont2.DropItem(new ChestOfHeirlooms());
            cont2.DropItem(new TomeOfEnlightenment());

            PlaceItemIn(cont, 53, 83, cont2);
            // End bag of Tokuno minor artifacts

            // Begin bag of Tokuno major artifacts
            cont2      = new Bag();
            cont2.Hue  = 1281;
            cont2.Name = "Tokuno Major Artifacts";

            cont2.DropItem(new DarkenedSky());
            cont2.DropItem(new KasaOfTheRajin());
            cont2.DropItem(new RuneBeetleCarapace());
            cont2.DropItem(new Stormgrip());
            cont2.DropItem(new SwordOfTheStampede());
            cont2.DropItem(new SwordsOfProsperity());
            cont2.DropItem(new TheHorselord());
            cont2.DropItem(new TomeOfLostKnowledge());
            cont2.DropItem(new WindsEdge());
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.ParagonGold, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.VioletCouragePurple, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.InvulnerabilityBlue, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.LunaWhite, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.DryadGreen, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.ShadowDancerBlack, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.BerserkerRed, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.NoxGreen, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.RumRed, 50));
            //cont2.DropItem(new PigmentsOfTokunoMajor(PigmentsType.FireOrange, 50));

            PlaceItemIn(cont, 127, 83, cont2);
            // End bag of Tokuno major artifacts

            // Begin bag of ML Minor artifacts
            cont2      = new Bag();
            cont2.Hue  = 1167;
            cont2.Name = "Minor Artifacts";

            cont2.DropItem(new AegisOfGrace());
            cont2.DropItem(new BladeDance());
            cont2.DropItem(new BloodwoodSpirit());
            cont2.DropItem(new Bonesmasher());
            cont2.DropItem(new Boomstick());
            cont2.DropItem(new BrightsightLenses());
            cont2.DropItem(new FeyLeggings());
            cont2.DropItem(new FleshRipper());
            cont2.DropItem(new HelmOfSwiftness());
            cont2.DropItem(new PadsOfTheCuSidhe());
            cont2.DropItem(new QuiverOfRage());
            cont2.DropItem(new QuiverOfElements());
            cont2.DropItem(new RaedsGlory());
            cont2.DropItem(new RighteousAnger());
            cont2.DropItem(new RobeOfTheEclipse());
            cont2.DropItem(new RobeOfTheEquinox());
            cont2.DropItem(new SoulSeeker());
            cont2.DropItem(new TalonBite());
            cont2.DropItem(new TotemOfVoid());
            cont2.DropItem(new WildfireBow());
            cont2.DropItem(new Windsong());

            PlaceItemIn(cont, 140, 83, cont2);
            // End bag of ML Minor artifacts

            PlaceItemIn(bank, 63, 106, cont);
            // End box of Artifacts

            // Begin box of General Resources
            cont        = new WoodenBox();
            cont.ItemID = 0xE7D;
            cont.Hue    = 1193;
            cont.Name   = "Genereal Resources";

            // Begin bag of raw materials
            cont2      = new Bag();
            cont2.Name = "Raw Materials Bag";

            PlaceItemIn(cont2, 92, 60, new BarbedLeather(5000));
            PlaceItemIn(cont2, 92, 68, new HornedLeather(5000));
            PlaceItemIn(cont2, 92, 76, new SpinedLeather(5000));
            PlaceItemIn(cont2, 92, 84, new Leather(5000));

            PlaceItemIn(cont2, 30, 118, new Cloth(5000));
            PlaceItemIn(cont2, 30, 84, new Board(5000));
            PlaceItemIn(cont2, 57, 80, new BlankScroll(500));
            PlaceItemIn(cont2, 57, 80, new Bone(100));

            PlaceItemIn(cont2, 30, 35, new DullCopperIngot(5000));
            PlaceItemIn(cont2, 37, 35, new ShadowIronIngot(5000));
            PlaceItemIn(cont2, 44, 35, new CopperIngot(5000));
            PlaceItemIn(cont2, 51, 35, new BronzeIngot(5000));
            PlaceItemIn(cont2, 58, 35, new GoldIngot(5000));
            PlaceItemIn(cont2, 65, 35, new AgapiteIngot(5000));
            PlaceItemIn(cont2, 72, 35, new VeriteIngot(5000));
            PlaceItemIn(cont2, 79, 35, new ValoriteIngot(5000));
            PlaceItemIn(cont2, 86, 35, new IronIngot(5000));

            PlaceItemIn(cont2, 30, 59, new RedScales(5000));
            PlaceItemIn(cont2, 36, 59, new YellowScales(5000));
            PlaceItemIn(cont2, 42, 59, new BlackScales(5000));
            PlaceItemIn(cont2, 48, 59, new GreenScales(5000));
            PlaceItemIn(cont2, 54, 59, new WhiteScales(5000));
            PlaceItemIn(cont2, 60, 59, new BlueScales(5000));

            PlaceItemIn(cont, 40, 93, cont2);
            // End bag of raw materials

            // Begin bag of tools
            cont2      = new Bag();
            cont2.Name = "Tool Bag";

            cont2.DropItem(new TinkerTools(30000));
            cont2.DropItem(new HousePlacementTool());
            cont2.DropItem(new DovetailSaw(30000));
            cont2.DropItem(new Scissors());
            cont2.DropItem(new MortarPestle(30000));
            cont2.DropItem(new ScribesPen(30000));
            cont2.DropItem(new SmithHammer(30000));
            cont2.DropItem(new TwoHandedAxe());
            cont2.DropItem(new FletcherTools(30000));
            cont2.DropItem(new SewingKit(30000));
            cont2.DropItem(new Clippers(30000));

            PlaceItemIn(cont, 90, 93, cont2);
            // End bag of tools

            // Begin bag of runic tools
            cont2      = new Backpack();
            cont2.Name = "Runic Tool Bag";

            PlaceItemIn(cont2, 54, 74, new RunicHammer(CraftResource.DullCopper, 30000));
            PlaceItemIn(cont2, 64, 74, new RunicHammer(CraftResource.ShadowIron, 30000));
            PlaceItemIn(cont2, 74, 74, new RunicHammer(CraftResource.Copper, 30000));
            PlaceItemIn(cont2, 84, 74, new RunicHammer(CraftResource.Bronze, 30000));
            PlaceItemIn(cont2, 94, 74, new RunicHammer(CraftResource.Gold, 30000));
            PlaceItemIn(cont2, 104, 74, new RunicHammer(CraftResource.Agapite, 30000));
            PlaceItemIn(cont2, 114, 74, new RunicHammer(CraftResource.Verite, 30000));
            PlaceItemIn(cont2, 124, 74, new RunicHammer(CraftResource.Valorite, 30000));

            PlaceItemIn(cont2, 54, 90, new RunicSewingKit(CraftResource.SpinedLeather, 30000));
            PlaceItemIn(cont2, 64, 90, new RunicSewingKit(CraftResource.HornedLeather, 30000));
            PlaceItemIn(cont2, 74, 90, new RunicSewingKit(CraftResource.BarbedLeather, 30000));

            PlaceItemIn(cont2, 54, 107, new RunicFletcherTool(CraftResource.OakWood, 30000));
            PlaceItemIn(cont2, 69, 107, new RunicFletcherTool(CraftResource.AshWood, 30000));
            PlaceItemIn(cont2, 83, 107, new RunicFletcherTool(CraftResource.YewWood, 30000));
            PlaceItemIn(cont2, 97, 107, new RunicFletcherTool(CraftResource.Heartwood, 30000));

            PlaceItemIn(cont2, 93, 90, new RunicDovetailSaw(CraftResource.OakWood, 30000));
            PlaceItemIn(cont2, 102, 90, new RunicDovetailSaw(CraftResource.AshWood, 30000));
            PlaceItemIn(cont2, 112, 90, new RunicDovetailSaw(CraftResource.YewWood, 30000));
            PlaceItemIn(cont2, 122, 90, new RunicDovetailSaw(CraftResource.Heartwood, 30000));

            PlaceItemIn(cont, 65, 67, cont2);
            // End bag of runic tools

            // Begin bag of recipes
            cont2      = new Bag();
            cont2.Name = "Bag of Recipes";
            cont2.Hue  = 2301;

            for (int i = 0; i <= 92; i++)
            {
                cont2.DropItem(new RecipeScroll(i));
            }

            PlaceItemIn(cont, 115, 93, cont2);
            // End bag of recipes

            // Begin bag of archery ammo
            cont2      = new Bag();
            cont2.Name = "Bag Of Archery Ammo";

            PlaceItemIn(cont2, 48, 76, new Arrow(5000));
            PlaceItemIn(cont2, 72, 76, new Bolt(5000));

            PlaceItemIn(cont, 65, 93, cont2);
            // End bag of archery ammo

            // Begin bag of Wood
            cont2      = new Bag();
            cont2.Hue  = 1321;
            cont2.Name = "Bag of Wood";

            cont2.DropItem(new AshBoard(500));
            cont2.DropItem(new YewBoard(500));
            cont2.DropItem(new OakBoard(500));
            cont2.DropItem(new HeartwoodBoard(500));
            cont2.DropItem(new BloodwoodBoard(500));
            cont2.DropItem(new FrostwoodBoard(500));

            PlaceItemIn(cont, 139, 93, cont2);
            // End bag of Wood

            // Begin Bag of Imbuing Materials
            cont2      = new Bag();
            cont2.Hue  = 0x4B;
            cont2.Name = "Bag of Imbuing Materials";

            /*
             * foreach (ImbuingResource resource in Enum.GetValues(typeof(ImbuingResource)))
             * {
             *  try
             *  {
             *      Type type = ScriptCompiler.FindTypeByFullName(String.Format("Server.Items.{0}", resource.ToString()));
             *
             *      Item item = (Item)Activator.CreateInstance(type);
             *      item.Amount = 1000;
             *
             *      cont2.DropItem(item);
             *  }
             *  catch
             *  {
             *  }
             * }
             */

            PlaceItemIn(cont, 16, 67, cont2);
            // End Bag of Imbuing Materials

            // Begin Bag of Elven Materials
            cont2      = new Bag();
            cont2.Hue  = 1195;
            cont2.Name = "Bag of Elven Materials";

            cont2.DropItem(new BarkFragment(200));
            cont2.DropItem(new Blight(200));
            cont2.DropItem(new BlueDiamond(200));
            cont2.DropItem(new BrilliantAmber(200));
            cont2.DropItem(new CapturedEssence(200));
            cont2.DropItem(new Corruption(200));
            cont2.DropItem(new DarkSapphire(200));
            cont2.DropItem(new DiseasedBark(200));
            cont2.DropItem(new DreadHornMane(200));
            cont2.DropItem(new EcruCitrine(200));
            cont2.DropItem(new EnchantedSwitch(200));
            cont2.DropItem(new EyeOfTheTravesty(200));
            cont2.DropItem(new FireRuby(200));
            cont2.DropItem(new GrizzledBones(200));
            cont2.DropItem(new HollowPrism(200));
            cont2.DropItem(new JeweledFiligree(200));
            cont2.DropItem(new LardOfParoxysmus(200));
            cont2.DropItem(new LuminescentFungi(200));
            cont2.DropItem(new Muculent(200));
            cont2.DropItem(new ParasiticPlant(200));
            cont2.DropItem(new PerfectEmerald(200));
            cont2.DropItem(new PristineDreadHorn(200));
            cont2.DropItem(new Putrefication(200));
            cont2.DropItem(new RunedPrism(200));
            cont2.DropItem(new Scourge(200));
            cont2.DropItem(new SwitchItem(200));
            cont2.DropItem(new Taint(200));
            cont2.DropItem(new Turquoise(200));
            cont2.DropItem(new WhitePearl(200));

            PlaceItemIn(cont, 40, 67, cont2);
            // End Bag of Elven Materials

            PlaceItemIn(bank, 88, 142, cont);
            // End box of General Resources

            // Begin box of Armor Set Pieces
            cont        = new WoodenBox();
            cont.ItemID = 0xE7D;
            cont.Hue    = 1194;
            cont.Name   = "Armor Set Pieces";

            // Begin Bag of Juggernaut Set
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Juggernaut Set";

            cont2.DropItem(new MalekisHonor());
            cont2.DropItem(new Evocaricus());

            PlaceItemIn(cont, 17, 63, cont2);
            // End Bag of Juggernaut Set

            // Begin Bag of Hunter Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Hunter Set Armor";

            cont2.DropItem(new HunterGloves());
            cont2.DropItem(new HunterLegs());
            cont2.DropItem(new HunterArms());
            cont2.DropItem(new HunterChest());

            PlaceItemIn(cont, 40, 63, cont2);
            // End Bag of Hunter Set Armor

            // Begin Bag of Paladin Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Paladin Set Armor";

            cont2.DropItem(new PaladinArms());
            cont2.DropItem(new PaladinChest());
            cont2.DropItem(new PaladinGloves());
            cont2.DropItem(new PaladinGorget());
            cont2.DropItem(new PaladinHelm());
            cont2.DropItem(new PaladinLegs());

            PlaceItemIn(cont, 65, 63, cont2);
            // End Bag of Paladin Set Armor

            // Begin Bag of Necromancer Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Necromancer Set Armor";

            cont2.DropItem(new DeathGloves());
            cont2.DropItem(new DeathBoneHelm());
            cont2.DropItem(new DeathLegs());
            cont2.DropItem(new DeathArms());
            cont2.DropItem(new DeathChest());

            PlaceItemIn(cont, 90, 63, cont2);
            // End Bag of Necromancer Set Armor

            // Begin Bag of Acolyte Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Acolyte Set Armor";

            cont2.DropItem(new GreymistGloves());
            cont2.DropItem(new GreymistLegs());
            cont2.DropItem(new GreymistArms());
            cont2.DropItem(new GreymistChest());

            PlaceItemIn(cont, 115, 63, cont2);
            // End Bag of Acolyte Set Armor

            // Begin Bag of Marksman Set
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Marksman Set";

            cont2.DropItem(new Feathernock());
            cont2.DropItem(new Swiftflight());

            PlaceItemIn(cont, 139, 63, cont2);
            // End Bag of Marksman Set

            // Begin Bag of Monstrous Interred Grizzle Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Monstrous Interred Grizzle Set Armor";

            cont2.DropItem(new GrizzleGauntlets());
            cont2.DropItem(new GrizzleGreaves());
            cont2.DropItem(new GrizzleHelm());
            cont2.DropItem(new GrizzleTunic());
            cont2.DropItem(new GrizzleVambraces());

            PlaceItemIn(cont, 17, 89, cont2);
            // End Bag of Monstrous Interred Grizzle Set Armor

            // Begin Bag of Warrior Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Warrior Set Armor";

            cont2.DropItem(new DarkwoodChest());
            cont2.DropItem(new DarkwoodCrown());
            cont2.DropItem(new DarkwoodGloves());
            cont2.DropItem(new DarkwoodGorget());
            cont2.DropItem(new DarkwoodPauldrons());
            cont2.DropItem(new DarkwoodLegs());

            PlaceItemIn(cont, 40, 89, cont2);
            // End Bag of Warrior Set Armor

            // Begin Bag of Mage Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Mage Set Armor";

            cont2.DropItem(new LeafweaveGloves());
            cont2.DropItem(new LeafweaveLegs());
            cont2.DropItem(new LeafweavePauldrons());
            cont2.DropItem(new LeafweaveChest());

            PlaceItemIn(cont, 65, 89, cont2);
            // End Bag of Mage Set Armor

            // Begin Bag of Assassin Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Assassin Set Armor";

            cont2.DropItem(new AssassinGloves());
            cont2.DropItem(new AssassinLegs());
            cont2.DropItem(new AssassinArms());
            cont2.DropItem(new AssassinChest());

            PlaceItemIn(cont, 90, 89, cont2);
            // End Bag of Assassin Set Armor

            // Begin Bag of Myrmidon Set Armor
            cont2      = new Bag();
            cont2.Hue  = 1177;
            cont2.Name = "Myrmidon Set Armor";

            cont2.DropItem(new MyrmidonArms());
            cont2.DropItem(new MyrmidonChest());
            cont2.DropItem(new MyrmidonGloves());
            cont2.DropItem(new MyrmidonGorget());
            cont2.DropItem(new MyrmidonBascinet());
            cont2.DropItem(new MyrmidonLegs());

            PlaceItemIn(cont, 115, 89, cont2);
            // End Bag of Myrmidon Set Armor

            PlaceItemIn(bank, 113, 142, cont);
            // End box of Armor Set Pieces

            PlaceItemIn(bank, 118, 111, new ChargerOfTheFallen());
        }
示例#11
0
        private static void SetSkills(Mobile m, SkillNameValue[] skills, int prof)
        {
            switch (prof)
            {
            case 1:                     // Warrior
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Anatomy, 30),
                    new SkillNameValue(SkillName.Healing, 45),
                    new SkillNameValue(SkillName.Swords, 35),
                    new SkillNameValue(SkillName.Tactics, 50)
                };

                break;
            }

            case 2:                     // Magician
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.EvalInt, 30),
                    new SkillNameValue(SkillName.Wrestling, 30),
                    new SkillNameValue(SkillName.Magery, 50),
                    new SkillNameValue(SkillName.Meditation, 50)
                };

                break;
            }

            case 3:                     // Blacksmith
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Mining, 30),
                    new SkillNameValue(SkillName.ArmsLore, 30),
                    new SkillNameValue(SkillName.Blacksmith, 50),
                    new SkillNameValue(SkillName.Tinkering, 50)
                };

                break;
            }

            case 4:                     // Necromancer
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Necromancy, 50),
                    new SkillNameValue(SkillName.Focus, 30),
                    new SkillNameValue(SkillName.SpiritSpeak, 30),
                    new SkillNameValue(SkillName.Swords, 30),
                    new SkillNameValue(SkillName.Tactics, 20)
                };

                break;
            }

            case 5:                     // Paladin
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Chivalry, 51),
                    new SkillNameValue(SkillName.Swords, 49),
                    new SkillNameValue(SkillName.Focus, 30),
                    new SkillNameValue(SkillName.Tactics, 30)
                };

                break;
            }

            case 6:                     //Samurai
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Bushido, 50),
                    new SkillNameValue(SkillName.Swords, 50),
                    new SkillNameValue(SkillName.Anatomy, 30),
                    new SkillNameValue(SkillName.Healing, 30)
                };
                break;
            }

            case 7:                     //Ninja
            {
                skills = new SkillNameValue[]
                {
                    new SkillNameValue(SkillName.Ninjitsu, 50),
                    new SkillNameValue(SkillName.Hiding, 50),
                    new SkillNameValue(SkillName.Fencing, 30),
                    new SkillNameValue(SkillName.Stealth, 30)
                };
                break;
            }

            default:
            {
                if (!ValidSkills(skills))
                {
                    return;
                }

                break;
            }
            }

            bool addSkillItems = true;
            bool elf           = m.Race == Race.Elf;

            switch (prof)
            {
            case 1:                     // Warrior
            {
                EquipItem(new LeatherChest());

                break;
            }

            case 4:                     // Necromancer
            {
                Container regs = new BagOfNecroReagents(50);

                foreach (Item item in regs.Items)
                {
                    item.LootType = LootType.Newbied;
                }

                PackItem(regs);

                regs.LootType = LootType.Regular;

                EquipItem(new BoneHelm());
                EquipItem(NecroHue(new LeatherChest()));
                EquipItem(NecroHue(new LeatherArms()));
                EquipItem(NecroHue(new LeatherGloves()));
                EquipItem(NecroHue(new LeatherGorget()));
                EquipItem(NecroHue(new LeatherLegs()));
                EquipItem(NecroHue(new Skirt()));
                EquipItem(new Sandals(0x8FD));

                addSkillItems = false;

                break;
            }

            case 5:                     // Paladin
            {
                EquipItem(new Broadsword());
                EquipItem(new Helmet());
                EquipItem(new PlateGorget());
                EquipItem(new RingmailArms());
                EquipItem(new RingmailChest());
                EquipItem(new RingmailLegs());
                EquipItem(new ThighBoots(0x748));
                EquipItem(new Cloak(0xCF));
                EquipItem(new BodySash(0xCF));

                addSkillItems = false;

                break;
            }

            case 6:                     // Samurai
            {
                addSkillItems = false;

                PackItem(new Scissors());
                PackItem(new Bandage(50));

                break;
            }

            case 7:                     // Ninja
            {
                addSkillItems = false;

                break;
            }
            }

            for (int i = 0; i < skills.Length; ++i)
            {
                SkillNameValue snv = skills[i];

                if (snv.Value > 0 && (snv.Name != SkillName.Stealth || prof == 7) && snv.Name != SkillName.RemoveTrap && snv.Name != SkillName.Spellweaving)
                {
                    Skill skill = m.Skills[snv.Name];

                    if (skill != null)
                    {
                        skill.BaseFixedPoint = snv.Value * 10;

                        if (addSkillItems)
                        {
                            AddSkillItems(snv.Name, m);
                        }
                    }
                }
            }
        }
示例#12
0
        public static void SetSkills(Mobile m, Expansion e, SkillNameValue[] skills, int prof)
        {
            switch (prof)
            {
            case 1:                     // Warrior
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Anatomy, 30), new SkillNameValue(SkillName.Healing, 45),
                    new SkillNameValue(SkillName.Swords, 35), new SkillNameValue(SkillName.Tactics, 50)
                };

                break;
            }

            case 2:                     // Magician
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.EvalInt, 30), new SkillNameValue(SkillName.Wrestling, 30),
                    new SkillNameValue(SkillName.Magery, 50), new SkillNameValue(SkillName.Meditation, 50)
                };

                break;
            }

            case 3:                     // Blacksmith
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Mining, 30), new SkillNameValue(SkillName.ArmsLore, 30),
                    new SkillNameValue(SkillName.Blacksmith, 50), new SkillNameValue(SkillName.Tinkering, 50)
                };

                break;
            }

            case 4:                     // Necromancer
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Necromancy, 50), new SkillNameValue(SkillName.Focus, 30),
                    new SkillNameValue(SkillName.SpiritSpeak, 30), new SkillNameValue(SkillName.Swords, 30),
                    new SkillNameValue(SkillName.Tactics, 20)
                };

                break;
            }

            case 5:                     // Paladin
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Chivalry, 51), new SkillNameValue(SkillName.Swords, 49),
                    new SkillNameValue(SkillName.Focus, 30), new SkillNameValue(SkillName.Tactics, 30)
                };

                break;
            }

            case 6:                     //Samurai
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Bushido, 50), new SkillNameValue(SkillName.Swords, 50),
                    new SkillNameValue(SkillName.Anatomy, 30), new SkillNameValue(SkillName.Healing, 30)
                };
                break;
            }

            case 7:                     //Ninja
            {
                skills = new[]
                {
                    new SkillNameValue(SkillName.Ninjitsu, 50), new SkillNameValue(SkillName.Hiding, 50),
                    new SkillNameValue(SkillName.Fencing, 30), new SkillNameValue(SkillName.Stealth, 30)
                };
                break;
            }

            default:
            {
                if (!ValidSkills(e, skills))
                {
                    return;
                }

                break;
            }
            }

            bool addSkillItems = true;
            bool elf           = (m.Race == Race.Elf);

            switch (prof)
            {
            case 1:                     // Warrior
            {
                if (elf)
                {
                    EquipItem(new LeafChest(), e);
                }
                else
                {
                    EquipItem(new LeatherChest(), e);
                }
                break;
            }

            case 4:                     // Necromancer
            {
                Container regs = new BagOfNecroReagents(50);

                /*
                 * if (e < Expansion.AOS)
                 * {
                 *      foreach (Item item in regs.Items)
                 *      {
                 *              item.LootType = LootType.Newbied;
                 *      }
                 * }
                 */
                PackItem(regs, e);

                regs.LootType = LootType.Regular;

                EquipItem(new BoneHelm(), e);

                if (elf)
                {
                    EquipItem(new ElvenMachete(), e);
                    EquipItem(NecroHue(new LeafChest()), e);
                    EquipItem(NecroHue(new LeafArms()), e);
                    EquipItem(NecroHue(new LeafGloves()), e);
                    EquipItem(NecroHue(new LeafGorget()), e);
                    EquipItem(NecroHue(new LeafGorget()), e);
                    EquipItem(NecroHue(new ElvenPants()), e);                                     //TODO: Verify the pants
                    EquipItem(new ElvenBoots(), e);
                }
                else
                {
                    EquipItem(new BoneHarvester(), e);
                    EquipItem(NecroHue(new LeatherChest()), e);
                    EquipItem(NecroHue(new LeatherArms()), e);
                    EquipItem(NecroHue(new LeatherGloves()), e);
                    EquipItem(NecroHue(new LeatherGorget()), e);
                    EquipItem(NecroHue(new LeatherLegs()), e);
                    EquipItem(NecroHue(new Skirt()), e);
                    EquipItem(new Sandals(0x8FD), e);
                }

                addSkillItems = false;

                break;
            }

            case 5:                     // Paladin
            {
                if (elf)
                {
                    EquipItem(new ElvenMachete(), e);
                    EquipItem(new WingedHelm(), e);
                    EquipItem(new LeafGorget(), e);
                    EquipItem(new LeafArms(), e);
                    EquipItem(new LeafChest(), e);
                    EquipItem(new LeafLegs(), e);
                    EquipItem(new ElvenBoots(), e);                                     //Verify hue
                }
                else
                {
                    EquipItem(new Broadsword(), e);
                    EquipItem(new Helmet(), e);
                    EquipItem(new PlateGorget(), e);
                    EquipItem(new RingmailArms(), e);
                    EquipItem(new RingmailChest(), e);
                    EquipItem(new RingmailLegs(), e);
                    EquipItem(new ThighBoots(0x748), e);
                    EquipItem(new Cloak(0xCF), e);
                    EquipItem(new BodySash(0xCF), e);
                }

                addSkillItems = false;

                break;
            }

            case 6:                     // Samurai
            {
                addSkillItems = false;
                EquipItem(new HakamaShita(0x2C3), e);
                EquipItem(new Hakama(0x2C3), e);
                EquipItem(new SamuraiTabi(0x2C3), e);
                EquipItem(new TattsukeHakama(0x22D), e);
                EquipItem(new Bokuto(), e);

                if (elf)
                {
                    EquipItem(new RavenHelm(), e);
                }
                else
                {
                    EquipItem(new LeatherJingasa(), e);
                }

                PackItem(new Scissors(), e);
                PackItem(new Bandage(50), e);

                break;
            }

            case 7:                     // Ninja
            {
                addSkillItems = false;
                EquipItem(new Kasa(), e);

                var hues = new[] { 0x1A8, 0xEC, 0x99, 0x90, 0xB5, 0x336, 0x89 };
                //TODO: Verify that's ALL the hues for that above.

                EquipItem(new TattsukeHakama(hues[Utility.Random(hues.Length)]), e);

                EquipItem(new HakamaShita(0x2C3), e);
                EquipItem(new NinjaTabi(0x2C3), e);

                if (elf)
                {
                    EquipItem(new AssassinSpike(), e);
                }
                else
                {
                    EquipItem(new Tekagi(), e);
                }

                PackItem(new SmokeBomb(), e);

                break;
            }
            }

            foreach (SkillNameValue snv in skills)
            {
                if (snv.Value <= 0 || (snv.Name == SkillName.Stealth && prof != 7) || snv.Name == SkillName.RemoveTrap ||
                    snv.Name == SkillName.Spellweaving)
                {
                    continue;
                }

                Skill skill = m.Skills[snv.Name];

                if (skill == null)
                {
                    continue;
                }

                skill.BaseFixedPoint = snv.Value * 10;

                if (addSkillItems)
                {
                    AddSkillItems(snv.Name, m, e);
                }
            }

            // all players start with a spellbook with level 1-4 spells
            PackItem(
                new Spellbook(0xFFFFFFFF)
            {
                LootType = LootType.Blessed
            },
                e);
        }