Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/Mobiles/Named/Abscess.cs

@@ -0,0 +1,105 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an abscess's corpse")]
+    public class Abscess : BaseCreature
+    {
+        [Constructable]
+        public Abscess()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "Abscess";
+            Body = 0x109;
+            Hue = 0x8FD;
+            BaseSoundID = 0x16A;
+
+            SetStr(845, 871);
+            SetDex(121, 134);
+            SetInt(128, 142);
+
+            SetHits(7470, 7540);
+
+            SetDamage(26, 31);
+
+            SetDamageType(ResistanceType.Physical, 60);
+            SetDamageType(ResistanceType.Fire, 10);
+            SetDamageType(ResistanceType.Cold, 10);
+            SetDamageType(ResistanceType.Poison, 10);
+            SetDamageType(ResistanceType.Energy, 10);
+
+            SetResistance(ResistanceType.Physical, 65, 75);
+            SetResistance(ResistanceType.Fire, 70, 80);
+            SetResistance(ResistanceType.Cold, 25, 35);
+            SetResistance(ResistanceType.Poison, 35, 45);
+            SetResistance(ResistanceType.Energy, 35, 45);
+
+            SetSkill(SkillName.Wrestling, 132.3, 143.8);
+            SetSkill(SkillName.Tactics, 121.0, 130.5);
+            SetSkill(SkillName.MagicResist, 102.9, 119.0);
+            SetSkill(SkillName.Anatomy, 91.8, 94.3);
+
+            for (int i = 0; i < Utility.RandomMinMax(1, 2); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public Abscess(Serial serial)
+            : base(serial)
+        {
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 40;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 19;
+            }
+        }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }       
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.AosUltraRich, 4);
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);		
+			
+            c.DropItem(new AbscessTail());			
+			
+            if ( Paragon.ChestChance > Utility.RandomDouble() )
+            c.DropItem( new ParagonChest( Name, 5 ) );
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+			
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/AcidElementalRenowned.cs

@@ -0,0 +1,101 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Acid Elemental [Renowned] corpse")]
+    public class AcidElementalRenowned : BaseRenowned
+    {
+        [Constructable]
+        public AcidElementalRenowned()
+            : base(AIType.AI_Mage)
+        {
+            this.Name = "Acid Elemental";
+            this.Title = "[Renowned]";
+            this.Body = 0x9E;
+            this.BaseSoundID = 278;
+
+            this.SetStr(450, 600);
+            this.SetDex(120, 185);
+            this.SetInt(361, 435);
+
+            this.SetHits(2000, 2400);
+
+            this.SetDamage(9, 15);
+
+            this.SetDamageType(ResistanceType.Physical, 25);
+            this.SetDamageType(ResistanceType.Poison, 50);
+            this.SetDamageType(ResistanceType.Energy, 25);
+
+            this.SetResistance(ResistanceType.Physical, 40, 70);
+            this.SetResistance(ResistanceType.Fire, 30, 50);
+            this.SetResistance(ResistanceType.Cold, 20, 40);
+            this.SetResistance(ResistanceType.Poison, 10, 30);
+            this.SetResistance(ResistanceType.Energy, 20, 50);
+
+            this.SetSkill(SkillName.EvalInt, 80.1, 100.0);
+            this.SetSkill(SkillName.Magery, 80.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 65.2, 100.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+            this.Fame = 12500;
+            this.Karma = -12500;
+
+            this.VirtualArmor = 70;
+
+            this.PackItem(new Nightshade(4));
+            this.PackItem(new LesserPoisonPotion());
+        }
+
+        public AcidElementalRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(BreastplateOfTheBerserker),  typeof(TerathanWarriorCostume)};
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(MysticsGarb) };
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Rich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/AncientLichRenowned.cs

@@ -0,0 +1,140 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Ancient Lich [Renowned] corpse")]  
+    public class AncientLichRenowned : BaseRenowned
+    {
+        [Constructable]
+        public AncientLichRenowned()
+            : base(AIType.AI_NecroMage)
+        {
+            this.Name = "Ancient Lich";
+            this.Title = "[Renowned]";
+            this.Body = 78;
+            this.BaseSoundID = 412;
+
+            this.SetStr(250, 305);
+            this.SetDex(96, 115);
+            this.SetInt(966, 1045);
+
+            this.SetHits(2000, 2500);
+
+            this.SetDamage(15, 27);
+
+            this.SetDamageType(ResistanceType.Physical, 20);
+            this.SetDamageType(ResistanceType.Cold, 40);
+            this.SetDamageType(ResistanceType.Energy, 40);
+
+            this.SetResistance(ResistanceType.Physical, 55, 65);
+            this.SetResistance(ResistanceType.Fire, 25, 30);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 50, 60);
+            this.SetResistance(ResistanceType.Energy, 25, 30);
+
+            this.SetSkill(SkillName.EvalInt, 120.1, 130.0);
+            this.SetSkill(SkillName.Magery, 120.1, 130.0);
+            this.SetSkill(SkillName.Meditation, 100.1, 101.0);
+            this.SetSkill(SkillName.MagicResist, 175.2, 200.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.Wrestling, 75.1, 100.0);
+
+            this.Fame = 23000;
+            this.Karma = -23000;
+
+            this.VirtualArmor = 60;
+
+            this.PackNecroReg(30, 275);
+        }
+
+        public AncientLichRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(SpinedBloodwormBracers), typeof(DefenderOfTheMagus) };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(SummonersKilt) };
+            }
+        }
+        public override OppositionGroup OppositionGroup
+        {
+            get
+            {
+                return OppositionGroup.FeyAndUndead;
+            }
+        }
+        public override bool Unprovokable
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override int GetIdleSound()
+        {
+            return 0x19D;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x175;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x108;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0xE2;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x28B;
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Chiikkaha.cs

@@ -0,0 +1,58 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Chiikkaha the Toothed corpse")]
+    public class Chiikkaha : RatmanMage
+    {
+        [Constructable]
+        public Chiikkaha()
+        {
+            this.Name = "Chiikkaha the Toothed";
+
+            this.SetStr(450, 476);
+            this.SetDex(157, 179);
+            this.SetInt(251, 275);
+
+            this.SetHits(400, 425);
+
+            this.SetDamage(10, 17);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 40, 45);
+            this.SetResistance(ResistanceType.Fire, 10, 20);
+            this.SetResistance(ResistanceType.Cold, 10, 20);
+            this.SetResistance(ResistanceType.Poison, 10, 20);
+            this.SetResistance(ResistanceType.Energy, 100);
+
+            this.SetSkill(SkillName.EvalInt, 70.1, 80.0);
+            this.SetSkill(SkillName.Magery, 70.1, 90.0);
+            this.SetSkill(SkillName.MagicResist, 65.1, 96.0);
+            this.SetSkill(SkillName.Tactics, 50.1, 75.0);
+            this.SetSkill(SkillName.Wrestling, 50.1, 75.0);
+
+            this.Fame = 7500;
+            this.Karma = -7500;
+        }
+
+        public Chiikkaha(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Coil.cs

@@ -0,0 +1,146 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a coil corpse")]
+    public class Coil : SilverSerpent
+    {
+        [Constructable]
+        public Coil()
+            : base()
+        {
+            ActiveSpeed = 0.1;
+            PassiveSpeed = 0.2;
+		
+            Name = "Coil";
+
+            Hue = 0x3F;
+            BaseSoundID = 0xDB;
+
+            SetStr(205, 343);
+            SetDex(202, 283);
+            SetInt(88, 142);
+
+            SetHits(628, 1291);
+
+            SetDamage(19, 28);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Poison, 50);
+
+            SetResistance(ResistanceType.Physical, 56, 62);
+            SetResistance(ResistanceType.Fire, 25, 29);
+            SetResistance(ResistanceType.Cold, 25, 30);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 27, 30);
+
+            SetSkill(SkillName.Wrestling, 124.5, 134.5);
+            SetSkill(SkillName.Tactics, 130.2, 142.0);
+            SetSkill(SkillName.MagicResist, 102.3, 113.0);
+            SetSkill(SkillName.Anatomy, 120.8, 138.1);
+            SetSkill(SkillName.Poisoning, 110.1, 133.4);
+
+            Fame = 17500;
+            Karma = -17500;
+
+            PackGem(2);
+            PackItem(new Bone());
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.MortalStrike);
+        }
+
+        public Coil(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Poison HitPoison
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 48;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.AosUltraRich, 3);
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);		
+			
+            c.DropItem(new CoilsFang());
+			
+            if (Utility.RandomDouble() < 0.025)
+            {
+                switch( Utility.Random(5) )
+                {
+                    case 0:
+                        c.DropItem(new AssassinChest());
+                        break;
+                    case 1:
+                        c.DropItem(new DeathGloves());
+                        break;
+                    case 2:
+                        c.DropItem(new LeafweaveLegs());
+                        break;
+                    case 3:
+                        c.DropItem(new HunterLegs());
+                        break;
+                    case 4:
+                        c.DropItem(new MyrmidonLegs());
+                        break;
+                }
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+			
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/DevourerRenowned.cs

@@ -0,0 +1,103 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Devourer of Souls [Renowned] corpse")]  
+    public class DevourerRenowned : BaseRenowned
+    {
+        [Constructable]
+        public DevourerRenowned()
+            : base(AIType.AI_NecroMage)
+        {
+            this.Name = "Devourer of Souls";
+            this.Title = "[Renowned]";
+            this.Body = 303;
+            this.BaseSoundID = 357;
+
+            this.SetStr(801, 950);
+            this.SetDex(126, 175);
+            this.SetInt(201, 250);
+
+            this.SetHits(2000);
+
+            this.SetDamage(22, 26);
+
+            this.SetDamageType(ResistanceType.Physical, 60);
+            this.SetDamageType(ResistanceType.Cold, 20);
+            this.SetDamageType(ResistanceType.Energy, 20);
+
+            this.SetResistance(ResistanceType.Physical, 45, 55);
+            this.SetResistance(ResistanceType.Fire, 25, 35);
+            this.SetResistance(ResistanceType.Cold, 15, 25);
+            this.SetResistance(ResistanceType.Poison, 60, 70);
+            this.SetResistance(ResistanceType.Energy, 40, 50);
+
+            this.SetSkill(SkillName.Necromancy, 90.1, 100.0);
+            this.SetSkill(SkillName.SpiritSpeak, 90.1, 100.0);
+            this.SetSkill(SkillName.EvalInt, 90.1, 100.0);
+            this.SetSkill(SkillName.Magery, 90.1, 100.0);
+            this.SetSkill(SkillName.Meditation, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 90.1, 105.0);
+            this.SetSkill(SkillName.Tactics, 75.1, 85.0);
+            this.SetSkill(SkillName.Wrestling, 80.1, 100.0);
+
+            this.Fame = 9500;
+            this.Karma = -9500;
+
+            this.VirtualArmor = 44;
+
+            this.PackNecroReg(24, 45);
+        }
+
+        public DevourerRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(AnimatedLegsoftheInsaneTinker), typeof(StormCaller), typeof(PillarOfStrength) };
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Drelgor.cs

@@ -0,0 +1,155 @@
+
+using System;
+using Server;
+using System.Collections;
+using System.Collections.Generic;
+using Server.Items;
+using Server.Misc;
+using Server.Regions;
+using Server.Network;
+using Server.Targeting;
+
+namespace Server.Mobiles
+{
+    [CorpseName("A Drelgor The Impaler Corpse")]
+    public class Drelgor : BaseCreature
+    {
+        private bool init = false; //Don't change this.
+        private double msgevery = 1.0; //Recurring message. Change to 0 to disable.
+        private DateTime m_NextMsgTime;
+
+        [Constructable]
+        public Drelgor()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "Drelgor the Impaler";
+            Body = 147;
+            BaseSoundID = 451;
+
+            SetStr(127, 137);
+            SetDex(82, 94);
+            SetInt(48, 55);
+
+            SetHits(131, 136);
+
+            SetDamage(6, 8);
+
+            SetDamageType(ResistanceType.Physical, 40);
+            SetDamageType(ResistanceType.Cold, 60);
+
+            SetResistance(ResistanceType.Physical, 35, 45);
+            SetResistance(ResistanceType.Fire, 20, 30);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 20, 30);
+            SetResistance(ResistanceType.Energy, 30, 40);
+
+            SetSkill(SkillName.Wrestling, 60);
+            SetSkill(SkillName.Tactics, 60);
+            SetSkill(SkillName.MagicResist, 60);
+
+            Fame = 3600;
+            Karma = -3600;
+
+            VirtualArmor = 40;
+
+            PackItem(new Scimitar());
+            PackItem(new WoodenShield());
+
+            switch (Utility.Random(5))
+            {
+                case 0:
+                    this.PackItem(new BoneArms());
+                    break;
+                case 1:
+                    this.PackItem(new BoneChest());
+                    break;
+                case 2:
+                    this.PackItem(new BoneGloves());
+                    break;
+                case 3:
+                    this.PackItem(new BoneLegs());
+                    break;
+                case 4:
+                    this.PackItem(new BoneHelm());
+                    break;
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.Meager);
+        }
+
+        public override bool BleedImmune { get { return true; } }
+
+        #region Start/Stop
+        private void Start()
+        {
+            m_NextMsgTime = DateTime.UtcNow + TimeSpan.FromMinutes(msgevery);
+
+            BroadcastMessage();
+            init = true;
+        }
+        #endregion
+        
+        #region Broadcast Message
+        public void BroadcastMessage()
+        {
+            foreach (NetState state in NetState.Instances)
+            {
+                Mobile m = state.Mobile;
+
+                if (m != null && this.Region.Name == "Old Haven Training" && m.Region.Name == "Old Haven Training")
+                {
+                    m.SendLocalizedMessage(1077840, "", 34); // // Who dares to defile Haven? I am Drelgor the Impaler! I shall claim your souls as payment for this intrusion!
+                    m.PlaySound(0x14);
+                }
+            }
+        }
+        #endregion
+
+        #region OnThink
+        public override void OnThink()
+        {
+            if (!init)
+                Start();
+
+            if (msgevery != 0 && DateTime.UtcNow >= m_NextMsgTime)
+            {
+                BroadcastMessage();
+                m_NextMsgTime = DateTime.UtcNow + TimeSpan.FromMinutes(msgevery);
+            }
+
+            base.OnThink();
+        }
+        #endregion
+
+        public Drelgor(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override OppositionGroup OppositionGroup
+        {
+            get { return OppositionGroup.FeyAndUndead; }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+            writer.Write(init);
+            writer.Write(m_NextMsgTime);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+            init = reader.ReadBool();
+            m_NextMsgTime = reader.ReadDateTime();
+        }
+    }
+}
+

Scripts/Mobiles/Named/FireDaemonRenowned.cs

@@ -0,0 +1,91 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Fire Daemon [Renowned] corpse")]  
+    public class FireDaemonRenowned : BaseRenowned
+    {
+        [Constructable]
+        public FireDaemonRenowned()
+            : base(AIType.AI_Mage)
+        {
+            Name = "Fire Daemon";
+            Title = "[Renowned]";
+            Body = 40;
+            BaseSoundID = 357;
+
+            Hue = 243;
+
+            SetStr(800, 1199);
+            SetDex(200, 250);
+            SetInt(202, 336);
+
+            SetHits(1111, 1478);
+
+            SetDamage(22, 29);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Fire, 25);
+            SetDamageType(ResistanceType.Energy, 25);
+
+            SetResistance(ResistanceType.Physical, 60, 93);
+            SetResistance(ResistanceType.Fire, 60, 100);
+            SetResistance(ResistanceType.Cold, 40, 70);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 37, 50);
+
+            SetSkill(SkillName.MagicResist, 110.1, 132.6);
+            SetSkill(SkillName.Tactics, 86.9, 95.5);
+            SetSkill(SkillName.Wrestling, 42.2, 98.8);
+            SetSkill(SkillName.Magery, 97.1, 100.8);
+            SetSkill(SkillName.EvalInt, 91.1, 91.8);
+            SetSkill(SkillName.Meditation, 45.4, 94.1);
+            SetSkill(SkillName.Anatomy, 45.4, 74.1);
+
+            Fame = 7000;
+            Karma = -10000;
+
+            VirtualArmor = 55;
+
+            SetWeaponAbility(WeaponAbility.ConcussionBlow);
+        }
+
+        public FireDaemonRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(ResonantStaffofEnlightenment), typeof(MantleOfTheFallen) };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/FireElementalRenowned.cs

@@ -0,0 +1,117 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Fire Elemental [Renowned] corpse")] 
+    public class FireElementalRenowned : BaseRenowned
+    {
+        [Constructable]
+        public FireElementalRenowned()
+            : base(AIType.AI_Mage)
+        {
+            this.Name = "Fire Elemental";
+            this.Title = "[Renowned]";
+            this.Body = 15;
+            this.BaseSoundID = 838;
+
+            this.Hue = 1161;
+
+            this.SetStr(450, 500);
+            this.SetDex(200, 250);
+            this.SetInt(300, 350);
+
+            this.SetHits(1200, 1600);
+
+            this.SetDamage(7, 9);
+
+            this.SetDamageType(ResistanceType.Physical, 25);
+            this.SetDamageType(ResistanceType.Fire, 75);
+
+            this.SetResistance(ResistanceType.Physical, 45, 60);
+            this.SetResistance(ResistanceType.Fire, 70, 80);
+            this.SetResistance(ResistanceType.Cold, 5, 10);
+            this.SetResistance(ResistanceType.Poison, 30, 50);
+            this.SetResistance(ResistanceType.Energy, 40, 60);
+
+            this.SetSkill(SkillName.EvalInt, 100.1, 110.0);
+            this.SetSkill(SkillName.Magery, 105.1, 110.0);
+            this.SetSkill(SkillName.MagicResist, 110.2, 120.0);
+            this.SetSkill(SkillName.Tactics, 100.1, 105.0);
+            this.SetSkill(SkillName.Wrestling, 90.1, 100.0);
+
+            this.Fame = 4500;
+            this.Karma = -4500;
+
+            this.VirtualArmor = 40;
+            
+            this.PackItem(new SulfurousAsh(3));
+
+            this.AddItem(new LightSource());
+        }
+
+        public FireElementalRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(JadeWarAxe) };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(TokenOfHolyFavor), typeof(SwordOfShatteredHopes), typeof(LegacyOfDespair) };
+            }
+        }
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Flurry.cs

@@ -0,0 +1,110 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("The remains of Flurry")]
+    public class Flurry : BaseCreature
+    {
+        [Constructable]
+        public Flurry()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Flurry";
+            this.Body = 13;
+            this.Hue = 3;
+            this.BaseSoundID = 655;
+
+            this.SetStr(149, 195);
+            this.SetDex(218, 264);
+            this.SetInt(130, 199);
+
+            this.SetHits(474, 477);
+
+            this.SetDamage(10, 15);  // Erica's
+
+            this.SetDamageType(ResistanceType.Energy, 20);
+            this.SetDamageType(ResistanceType.Cold, 80);
+
+            this.SetResistance(ResistanceType.Physical, 56, 57);
+            this.SetResistance(ResistanceType.Fire, 38, 44);
+            this.SetResistance(ResistanceType.Cold, 40, 45);
+            this.SetResistance(ResistanceType.Poison, 31, 37);
+            this.SetResistance(ResistanceType.Energy, 39, 41);
+
+            this.SetSkill(SkillName.EvalInt, 99.1, 100.2);
+            this.SetSkill(SkillName.Magery, 105.1, 108.8);
+            this.SetSkill(SkillName.MagicResist, 104.0, 112.8);
+            this.SetSkill(SkillName.Tactics, 113.1, 119.8);
+            this.SetSkill(SkillName.Wrestling, 105.6, 106.4);
+
+            this.Fame = 4500;
+            this.Karma = -4500;
+
+            this.VirtualArmor = 54;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get { return true; }
+        }
+
+        public Flurry(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Rich, 10);
+            this.AddLoot(LootPack.Meager);
+            this.AddLoot(LootPack.LowScrolls);
+            this.AddLoot(LootPack.MedScrolls);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Gnaw.cs

@@ -0,0 +1,97 @@
+
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Gnaw corpse")]
+    public class Gnaw : DireWolf
+    {
+        [Constructable]
+        public Gnaw()
+        {
+            Name = "Gnaw";
+            Hue = 0x130;
+
+            SetStr(142, 169);
+            SetDex(102, 145);
+            SetInt(44, 69);
+
+            SetHits(786, 837);
+            SetStam(102, 145);
+            SetMana(44, 69);
+
+            SetDamage(16, 22);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 20, 30);
+            SetResistance(ResistanceType.Poison, 20, 30);
+            SetResistance(ResistanceType.Energy, 23, 40);
+
+            SetSkill(SkillName.Wrestling, 96.3, 119.7);
+            SetSkill(SkillName.Tactics, 89.5, 107.7);
+            SetSkill(SkillName.MagicResist, 93.6, 112.8);
+
+            Fame = 17500;
+            Karma = -17500;
+
+            Tamable = false;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.Rage);
+        }
+        public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            if (Utility.RandomDouble() < 0.3)
+                c.DropItem(new GnawsFang());
+        }
+
+        public Gnaw(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int Hides
+        {
+            get
+            {
+                return 28;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 4;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/GrayGoblinMageRenowned.cs

@@ -0,0 +1,147 @@
+using System;
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Gray Goblin Mage [Renowned] corpse")] 
+    public class GrayGoblinMageRenowned : BaseRenowned
+    {
+        [Constructable]
+        public GrayGoblinMageRenowned()
+            : base(AIType.AI_Mage)
+        {
+            Name = "Gray Goblin Mage";
+            Title = "[Renowned]";
+
+            Body = 723;
+            Hue = 1900;
+
+            BaseSoundID = 0x600;
+
+            SetStr(550, 600);
+            SetDex(70, 75);
+            SetInt(500, 600);
+
+            SetHits(1100, 1300);
+
+            SetDamage(5, 7);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 30, 35);
+            SetResistance(ResistanceType.Fire, 45, 50);
+            SetResistance(ResistanceType.Cold, 40, 50);
+            SetResistance(ResistanceType.Poison, 40, 50);
+            SetResistance(ResistanceType.Energy, 20, 25);
+
+            SetSkill(SkillName.MagicResist, 120.0, 125.0);
+            SetSkill(SkillName.Tactics, 95.0, 100.0);
+            SetSkill(SkillName.Wrestling, 100.0, 110.0);
+            SetSkill(SkillName.EvalInt, 100.0, 120.0);
+            SetSkill(SkillName.Meditation, 100.0, 105.0);
+            SetSkill(SkillName.Magery, 100.0, 110.0);
+
+            Fame = 1500;
+            Karma = -1500;
+
+            VirtualArmor = 28;
+			
+            switch ( Utility.Random(20) )
+            {
+                case 0:
+                    PackItem(new Scimitar());
+                    break;
+                case 1:
+                    PackItem(new Katana());
+                    break;
+                case 2:
+                    PackItem(new WarMace());
+                    break;
+                case 3:
+                    PackItem(new WarHammer());
+                    break;
+                case 4:
+                    PackItem(new Kryss());
+                    break;
+                case 5:
+                    PackItem(new Pitchfork());
+                    break;
+            }
+
+            PackItem(new ThighBoots());
+
+            switch ( Utility.Random(3) )
+            {
+                case 0:
+                    PackItem(new Ribs());
+                    break;
+                case 1:
+                    PackItem(new Shaft());
+                    break;
+                case 2:
+                    PackItem(new Candle());
+                    break;
+            }
+
+            if (0.2 > Utility.RandomDouble())
+                PackItem(new BolaBall());
+        }
+
+        public GrayGoblinMageRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(StormCaller), typeof(TorcOfTheGuardians), typeof(GiantSteps), typeof(CavalrysFolly) };
+            }
+        }
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        
+		public override int GetAngerSound() { return 0x600; }
+        public override int GetIdleSound() { return 0x600; }
+        public override int GetAttackSound() { return 0x5FD; }
+        public override int GetHurtSound() { return 0x5FF; }
+        public override int GetDeathSound() { return 0x5FE; }
+		
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)1);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            if (version == 0)
+            {
+                Body = 723;
+                Hue = 1900;
+            }
+        }
+    }
+}

Scripts/Mobiles/Named/GreenGoblinAlchemistRenowned.cs

@@ -0,0 +1,136 @@
+using System;
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Green Goblin Alchemist [Renowned] corpse")]
+    public class GreenGoblinAlchemistRenowned : BaseRenowned
+    {
+        [Constructable]
+        public GreenGoblinAlchemistRenowned()
+            : base(AIType.AI_Melee)
+        {
+            Name = "Green Goblin Alchemist";
+            Title = "[Renowned]";
+            Body = 723;
+            BaseSoundID = 0x600;
+
+            SetStr(600, 650);
+            SetDex(50, 70);
+            SetInt(100, 250);
+
+            SetHits(1000, 1500);
+
+            SetDamage(5, 7);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 50, 55);
+            SetResistance(ResistanceType.Fire, 55, 60);
+            SetResistance(ResistanceType.Cold, 40, 50);
+            SetResistance(ResistanceType.Poison, 40, 50);
+            SetResistance(ResistanceType.Energy, 20, 25);
+
+            SetSkill(SkillName.MagicResist, 120.0, 125.0);
+            SetSkill(SkillName.Tactics, 95.0, 100.0);
+            SetSkill(SkillName.Wrestling, 100.0, 110.0);
+
+            Fame = 1500;
+            Karma = -1500;
+
+            VirtualArmor = 28;
+
+            switch ( Utility.Random(20) )
+            {
+                case 0:
+                    PackItem(new Scimitar());
+                    break;
+                case 1:
+                    PackItem(new Katana());
+                    break;
+                case 2:
+                    PackItem(new WarMace());
+                    break;
+                case 3:
+                    PackItem(new WarHammer());
+                    break;
+                case 4:
+                    PackItem(new Kryss());
+                    break;
+                case 5:
+                    PackItem(new Pitchfork());
+                    break;
+            }
+
+            PackItem(new ThighBoots());
+
+            switch ( Utility.Random(3) )
+            {
+                case 0:
+                    PackItem(new Ribs());
+                    break;
+                case 1:
+                    PackItem(new Shaft());
+                    break;
+                case 2:
+                    PackItem(new Candle());
+                    break;
+            }
+
+            if (0.2 > Utility.RandomDouble())
+                PackItem(new BolaBall());
+        }
+
+        public GreenGoblinAlchemistRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(ObsidianEarrings), typeof(TheImpalersPick) };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+        
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+		
+		public override int GetAngerSound() { return 0x600; }
+        public override int GetIdleSound() { return 0x600; }
+        public override int GetAttackSound() { return 0x5FD; }
+        public override int GetHurtSound() { return 0x5FF; }
+        public override int GetDeathSound() { return 0x5FE; }
+		
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.FilthyRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Grim.cs

@@ -0,0 +1,105 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("the remains of Grim")]
+    public class Grim : Drake 
+    {
+        [Constructable]
+        public Grim()
+            : base()
+        {
+            Name = "Grim";
+            Hue = 1744;
+
+            SetStr(527, 580);
+            SetDex(284, 322);
+            SetInt(249, 386);
+
+            SetHits(1762, 2502);
+
+            SetDamage(17, 25);
+
+            SetDamageType(ResistanceType.Physical, 80);
+            SetDamageType(ResistanceType.Fire, 20);
+
+            SetResistance(ResistanceType.Physical, 55, 60);
+            SetResistance(ResistanceType.Fire, 62, 68);
+            SetResistance(ResistanceType.Cold, 52, 57);
+            SetResistance(ResistanceType.Poison, 30, 40);
+            SetResistance(ResistanceType.Energy, 40, 44);
+
+            SetSkill(SkillName.MagicResist, 105.8, 115.6);
+            SetSkill(SkillName.Tactics, 102.8, 120.8);
+            SetSkill(SkillName.Wrestling, 111.7, 119.2);
+            SetSkill(SkillName.Anatomy, 105.0, 128.4);
+
+            Fame = 17500;
+            Karma = -5500;
+
+            VirtualArmor = 54;
+
+            Tamable = false;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.CrushingBlow);
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get { return true; }
+        }
+
+        public Grim(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ReacquireOnMovement
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 20;
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 3);
+            AddLoot(LootPack.MedScrolls);
+            AddLoot(LootPack.HighScrolls, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/GrimmochDrummel.cs

@@ -0,0 +1,155 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    public class GrimmochDrummel : BaseCreature
+    {
+        [Constructable]
+        public GrimmochDrummel()
+            : base(AIType.AI_Archer, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Title = "the Cursed";
+
+            this.Hue = 0x8596;
+            this.Body = 0x190;
+            this.Name = "Grimmoch Drummel";
+
+            this.HairItemID = 0x204A;	//Krisna
+
+            Bow bow = new Bow();
+            bow.Movable = false;
+            this.AddItem(bow);
+
+            this.AddItem(new Boots(0x8A4));
+            this.AddItem(new BodySash(0x8A4));
+
+            Backpack backpack = new Backpack();
+            backpack.Movable = false;
+            this.AddItem(backpack);
+
+            LeatherGloves gloves = new LeatherGloves();
+            LeatherChest chest = new LeatherChest();
+            gloves.Hue = 0x96F;
+            chest.Hue = 0x96F;
+
+            this.AddItem(gloves);
+            this.AddItem(chest);
+
+            this.SetStr(111, 120);
+            this.SetDex(151, 160);
+            this.SetInt(41, 50);
+
+            this.SetHits(180, 207);
+            this.SetMana(0);
+
+            this.SetDamage(13, 16);
+
+            this.SetResistance(ResistanceType.Physical, 35, 45);
+            this.SetResistance(ResistanceType.Fire, 25, 30);
+            this.SetResistance(ResistanceType.Cold, 45, 55);
+            this.SetResistance(ResistanceType.Poison, 30, 40);
+            this.SetResistance(ResistanceType.Energy, 20, 25);
+
+            this.SetSkill(SkillName.Archery, 90.1, 110.0);
+            this.SetSkill(SkillName.Swords, 60.1, 70.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 60.1, 70.0);
+            this.SetSkill(SkillName.Anatomy, 90.1, 100.0);
+
+            this.Fame = 5000;
+            this.Karma = -1000;
+
+            this.PackItem(new Arrow(40));
+
+            if (3 > Utility.Random(100))
+                this.PackItem(new FireHorn());
+
+            if (1 > Utility.Random(3))
+                this.PackItem(Loot.RandomGrimmochJournal());
+        }
+
+        public GrimmochDrummel(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ClickTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool ShowFameTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool DeleteCorpseOnDeath
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int GetIdleSound()
+        {
+            return 0x178;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x1AC;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x27E;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x177;
+        }
+
+        public override bool OnBeforeDeath()
+        {
+            Gold gold = new Gold(Utility.RandomMinMax(190, 230));
+            gold.MoveToWorld(this.Location, this.Map);
+
+            Container pack = this.Backpack;
+            if (pack != null)
+            {
+                pack.Movable = true;
+                pack.MoveToWorld(this.Location, this.Map);
+            }
+
+            Effects.SendLocationEffect(this.Location, this.Map, 0x376A, 10, 1);
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Grobu.cs

@@ -0,0 +1,83 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Grobu corpse")]
+    public class Grobu : BlackBear
+    {
+        [Constructable]
+        public Grobu()
+        {
+
+            this.Name = "Grobu";
+            this.Hue = 0x455;
+
+            this.AI = AIType.AI_Melee;
+            this.FightMode = FightMode.Closest;
+
+            this.SetStr(192, 210);
+            this.SetDex(132, 150);
+            this.SetInt(50, 52);
+
+            this.SetHits(1235, 1299);
+            this.SetStam(132, 150);
+            this.SetMana(9);
+
+            this.SetDamage(15, 18);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 40, 45);
+            this.SetResistance(ResistanceType.Fire, 20, 40);
+            this.SetResistance(ResistanceType.Cold, 32, 35);
+            this.SetResistance(ResistanceType.Poison, 25, 30);
+            this.SetResistance(ResistanceType.Energy, 22, 34);
+
+            this.SetSkill(SkillName.Wrestling, 96.4, 119.0);
+            this.SetSkill(SkillName.Tactics, 96.2, 116.5);
+            this.SetSkill(SkillName.MagicResist, 66.2, 83.7);
+
+            this.Fame = 1000;
+            this.Karma = 1000;
+
+            Tamable = false;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public Grobu(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            c.DropItem( new GrobusFur() );
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.FilthyRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Guile.cs

@@ -0,0 +1,96 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Guile corpse")]
+    public class Guile : Changeling
+    {
+        [Constructable]
+        public Guile()
+        {
+            Hue = DefaultHue;
+
+            SetStr(53, 214);
+            SetDex(243, 367);
+            SetInt(369, 586);
+
+            SetHits(1013, 1058);
+            SetStam(243, 367);
+            SetMana(369, 586);
+
+            SetDamage(14, 20);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 80, 90);
+            SetResistance(ResistanceType.Fire, 43, 46);
+            SetResistance(ResistanceType.Cold, 42, 44);
+            SetResistance(ResistanceType.Poison, 42, 50);
+            SetResistance(ResistanceType.Energy, 47, 50);
+
+            SetSkill(SkillName.Wrestling, 12.8, 16.7);
+            SetSkill(SkillName.Tactics, 102.6, 131.0);
+            SetSkill(SkillName.MagicResist, 141.2, 161.6);
+            SetSkill(SkillName.Magery, 108.4, 120.0);
+            SetSkill(SkillName.EvalInt, 108.4, 120.0);
+            SetSkill(SkillName.Meditation, 109.2, 120.0);
+
+            Fame = 21000;
+            Karma = -21000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.StealLife);
+        }
+
+        public Guile(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override string DefaultName
+        {
+            get
+            {
+                return "Guile";
+            }
+        }
+        public override int DefaultHue
+        {
+            get
+            {
+                return 0x3F;
+            }
+        }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Ilhenir.cs

@@ -0,0 +1,355 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server.Engines.CannedEvil;
+using Server.Items;
+using Server.Network;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a corpse of Ilhenir")]
+    public class Ilhenir : BaseChampion
+    {
+        private readonly DateTime m_NextDrop = DateTime.UtcNow;
+
+        [Constructable]
+        public Ilhenir()
+            : base(AIType.AI_Mage)
+        {
+            Name = "Ilhenir";
+            Title = "the Stained";
+            Body = 0x103;
+            Hue = 1164;
+
+            BaseSoundID = 589;
+
+            SetStr(1105, 1350);
+            SetDex(82, 160);
+            SetInt(505, 750);
+
+            SetHits(9000);
+
+            SetDamage(21, 28);
+
+            SetDamageType(ResistanceType.Physical, 60);
+            SetDamageType(ResistanceType.Fire, 20);
+            SetDamageType(ResistanceType.Poison, 20);
+
+            SetResistance(ResistanceType.Physical, 55, 65);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 55, 65);
+            SetResistance(ResistanceType.Poison, 70, 90);
+            SetResistance(ResistanceType.Energy, 65, 75);
+
+            SetSkill(SkillName.EvalInt, 100);
+            SetSkill(SkillName.Magery, 100);
+            SetSkill(SkillName.Meditation, 0);
+            SetSkill(SkillName.Poisoning, 5.4);
+            SetSkill(SkillName.Anatomy, 117.5);
+            SetSkill(SkillName.MagicResist, 120.0);
+            SetSkill(SkillName.Tactics, 119.9);
+            SetSkill(SkillName.Wrestling, 119.9);
+
+            Fame = 24000;
+            Karma = -24000;
+
+            VirtualArmor = 44;
+
+            for (int i = 0; i < Utility.RandomMinMax(1, 3); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            if (Core.ML)
+            {
+                PackTalismans(5);
+            }
+
+            PackGold(2000, 2500);
+
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public Ilhenir(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override ChampionSkullType SkullType
+        {
+            get
+            {
+                return ChampionSkullType.Pain;
+            }
+        }
+        public override Type[] UniqueList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+        public override Type[] SharedList
+        {
+            get
+            {
+                return new Type[]
+                {
+                    typeof(ANecromancerShroud),
+                    typeof(LieutenantOfTheBritannianRoyalGuard),
+                    typeof(OblivionsNeedle),
+                    typeof(TheRobeOfBritanniaAri)
+                };
+            }
+        }
+        public override Type[] DecorativeList
+        {
+            get
+            {
+                return new Type[] { typeof(MonsterStatuette) };
+            }
+        }
+        public override MonsterStatuetteType[] StatueTypes
+        {
+            get
+            {
+                return new MonsterStatuetteType[] { };         
+            }
+        }
+        public override bool Unprovokable { get { return true; } }
+        public override bool Uncalmable { get { return true; } }
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+        public override int TreasureMapLevel { get { return 5; } }   
+
+        public virtual void PackTalismans(int amount)
+        {
+            int count = Utility.Random(amount);
+
+            for (int i = 0; i < count; i++)
+                PackItem(new RandomTalisman());
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 4);
+            AddLoot(LootPack.FilthyRich);
+        }
+  
+        public override void OnDamage(int amount, Mobile from, bool willKill)
+        {
+            if (Utility.RandomDouble() < 0.1)
+                DropOoze();
+
+            base.OnDamage(amount, from, willKill);
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x581;
+        }
+
+        public override int GetIdleSound()
+        {
+            return 0x582;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x580;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x583;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x584;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+
+        public virtual void DropOoze()
+        {
+            int amount = Utility.RandomMinMax(1, 3);
+            bool corrosive = Utility.RandomBool();
+
+            for (int i = 0; i < amount; i++)
+            {
+                Item ooze = new StainedOoze(corrosive);
+                Point3D p = new Point3D(Location);
+
+                for (int j = 0; j < 5; j++)
+                {
+                    p = GetSpawnPosition(2);
+                    bool found = false;
+
+                    foreach (Item item in Map.GetItemsInRange(p, 0))
+                        if (item is StainedOoze)
+                        {
+                            found = true;
+                            break;
+                        }
+
+                    if (!found)
+                        break;
+                }
+
+                ooze.MoveToWorld(p, Map);
+            }
+
+            if (Combatant is PlayerMobile)
+            {
+                if (corrosive)
+                    ((PlayerMobile)Combatant).SendLocalizedMessage(1072071); // A corrosive gas seeps out of your enemy's skin!
+                else
+                    ((PlayerMobile)Combatant).SendLocalizedMessage(1072072); // A poisonous gas seeps out of your enemy's skin!
+            }
+        }
+    }
+
+    public class StainedOoze : Item
+    {
+        private bool m_Corrosive;
+        private Timer m_Timer;
+        private int m_Ticks;
+
+        [Constructable]
+        public StainedOoze()
+            : this(false)
+        {
+        }
+
+        [Constructable]
+        public StainedOoze(bool corrosive)
+            : base(0x122A)
+        {
+            Movable = false;
+            Hue = 0x95;
+
+            m_Corrosive = corrosive;
+            m_Timer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(1), OnTick);
+            m_Ticks = 0;
+        }
+
+        public StainedOoze(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool Corrosive
+        {
+            get
+            {
+                return m_Corrosive;
+            }
+            set
+            {
+                m_Corrosive = value;
+            }
+        }
+        public override void OnAfterDelete()
+        {
+            if (m_Timer != null)
+            {
+                m_Timer.Stop();
+                m_Timer = null;
+            }
+        }
+
+        public void Damage(Mobile m)
+        {
+            if (m_Corrosive)
+            {
+                List<Item> items = m.Items;
+                bool damaged = false;
+
+                for (int i = 0; i < items.Count; ++i)
+                {
+                    IDurability wearable = items[i] as IDurability;
+
+                    if (wearable != null && wearable.HitPoints >= 10 && Utility.RandomDouble() < 0.25)
+                    {
+                        wearable.HitPoints -= (wearable.HitPoints == 10) ? Utility.Random(1, 5) : 10;
+                        damaged = true;
+                    }
+                }
+
+                if (damaged)
+                {
+                    m.LocalOverheadMessage(MessageType.Regular, 0x21, 1072070); // The infernal ooze scorches you, setting you and your equipment ablaze!
+                    return;
+                }
+            }
+
+            AOS.Damage(m, 40, 0, 0, 0, 100, 0);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write(m_Corrosive);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_Corrosive = reader.ReadBool();
+
+            m_Timer = Timer.DelayCall(TimeSpan.Zero, TimeSpan.FromSeconds(1), OnTick);
+            m_Ticks = (ItemID == 0x122A) ? 0 : 30;
+        }
+
+        private void OnTick()
+        {
+            List<Mobile> toDamage = new List<Mobile>();
+            IPooledEnumerable eable = GetMobilesInRange(0);
+
+            foreach (Mobile m in eable)
+            {
+                if (m is BaseCreature)
+                {
+                    BaseCreature bc = (BaseCreature)m;
+
+                    if (!bc.Controlled && !bc.Summoned)
+                        continue;
+                }
+                else if (!m.Player)
+                {
+                    continue;
+                }
+
+                if (m.Alive && !m.IsDeadBondedPet && m.CanBeDamaged())
+                    toDamage.Add(m);
+            }
+
+            eable.Free();
+
+            for (int i = 0; i < toDamage.Count; ++i)
+                Damage(toDamage[i]);
+
+            ++m_Ticks;
+
+            if (m_Ticks >= 35)
+                Delete();
+            else if (m_Ticks == 30)
+                ItemID = 0x122B;
+        }
+    }
+}

Scripts/Mobiles/Named/Irk.cs

@@ -0,0 +1,98 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an Irk corpse")]
+    public class Irk : Changeling
+    {
+        [Constructable]
+        public Irk()
+        {
+            Hue = DefaultHue;
+
+            SetStr(23, 183);
+            SetDex(259, 360);
+            SetInt(374, 600);
+
+            SetHits(1006, 1064);
+            SetStam(259, 360);
+            SetMana(374, 600);
+
+            SetDamage(14, 20);
+
+            SetResistance(ResistanceType.Physical, 80, 90);
+            SetResistance(ResistanceType.Fire, 40, 50);
+            SetResistance(ResistanceType.Cold, 40, 50);
+            SetResistance(ResistanceType.Poison, 41, 50);
+            SetResistance(ResistanceType.Energy, 40, 49);
+
+            SetSkill(SkillName.Wrestling, 120.3, 123.0);
+            SetSkill(SkillName.Tactics, 120.1, 131.8);
+            SetSkill(SkillName.MagicResist, 132.3, 165.8);
+            SetSkill(SkillName.Magery, 108.9, 119.7);
+            SetSkill(SkillName.EvalInt, 108.4, 120.0);
+            SetSkill(SkillName.Meditation, 108.9, 119.1);
+
+            Fame = 21000;
+            Karma = -21000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.AngryFire);
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.25 )
+            c.DropItem( new IrksBrain() );
+
+            if ( Utility.RandomDouble() < 0.025 )
+            c.DropItem( new PaladinGloves() );
+        }
+ 
+        public Irk(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override string DefaultName
+        {
+            get
+            {
+                return "Irk";
+            }
+        }
+        public override int DefaultHue
+        {
+            get
+            {
+                return 0x489;
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/LadyJennifyr.cs

@@ -0,0 +1,142 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Lady Jennifyr corpse")]
+    public class LadyJennifyr : SkeletalKnight
+    {
+        private static readonly Dictionary<Mobile, ExpireTimer> m_Table = new Dictionary<Mobile, ExpireTimer>();
+        [Constructable]
+        public LadyJennifyr()
+        {
+            this.Name = "Lady Jennifyr";
+            this.Hue = 0x76D;
+
+            this.SetStr(208, 309);
+            this.SetDex(91, 118);
+            this.SetInt(44, 101);
+
+            this.SetHits(1113, 1285);
+
+            this.SetDamage(15, 25);
+
+            this.SetDamageType(ResistanceType.Physical, 40);
+            this.SetDamageType(ResistanceType.Cold, 60);
+
+            this.SetResistance(ResistanceType.Physical, 56, 65);
+            this.SetResistance(ResistanceType.Fire, 41, 49);
+            this.SetResistance(ResistanceType.Cold, 71, 80);
+            this.SetResistance(ResistanceType.Poison, 41, 50);
+            this.SetResistance(ResistanceType.Energy, 50, 58);
+
+            this.SetSkill(SkillName.Wrestling, 127.9, 137.1);
+            this.SetSkill(SkillName.Tactics, 128.4, 141.9);
+            this.SetSkill(SkillName.MagicResist, 102.1, 119.5);
+            this.SetSkill(SkillName.Anatomy, 129.0, 137.5);
+
+            this.Fame = 18000;
+            this.Karma = -18000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public LadyJennifyr(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override bool CanBeParagon { get { return false; } }
+
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.15 )
+            c.DropItem( new DisintegratingThesisNotes() );
+
+            if ( Utility.RandomDouble() < 0.1 )
+            c.DropItem( new ParrotItem() );
+        }
+     
+        /*public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }*/
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 3);
+        }
+
+        public override void OnGaveMeleeAttack(Mobile defender)
+        {
+            base.OnGaveMeleeAttack(defender);
+
+            if (Utility.RandomDouble() < 0.1)
+            {
+                ExpireTimer timer;
+
+                if (m_Table.TryGetValue(defender, out timer))
+                    timer.DoExpire();
+
+                defender.FixedParticles(0x3709, 10, 30, 5052, EffectLayer.LeftFoot);
+                defender.PlaySound(0x208);
+                defender.SendLocalizedMessage(1070833); // The creature fans you with fire, reducing your resistance to fire attacks.
+
+                ResistanceMod mod = new ResistanceMod(ResistanceType.Fire, -10);
+                defender.AddResistanceMod(mod);
+
+                m_Table[defender] = timer = new ExpireTimer(defender, mod);
+                timer.Start();
+            }
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+
+        private class ExpireTimer : Timer
+        {
+            private readonly Mobile m_Mobile;
+            private readonly ResistanceMod m_Mod;
+            public ExpireTimer(Mobile m, ResistanceMod mod)
+                : base(TimeSpan.FromSeconds(10))
+            {
+                this.m_Mobile = m;
+                this.m_Mod = mod;
+                this.Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            public void DoExpire()
+            {
+                this.m_Mobile.RemoveResistanceMod(this.m_Mod);
+
+                this.Stop();
+                m_Table.Remove(this.m_Mobile);
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Mobile.SendLocalizedMessage(1070834); // Your resistance to fire attacks has returned.
+                this.DoExpire();
+            }
+        }
+    }
+}

Scripts/Mobiles/Named/LadyLissith.cs

@@ -0,0 +1,96 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Lady Lissith corpse")]
+    public class LadyLissith : GiantBlackWidow
+    {
+        [Constructable]
+        public LadyLissith()
+        {
+
+            Name = "Lady Lissith";
+            Hue = 0x452;
+
+            SetStr(81, 130);
+            SetDex(116, 152);
+            SetInt(44, 100);
+
+            SetHits(245, 375);
+            SetStam(116, 157);
+            SetMana(44, 100);
+
+            SetDamage(15, 22);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 40, 50);
+            SetResistance(ResistanceType.Fire, 31, 39);
+            SetResistance(ResistanceType.Cold, 30, 40);
+            SetResistance(ResistanceType.Poison, 71, 80);
+            SetResistance(ResistanceType.Energy, 30, 40);
+
+            SetSkill(SkillName.Wrestling, 108.6, 123.0);
+            SetSkill(SkillName.Tactics, 102.7, 119.0);
+            SetSkill(SkillName.MagicResist, 78.8, 95.6);
+            SetSkill(SkillName.Anatomy, 68.6, 106.8);
+            SetSkill(SkillName.Poisoning, 96.6, 112.9);
+
+            Fame = 18900;
+            Karma = -18900;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.BleedAttack);
+        }
+
+        public LadyLissith(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.025 )
+            c.DropItem( new GreymistChest() );
+
+            if ( Utility.RandomDouble() < 0.45 )
+            c.DropItem( new LissithsSilk() );
+
+            if ( Utility.RandomDouble() < 0.1 )
+            c.DropItem( new ParrotItem() );
+        }
+
+        /*public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }*/
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/LadyMarai.cs

@@ -0,0 +1,90 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Lady Marai corpse")]
+    public class LadyMarai : SkeletalKnight
+    {
+        [Constructable]
+        public LadyMarai()
+        {
+            Name = "Lady Marai";
+            Hue = 0x21;
+
+            SetStr(221, 304);
+            SetDex(98, 138);
+            SetInt(54, 99);
+
+            SetHits(694, 846);
+
+            SetDamage(15, 25);
+
+            SetDamageType(ResistanceType.Physical, 40);
+            SetDamageType(ResistanceType.Cold, 60);
+
+            SetResistance(ResistanceType.Physical, 55, 65);
+            SetResistance(ResistanceType.Fire, 40, 50);
+            SetResistance(ResistanceType.Cold, 70, 80);
+            SetResistance(ResistanceType.Poison, 40, 50);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.Wrestling, 126.6, 137.2);
+            SetSkill(SkillName.Tactics, 128.7, 134.5);
+            SetSkill(SkillName.MagicResist, 102.1, 119.1);
+            SetSkill(SkillName.Anatomy, 126.2, 136.5);
+
+            Fame = 18000;
+            Karma = -18000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.CrushingBlow);
+        }
+
+        public LadyMarai(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.15 )
+            c.DropItem( new DisintegratingThesisNotes() );
+
+            if ( Utility.RandomDouble() < 0.1 )
+            c.DropItem( new ParrotItem() );
+        }
+
+        /*public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }*/
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/LadySabrix.cs

@@ -0,0 +1,94 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Lady Sabrix corpse")]
+    public class LadySabrix : GiantBlackWidow
+    {
+        [Constructable]
+        public LadySabrix()
+        {
+            Name = "Lady Sabrix";
+            Hue = 0x497;
+
+            SetStr(82, 130);
+            SetDex(117, 146);
+            SetInt(50, 98);
+
+            SetHits(233, 361);
+            SetStam(117, 146);
+            SetMana(50, 98);
+
+            SetDamage(15, 22);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 40, 50);
+            SetResistance(ResistanceType.Fire, 30, 40);
+            SetResistance(ResistanceType.Cold, 30, 39);
+            SetResistance(ResistanceType.Poison, 70, 80);
+            SetResistance(ResistanceType.Energy, 35, 44);
+
+            SetSkill(SkillName.Wrestling, 109.8, 122.8);
+            SetSkill(SkillName.Tactics, 102.8, 120.0);
+            SetSkill(SkillName.MagicResist, 79.4, 95.1);
+            SetSkill(SkillName.Anatomy, 68.8, 105.1);
+            SetSkill(SkillName.Poisoning, 97.8, 116.7);
+
+            Fame = 18900;
+            Karma = -18900;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.ArmorIgnore);
+        }
+
+        public LadySabrix(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.2 )
+            c.DropItem( new SabrixsEye() );
+
+            if ( Utility.RandomDouble() < 0.25 )
+            {
+                switch ( Utility.Random( 2 ) )
+                {
+                    case 0: AddToBackpack( new PaladinArms() ); break;
+                    case 1: AddToBackpack( new HunterLegs() ); break;
+                }
+            }
+
+            if ( Utility.RandomDouble() < 0.1 )
+            c.DropItem( new ParrotItem() );
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Lurg.cs

@@ -0,0 +1,95 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Lurg corpse")]
+    public class Lurg : Troglodyte
+    {
+        [Constructable]
+        public Lurg()
+        {
+            Name = "Lurg";
+            Hue = 0x455;
+
+            SetStr(584, 625);
+            SetDex(163, 176);
+            SetInt(90, 106);
+
+            SetHits(3034, 3189);
+            SetStam(163, 176);
+            SetMana(90, 106);
+
+            SetDamage(16, 19);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 50, 53);
+            SetResistance(ResistanceType.Fire, 45, 47);
+            SetResistance(ResistanceType.Cold, 56, 60);
+            SetResistance(ResistanceType.Poison, 50, 60);
+            SetResistance(ResistanceType.Energy, 41, 56);
+
+            SetSkill(SkillName.Wrestling, 122.7, 130.5);
+            SetSkill(SkillName.Tactics, 109.3, 118.5);
+            SetSkill(SkillName.MagicResist, 72.9, 87.6);
+            SetSkill(SkillName.Anatomy, 110.5, 124.0);
+            SetSkill(SkillName.Healing, 84.1, 105.0);
+
+            Fame = 10000;
+            Karma = -10000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.CrushingBlow);
+        }
+
+        public Lurg(Serial serial)
+            : base(serial)
+        {
+        }
+        public override bool CanBeParagon { get { return false; } }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 4;
+            }
+        }
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/LysanderGathenwale.cs

@@ -0,0 +1,156 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    public class LysanderGathenwale : BaseCreature
+    {
+        [Constructable]
+        public LysanderGathenwale()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Title = "the Cursed";
+
+            this.Hue = 0x8838;
+            this.Body = 0x190;
+            this.Name = "Lysander Gathenwale";
+
+            this.AddItem(new Boots(0x599));
+            this.AddItem(new Cloak(0x96F));
+
+            Spellbook spellbook = new Spellbook();
+            RingmailGloves gloves = new RingmailGloves();
+            StuddedChest chest = new StuddedChest();
+            PlateArms arms = new PlateArms();
+
+            spellbook.Hue = 0x599;
+            gloves.Hue = 0x599;
+            chest.Hue = 0x96F;
+            arms.Hue = 0x599;
+
+            this.AddItem(spellbook);
+            this.AddItem(gloves);
+            this.AddItem(chest);
+            this.AddItem(arms);
+
+            this.SetStr(111, 120);
+            this.SetDex(71, 80);
+            this.SetInt(121, 130);
+
+            this.SetHits(180, 207);
+            this.SetMana(227, 265);
+
+            this.SetDamage(5, 13);
+
+            this.SetResistance(ResistanceType.Physical, 35, 45);
+            this.SetResistance(ResistanceType.Fire, 25, 30);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 25, 35);
+            this.SetResistance(ResistanceType.Energy, 25, 35);
+
+            this.SetSkill(SkillName.Wrestling, 80.1, 90.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 80.1, 90.0);
+            this.SetSkill(SkillName.Magery, 90.1, 100.0);
+            this.SetSkill(SkillName.EvalInt, 95.1, 100.0);
+            this.SetSkill(SkillName.Meditation, 90.1, 100.0);
+
+            this.Fame = 5000;
+            this.Karma = -10000;
+
+            Item reags = Loot.RandomReagent();
+            reags.Amount = 30;
+            this.PackItem(reags);
+        }
+
+        public LysanderGathenwale(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ClickTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool ShowFameTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool DeleteCorpseOnDeath
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int GetIdleSound()
+        {
+            return 0x1CE;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x1AC;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x182;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x28D;
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.MedScrolls, 2);
+        }
+
+        public override bool OnBeforeDeath()
+        {
+            if (!base.OnBeforeDeath())
+                return false;
+
+            if (this.Backpack != null)
+                this.Backpack.Destroy();
+
+            if (Utility.Random(3) == 0)
+            {
+                BaseBook notebook = Loot.RandomLysanderNotebook();
+                notebook.MoveToWorld(this.Location, this.Map);
+            }
+
+            Effects.SendLocationEffect(this.Location, this.Map, 0x376A, 10, 1);
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Malefic.cs

@@ -0,0 +1,90 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Malefic corpse")]
+    public class Malefic : DreadSpider
+    {
+        [Constructable]
+        public Malefic()
+        {
+            Name = "Malefic";
+            Hue = 0x455;
+
+            SetStr(210, 284);
+            SetDex(153, 197);
+            SetInt(349, 390);
+
+            SetHits(600, 747);
+            SetStam(153, 197);
+            SetMana(349, 390);
+
+            SetDamage(15, 22);
+
+            SetDamageType(ResistanceType.Physical, 20);
+            SetDamageType(ResistanceType.Poison, 80);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 40, 50);
+            SetResistance(ResistanceType.Cold, 40, 49);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 41, 48);
+
+            SetSkill(SkillName.Wrestling, 96.9, 112.4);
+            SetSkill(SkillName.Tactics, 91.3, 105.4);
+            SetSkill(SkillName.MagicResist, 79.8, 95.1);
+            SetSkill(SkillName.Magery, 103.0, 118.6);
+            SetSkill(SkillName.EvalInt, 105.7, 119.6);
+            SetSkill(SkillName.Meditation, 0);
+
+            Fame = 21000;
+            Karma = -21000;
+            
+            Tamable = false;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.Dismount);
+            /*
+            // TODO: uncomment once added
+            if ( Utility.RandomDouble() < 0.1 )
+            PackItem( new ParrotItem() );
+            */
+        }
+
+        public Malefic(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/MasterJonath.cs

@@ -0,0 +1,97 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Master Jonath corpse")]
+    public class MasterJonath : BoneMagi
+    {
+        [Constructable]
+        public MasterJonath()
+        {
+            Name = "Master Jonath";
+            Hue = 0x455;
+
+            SetStr(109, 131);
+            SetDex(98, 110);
+            SetInt(232, 259);
+
+            SetHits(766, 920);
+
+            SetDamage(10, 15);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 55, 60);
+            SetResistance(ResistanceType.Fire, 43, 49);
+            SetResistance(ResistanceType.Cold, 45, 80);
+            SetResistance(ResistanceType.Poison, 41, 45);
+            SetResistance(ResistanceType.Energy, 54, 55);
+
+            SetSkill(SkillName.Wrestling, 80.5, 88.6);
+            SetSkill(SkillName.Tactics, 88.5, 95.1);
+            SetSkill(SkillName.MagicResist, 102.7, 102.9);
+            SetSkill(SkillName.Magery, 100.0, 106.6);
+            SetSkill(SkillName.EvalInt, 99.6, 106.9);
+            SetSkill(SkillName.Necromancy, 100.0, 106.6);
+            SetSkill(SkillName.SpiritSpeak, 99.6, 106.9);
+
+            Fame = 18000;
+            Karma = -18000;
+
+            PackReg(7);
+            PackReg(7);
+            PackReg(8);
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public MasterJonath(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.05 )
+            	c.DropItem( new ParrotItem() );
+
+            if ( Utility.RandomDouble() < 0.15 )
+            	c.DropItem( new DisintegratingThesisNotes() );
+        }
+
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 3);
+            this.AddLoot(LootPack.MedScrolls, 2);
+            this.AddLoot(LootPack.HighScrolls, 2);
+        }
+
+        // TODO: Special move?
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/MasterMikael.cs

@@ -0,0 +1,96 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Master Mikael corpse")]
+    public class MasterMikael : BoneMagi
+    {
+        [Constructable]
+        public MasterMikael()
+        {
+            this.Name = "Master Mikael";
+            this.Hue = 0x8FD;
+
+            this.SetStr(93, 122);
+            this.SetDex(91, 100);
+            this.SetInt(252, 271);
+
+            this.SetHits(789, 1014);
+
+            this.SetDamage(11, 19);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 55, 59);
+            this.SetResistance(ResistanceType.Fire, 40, 46);
+            this.SetResistance(ResistanceType.Cold, 72, 80);
+            this.SetResistance(ResistanceType.Poison, 44, 49);
+            this.SetResistance(ResistanceType.Energy, 50, 57);
+
+            this.SetSkill(SkillName.Wrestling, 80.1, 87.2);
+            this.SetSkill(SkillName.Tactics, 79.0, 90.9);
+            this.SetSkill(SkillName.MagicResist, 90.3, 106.9);
+            this.SetSkill(SkillName.Magery, 103.8, 108.0);
+            this.SetSkill(SkillName.EvalInt, 96.1, 105.3);
+            this.SetSkill(SkillName.Necromancy, 103.8, 108.0);
+            this.SetSkill(SkillName.SpiritSpeak, 96.1, 105.3);
+
+            this.Fame = 18000;
+            this.Karma = -18000;
+
+            this.PackReg(3);
+            this.PackNecroReg(1, 10);
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public MasterMikael(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.15 )
+            c.DropItem( new DisintegratingThesisNotes() );
+
+            if ( Utility.RandomDouble() < 0.1 )
+            c.DropItem( new ParrotItem() );
+        }
+
+        /*public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }*/
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 2);
+            this.AddLoot(LootPack.MedScrolls, 2);
+            this.AddLoot(LootPack.HighScrolls, 2);
+        }
+
+        // TODO: Special move?
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/MasterTheophilus.cs

@@ -0,0 +1,110 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Master Theophilus corpse")]
+    public class MasterTheophilus : EvilMageLord
+    {
+        [Constructable]
+        public MasterTheophilus()
+        {
+            Name = "Master Theophilus";
+            Title = "the necromancer";
+            Hue = 0;
+
+            SetStr(137, 187);
+            SetDex(253, 301);
+            SetInt(393, 444);
+
+            SetHits(663, 876);
+
+            SetDamage(15, 20);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 55, 60);
+            SetResistance(ResistanceType.Fire, 50, 58);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 50, 60);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.Wrestling, 69.9, 105.3);
+            SetSkill(SkillName.Tactics, 113.0, 117.9);
+            SetSkill(SkillName.MagicResist, 127.0, 132.8);
+            SetSkill(SkillName.Magery, 138.1, 143.7);
+            SetSkill(SkillName.EvalInt, 125.6, 133.8);
+            SetSkill(SkillName.Necromancy, 125.6, 133.8);
+            SetSkill(SkillName.SpiritSpeak, 125.6, 133.8);
+            SetSkill(SkillName.Meditation, 128.8, 132.9);
+
+            Fame = 18000;
+            Karma = -18000;
+
+            AddItem(new Shoes(0x537));
+            AddItem(new Robe(0x452));
+
+            PackReg(7);
+            PackReg(7);
+            PackReg(8);
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.ParalyzingBlow);
+        }
+
+        public MasterTheophilus(Serial serial)
+            : base(serial)
+        {
+        }
+        public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.15 )
+            c.DropItem( new DisintegratingThesisNotes() );
+
+            if ( Paragon.ChestChance > Utility.RandomDouble() )
+            c.DropItem( new ParagonChest( Name, 5 ) );
+        }
+
+        /*public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }*/
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }       
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 3);
+            AddLoot(LootPack.MedScrolls, 4);
+            AddLoot(LootPack.HighScrolls, 4);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Meraktus.cs

@@ -0,0 +1,351 @@
+using System;
+using System.Collections;
+using Server.Engines.CannedEvil;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("the remains of Meraktus")]
+    public class Meraktus : BaseChampion
+    {
+        public override ChampionSkullType SkullType
+        {
+            get
+            {
+                return ChampionSkullType.Pain;
+            }
+        }
+
+        public override Type[] UniqueList
+        {
+            get
+            {
+                return new Type[] { typeof(Subdue) };
+            }
+        }
+        public override Type[] SharedList
+        {
+            get
+            {
+                return new Type[]
+                {
+                    typeof(RoyalGuardSurvivalKnife),
+                    typeof(TheMostKnowledgePerson),
+                    typeof(OblivionsNeedle)
+                };
+            }
+        }
+        public override Type[] DecorativeList
+        {
+            get
+            {
+                return new Type[]
+                {
+                    typeof(ArtifactLargeVase),
+                    typeof(ArtifactVase),
+                    typeof(MinotaurStatueDeed)
+                };
+            }
+        }
+
+        public override MonsterStatuetteType[] StatueTypes
+        {
+            get
+            {
+                return new MonsterStatuetteType[]
+                {
+                    MonsterStatuetteType.Minotaur
+                };
+            }
+        }
+
+        [Constructable]
+        public Meraktus()
+            : base(AIType.AI_Melee)
+        {
+            Name = "Meraktus";
+            Title = "the Tormented";
+            Body = 263;
+            BaseSoundID = 680;
+            Hue = 0x835;
+
+            SetStr(1419, 1438);
+            SetDex(309, 413);
+            SetInt(129, 131);
+
+            SetHits(4100, 4200);
+
+            SetDamage(16, 30);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 65, 90);
+            SetResistance(ResistanceType.Fire, 65, 70);
+            SetResistance(ResistanceType.Cold, 50, 60);
+            SetResistance(ResistanceType.Poison, 40, 60);
+            SetResistance(ResistanceType.Energy, 50, 55);
+
+            SetSkill(SkillName.Anatomy, 0);
+            SetSkill(SkillName.MagicResist, 107.0, 111.3);
+            SetSkill(SkillName.Tactics, 107.0, 117.0);
+            SetSkill(SkillName.Wrestling, 100.0, 105.0);
+
+            Fame = 70000;
+            Karma = -70000;
+
+            VirtualArmor = 28; // Don't know what it should be
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            NoKillAwards = true;
+
+            if (Core.ML)
+            {
+                PackResources(8);
+                PackTalismans(5);
+            }
+
+            Timer.DelayCall(TimeSpan.FromSeconds(1), new TimerCallback(SpawnTormented));
+
+            SetWeaponAbility(WeaponAbility.Dismount);
+        }
+
+        public virtual void PackResources(int amount)
+        {
+            for (int i = 0; i < amount; i++)
+                switch (Utility.Random(6))
+                {
+                    case 0:
+                        PackItem(new Blight());
+                        break;
+                    case 1:
+                        PackItem(new Scourge());
+                        break;
+                    case 2:
+                        PackItem(new Taint());
+                        break;
+                    case 3:
+                        PackItem(new Putrefaction());
+                        break;
+                    case 4:
+                        PackItem(new Corruption());
+                        break;
+                    case 5:
+                        PackItem(new Muculent());
+                        break;
+                }
+        }
+
+        public virtual void PackTalismans(int amount)
+        {
+            int count = Utility.Random(amount);
+
+            for (int i = 0; i < count; i++)
+                PackItem(new RandomTalisman());
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            if (Core.ML)
+            {
+                c.DropItem(new MalletAndChisel());
+
+                switch (Utility.Random(3))
+                {
+                    case 0:
+                        c.DropItem(new MinotaurHedge());
+                        break;
+                    case 1:
+                        c.DropItem(new BonePile());
+                        break;
+                    case 2:
+                        c.DropItem(new LightYarn());
+                        break;
+                }
+
+                if (Utility.RandomBool())
+                    c.DropItem(new TormentedChains());
+
+                if (Utility.RandomDouble() < 0.025)
+                    c.DropItem(new CrimsonCincture());
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            if (Core.ML)
+            {
+                AddLoot(LootPack.AosSuperBoss, 5);  // Need to verify
+            }
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x597;
+        }
+
+        public override int GetIdleSound()
+        {
+            return 0x596;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x599;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x59a;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x59c;
+        }
+
+        public override int Meat
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 10;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Regular;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Regular;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 3;
+            }
+        }
+        public override bool BardImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool Unprovokable
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool Uncalmable
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override void OnGaveMeleeAttack(Mobile defender)
+        {
+            base.OnGaveMeleeAttack(defender);
+            if (0.2 >= Utility.RandomDouble())
+                Earthquake();
+        }
+
+        public void Earthquake()
+        {
+            Map map = Map;
+            if (map == null)
+                return;
+            ArrayList targets = new ArrayList();
+            IPooledEnumerable eable = GetMobilesInRange(8);
+            foreach (Mobile m in eable)
+            {
+                if (m == this || !CanBeHarmful(m))
+                    continue;
+                if (m is BaseCreature && (((BaseCreature)m).Controlled || ((BaseCreature)m).Summoned || ((BaseCreature)m).Team != Team))
+                    targets.Add(m);
+                else if (m.Player)
+                    targets.Add(m);
+            }
+            eable.Free();
+            PlaySound(0x2F3);
+            for (int i = 0; i < targets.Count; ++i)
+            {
+                Mobile m = (Mobile)targets[i];
+                if (m != null && !m.Deleted && m is PlayerMobile)
+                {
+                    PlayerMobile pm = m as PlayerMobile;
+                    if (pm != null && pm.Mounted)
+                    {
+                        pm.SetMountBlock(BlockMountType.DismountRecovery, TimeSpan.FromSeconds(10), true);
+                    }
+                }
+                double damage = m.Hits * 0.6;//was .6
+                if (damage < 10.0)
+                    damage = 10.0;
+                else if (damage > 75.0)
+                    damage = 75.0;
+                DoHarmful(m);
+                AOS.Damage(m, this, (int)damage, 100, 0, 0, 0, 0);
+                if (m.Alive && m.Body.IsHuman && !m.Mounted)
+                    m.Animate(20, 7, 1, true, false, 0); // take hit
+            }
+        }
+
+        public Meraktus(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+
+        #region SpawnHelpers
+        public void SpawnTormented()
+        {
+            BaseCreature spawna = new TormentedMinotaur();
+            spawna.MoveToWorld(Location, Map);
+
+            BaseCreature spawnb = new TormentedMinotaur();
+            spawnb.MoveToWorld(Location, Map);
+
+            BaseCreature spawnc = new TormentedMinotaur();
+            spawnc.MoveToWorld(Location, Map);
+
+            BaseCreature spawnd = new TormentedMinotaur();
+            spawnd.MoveToWorld(Location, Map);
+        }
+        #endregion
+    }
+}

Scripts/Mobiles/Named/Miasma.cs

@@ -0,0 +1,119 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Miasma corpse")]
+    public class Miasma : Scorpion
+    {
+        [Constructable]
+        public Miasma()
+        {
+
+            Name = "Miasma";
+            Hue = 0x8FD;
+
+            SetStr(255, 847);
+            SetDex(145, 428);
+            SetInt(26, 380);
+
+            SetHits(272, 2000);
+            SetMana(5, 60);
+
+            SetDamage(20, 30);
+
+            SetDamageType(ResistanceType.Physical, 60);
+            SetDamageType(ResistanceType.Poison, 40);
+
+            SetResistance(ResistanceType.Physical, 50, 54);
+            SetResistance(ResistanceType.Fire, 40, 45);
+            SetResistance(ResistanceType.Cold, 50, 55);
+            SetResistance(ResistanceType.Poison, 70, 80);
+            SetResistance(ResistanceType.Energy, 40, 45);
+
+            SetSkill(SkillName.Wrestling, 64.9, 73.3);
+            SetSkill(SkillName.Tactics, 98.4, 110.6);
+            SetSkill(SkillName.MagicResist, 74.4, 77.7);
+            SetSkill(SkillName.Poisoning, 128.5, 143.6);
+
+            Fame = 21000;
+            Karma = -21000;
+
+            Tamable = false;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.MortalStrike);
+
+            ForceActiveSpeed = 0.3;
+            ForcePassiveSpeed = 0.6;
+        }
+
+        public Miasma(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Paragon.ChestChance > Utility.RandomDouble() )
+            c.DropItem( new ParagonChest( Name, 5 ) );
+
+            if ( Utility.RandomDouble() < 0.025 )
+            {
+                switch ( Utility.Random( 18 ) )
+                {
+                    case 0: c.DropItem( new MyrmidonGloves() ); break;
+                    case 1: c.DropItem( new MyrmidonGorget() ); break;
+                    case 2: c.DropItem( new MyrmidonLegs() ); break;
+                    case 3: c.DropItem( new MyrmidonArms() ); break;
+                    case 4: c.DropItem( new PaladinArms() ); break;
+                    case 5: c.DropItem( new PaladinGorget() ); break;
+                    case 6: c.DropItem( new LeafweaveLegs() ); break;
+                    case 7: c.DropItem( new DeathChest() ); break;
+                    case 8: c.DropItem( new DeathGloves() ); break;
+                    case 9: c.DropItem( new DeathLegs() ); break;
+                    case 10: c.DropItem( new GreymistGloves() ); break;
+                    case 11: c.DropItem( new GreymistArms() ); break;
+                    case 12: c.DropItem( new AssassinChest() ); break;
+                    case 13: c.DropItem( new AssassinArms() ); break;
+                    case 14: c.DropItem( new HunterGloves() ); break;
+                    case 15: c.DropItem( new HunterLegs() ); break;
+                    case 16: c.DropItem(new GreymistLegs()); break;
+                    case 17: c.DropItem(new MyrmidonChest()); break;
+                }
+            }
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }        
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Mistral.cs

@@ -0,0 +1,111 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a mistral corpse")]
+    public class Mistral : BaseCreature
+    {
+        [Constructable]
+        public Mistral()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Mistral";
+            this.Body = 13;
+            this.Hue = 924;
+            this.BaseSoundID = 263;
+
+            this.SetStr(134, 201);
+            this.SetDex(226, 238);
+            this.SetInt(126, 134);
+
+            this.SetHits(386, 609);
+
+            this.SetDamage(17, 20);  // Erica's
+
+            this.SetDamageType(ResistanceType.Energy, 20);
+            this.SetDamageType(ResistanceType.Cold, 40);
+            this.SetDamageType(ResistanceType.Physical, 40);
+
+            this.SetResistance(ResistanceType.Physical, 55, 64);
+            this.SetResistance(ResistanceType.Fire, 36, 40);
+            this.SetResistance(ResistanceType.Cold, 33, 39);
+            this.SetResistance(ResistanceType.Poison, 30, 39);
+            this.SetResistance(ResistanceType.Energy, 49, 53);
+
+            this.SetSkill(SkillName.EvalInt, 96.2, 97.8);
+            this.SetSkill(SkillName.Magery, 100.8, 112.9);
+            this.SetSkill(SkillName.MagicResist, 106.2, 111.2);
+            this.SetSkill(SkillName.Tactics, 110.2, 117.1);
+            this.SetSkill(SkillName.Wrestling, 100.3, 104.0);
+
+            this.Fame = 4500;
+            this.Karma = -4500;
+
+            this.VirtualArmor = 40;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get { return true; }
+        }
+
+        public Mistral(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Average);
+            this.AddLoot(LootPack.Meager);
+            this.AddLoot(LootPack.LowScrolls);
+            this.AddLoot(LootPack.MedScrolls);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/MorgBergen.cs

@@ -0,0 +1,136 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    public class MorgBergen : BaseCreature
+    {
+        [Constructable]
+        public MorgBergen()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Title = "the Cursed";
+
+            this.Hue = 0x8596;
+            this.Body = 0x190;
+            this.Name = "Morg Bergen";
+
+            this.AddItem(new ShortPants(0x59C));
+
+            Bardiche bardiche = new Bardiche();
+            LeatherGloves gloves = new LeatherGloves();
+            LeatherArms arms = new LeatherArms();
+
+            bardiche.Hue = 0x96F;
+            bardiche.Movable = false;
+            gloves.Hue = 0x96F;
+            arms.Hue = 0x96F;
+
+            this.AddItem(bardiche);
+            this.AddItem(gloves);
+            this.AddItem(arms);
+
+            this.SetStr(111, 120);
+            this.SetDex(111, 120);
+            this.SetInt(51, 60);
+
+            this.SetHits(180, 207);
+            this.SetMana(0);
+
+            this.SetDamage(9, 17);
+
+            this.SetDamageType(ResistanceType.Physical, 40);
+            this.SetDamageType(ResistanceType.Cold, 60);
+
+            this.SetResistance(ResistanceType.Physical, 35, 45);
+            this.SetResistance(ResistanceType.Fire, 25, 30);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 25, 35);
+            this.SetResistance(ResistanceType.Energy, 25, 35);
+
+            this.SetSkill(SkillName.Swords, 90.1, 100.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 80.1, 90.0);
+            this.SetSkill(SkillName.Anatomy, 90.1, 100.0);
+
+            this.Fame = 5000;
+            this.Karma = -1000;
+        }
+
+        public MorgBergen(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ClickTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool ShowFameTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool DeleteCorpseOnDeath
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int GetIdleSound()
+        {
+            return 0x1CE;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x263;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x1D1;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x25E;
+        }
+
+        public override bool OnBeforeDeath()
+        {
+            Gold gold = new Gold(Utility.RandomMinMax(190, 230));
+            gold.MoveToWorld(this.Location, this.Map);
+
+            Effects.SendLocationEffect(this.Location, this.Map, 0x376A, 10, 1);
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/MougGuur.cs

@@ -0,0 +1,62 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Moug-Guur corpse")]
+    public class MougGuur : Ettin
+    {
+        [Constructable]
+        public MougGuur()
+        {
+            this.Name = "Moug-Guur";
+
+            this.SetStr(556, 575);
+            this.SetDex(84, 94);
+            this.SetInt(59, 73);
+
+            this.SetHits(400, 415);
+
+            this.SetDamage(12, 20);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 61, 65);
+            this.SetResistance(ResistanceType.Fire, 16, 19);
+            this.SetResistance(ResistanceType.Cold, 41, 46);
+            this.SetResistance(ResistanceType.Poison, 21, 24);
+            this.SetResistance(ResistanceType.Energy, 19, 25);
+
+            this.SetSkill(SkillName.MagicResist, 70.2, 75.0);
+            this.SetSkill(SkillName.Tactics, 80.8, 81.7);
+            this.SetSkill(SkillName.Wrestling, 93.9, 99.4);
+
+            this.Fame = 3000;
+            this.Karma = -3000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public MougGuur(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/NightTerror.cs

@@ -0,0 +1,81 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a night terror corpse")]
+    public class NightTerror : BaseCreature
+    {
+        [Constructable]
+        public NightTerror()
+            : base(AIType.AI_NecroMage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Night Terror";
+            this.Body = 0x30c;
+            this.Hue = 2963;
+
+            this.SetStr(385, 467);
+            this.SetDex(40, 70);
+            this.SetInt(600, 800);
+
+            this.SetHits(50000);
+
+            this.SetDamage(10, 23);
+
+            this.SetDamageType(ResistanceType.Physical, 20);
+            this.SetDamageType(ResistanceType.Fire, 20);
+            this.SetDamageType(ResistanceType.Cold, 20);
+            this.SetDamageType(ResistanceType.Poison, 20);
+            this.SetDamageType(ResistanceType.Energy, 20);
+
+            this.SetResistance(ResistanceType.Physical, 60, 70);
+            this.SetResistance(ResistanceType.Fire, 100);
+            this.SetResistance(ResistanceType.Cold, 80, 90);
+            this.SetResistance(ResistanceType.Poison, 100);
+            this.SetResistance(ResistanceType.Energy, 70, 80);
+
+            this.SetSkill(SkillName.MagicResist, 90.0, 100.0);
+            this.SetSkill(SkillName.Tactics, 120.0);
+            this.SetSkill(SkillName.Wrestling, 110.0);
+            this.SetSkill(SkillName.Poisoning, 120.0);
+            this.SetSkill(SkillName.DetectHidden, 120.0);
+            this.SetSkill(SkillName.Parry, 60.0, 70.0);
+            this.SetSkill(SkillName.Magery, 100.0);
+            this.SetSkill(SkillName.EvalInt, 110.0);
+            this.SetSkill(SkillName.Necromancy, 120.0);
+            this.SetSkill(SkillName.SpiritSpeak, 120.0);
+
+            this.Fame = 8000;
+            this.Karma = -8000;
+
+            this.VirtualArmor = 54;
+        }
+
+        public NightTerror(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override int TreasureMapLevel { get { return 4; } }
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+        public override Poison HitPoison { get { return Poison.Lethal; } }
+        public override double HitPoisonChance { get { return 0.75; } }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.FilthyRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/PixieRenowned.cs

@@ -0,0 +1,124 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Pixie [Renowned] corpse")]
+    public class PixieRenowned : BaseRenowned
+    {
+        [Constructable]
+        public PixieRenowned()
+            : base(AIType.AI_Mage)
+        {
+            this.Name = "Pixie";
+            this.Title = "[Renowned]";
+            this.Body = 128;
+            this.BaseSoundID = 0x467;
+
+            this.SetStr(-350, 380);
+            this.SetDex(450, 600);
+            this.SetInt(700, 8500);
+
+            this.SetHits(9100, 9200);
+            this.SetStam(450, 600);
+            this.SetMana(700, 800);
+
+            this.SetDamage(9, 15);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 70, 90);
+            this.SetResistance(ResistanceType.Fire, 60, 70);
+            this.SetResistance(ResistanceType.Cold, 70, 80);
+            this.SetResistance(ResistanceType.Poison, 60, 70);
+            this.SetResistance(ResistanceType.Energy, 60, 70);
+
+            this.SetSkill(SkillName.EvalInt, 100.0, 100.0);
+            this.SetSkill(SkillName.Magery, 90.1, 110.0);
+            this.SetSkill(SkillName.Meditation, 100.0, 100.0);
+            this.SetSkill(SkillName.MagicResist, 110.5, 150.0);
+            this.SetSkill(SkillName.Tactics, 100.1, 120.0);
+            this.SetSkill(SkillName.Wrestling, 100.1, 120.0);
+
+            this.Fame = 7000;
+            this.Karma = 7000;
+
+            this.VirtualArmor = 100;
+
+            if (0.02 > Utility.RandomDouble())
+                this.PackStatue();				
+        }
+
+        public PixieRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(DemonHuntersStandard), typeof(DragonJadeEarrings) };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(PillarOfStrength), typeof(SwordOfShatteredHopes) };
+            }
+        }
+        public override bool InitialInnocent
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Spined;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override OppositionGroup OppositionGroup
+        {
+            get
+            {
+                return OppositionGroup.FeyAndUndead;
+            }
+        }
+        public override void GenerateLoot()
+        {
+			AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Putrefier.cs

@@ -0,0 +1,179 @@
+using System;
+using Server.Items;
+using System.Collections.Generic;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Putrefier corpse")]
+    public class Putrefier : Balron
+    {
+        [Constructable]
+        public Putrefier()
+        {
+            this.Name = "Putrefier";
+            this.Hue = 63;
+
+            this.SetStr(1057, 1400);
+            this.SetDex(232, 560);
+            this.SetInt(201, 440);
+
+            this.SetHits(3010, 4092);
+
+            this.SetDamage(27, 34);
+
+            this.SetDamageType(ResistanceType.Physical, 50);
+            this.SetDamageType(ResistanceType.Fire, 0);
+            this.SetDamageType(ResistanceType.Poison, 50);
+            this.SetDamageType(ResistanceType.Energy, 0);
+
+            this.SetResistance(ResistanceType.Physical, 65, 80);
+            this.SetResistance(ResistanceType.Fire, 65, 80);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 100);
+            this.SetResistance(ResistanceType.Energy, 40, 50);
+
+            this.SetSkill(SkillName.Wrestling, 111.2, 128.0);
+            this.SetSkill(SkillName.Tactics, 115.2, 125.2);
+            this.SetSkill(SkillName.MagicResist, 143.4, 170.0);
+            this.SetSkill(SkillName.Anatomy, 44.6, 67.0);
+            this.SetSkill(SkillName.Magery, 117.6, 118.8);
+            this.SetSkill(SkillName.EvalInt, 113.0, 128.8);
+            this.SetSkill(SkillName.Meditation, 41.4, 85.0);
+            this.SetSkill(SkillName.Poisoning, 45.0, 50.0);
+
+            this.Fame = 24000;
+            this.Karma = -24000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 2); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public Putrefier(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            c.DropItem( new SpleenOfThePutrefier() );
+
+            if ( Utility.RandomDouble() < 0.6 )
+            c.DropItem( new ParrotItem() );
+
+            if ( Paragon.ChestChance > Utility.RandomDouble() )
+            c.DropItem( new ParagonChest( Name, 5 ) );
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison HitPoison
+        {
+            get
+            {
+                return Poison.Deadly;
+            }
+        }// Becomes Lethal with Paragon bonus   
+        public override void OnDamagedBySpell(Mobile attacker)
+        {
+            base.OnDamagedBySpell(attacker);
+
+            this.DoCounter(attacker);
+        }
+
+        public override void OnGotMeleeAttack(Mobile attacker)
+        {
+            base.OnGotMeleeAttack(attacker);
+
+            this.DoCounter(attacker);
+        }
+
+        private void DoCounter(Mobile attacker)
+        {
+            if (this.Map == null || (attacker is BaseCreature && ((BaseCreature)attacker).BardProvoked))
+                return;
+
+            if (0.2 > Utility.RandomDouble())
+            {
+                /* Counterattack with Hit Poison Area
+                * 20-25 damage, unresistable
+                * Lethal poison, 100% of the time
+                * Particle effect: Type: "2" From: "0x4061A107" To: "0x0" ItemId: "0x36BD" ItemIdName: "explosion" FromLocation: "(296 615, 17)" ToLocation: "(296 615, 17)" Speed: "1" Duration: "10" FixedDirection: "True" Explode: "False" Hue: "0xA6" RenderMode: "0x0" Effect: "0x1F78" ExplodeEffect: "0x1" ExplodeSound: "0x0" Serial: "0x4061A107" Layer: "255" Unknown: "0x0"
+                * Doesn't work on provoked monsters
+                */
+                Mobile target = null;
+
+                if (attacker is BaseCreature)
+                {
+                    Mobile m = ((BaseCreature)attacker).GetMaster();
+
+                    if (m != null)
+                        target = m;
+                }
+
+                if (target == null || !target.InRange(this, 25))
+                    target = attacker;
+
+                this.Animate(10, 4, 1, true, false, 0);
+
+                List<Mobile> targets = new List<Mobile>();
+                IPooledEnumerable eable = target.GetMobilesInRange(8);
+
+                foreach (Mobile m in eable)
+                {
+                    if (m == this || !this.CanBeHarmful(m))
+                        continue;
+
+                    if (m is BaseCreature && (((BaseCreature)m).Controlled || ((BaseCreature)m).Summoned || ((BaseCreature)m).Team != this.Team))
+                        targets.Add(m);
+                    else if (m.Player)
+                        targets.Add(m);
+                }
+                eable.Free();
+
+                for (int i = 0; i < targets.Count; ++i)
+                {
+                    Mobile m = (Mobile)targets[i];
+
+                    this.DoHarmful(m);
+
+                    AOS.Damage(m, this, Utility.RandomMinMax(20, 25), true, 0, 0, 0, 100, 0);
+
+                    m.FixedParticles(0x36BD, 1, 10, 0x1F78, 0xA6, 0, (EffectLayer)255);
+                    m.ApplyPoison(this, Poison.Lethal);
+                }
+
+                targets.Clear();
+                targets.TrimExcess();
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 3);
+            this.AddLoot(LootPack.MedScrolls, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Pyre.cs

@@ -0,0 +1,91 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Pyre corpse")]
+    public class Pyre : Phoenix
+    {
+        [Constructable]
+        public Pyre()
+        {
+            Name = "Pyre";
+            Hue = 0x489;
+
+            FightMode = FightMode.Closest;
+
+            SetStr(605, 611);
+            SetDex(391, 519);
+            SetInt(669, 818);
+
+            SetHits(1783, 1939);
+
+            SetDamage(30);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Fire, 50);
+
+            SetResistance(ResistanceType.Physical, 65);
+            SetResistance(ResistanceType.Fire, 72, 75);
+            SetResistance(ResistanceType.Poison, 36, 41);
+            SetResistance(ResistanceType.Energy, 50, 51);
+
+            SetSkill(SkillName.Wrestling, 121.9, 130.6);
+            SetSkill(SkillName.Tactics, 114.4, 117.4);
+            SetSkill(SkillName.MagicResist, 147.7, 153.0);
+            SetSkill(SkillName.Poisoning, 122.8, 124.0);
+            SetSkill(SkillName.Magery, 121.8, 127.8);
+            SetSkill(SkillName.EvalInt, 103.6, 117.0);
+            SetSkill(SkillName.Meditation, 100.0, 110.0);
+
+            Fame = 21000;
+            Karma = -21000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.BleedAttack);
+            SetWeaponAbility(WeaponAbility.ParalyzingBlow);
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get { return true; }
+        }
+
+        public Pyre(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Paragon.ChestChance > Utility.RandomDouble() )
+            c.DropItem( new ParagonChest( Name, 5 ) );
+
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/RakktaviRenowned.cs

@@ -0,0 +1,122 @@
+using System;
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Rakktavi [Renowned] corpse")]
+    public class RakktaviRenowned : BaseRenowned
+    {
+        [Constructable]
+        public RakktaviRenowned()
+            : base(AIType.AI_Archer)
+        {
+            this.Name = "Rakktavi";
+            this.Title = "[Renowned]";
+            this.Body = 0x8E;
+            this.BaseSoundID = 437;
+
+            this.SetStr(119);
+            this.SetDex(279);
+            this.SetInt(327);
+
+            this.SetHits(50000);
+			this.SetMana(327);
+			this.SetStam(279);
+
+            this.SetDamage(8, 10);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 20, 30);
+            this.SetResistance(ResistanceType.Fire, 10, 25);
+            this.SetResistance(ResistanceType.Cold, 30, 40);
+            this.SetResistance(ResistanceType.Poison, 10, 20);
+            this.SetResistance(ResistanceType.Energy, 10, 20);
+
+            this.SetSkill(SkillName.Anatomy, 0);
+            this.SetSkill(SkillName.Archery, 80.1, 90.0);
+            this.SetSkill(SkillName.MagicResist, 66.0);
+            this.SetSkill(SkillName.Tactics, 68.1);
+            this.SetSkill(SkillName.Wrestling, 85.5);
+
+            this.Fame = 6500;
+            this.Karma = -6500;
+
+            this.VirtualArmor = 56;
+			
+            this.AddItem(new Bow());
+            this.PackItem(new Arrow(Utility.RandomMinMax(10, 30)));
+        }
+
+        public RakktaviRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(CavalrysFolly), typeof(TorcOfTheGuardians) };
+            }
+        }
+        public override InhumanSpeech SpeechType
+        {
+            get
+            {
+                return InhumanSpeech.Ratman;
+            }
+        }
+        public override bool CanRummageCorpses
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Spined;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/RedDeath.cs

@@ -0,0 +1,101 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Red Death corpse")]
+    public class RedDeath : SkeletalMount
+    {
+        [Constructable]
+        public RedDeath()
+            : base("Red Death")
+        {
+            Hue = 0x21;
+            BaseSoundID = 0x1C3;
+
+            AI = AIType.AI_Melee;
+            FightMode = FightMode.Closest;
+
+            SetStr(319, 324);
+            SetDex(241, 244);
+            SetInt(242, 255);
+
+            SetHits(1540, 1605);
+
+            SetDamage(25, 29);
+
+            SetDamageType(ResistanceType.Physical, 25);
+            SetDamageType(ResistanceType.Fire, 75);
+            SetDamageType(ResistanceType.Cold, 0);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 90);
+            SetResistance(ResistanceType.Cold, 0);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 0);
+
+            SetSkill(SkillName.Wrestling, 121.4, 143.7);
+            SetSkill(SkillName.Tactics, 120.9, 142.2);
+            SetSkill(SkillName.MagicResist, 120.1, 142.3);
+            SetSkill(SkillName.Anatomy, 120.2, 144.0);
+
+            Fame = 28000;
+            Karma = -28000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.WhirlwindAttack);
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public RedDeath(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 3);
+            AddLoot(LootPack.MedScrolls, 2);
+            AddLoot(LootPack.HighScrolls, 2);
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            c.DropItem(new ResolvesBridle());
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Rend.cs

@@ -0,0 +1,84 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Rend corpse")]
+    public class Rend : Reptalon
+    {
+        [Constructable]
+        public Rend()
+        {
+
+            Name = "Rend";
+            Hue = 0x455;
+
+            SetStr(1261, 1284);
+            SetDex(363, 384);
+            SetInt(601, 642);
+
+            SetHits(5176, 6100);
+
+            SetDamage(26, 33);
+
+            SetDamageType(ResistanceType.Physical, 100);
+            SetDamageType(ResistanceType.Poison, 0);
+            SetDamageType(ResistanceType.Energy, 0);
+
+            SetResistance(ResistanceType.Physical, 75, 85);
+            SetResistance(ResistanceType.Fire, 81, 94);
+            SetResistance(ResistanceType.Cold, 46, 55);
+            SetResistance(ResistanceType.Poison, 35, 44);
+            SetResistance(ResistanceType.Energy, 45, 52);
+
+            SetSkill(SkillName.Wrestling, 136.3, 150.3);
+            SetSkill(SkillName.Tactics, 133.4, 141.4);
+            SetSkill(SkillName.MagicResist, 90.9, 110.0);
+            SetSkill(SkillName.Anatomy, 66.6, 72.0);
+
+            Fame = 21000;
+            Karma = -21000;
+
+            Tamable = false;
+
+            SetSpecialAbility(SpecialAbility.GraspingClaw);
+            SetWeaponAbility(WeaponAbility.BleedAttack);
+            SetWeaponAbility(WeaponAbility.ParalyzingBlow);
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public Rend(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override bool GivesMLMinorArtifact{get{ return true; } }
+		
+		public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Paragon.ChestChance > Utility.RandomDouble() )
+            c.DropItem( new ParagonChest( Name, 5 ) );
+        }
+        
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Saliva.cs

@@ -0,0 +1,76 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a saliva corpse")]
+    public class Saliva : Harpy
+    {
+        [Constructable]
+        public Saliva()
+            : base()
+        {
+            this.Name = "a saliva";
+            this.Hue = 0x11E;
+
+            this.SetStr(136, 206);
+            this.SetDex(123, 222);
+            this.SetInt(118, 127);
+
+            this.SetHits(409, 842);
+
+            this.SetDamage(19, 28);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 46, 47);
+            this.SetResistance(ResistanceType.Fire, 32, 40);
+            this.SetResistance(ResistanceType.Cold, 34, 49);
+            this.SetResistance(ResistanceType.Poison, 40, 48);
+            this.SetResistance(ResistanceType.Energy, 35, 39);
+
+            this.SetSkill(SkillName.Wrestling, 106.4, 128.8);
+            this.SetSkill(SkillName.Tactics, 129.9, 141.0);
+            this.SetSkill(SkillName.MagicResist, 84.3, 90.1);
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public Saliva(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.AosUltraRich, 2);
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);		
+			
+            c.DropItem(new SalivasFeather());
+			
+            if (Utility.RandomDouble() < 0.1)				
+                c.DropItem(new ParrotItem());
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+			
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/ShadowKnight.cs

@@ -0,0 +1,241 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a shadow knight corpse")]
+    public class ShadowKnight : BaseCreature
+    {
+        public override bool CanStealth { get { return true; } }
+
+        private Timer m_SoundTimer;
+        private bool m_HasTeleportedAway;
+        [Constructable]
+        public ShadowKnight()
+            : base(AIType.AI_NecroMage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = NameList.RandomName("shadow knight");
+            Title = "the Shadow Knight";
+            Body = 311;
+
+            SetStr(250);
+            SetDex(100);
+            SetInt(100, 120);
+
+            SetHits(5000);
+
+            SetDamage(20, 30);
+
+            SetDamageType(ResistanceType.Physical, 60);
+            SetDamageType(ResistanceType.Cold, 40);
+
+            SetResistance(ResistanceType.Physical, 90);
+            SetResistance(ResistanceType.Fire, 65);
+            SetResistance(ResistanceType.Cold, 75);
+            SetResistance(ResistanceType.Poison, 75);
+            SetResistance(ResistanceType.Energy, 55);
+
+            SetSkill(SkillName.Wrestling, 100.0);
+            SetSkill(SkillName.Tactics, 100.0);
+            SetSkill(SkillName.MagicResist, 120.0);
+            SetSkill(SkillName.Poisoning, 75.0, 85.0);
+            SetSkill(SkillName.DetectHidden, 100.0);
+            SetSkill(SkillName.Hiding, 100.0);
+            SetSkill(SkillName.Magery, 100.0);
+            SetSkill(SkillName.EvalInt, 100.0);
+            SetSkill(SkillName.Meditation, 100.0);
+            SetSkill(SkillName.Necromancy, 110.0);
+            SetSkill(SkillName.SpiritSpeak, 110.0);
+            SetSkill(SkillName.Focus, 120.0);
+
+            Fame = 25000;
+            Karma = -25000;
+
+            VirtualArmor = 54;
+
+            SetWeaponAbility(WeaponAbility.ConcussionBlow);
+            SetWeaponAbility(WeaponAbility.CrushingBlow);
+        }
+
+        public ShadowKnight(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override void OnDamage(int amount, Mobile from, bool willKill)
+		{
+			RevealingAction();
+			base.OnDamage(amount, from, willKill);
+		}
+
+		public override void OnDamagedBySpell(Mobile from)
+		{
+			RevealingAction();
+			base.OnDamagedBySpell(from);
+		}
+
+        public override bool IgnoreYoungProtection
+        {
+            get
+            {
+                return Core.ML;
+            }
+        }
+
+        public override bool CanFlee { get { return false; } }
+        public override TribeType Tribe { get { return TribeType.Undead; } }
+
+        public override OppositionGroup OppositionGroup
+        {
+            get
+            {
+                return OppositionGroup.FeyAndUndead;
+            }
+        }
+        public override bool BardImmune
+        {
+            get
+            {
+                return !Core.SE;
+            }
+        }
+        public override bool Unprovokable
+        {
+            get
+            {
+                return Core.SE;
+            }
+        }
+        public override bool AreaPeaceImmune
+        {
+            get
+            {
+                return Core.SE;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 1;
+            }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override int GetIdleSound()
+        {
+            return 0x2CE;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x2C1;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x2D1;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x2C8;
+        }
+
+        public override void OnCombatantChange()
+        {
+            base.OnCombatantChange();
+
+            if (Hidden && Combatant != null)
+                Combatant = null;
+        }
+
+        public virtual void SendTrackingSound()
+        {
+            if (Hidden)
+            {
+                Effects.PlaySound(Location, Map, 0x2C8);
+                Combatant = null;
+            }
+            else
+            {
+                Frozen = false;
+
+                if (m_SoundTimer != null)
+                    m_SoundTimer.Stop();
+
+                m_SoundTimer = null;
+            }
+        }
+
+        public override void OnThink()
+        {
+            if (!m_HasTeleportedAway && Hits < (HitsMax / 2))
+            {
+                Map map = Map;
+
+                if (map != null)
+                {
+                    // try 10 times to find a teleport spot
+                    for (int i = 0; i < 10; ++i)
+                    {
+                        int x = X + (Utility.RandomMinMax(5, 10) * (Utility.RandomBool() ? 1 : -1));
+                        int y = Y + (Utility.RandomMinMax(5, 10) * (Utility.RandomBool() ? 1 : -1));
+                        int z = Z;
+
+                        if (!map.CanFit(x, y, z, 16, false, false))
+                            continue;
+
+                        Point3D from = Location;
+                        Point3D to = new Point3D(x, y, z);
+
+                        if (!InLOS(to))
+                            continue;
+
+                        Location = to;
+                        ProcessDelta();
+                        Hidden = true;
+                        Combatant = null;
+
+                        Effects.SendLocationParticles(EffectItem.Create(from, map, EffectItem.DefaultDuration), 0x3728, 10, 10, 2023);
+                        Effects.SendLocationParticles(EffectItem.Create(to, map, EffectItem.DefaultDuration), 0x3728, 10, 10, 5023);
+
+                        Effects.PlaySound(to, map, 0x1FE);
+
+                        m_HasTeleportedAway = true;
+                        m_SoundTimer = Timer.DelayCall(TimeSpan.FromSeconds(5.0), TimeSpan.FromSeconds(2.5), new TimerCallback(SendTrackingSound));
+
+                        Frozen = true;
+
+                        break;
+                    }
+                }
+            }
+
+            base.OnThink();
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Silk.cs

@@ -0,0 +1,81 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Silk corpse")]
+    public class Silk : GiantBlackWidow
+    {
+        [Constructable]
+        public Silk()
+        {
+            Name = "Silk";
+            Hue = 0x47E;
+
+            SetStr(80, 131);
+            SetDex(126, 156);
+            SetInt(63, 102);
+
+            SetHits(279, 378);
+            SetStam(126, 156);
+            SetMana(63, 102);
+
+            SetDamage(15, 22);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 40, 50);
+            SetResistance(ResistanceType.Fire, 30, 39);
+            SetResistance(ResistanceType.Cold, 30, 40);
+            SetResistance(ResistanceType.Poison, 70, 76);
+            SetResistance(ResistanceType.Energy, 30, 40);
+
+            SetSkill(SkillName.Wrestling, 114.1, 123.7);
+            SetSkill(SkillName.Tactics, 102.6, 118.3);
+            SetSkill(SkillName.MagicResist, 78.6, 94.8);
+            SetSkill(SkillName.Anatomy, 81.3, 105.7);
+            SetSkill(SkillName.Poisoning, 106.0, 119.2);
+
+            Fame = 18900;
+            Karma = -18900;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.ParalyzingBlow);
+        }
+
+        public Silk(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/SirPatrick.cs

@@ -0,0 +1,93 @@
+using System;
+using System.Collections.Generic;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Sir Patrick corpse")]
+    public class SirPatrick : SkeletalKnight
+    {
+        [Constructable]
+        public SirPatrick()
+        {
+            Name = "Sir Patrick";
+            Hue = 0x47E;
+
+            SetStr(208, 319);
+            SetDex(98, 132);
+            SetInt(45, 91);
+
+            SetHits(616, 884);
+
+            SetDamage(15, 25);
+
+            SetDamageType(ResistanceType.Physical, 40);
+            SetDamageType(ResistanceType.Cold, 60);
+
+            SetResistance(ResistanceType.Physical, 55, 62);
+            SetResistance(ResistanceType.Fire, 40, 48);
+            SetResistance(ResistanceType.Cold, 71, 80);
+            SetResistance(ResistanceType.Poison, 40, 50);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.Wrestling, 126.3, 136.5);
+            SetSkill(SkillName.Tactics, 128.5, 143.8);
+            SetSkill(SkillName.MagicResist, 102.8, 117.9);
+            SetSkill(SkillName.Anatomy, 127.5, 137.2);
+
+            Fame = 18000;
+            Karma = -18000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.LifeDrain);
+        }
+
+        public SirPatrick(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override bool CanBeParagon { get { return false; } }
+
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.15 )
+            c.DropItem( new DisintegratingThesisNotes() );
+
+            if ( Utility.RandomDouble() < 0.05 )
+            c.DropItem( new AssassinChest() );
+        }
+
+        /*public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }*/
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/SkeletalDragonRenowned.cs

@@ -0,0 +1,144 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Skeletal Dragon [Renowned] corpse")]  
+    public class SkeletalDragonRenowned : BaseRenowned
+    {
+        [Constructable]
+        public SkeletalDragonRenowned()
+            : base(AIType.AI_Mage)
+        {
+            Name = "Skeletal Dragon";
+            Title = "[Renowned]";
+            Body = 104;
+            BaseSoundID = 0x488;
+
+            Hue = 906;
+
+            SetStr(898, 1030);
+            SetDex(100, 200);
+            SetInt(488, 620);
+
+            SetHits(558, 599);
+
+            SetDamage(29, 35);
+
+            SetDamageType(ResistanceType.Physical, 75);
+            SetDamageType(ResistanceType.Fire, 25);
+
+            SetResistance(ResistanceType.Physical, 75, 80);
+            SetResistance(ResistanceType.Fire, 40, 60);
+            SetResistance(ResistanceType.Cold, 40, 60);
+            SetResistance(ResistanceType.Poison, 70, 80);
+            SetResistance(ResistanceType.Energy, 40, 60);
+
+            SetSkill(SkillName.EvalInt, 80.1, 100.0);
+            SetSkill(SkillName.Magery, 80.1, 100.0);
+            SetSkill(SkillName.MagicResist, 100.3, 130.0);
+            SetSkill(SkillName.Tactics, 97.6, 100.0);
+            SetSkill(SkillName.Wrestling, 97.6, 100.0);
+
+            Fame = 22500;
+            Karma = -22500;
+
+            VirtualArmor = 80;
+
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public SkeletalDragonRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(AxeOfAbandon), typeof(DemonBridleRing), typeof(VoidInfusedKilt), typeof(BladeOfBattle) };
+            }
+        }
+        public override bool ReacquireOnMovement
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override double BonusPetDamageScalar
+        {
+            get
+            {
+                return (Core.SE) ? 3.0 : 1.0;
+            }
+        }
+        // TODO: Undead summoning?
+        public override bool AutoDispel
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 19;
+            }
+        }// where's it hiding these? :)
+        public override int Hides
+        {
+            get
+            {
+                return 20;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Barbed;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Rich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Spite.cs

@@ -0,0 +1,96 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Spite corpse")]
+    public class Spite : Changeling
+    {
+        [Constructable]
+        public Spite()
+        {
+            Hue = DefaultHue;
+
+            SetStr(53, 214);
+            SetDex(243, 367);
+            SetInt(369, 586);
+
+            SetHits(1013, 1052);
+            SetStam(243, 367);
+            SetMana(369, 586);
+
+            SetDamage(14, 20);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 85, 90);
+            SetResistance(ResistanceType.Fire, 41, 46);
+            SetResistance(ResistanceType.Cold, 40, 44);
+            SetResistance(ResistanceType.Poison, 42, 46);
+            SetResistance(ResistanceType.Energy, 45, 47);
+
+            SetSkill(SkillName.Wrestling, 12.8, 16.7);
+            SetSkill(SkillName.Tactics, 102.6, 131.0);
+            SetSkill(SkillName.MagicResist, 141.2, 161.6);
+            SetSkill(SkillName.Magery, 108.4, 119.2);
+            SetSkill(SkillName.EvalInt, 108.4, 120.0);
+            SetSkill(SkillName.Meditation, 109.2, 120.0);
+            SetSkill(SkillName.Spellweaving, 120.0);
+
+            Fame = 21000;
+            Karma = -21000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.ManaDrain);
+        }
+
+        public Spite(Serial serial)
+            : base(serial)
+        {
+        }
+		public override bool CanBeParagon { get { return false; } }
+        public override string DefaultName
+        {
+            get
+            {
+                return "Spite";
+            }
+        }
+        public override int DefaultHue
+        {
+            get
+            {
+                return 0x21;
+            }
+        }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Swoop.cs

@@ -0,0 +1,137 @@
+using System;
+using System.Collections;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Swoop corpse")]
+    public class Swoop : Eagle
+    {
+        [Constructable]
+        public Swoop()
+        {
+
+            Name = "Swoop";
+            Hue = 0xE0;
+
+            AI = AIType.AI_Melee;
+
+            SetStr(100, 150);
+            SetDex(400, 480);
+            SetInt(75, 90);
+
+            SetHits(1350, 1550);
+
+            SetDamage(20, 30);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 75, 90);
+            SetResistance(ResistanceType.Fire, 60, 70);
+            SetResistance(ResistanceType.Cold, 70, 85);
+            SetResistance(ResistanceType.Poison, 55, 60);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.Wrestling, 120.0, 140.0);
+            SetSkill(SkillName.Tactics, 120.0, 140.0);
+            SetSkill(SkillName.MagicResist, 95.0, 105.0);
+
+            Fame = 18000;
+            Karma = 0;
+
+            PackReg(4);
+
+            Tamable = false;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.GraspingClaw);
+        }
+
+		public override bool CanBeParagon { get { return false; } }
+
+        public override void OnDeath( Container c )
+        {
+            base.OnDeath( c );
+
+            if ( Utility.RandomDouble() < 0.025 )
+            {
+                switch ( Utility.Random( 20 ) )
+                {
+                    case 0: c.DropItem( new AssassinChest() ); break;
+                    case 1: c.DropItem( new AssassinArms() ); break;
+                    case 2: c.DropItem( new DeathChest() ); break;
+                    case 3: c.DropItem( new MyrmidonArms() ); break;
+                    case 4: c.DropItem( new MyrmidonLegs() ); break;
+                    case 5: c.DropItem( new MyrmidonGorget() ); break;
+                    case 6: c.DropItem( new LeafweaveGloves() ); break;
+                    case 7: c.DropItem( new LeafweaveLegs() ); break;
+                    case 8: c.DropItem( new LeafweavePauldrons() ); break;
+                    case 9: c.DropItem( new PaladinGloves() ); break;
+                    case 10: c.DropItem( new PaladinGorget() ); break;
+                    case 11: c.DropItem( new PaladinArms() ); break;
+                    case 12: c.DropItem( new HunterArms() ); break;
+                    case 13: c.DropItem( new HunterGloves() ); break;
+                    case 14: c.DropItem( new HunterLegs() ); break;
+                    case 15: c.DropItem( new HunterChest() ); break;
+                    case 16: c.DropItem( new GreymistArms() ); break;
+                    case 17: c.DropItem( new GreymistGloves() ); break;
+                    case 18: c.DropItem(new GreymistLegs()); break;
+                    case 19: c.DropItem(new MyrmidonChest()); break;
+                }
+            }
+
+            if ( Utility.RandomDouble() < 0.1 )
+            c.DropItem( new ParrotItem() );
+        }
+        
+        public Swoop(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool CanFly
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Feathers
+        {
+            get
+            {
+                return 72;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich, 2);
+            AddLoot(LootPack.HighScrolls);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Szavetra.cs

@@ -0,0 +1,70 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a Szavetra corpse")]
+    public class Szavetra : Succubus
+    {
+        [Constructable]
+        public Szavetra()
+        {
+            Name = "Szavetra";
+
+            SetStr(627, 655);
+            SetDex(164, 193);
+            SetInt(566, 595);
+
+            SetHits(312, 415);
+
+            SetDamage(20, 30);
+
+            SetDamageType(ResistanceType.Physical, 75);
+            SetDamageType(ResistanceType.Energy, 25);
+
+            SetResistance(ResistanceType.Physical, 83, 90);
+            SetResistance(ResistanceType.Fire, 72, 80);
+            SetResistance(ResistanceType.Cold, 40, 49);
+            SetResistance(ResistanceType.Poison, 51, 60);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.EvalInt, 90.3, 99.8);
+            SetSkill(SkillName.Magery, 100.1, 100.6); // 10.1-10.6 on OSI, bug?
+            SetSkill(SkillName.Meditation, 90.1, 110.0);
+            SetSkill(SkillName.MagicResist, 112.2, 127.2);
+            SetSkill(SkillName.Tactics, 91.2, 92.8);
+            SetSkill(SkillName.Wrestling, 80.2, 86.4);
+
+            Fame = 24000;
+            Karma = -24000;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetSpecialAbility(SpecialAbility.LifeDrain);
+        }
+
+        public Szavetra(Serial serial)
+            : base(serial)
+        {
+        }
+
+		public override bool CanBeParagon { get { return false; } }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Tangle.cs

@@ -0,0 +1,99 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a tangle corpse")]
+    public class Tangle : BogThing
+    {
+        [Constructable]
+        public Tangle()
+            : base()
+        {
+            this.Name = "Tangle";
+            this.Hue = 0x21;
+
+            this.SetStr(843, 943);
+            this.SetDex(58, 74);
+            this.SetInt(46, 58);
+
+            this.SetHits(2468, 2733);
+
+            this.SetDamage(15, 28);
+
+            this.SetDamageType(ResistanceType.Physical, 60);
+            this.SetDamageType(ResistanceType.Poison, 40);
+
+            this.SetResistance(ResistanceType.Physical, 50, 57);
+            this.SetResistance(ResistanceType.Fire, 40, 43);
+            this.SetResistance(ResistanceType.Cold, 30, 35);
+            this.SetResistance(ResistanceType.Poison, 61, 69);
+            this.SetResistance(ResistanceType.Energy, 41, 45);
+
+            this.SetSkill(SkillName.Wrestling, 80.8, 94.6);
+            this.SetSkill(SkillName.Tactics, 90.6, 100.4);
+            this.SetSkill(SkillName.MagicResist, 108.4, 114.0);
+
+            this.Fame = 16000;
+            this.Karma = -16000;
+
+            this.VirtualArmor = 54;
+
+            for (int i = 0; i < Utility.RandomMinMax(1, 3); i++)
+            {
+                this.PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+        }
+
+        public Tangle(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get { return true; }
+        }
+
+        public override bool BardImmune
+        {
+            get
+            {
+                return !Core.AOS;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.AosUltraRich, 3);
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            if (Utility.RandomDouble() < 0.3)
+                c.DropItem(new TaintedSeeds());
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/TavaraSewel.cs

@@ -0,0 +1,146 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    public class TavaraSewel : BaseCreature
+    {
+        [Constructable]
+        public TavaraSewel()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Title = "the Cursed";
+
+            this.Hue = 0x8838;
+            this.Female = true;
+            this.Body = 0x191;
+            this.Name = "Tavara Sewel";
+
+            this.AddItem(new Kilt(0x59C));
+            this.AddItem(new Sandals(0x599));
+
+            Kryss kryss = new Kryss();
+            Buckler buckler = new Buckler();
+            RingmailGloves gloves = new RingmailGloves();
+            FemalePlateChest chest = new FemalePlateChest();
+
+            kryss.Hue = 0x96F;
+            kryss.Movable = false;
+            buckler.Hue = 0x96F;
+            buckler.Movable = false;
+            gloves.Hue = 0x599;
+            chest.Hue = 0x96F;
+
+            this.AddItem(kryss);
+            this.AddItem(buckler);
+            this.AddItem(gloves);
+            this.AddItem(chest);
+
+            this.SetStr(111, 120);
+            this.SetDex(111, 120);
+            this.SetInt(111, 120);
+
+            this.SetHits(180, 207);
+            this.SetStam(126, 150);
+            this.SetMana(0);
+
+            this.SetDamage(13, 16);
+
+            this.SetResistance(ResistanceType.Physical, 25, 30);
+            this.SetResistance(ResistanceType.Fire, 25, 30);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 25, 35);
+            this.SetResistance(ResistanceType.Energy, 25, 35);
+
+            this.SetSkill(SkillName.Fencing, 90.1, 100.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 80.1, 90.0);
+            this.SetSkill(SkillName.Anatomy, 90.1, 100.0);
+
+            this.Fame = 5000;
+            this.Karma = -1000;
+        }
+
+        public TavaraSewel(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ClickTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool ShowFameTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool DeleteCorpseOnDeath
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int GetIdleSound()
+        {
+            return 0x27F;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x258;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x25B;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x257;
+        }
+
+        public override bool OnBeforeDeath()
+        {
+            Gold gold = new Gold(Utility.RandomMinMax(190, 230));
+            gold.MoveToWorld(this.Location, this.Map);
+
+            if (Utility.Random(3) == 0)
+            {
+                BaseBook journal = Loot.RandomTavarasJournal();
+                journal.MoveToWorld(this.Location, this.Map);
+            }
+
+            Effects.SendLocationEffect(this.Location, this.Map, 0x376A, 10, 1);
+            return true;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Tempest.cs

@@ -0,0 +1,105 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("the remains of Tempest")]
+    public class Tempest : BaseCreature
+    {
+        [Constructable]
+        public Tempest()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Tempest";
+            this.Body = 13;
+            this.Hue = 1175;
+            this.BaseSoundID = 263;
+
+            this.SetStr(116, 135);
+            this.SetDex(166, 185);
+            this.SetInt(101, 125);
+
+            this.SetHits(602);
+
+            this.SetDamage(18, 20);  // Erica's
+
+            this.SetDamageType(ResistanceType.Energy, 80);
+            this.SetDamageType(ResistanceType.Cold, 20);
+
+            this.SetResistance(ResistanceType.Physical, 46);
+            this.SetResistance(ResistanceType.Fire, 39);
+            this.SetResistance(ResistanceType.Cold, 33);
+            this.SetResistance(ResistanceType.Poison, 36);
+            this.SetResistance(ResistanceType.Energy, 58);
+
+            this.SetSkill(SkillName.EvalInt, 99.6);
+            this.SetSkill(SkillName.Magery, 101.0);
+            this.SetSkill(SkillName.MagicResist, 104.6);
+            this.SetSkill(SkillName.Tactics, 111.8);
+            this.SetSkill(SkillName.Wrestling, 116.0);
+
+            this.Fame = 4500;
+            this.Karma = -4500;
+
+            this.VirtualArmor = 40;
+            this.ControlSlots = 2;
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get { return true; }
+        }
+
+        public Tempest(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 2;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Average);
+            this.AddLoot(LootPack.Meager);
+            this.AddLoot(LootPack.LowScrolls);
+            this.AddLoot(LootPack.MedScrolls);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Thrasher.cs

@@ -0,0 +1,99 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a thrasher corpse")]
+    public class Thrasher : BaseCreature
+    {
+        [Constructable]
+        public Thrasher()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.1, 0.2)
+        {
+            Name = "Thrasher";
+            Body = 0xCE;
+            Hue = 0x497;
+            BaseSoundID = 0x294;
+
+            SetStr(93, 327);
+            SetDex(7, 201);
+            SetInt(15, 67);
+
+            SetHits(260, 984);
+
+            SetDamage(15, 25);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 53, 55);
+            SetResistance(ResistanceType.Fire, 25, 29);
+            SetResistance(ResistanceType.Poison, 25, 28);
+
+            SetSkill(SkillName.Wrestling, 101.2, 118.3);
+            SetSkill(SkillName.Tactics, 99.1, 117.3);
+            SetSkill(SkillName.MagicResist, 102.4, 118.6);
+
+            Fame = 22400;
+            Karma = -22400;
+
+            for (int i = 0; i < Utility.RandomMinMax(0, 1); i++)
+            {
+                PackItem(Loot.RandomScroll(0, Loot.ArcanistScrollTypes.Length, SpellbookType.Arcanist));
+            }
+
+            SetWeaponAbility(WeaponAbility.ArmorIgnore);
+        }
+
+        public Thrasher(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool GivesMLMinorArtifact
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 48;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.AosFilthyRich, 4);
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);		
+							
+            c.DropItem(new ThrashersTail());
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+			
+            writer.Write((int)0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+			
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/TikitaviRenowned.cs

@@ -0,0 +1,118 @@
+using System;
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Tikitavi [Renowned] corpse")] 
+    public class TikitaviRenowned : BaseRenowned
+    {
+        [Constructable]
+        public TikitaviRenowned()
+            : base(AIType.AI_Melee)
+        {
+            this.Name = "Tikitavi";
+            this.Title = "[Renowned]";
+            this.Body = 42;
+            this.BaseSoundID = 437;
+
+            this.SetStr(315, 354);
+            this.SetDex(139, 177);
+            this.SetInt(243, 288);
+
+            this.SetHits(50000);
+			this.SetMana(243, 288);
+			this.SetStam(139, 177);
+
+            this.SetDamage(7, 9);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 26, 28);
+            this.SetResistance(ResistanceType.Fire, 22, 25);
+            this.SetResistance(ResistanceType.Cold, 30, 38);
+            this.SetResistance(ResistanceType.Poison, 14, 17);
+            this.SetResistance(ResistanceType.Energy, 15, 18);
+
+            this.SetSkill(SkillName.MagicResist, 40.4);
+            this.SetSkill(SkillName.Tactics, 73.6);
+            this.SetSkill(SkillName.Wrestling, 66.5);
+
+            this.Fame = 1500;
+            this.Karma = -1500;
+
+            this.VirtualArmor = 28;
+        }
+
+        public TikitaviRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get
+            {
+                return new Type[] { typeof(BasiliskHideBreastplate) };
+            }
+        }
+        public override Type[] SharedSAList
+        {
+            get
+            {
+                return new Type[] { typeof(LegacyOfDespair), typeof(MysticsGarb) };
+            }
+        }
+        public override InhumanSpeech SpeechType
+        {
+            get
+            {
+                return InhumanSpeech.Ratman;
+            }
+        }
+        public override bool CanRummageCorpses
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Spined;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.FilthyRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/Twaulo.cs

@@ -0,0 +1,222 @@
+using System;
+using Server.Engines.CannedEvil;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a corpse of Twaulo")]
+    public class Twaulo : BaseChampion
+    {
+        [Constructable]
+        public Twaulo()
+            : base(AIType.AI_Melee)
+        {
+            this.Name = "Twaulo";
+            this.Title = "of the Glade";
+            this.Body = 101;
+            this.BaseSoundID = 679;
+            this.Hue = 0x455;
+
+            this.SetStr(1751, 1950);
+            this.SetDex(251, 450);
+            this.SetInt(801, 1000);
+
+            this.SetHits(7500);
+
+            this.SetDamage(19, 24);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 65, 75);
+            this.SetResistance(ResistanceType.Fire, 45, 55);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 50, 60);
+            this.SetResistance(ResistanceType.Energy, 50, 60);
+
+            this.SetSkill(SkillName.EvalInt, 0); // Per Stratics?!?
+            this.SetSkill(SkillName.Magery, 0); // Per Stratics?!?
+            this.SetSkill(SkillName.Meditation, 0); // Per Stratics?!?
+            this.SetSkill(SkillName.Anatomy, 95.1, 115.0);
+            this.SetSkill(SkillName.Archery, 95.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 50.3, 80.0);
+            this.SetSkill(SkillName.Tactics, 90.1, 100.0);
+            this.SetSkill(SkillName.Wrestling, 95.1, 100.0);
+
+            this.Fame = 50000;
+            this.Karma = 50000;
+
+            this.VirtualArmor = 50;
+
+            this.AddItem(new Bow());
+            this.PackItem(new Arrow(Utility.RandomMinMax(500, 700)));
+        }
+
+        public Twaulo(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override ChampionSkullType SkullType
+        {
+            get
+            {
+                return ChampionSkullType.Pain;
+            }
+        }
+        public override Type[] UniqueList
+        {
+            get
+            {
+                return new Type[] { typeof(Quell) };
+            }
+        }
+        public override Type[] SharedList
+        {
+            get
+            {
+                return new Type[] { typeof(TheMostKnowledgePerson), typeof(OblivionsNeedle), typeof(BraveKnightOfTheBritannia) };
+            }
+        }
+        public override Type[] DecorativeList
+        {
+            get
+            {
+                return new Type[] { typeof(Pier), typeof(MonsterStatuette) };
+            }
+        }
+        public override MonsterStatuetteType[] StatueTypes
+        {
+            get
+            {
+                return new MonsterStatuetteType[] { MonsterStatuetteType.DreadHorn };
+            }
+        }
+        public override OppositionGroup OppositionGroup
+        {
+            get
+            {
+                return OppositionGroup.FeyAndUndead;
+            }
+        }
+        public override bool Unprovokable
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Regular;
+            }
+        }
+        public override int TreasureMapLevel
+        {
+            get
+            {
+                return 5;
+            }
+        }
+        public override int Meat
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 8;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Spined;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.UltraRich, 2);
+            this.AddLoot(LootPack.Average);
+            this.AddLoot(LootPack.Gems);
+        }
+
+        public void SpawnPixies(Mobile target)
+        {
+            Map map = this.Map;
+
+            if (map == null)
+                return;
+
+            int newPixies = Utility.RandomMinMax(3, 6);
+
+            for (int i = 0; i < newPixies; ++i)
+            {
+                Pixie pixie = new Pixie();
+
+                pixie.Team = this.Team;
+                pixie.FightMode = FightMode.Closest;
+
+                bool validLocation = false;
+                Point3D loc = this.Location;
+
+                for (int j = 0; !validLocation && j < 10; ++j)
+                {
+                    int x = this.X + Utility.Random(3) - 1;
+                    int y = this.Y + Utility.Random(3) - 1;
+                    int z = map.GetAverageZ(x, y);
+
+                    if (validLocation = map.CanFit(x, y, this.Z, 16, false, false))
+                        loc = new Point3D(x, y, this.Z);
+                    else if (validLocation = map.CanFit(x, y, z, 16, false, false))
+                        loc = new Point3D(x, y, z);
+                }
+
+                pixie.MoveToWorld(loc, map);
+                pixie.Combatant = target;
+            }
+        }
+
+        public override void AlterDamageScalarFrom(Mobile caster, ref double scalar)
+        {
+            if (0.1 >= Utility.RandomDouble())
+                this.SpawnPixies(caster);
+        }
+
+        public override void OnGaveMeleeAttack(Mobile defender)
+        {
+            base.OnGaveMeleeAttack(defender);
+
+            defender.Damage(Utility.Random(20, 10), this);
+            defender.Stam -= Utility.Random(20, 10);
+            defender.Mana -= Utility.Random(20, 10);
+        }
+
+        public override void OnGotMeleeAttack(Mobile attacker)
+        {
+            base.OnGotMeleeAttack(attacker);
+
+            if (0.1 >= Utility.RandomDouble())
+                this.SpawnPixies(attacker);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Named/VitaviRenowned.cs

@@ -0,0 +1,116 @@
+using System;
+using Server.Items;
+using Server.Misc;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Vitavi [Renowned] corpse")]
+    public class VitaviRenowned : BaseRenowned
+    {
+        [Constructable]
+        public VitaviRenowned()
+            : base(AIType.AI_Mystic)
+        {
+            this.Name = "Vitavi";
+            this.Title = "[Renowned]";
+            this.Body = 0x8F;
+            this.BaseSoundID = 437;
+
+            this.SetStr(300, 350);
+            this.SetDex(250, 300);
+            this.SetInt(300, 350);
+
+            this.SetHits(45000, 50000);
+
+            this.SetDamage(7, 14);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 50, 60);
+            this.SetResistance(ResistanceType.Fire, 30, 50);
+            this.SetResistance(ResistanceType.Cold, 60, 80);
+            this.SetResistance(ResistanceType.Poison, 20, 30);
+            this.SetResistance(ResistanceType.Energy, 30, 40);
+
+            this.SetSkill(SkillName.EvalInt, 70.1, 80.0);
+            this.SetSkill(SkillName.Magery, 70.1, 80.0);
+            this.SetSkill(SkillName.MagicResist, 75.1, 100.0);
+            this.SetSkill(SkillName.Tactics, 70.1, 75.0);
+            this.SetSkill(SkillName.Wrestling, 50.1, 75.0);
+
+            this.Fame = 7500;
+            this.Karma = -7500;
+
+            this.VirtualArmor = 44;
+            
+            this.PackReg(6);
+
+            if (0.02 > Utility.RandomDouble())
+                this.PackStatue();
+        }
+
+        public VitaviRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get { return new Type[] {}; }
+        }
+
+        public override Type[] SharedSAList
+        {
+            get { return new[] {typeof (AxeOfAbandon), typeof (DemonBridleRing), typeof (VoidInfusedKilt)}; }
+        }
+
+        public override InhumanSpeech SpeechType
+        {
+            get { return InhumanSpeech.Ratman; }
+        }
+        public override bool AllureImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override bool CanRummageCorpses
+        {
+            get { return true; }
+        }
+
+        public override int Meat
+        {
+            get { return 1; }
+        }
+
+        public override int Hides
+        {
+            get { return 8; }
+        }
+
+        public override HideType HideType
+        {
+            get { return HideType.Spined; }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 3);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            var version = reader.ReadInt();          
+        }
+    }
+}

Scripts/Mobiles/Named/WyvernRenowned.cs

@@ -0,0 +1,153 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("Wyvern [Renowned] corpse")]
+    public class WyvernRenowned : BaseRenowned
+    {
+        [Constructable]
+        public WyvernRenowned()
+            : base(AIType.AI_Mage)
+        {
+            this.Name = "Wyvern";
+            this.Title = "[Renowned]";
+            this.Body = 62;
+            this.Hue = 243;
+            this.BaseSoundID = 362;
+
+            this.SetStr(1370, 1422);
+            this.SetDex(103, 151);
+            this.SetInt(835, 1002);
+
+            this.SetHits(2412, 2734);
+            this.SetStam(103, 151);
+            this.SetMana(835, 1002);
+
+            this.SetDamage(29, 35);
+
+            this.SetDamageType(ResistanceType.Physical, 75);
+            this.SetDamageType(ResistanceType.Fire, 25);
+
+            this.SetResistance(ResistanceType.Physical, 60, 70);
+            this.SetResistance(ResistanceType.Fire, 80, 90);
+            this.SetResistance(ResistanceType.Cold, 70, 80);
+            this.SetResistance(ResistanceType.Poison, 60, 70);
+            this.SetResistance(ResistanceType.Energy, 60, 70);
+
+            this.SetSkill(SkillName.Magery, 107.7, 109.1);
+            this.SetSkill(SkillName.Meditation, 63.9, 78.2);
+            this.SetSkill(SkillName.EvalInt, 106.8, 111.1);
+            this.SetSkill(SkillName.Wrestling, 108.6, 109.4);
+            this.SetSkill(SkillName.MagicResist, 125.8, 127.6);
+            this.SetSkill(SkillName.Tactics, 112.8, 123.7);
+
+            this.Fame = 24000;
+            this.Karma = -24000;
+
+            this.VirtualArmor = 70;
+        }
+
+        public WyvernRenowned(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Type[] UniqueSAList
+        {
+            get { return new Type[] {}; }
+        }
+
+        public override Type[] SharedSAList
+        {
+            get { return new[] {typeof (AnimatedLegsoftheInsaneTinker), typeof (PillarOfStrength), typeof(StormCaller) }; }
+        }
+
+        public override bool ReacquireOnMovement
+        {
+            get { return true; }
+        }
+
+        public override Poison PoisonImmune
+        {
+            get { return Poison.Deadly; }
+        }
+
+        public override Poison HitPoison
+        {
+            get { return Poison.Deadly; }
+        }
+
+        public override bool AutoDispel
+        {
+            get { return true; }
+        }
+
+        public override bool BardImmune
+        {
+            get { return true; }
+        }
+
+        public override int TreasureMapLevel
+        {
+            get { return 5; }
+        }
+
+        public override int Meat
+        {
+            get { return 10; }
+        }
+
+        public override int Hides
+        {
+            get { return 20; }
+        }
+
+        public override HideType HideType
+        {
+            get { return HideType.Horned; }
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.UltraRich);
+        }
+
+        public override int GetAttackSound()
+        {
+            return 713;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 718;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 716;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 721;
+        }
+
+        public override int GetIdleSound()
+        {
+            return 725;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write(0);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            var version = reader.ReadInt();
+        }
+    }
+}