Overwrite

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

Scripts/Services/ExploringTheDeep/Mobiles/DiabolicalSeaweed.cs

@@ -0,0 +1,183 @@
+using System;
+using Server.Items;
+using System.Collections;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a seaweed corpse")]
+    public class DiabolicalSeaweed : BaseCreature
+    {
+        private PullTimer m_Timer;
+        [Constructable]
+
+        public DiabolicalSeaweed()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.0, 0.0)
+        {
+            Name = "Diabolical Seaweed";
+            Body = 129;
+            Hue = 1914;
+
+            SetStr(452, 485);
+            SetDex(401, 420);
+            SetInt(126, 140);
+
+            SetHits(501, 532);
+
+            SetDamage(10, 23);
+
+            SetDamageType(ResistanceType.Physical, 60);
+            SetDamageType(ResistanceType.Poison, 40);
+
+            SetResistance(ResistanceType.Physical, 35, 40);
+            SetResistance(ResistanceType.Fire, 20, 30);
+            SetResistance(ResistanceType.Cold, 10, 20);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 10, 20);
+
+            SetSkill(SkillName.MagicResist, 50.1, 54.7);
+            SetSkill(SkillName.Tactics, 100.3, 114.8);
+            SetSkill(SkillName.Wrestling, 45.1, 59.5);
+
+            Fame = 3000;
+            Karma = -3000;
+            CantWalk = true;
+
+            VirtualArmor = 60;
+
+            m_Timer = new PullTimer(this);
+            m_Timer.Start();
+
+            switch (Utility.Random(8))
+            {
+                case 0: PackItem(new BlueDiamond()); break;
+                case 1: PackItem(new FireRuby()); break;
+                case 2: PackItem(new BrilliantAmber()); break;
+                case 3: PackItem(new PerfectEmerald()); break;
+                case 4: PackItem(new DarkSapphire()); break;
+                case 5: PackItem(new Turquoise()); break;
+                case 6: PackItem(new EcruCitrine()); break;
+                case 7: PackItem(new WhitePearl()); break;
+            }
+            PackItem(new ParasiticPlant());
+            PackItem(new LuminescentFungi());
+        }
+
+        public DiabolicalSeaweed(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnAfterDelete()
+        {
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            m_Timer = null;
+
+            base.OnAfterDelete();
+        }
+
+        private class PullTimer : Timer
+        {
+            private static readonly ArrayList m_ToDrain = new ArrayList();
+            private readonly DiabolicalSeaweed m_Owner;
+
+            public PullTimer(DiabolicalSeaweed owner)
+                : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
+            {
+                m_Owner = owner;
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            protected override void OnTick()
+            {
+                if (m_Owner.Deleted)
+                {
+                    Stop();
+                    return;
+                }
+
+                IPooledEnumerable eable = m_Owner.GetMobilesInRange(9);
+                foreach (Mobile m in eable)
+                {
+                    if (m == null || m is DiabolicalSeaweed || !m_Owner.CanBeHarmful(m) || m.AccessLevel == AccessLevel.Player)
+                        continue;
+
+                    int offsetX = Math.Abs(m.Location.X - m_Owner.Location.X);
+                    int offsetY = Math.Abs(m.Location.Y - m_Owner.Location.Y);
+
+                    if (offsetX < 2 && offsetY < 2)
+                        continue;
+
+                    if (m is BaseCreature)
+                    {
+                        BaseCreature bc = m as BaseCreature;
+
+                        if (bc.Controlled || bc.Summoned)
+                            m_ToDrain.Add(m);
+                    }
+                    else if (m.Player)
+                    {
+                        m_ToDrain.Add(m);
+                    }
+                }
+
+                eable.Free();
+
+                foreach (Mobile m in m_ToDrain)
+                {
+                    m_Owner.DoHarmful(m);
+
+                    //m.FixedParticles( 0x376A, 10, 15, 5052, EffectLayer.Waist );
+                    //m.PlaySound(0x1F1);
+                    int drain = Utility.RandomMinMax(1, 10);
+                    int ownerlocX = m_Owner.Location.X + Utility.RandomMinMax(-1, 1);
+                    int ownerlocY = m_Owner.Location.Y + Utility.RandomMinMax(-1, 1);
+                    int ownerlocZ = m_Owner.Location.Z;
+                    m.MoveToWorld(new Point3D(ownerlocX, ownerlocY, ownerlocZ), m_Owner.Map);
+                    m.Damage(drain, m_Owner);
+                }
+
+                m_ToDrain.Clear();
+            }
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+            for (int i = Utility.Random(5, 6); i > 1; i--)
+            {
+                Item ReagentLoot = Loot.RandomReagent();
+                ReagentLoot.Amount = Utility.Random(4, 5);
+                c.DropItem(ReagentLoot);
+            }
+
+        }
+
+        public override bool CanRummageCorpses { get { return true; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Meager);
+        }
+
+        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();
+
+            m_Timer = new PullTimer(this);
+            m_Timer.Start();
+
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/Djinn.cs

@@ -0,0 +1,211 @@
+using System;
+using Server.Items;
+using System.Collections;
+using Server.Engines.Quests;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a djinn corpse")]
+    public class Djinn : BaseCreature
+    {
+        public static List<Djinn> Instances { get; set; }
+        private SummonEfreetTimer m_Timer;
+
+        [Constructable]
+        public Djinn()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Body = 0x311;
+			Hue = 33072;
+            Name = "Djinn";
+
+            SetStr(320, 500);
+            SetDex(200, 300);
+            SetInt(600, 700);
+
+            SetHits(2003);
+
+            SetDamage(11, 13);
+
+            SetDamageType(ResistanceType.Physical, 0);
+            SetDamageType(ResistanceType.Fire, 50);
+            SetDamageType(ResistanceType.Energy, 50);
+
+            SetResistance(ResistanceType.Physical, 50, 60);
+            SetResistance(ResistanceType.Fire, 60, 70);
+            SetResistance(ResistanceType.Cold, 30, 40);
+            SetResistance(ResistanceType.Poison, 30, 40);
+            SetResistance(ResistanceType.Energy, 80, 90);
+
+            SetSkill(SkillName.Wrestling, 60.0, 80.0);
+            SetSkill(SkillName.Tactics, 60.0, 80.0);
+            SetSkill(SkillName.MagicResist, 60.0, 80.0);
+            SetSkill(SkillName.Magery, 100.0, 120.0);
+            SetSkill(SkillName.EvalInt, 60.0, 110.0);
+			SetSkill(SkillName.DetectHidden, 55.0);
+
+            Fame = 15000;
+            Karma = -15000;
+
+            if (Instances == null)
+                Instances = new List<Djinn>();
+
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+
+            m_Timer = new SummonEfreetTimer(this);
+            m_Timer.Start();
+        }
+		
+		public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich);
+        }
+		
+		public override int TreasureMapLevel { get { return 4; } }
+
+        public override void OnDeath(Container c)
+        {
+            List<DamageStore> rights = GetLootingRights();            
+
+            foreach (Mobile m in rights.Select(x => x.m_Mobile).Distinct())
+            {
+                if (m is PlayerMobile)
+                {
+                    PlayerMobile pm = m as PlayerMobile;
+
+                    if (pm.ExploringTheDeepQuest == ExploringTheDeepQuestChain.CollectTheComponent)
+                    {
+						Item item = new AquaGem();
+						
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                        {
+                            m.BankBox.DropItem(item);
+                        }
+
+                        m.SendLocalizedMessage(1154489); // You received a Quest Item!
+                    }
+                }
+            }
+
+            if (Instances != null && Instances.Contains(this))
+                Instances.Remove(this);
+
+            base.OnDeath(c);
+        }
+
+        public static Djinn Spawn(Point3D platLoc, Map platMap)
+        {
+            if (Instances != null && Instances.Count > 0)
+                return null;
+
+            Djinn creature = new Djinn();
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private Djinn Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(60))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((Djinn)p);
+            }
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    Stop();
+                }
+            }
+        }
+
+        public Djinn(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnAfterDelete()
+        {
+            Instances.Remove(this);
+
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            m_Timer = null;
+
+            base.OnAfterDelete();
+        }
+
+        private class SummonEfreetTimer : Timer
+        {
+            //private static readonly ArrayList m_ToDrain = new ArrayList();
+            private readonly Djinn m_Owner;
+
+            public SummonEfreetTimer(Djinn owner)
+                : base(TimeSpan.FromSeconds(1), TimeSpan.FromSeconds(1))
+            {
+                m_Owner = owner;
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+            //Type type = m_Owner.GetType();
+            protected override void OnTick()
+            {
+                if (m_Owner.Deleted)
+                {
+                    Stop();
+                    return;
+                }
+
+                IPooledEnumerable eable = m_Owner.GetMobilesInRange(10);
+
+                foreach (Mobile m in eable)
+                {
+                    if (m == null || !(m is PlayerMobile))
+                        continue;
+
+                    if (m_Owner.CanBeHarmful(m) && m_Owner.Mana >= 100)
+                    {
+                        m_Owner.Mana -= 50;
+                        int ownerlocX = m_Owner.Location.X + Utility.RandomMinMax(-5, 5);
+                        int ownerlocY = m_Owner.Location.Y + Utility.RandomMinMax(-5, 5);
+                        int ownerlocZ = m_Owner.Location.Z;
+                        Efreet NewMobile = new Efreet();
+                        NewMobile.MoveToWorld(new Point3D(ownerlocX, ownerlocY, ownerlocZ), m_Owner.Map);
+                        NewMobile.Combatant = m;
+                    }
+                }
+
+                eable.Free();
+            }
+        }
+
+        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();
+
+            Instances = new List<Djinn>();
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();            
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/IceWyrm.cs

@@ -0,0 +1,136 @@
+using System;
+using Server.Items;
+using System.Collections.Generic;
+using System.Linq;
+using Server.Engines.Quests;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an ice wyrm corpse")]
+    public class IceWyrm : WhiteWyrm
+    {
+        public static List<IceWyrm> Instances { get; set; }
+        
+        [Constructable]
+        public IceWyrm()
+            : base()
+        {
+            Name = "Ice Wyrm";
+            Hue = 2729;
+            Body = 180;
+			
+			SetResistance(ResistanceType.Cold, 100);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+
+            Tamable = false;
+
+            if (Instances == null)
+                Instances = new List<IceWyrm>();
+
+            Instances.Add(this);
+        }
+
+        public static IceWyrm Spawn(Point3D platLoc, Map platMap)
+        {
+            if (Instances != null && Instances.Count > 0)
+                return null;
+
+            IceWyrm creature = new IceWyrm();
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private IceWyrm Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(60))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((IceWyrm)p);
+            }
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    Stop();
+                }
+            }
+        }
+
+        public override void OnDeath(Container c)
+        {
+            List<DamageStore> rights = GetLootingRights();            
+
+            foreach (Mobile m in rights.Select(x => x.m_Mobile).Distinct())
+            {
+                if (m is PlayerMobile)
+                {
+                    PlayerMobile pm = m as PlayerMobile;
+
+                    if (pm.ExploringTheDeepQuest == ExploringTheDeepQuestChain.CusteauPerron)
+                    {
+						Item item = new IceWyrmScale();
+						
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                        {
+                            m.BankBox.DropItem(item);
+                        }
+
+                        m.SendLocalizedMessage(1154489); // You received a Quest Item!
+                    }
+                }                
+            }
+
+            if (Instances != null && Instances.Contains(this))
+                Instances.Remove(this);
+
+            base.OnDeath(c);
+        }
+
+        public override bool ReacquireOnMovement { get { return true; } }
+        public override int TreasureMapLevel { get { return 4; } }
+        public override int Meat { get { return 20; } }
+        public override int Hides { get { return 25; } }
+        public override HideType HideType { get { return HideType.Barbed; } }
+        public override FoodType FavoriteFood { get { return FoodType.Meat; } }
+        public override bool CanAngerOnTame { get { return true; } }
+        public override bool CanRummageCorpses { get { return true; } }
+
+        public override void OnAfterDelete()
+        {
+            Instances.Remove(this);
+
+            base.OnAfterDelete();
+        }
+
+        public IceWyrm(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();
+
+            Instances = new List<IceWyrm>();
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();     
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/MercutioTheUnsavory.cs

@@ -0,0 +1,242 @@
+using System;
+using Server.Items;
+using System.Collections.Generic;
+using Server.Engines.Quests;
+using System.Linq;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a mercutio corpse")]
+    public class MercutioTheUnsavory : BaseCreature
+    {
+        public static List<MercutioTheUnsavory> Instances { get; set; }
+
+        [Constructable]
+        public MercutioTheUnsavory()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Body = 0x190;
+            Hue = Utility.RandomSkinHue();
+            Name = "Mercutio";
+            Title = "The Unsavory";
+            Female = false;
+
+            SetStr(1000, 1300);
+            SetDex(101, 125);
+            SetInt(61, 75);
+
+            SetDamage(11, 24);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 10, 15);
+            SetResistance(ResistanceType.Fire, 10, 15);
+            SetResistance(ResistanceType.Poison, 10, 15);
+            SetResistance(ResistanceType.Energy, 10, 15);
+
+            SetSkill(SkillName.Fencing, 106.0, 117.5);
+            SetSkill(SkillName.Macing, 105.0, 117.5);
+            SetSkill(SkillName.MagicResist, 50.0, 90.5);
+            SetSkill(SkillName.Swords, 105.0, 117.5);
+            SetSkill(SkillName.Parry, 105.0, 117.5);
+            SetSkill(SkillName.Tactics, 105.0, 117.5);
+            SetSkill(SkillName.Wrestling, 55.0, 87.5);
+
+            Fame = 3000;
+            Karma = -3000;
+
+            if (Instances == null)
+                Instances = new List<MercutioTheUnsavory>();
+
+            Instances.Add(this);
+
+            AddImmovableItem(new Cutlass());
+            AddImmovableItem(new ChainChest());
+            AddImmovableItem(Loot.RandomShield());
+            AddImmovableItem(new ShortPants(Utility.RandomNeutralHue()));
+            AddImmovableItem(new Boots(Utility.RandomNeutralHue()));
+
+            Utility.AssignRandomHair(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+
+        private void AddImmovableItem(Item item)
+        {
+            item.LootType = LootType.Blessed;
+            AddItem(item);
+        }
+
+        public override bool ClickTitle { get { return false; } }
+        public override bool AlwaysMurderer { get { return true; } }
+
+        public override void OnDeath(Container c)
+        {
+            List<DamageStore> rights = GetLootingRights();            
+
+            foreach (Mobile m in rights.Select(x => x.m_Mobile).Distinct())
+            {
+                if (m is PlayerMobile)
+                {
+                    PlayerMobile pm = m as PlayerMobile;
+
+                    if (pm.ExploringTheDeepQuest == ExploringTheDeepQuestChain.CollectTheComponent)
+                    {
+						Item item = new MercutiosCutlass();
+						
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                        {
+                            m.BankBox.DropItem(item);
+                        }
+
+                        m.SendLocalizedMessage(1154489); // You received a Quest Item!
+                    }
+                }
+            }
+
+            if (Instances != null && Instances.Contains(this))
+                Instances.Remove(this);
+
+            base.OnDeath(c);
+        }
+
+        public static MercutioTheUnsavory Spawn(Point3D platLoc, Map platMap)
+        {
+            if (Instances != null && Instances.Count > 0)
+                return null;
+
+            MercutioTheUnsavory creature = new MercutioTheUnsavory();
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+
+        public MercutioTheUnsavory(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+        }
+
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private MercutioTheUnsavory Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(60))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((MercutioTheUnsavory)p);
+            }
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    Stop();
+                }
+            }
+        }
+
+        public override void OnAfterDelete()
+        {
+            Instances.Remove(this);
+
+            base.OnAfterDelete();
+        }
+
+        public override void OnGotMeleeAttack(Mobile attacker)
+        {
+            base.OnGotMeleeAttack(attacker);
+
+            if (0.1 >= Utility.RandomDouble())
+                SpawnBrigand(attacker);
+        }
+
+        public override void OnGaveMeleeAttack(Mobile defender)
+        {
+            base.OnGaveMeleeAttack(defender);
+
+            if (0.1 >= Utility.RandomDouble())
+                SpawnBrigand(defender);
+        }
+
+        #region Helpers
+        public void SpawnBrigand(Mobile target)
+        {
+            Map map = Map;
+
+            if (map == null)
+                return;
+
+            int brigands = 0;
+
+            IPooledEnumerable eable = GetMobilesInRange(10);
+
+            foreach (Mobile m in eable)
+            {
+                if (m is Brigand)
+                    ++brigands;
+            }
+
+            eable.Free();
+
+            if (brigands < 16)
+            {
+                PlaySound(0x3D);
+
+                int newBrigands = Utility.RandomMinMax(3, 6);
+
+                for (int i = 0; i < newBrigands; ++i)
+                {
+                    BaseCreature brigand = new Brigand();
+
+                    brigand.Team = Team;
+
+                    bool validLocation = false;
+                    Point3D loc = Location;
+
+                    for (int j = 0; !validLocation && j < 10; ++j)
+                    {
+                        int x = X + Utility.Random(3) - 1;
+                        int y = Y + Utility.Random(3) - 1;
+                        int z = map.GetAverageZ(x, y);
+
+                        if (validLocation = map.CanFit(x, y, Z, 16, false, false))
+                            loc = new Point3D(x, y, Z);
+                        else if (validLocation = map.CanFit(x, y, z, 16, false, false))
+                            loc = new Point3D(x, y, z);
+                    }
+
+                    brigand.MoveToWorld(loc, map);
+                    brigand.Combatant = target;
+                }
+            }
+        }
+        #endregion
+
+        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();
+
+            Instances = new List<MercutioTheUnsavory>();
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/ObsidianWyvern.cs

@@ -0,0 +1,174 @@
+using System;
+using Server.Items;
+using System.Collections.Generic;
+using Server.Engines.Quests;
+using System.Linq;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an obsidian wyvern corpse")]
+    public class ObsidianWyvern : BaseCreature
+    {
+        public static List<ObsidianWyvern> Instances { get; set; }
+
+        [Constructable]
+        public ObsidianWyvern()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "Obsidian Wyvern";
+            Body = 0x2E;
+            Hue = 1910;
+            BaseSoundID = 362;
+
+            SetStr(1377, 1450);
+            SetDex(125, 180);
+            SetInt(780, 900);
+
+            SetHits(1225, 1400);
+
+            SetDamage(29, 35);
+
+            SetDamageType(ResistanceType.Physical, 75);
+            SetDamageType(ResistanceType.Fire, 25);
+
+            SetResistance(ResistanceType.Physical, 67);
+            SetResistance(ResistanceType.Fire, 80, 90);
+            SetResistance(ResistanceType.Cold, 70, 80);
+            SetResistance(ResistanceType.Poison, 60, 70);
+            SetResistance(ResistanceType.Energy, 60, 70);
+
+            SetSkill(SkillName.Magery, 108.7, 115.0);
+            SetSkill(SkillName.Meditation, 60.0, 87.6);
+            SetSkill(SkillName.EvalInt, 110.0, 115.0);
+            SetSkill(SkillName.Wrestling, 110.0, 115.0);
+            SetSkill(SkillName.Tactics, 119.6, 125.0);
+            SetSkill(SkillName.MagicResist, 115.0, 130.8);
+			SetSkill(SkillName.Parry, 75.0, 85.0);
+			SetSkill(SkillName.DetectHidden, 100.0);            
+
+            Fame = 24000;
+            Karma = -24000;
+            
+            VirtualArmor = 70;
+
+            if (Instances == null)
+                Instances = new List<ObsidianWyvern>();
+
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+
+            SetSpecialAbility(SpecialAbility.DragonBreath);
+        }
+
+        public static ObsidianWyvern Spawn(Point3D platLoc, Map platMap)
+        {
+            if (Instances != null && Instances.Count > 0)
+                return null;
+
+            ObsidianWyvern creature = new ObsidianWyvern();
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private ObsidianWyvern Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(60))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((ObsidianWyvern)p);
+            }
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    Stop();
+                }
+            }
+        }
+
+        public override void OnAfterDelete()
+        {
+            Instances.Remove(this);
+
+            base.OnAfterDelete();
+        }
+
+        public override void OnDeath(Container c)
+        {
+            List<DamageStore> rights = GetLootingRights();            
+
+            foreach (Mobile m in rights.Select(x => x.m_Mobile).Distinct())
+            {
+                if (m is PlayerMobile)
+                {
+                    PlayerMobile pm = m as PlayerMobile;
+
+                    if (pm.ExploringTheDeepQuest == ExploringTheDeepQuestChain.CollectTheComponent)
+                    {
+						Item item = new WillemHartesHat();
+						
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                        {
+                            m.BankBox.DropItem(item);
+                        }
+
+                        m.SendLocalizedMessage(1154489); // You received a Quest Item!
+                    }
+                }
+            }
+
+            if (Instances != null && Instances.Contains(this))
+                Instances.Remove(this);
+
+            base.OnDeath(c);
+        }
+
+        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 FoodType FavoriteFood { get { return FoodType.Meat; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 3);
+            AddLoot(LootPack.Gems, 5);
+        }
+
+        public override int GetIdleSound() { return 0x2D3; }
+        public override int GetHurtSound() { return 0x2D1; }
+
+        public ObsidianWyvern(Serial serial)
+            : base(serial)
+        {
+        }
+
+        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();
+
+            Instances = new List<ObsidianWyvern>();
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/OrcEngineer.cs

@@ -0,0 +1,147 @@
+using System;
+using Server.Items;
+using Server.Engines.Quests;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an orcish corpse")]
+    public class OrcEngineer : Orc
+    {
+        public static List<OrcEngineer> Instances { get; set; }
+
+        [Constructable]
+        public OrcEngineer()
+            : base()
+        {
+            Title = "the Orcish Engineer";
+
+            SetStr(500, 510);
+            SetDex(200, 210);
+            SetInt(200, 210);
+
+            SetHits(3500, 3700);
+
+            SetDamage(8, 14);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 65, 70);
+            SetResistance(ResistanceType.Fire, 65, 70);
+            SetResistance(ResistanceType.Cold, 65, 70);
+            SetResistance(ResistanceType.Poison, 60);
+            SetResistance(ResistanceType.Energy, 65, 70);
+
+            SetSkill(SkillName.Parry, 100.0, 110.0);
+            SetSkill(SkillName.MagicResist, 70.0, 80.0);
+            SetSkill(SkillName.Tactics, 110.0, 120.0);
+            SetSkill(SkillName.Wrestling, 120.0, 130.0);
+            SetSkill(SkillName.DetectHidden, 100.0, 110.0);
+
+            Fame = 1500;
+            Karma = -1500;
+
+            if (Instances == null)
+                Instances = new List<OrcEngineer>();
+
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+
+        public static OrcEngineer Spawn(Point3D platLoc, Map platMap)
+        {
+            if (Instances != null && Instances.Count > 0)
+                return null;
+
+            OrcEngineer creature = new OrcEngineer();
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+        
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private OrcEngineer Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(10))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((OrcEngineer)p);
+            }
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    Stop();
+                }
+            }
+        }
+
+        public override void OnDeath(Container c)
+        {
+            List<DamageStore> rights = GetLootingRights();            
+
+            foreach (Mobile m in rights.Select(x => x.m_Mobile).Distinct())
+            {
+                if (m is PlayerMobile)
+                {
+                    PlayerMobile pm = m as PlayerMobile;
+
+                    if (pm.ExploringTheDeepQuest == ExploringTheDeepQuestChain.CollectTheComponent)
+                    {
+						Item item = new OrcishSchematics();
+						
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, item, false))
+                        {
+                            m.BankBox.DropItem(item);
+                        }
+
+                        m.SendLocalizedMessage(1154489); // You received a Quest Item!
+                    }
+                }
+            }
+
+            if (Instances != null && Instances.Contains(this))
+                Instances.Remove(this);
+
+            base.OnDeath(c);
+        }
+
+        public override void OnAfterDelete()
+        {
+            Instances.Remove(this);
+
+            base.OnAfterDelete();
+        }
+
+        public OrcEngineer(Serial serial)
+            : base(serial)
+        {
+        }
+
+        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();
+
+            Instances = new List<OrcEngineer>();
+            Instances.Add(this);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/Paralithode.cs

@@ -0,0 +1,208 @@
+using Server.Items;
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a paralithode corpse")]
+    public class Paralithode : BaseCreature
+    {
+        private HideTimer m_Timer;
+
+        [Constructable]
+        public Paralithode()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "Paralithode";
+            Body = 729;
+            Hue = 1922;
+
+            SetStr(642, 729);
+            SetDex(87, 103);
+            SetInt(25, 30);
+
+            SetHits(1800, 2000);
+            SetMana(315, 343);
+
+            SetDamage(20, 24);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 65, 75);
+            SetResistance(ResistanceType.Fire, 50, 60);
+            SetResistance(ResistanceType.Cold, 60, 70);
+            SetResistance(ResistanceType.Poison, 50, 60);
+            SetResistance(ResistanceType.Energy, 50, 60);
+
+            SetSkill(SkillName.MagicResist, 68.7, 75.0);
+            SetSkill(SkillName.Anatomy, 98.0, 100.6);
+            SetSkill(SkillName.Tactics, 95.8, 100.9);
+            SetSkill(SkillName.Wrestling, 100.2, 109.0);
+            SetSkill(SkillName.Parry, 100.0, 110.0);
+            SetSkill(SkillName.Ninjitsu, 100.2, 109.0);
+            SetSkill(SkillName.DetectHidden, 50.0);
+
+            Fame = 2500;
+            Karma = -2500;
+
+            Tamable = true;
+            ControlSlots = 4;
+            MinTameSkill = 47.1;            
+
+            PackItem(new FertileDirt(2));
+            m_Timer = new HideTimer(this);
+            m_Timer.Start();
+
+            SetWeaponAbility(WeaponAbility.DualWield);
+            SetWeaponAbility(WeaponAbility.ForceOfNature);
+        }
+
+        public Paralithode(Serial serial)
+            : base(serial)
+        {
+        }
+        
+        public override void OnAfterDelete()
+        {
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            m_Timer = null;
+
+            base.OnAfterDelete();
+        }
+
+        public override void OnAfterTame(Mobile tamer)
+        {
+            if (m_Timer != null)
+                m_Timer.Stop();
+
+            CantWalk = false;
+            Hidden = false;
+
+            base.OnAfterTame(tamer);
+        }
+
+        private class HideTimer : Timer
+        {
+            private readonly Paralithode m_Creature;
+
+            public HideTimer(Paralithode owner)
+                : base(TimeSpan.FromSeconds(1.0), TimeSpan.FromSeconds(1.0))
+            {
+                m_Creature = owner;
+                Priority = TimerPriority.TwoFiftyMS;
+            }
+
+            protected override void OnTick()
+            {
+                if (!m_Creature.Controlled)
+                {
+                    if (m_Creature.Warmode == false && m_Creature.Hidden == false)
+                        m_Creature.PerformHide();
+                    else if (m_Creature.Warmode == true)
+                    {
+                        m_Creature.CantWalk = false;
+                        return;
+                    }
+
+                    IPooledEnumerable eable = m_Creature.GetMobilesInRange(5);
+
+                    foreach (Mobile m in eable)
+                    {
+                        if (m == m_Creature || (m is Paralithode) || !m_Creature.CanBeHarmful(m))
+                            continue;
+
+                        m_Creature.CantWalk = false;
+                    }
+
+                    eable.Free();
+                }
+                else
+                {
+                    Stop();
+                    m_Creature.CantWalk = false;
+                    m_Creature.Hidden = false;
+                }
+            }
+        }
+        
+        public void PerformHide()
+        {
+            if (Deleted)
+                return;
+
+            Hidden = true;
+            CantWalk = true;
+        }
+
+        public override bool IsScaredOfScaryThings { get { return false; } }
+        public override bool IsBondable { get { return false; } }
+        public override FoodType FavoriteFood { get { return FoodType.FruitsAndVegies; } }
+        public override bool BleedImmune { get { return true; } }
+        public override bool DeleteOnRelease { get { return true; } }
+        public override bool BardImmune { get { return !Core.AOS || Controlled; } }
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+        public override bool CanAngerOnTame { get { return true; } }
+        public override bool StatLossAfterTame { get { return true; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Gems, 2);
+        }
+
+        public override int GetAngerSound()
+        {
+            return 541;
+        }
+
+        public override int GetIdleSound()
+        {
+            if (!Controlled)
+                return 542;
+
+            return base.GetIdleSound();
+        }
+
+        public override int GetDeathSound()
+        {
+            if (!Controlled)
+                return 545;
+
+            return base.GetDeathSound();
+        }
+
+        public override int GetAttackSound()
+        {
+            return 562;
+        }
+
+        public override int GetHurtSound()
+        {
+            if (Controlled)
+                return 320;
+
+            return base.GetHurtSound();
+        }
+        public override int Meat { get { return 9; } }
+        public override int Hides { get { return 20; } }
+        public override HideType HideType { get { return HideType.Horned; } }
+
+        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();
+
+            if (!Controlled)
+            {
+                m_Timer = new HideTimer(this);
+                m_Timer.Start();
+            }
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/RockMite.cs

@@ -0,0 +1,99 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a rock mite corpse")]
+    public class RockMite : BaseCreature
+    {
+        [Constructable]
+        public RockMite()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "a rock mite";
+            Body = 787;
+            BaseSoundID = 1006;
+            Hue = 2500;
+
+            SetStr(733, 754);
+            SetDex(126, 144);
+            SetInt(75, 94);
+
+            SetHits(803, 817);
+            SetStam(126, 144);
+            SetMana(75, 94);
+
+            SetDamage(12, 19);
+
+            SetDamageType(ResistanceType.Physical, 50);
+            SetDamageType(ResistanceType.Cold, 50);
+
+            SetResistance(ResistanceType.Physical, 50, 59);
+            SetResistance(ResistanceType.Fire, 80, 90);
+            SetResistance(ResistanceType.Cold, 52, 59);
+            SetResistance(ResistanceType.Poison, 80, 85);
+            SetResistance(ResistanceType.Energy, 80, 90);
+
+            SetSkill(SkillName.MagicResist, 88.5, 119.6);
+            SetSkill(SkillName.Tactics, 84.9, 112.9);
+            SetSkill(SkillName.Wrestling, 82.7, 119.8);
+			SetSkill(SkillName.Parry, 90.0, 100.0);
+			SetSkill(SkillName.DetectHidden, 42.9);
+
+            Fame = 3500;
+            Karma = -3500;
+
+            VirtualArmor = 40;
+
+            SetSpecialAbility(SpecialAbility.TailSwipe);
+        }
+
+        public RockMite(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x5A;
+        }
+
+        public override int GetIdleSound()
+        {
+            return 0x5A;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x164;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x187;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 0x1BA;
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.FilthyRich, 2);
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.Gems, Utility.Random(1, 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/Services/ExploringTheDeep/Mobiles/SalvageHookMonsters.cs

@@ -0,0 +1,113 @@
+using Server.Items;
+using System;
+
+namespace Server.Mobiles
+{
+    public class HPKraken : Kraken
+    {
+        [Constructable]
+        public HPKraken() : base()
+        {
+            Timer.DelayCall(TimeSpan.FromMinutes(30), Delete);
+        }
+
+        public HPKraken(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();
+
+            Delete();
+        }
+    }
+
+    public class HPDeepSeaSerpent : DeepSeaSerpent
+    {
+        [Constructable]
+        public HPDeepSeaSerpent() : base()
+        {
+            Timer.DelayCall(TimeSpan.FromMinutes(30), Delete);
+        }
+
+        public HPDeepSeaSerpent(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();
+
+            Delete();
+        }
+    }
+
+    public class HPSeaSerpent : SeaSerpent
+    {
+        [Constructable]
+        public HPSeaSerpent() : base()
+        {
+            Timer.DelayCall(TimeSpan.FromMinutes(30), Delete);
+        }
+
+        public HPSeaSerpent(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();
+
+            Delete();
+        }
+    }
+
+    public class HPWaterElemental : WaterElemental
+    {
+        [Constructable]
+        public HPWaterElemental() : base()
+        {
+            Timer.DelayCall(TimeSpan.FromMinutes(30), Delete);
+        }
+
+        public HPWaterElemental(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();
+
+            Delete();
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/SeaSnake.cs

@@ -0,0 +1,74 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a sea snake corpse")]
+    public class SeaSnake : BaseCreature
+    {
+        [Constructable]
+        public SeaSnake()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Body = 92;
+            this.Name = "a sea snake";
+            this.BaseSoundID = 219;
+            this.Hue = 2041;
+
+            this.SetStr(261);
+            this.SetDex(193);
+            this.SetInt(39);
+
+            this.SetHits(194);
+
+            this.SetDamage(5, 21);
+
+            this.SetDamageType(ResistanceType.Physical, 50);
+            this.SetDamageType(ResistanceType.Poison, 50);
+
+            this.SetResistance(ResistanceType.Physical, 35, 45);
+            this.SetResistance(ResistanceType.Fire, 5, 10);
+            this.SetResistance(ResistanceType.Cold, 5, 10);
+            this.SetResistance(ResistanceType.Poison, 100);
+            this.SetResistance(ResistanceType.Energy, 5, 10);
+
+            this.SetSkill(SkillName.Poisoning, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 95.1, 100.0);
+            this.SetSkill(SkillName.Tactics, 80.1, 95.0);
+            this.SetSkill(SkillName.Wrestling, 85.1, 100.0);
+
+            this.Fame = 7000;
+            this.Karma = -7000;
+
+            this.VirtualArmor = 40;
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Average);
+            AddLoot(LootPack.Gems, 2);
+        }
+
+        public override bool DeathAdderCharmable { get { return true; } }
+        public override int Meat { get { return 1; } }
+        public override Poison PoisonImmune { get { return Poison.Deadly; } }
+        public override Poison HitPoison { get { return Poison.Deadly; } }
+
+        public SeaSnake(Serial serial)
+            : base(serial)
+        {
+        }
+
+        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/Services/ExploringTheDeep/Mobiles/Shadowlord.cs

@@ -0,0 +1,284 @@
+using System;
+using Server.Items;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Server.Mobiles
+{
+    public enum ShadowlordType
+    {
+        Astaroth,
+        Faulinei,
+        Nosfentor        
+    };
+    
+    [CorpseName("a shadowlord corpse")]
+    public class Shadowlord : BaseCreature
+    {
+        private static readonly ArrayList m_Instances = new ArrayList();
+        public static ArrayList Instances { get { return m_Instances; } }
+
+        private ShadowlordType m_Type;
+        public virtual Type[] ArtifactDrops { get { return _ArtifactTypes; } }
+
+        private Type[] _ArtifactTypes = new Type[]
+        {
+            typeof(Abhorrence),         typeof(CaptainJohnesBlade),             typeof(Craven),
+            typeof(Equivocation),       typeof(GargishCaptainJohnesBlade),      typeof(GargishEquivocation),
+            typeof(GargishPincer),      typeof(Pincer)
+        };
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public ShadowlordType Type
+        {
+            get
+            {
+                return m_Type;
+            }
+            set
+            {
+                m_Type = value;
+                InvalidateProperties();
+            }
+        }
+
+        [Constructable]
+        public Shadowlord()
+            : base(AIType.AI_NecroMage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            m_Instances.Add(this);
+
+            m_Type = (ShadowlordType)Utility.Random(3);
+            Name = m_Type.ToString();
+
+            Body = 146;
+            BaseSoundID = 0x4B0;
+
+            SetStr(981, 1078);
+            SetDex(1003, 1114);
+            SetInt(1098, 1245);
+
+            SetHits(50000, 55000);
+            SetStam(1003, 1114);
+
+            SetDamage(35, 41);
+
+            SetDamageType(ResistanceType.Physical, 20);
+            SetDamageType(ResistanceType.Fire, 20);
+            SetDamageType(ResistanceType.Cold, 20);
+            SetDamageType(ResistanceType.Poison, 20);
+            SetDamageType(ResistanceType.Energy, 20);
+
+            SetResistance(ResistanceType.Physical, 70, 80);
+            SetResistance(ResistanceType.Fire, 70, 80);
+            SetResistance(ResistanceType.Cold, 70, 80);
+            SetResistance(ResistanceType.Poison, 70, 80);
+            SetResistance(ResistanceType.Energy, 70, 80);
+
+            SetSkill(SkillName.EvalInt, 140.0);
+            SetSkill(SkillName.Magery, 120.0);
+            SetSkill(SkillName.Meditation, 140.0);
+            SetSkill(SkillName.MagicResist, 110.2, 120.0);
+            SetSkill(SkillName.Tactics, 110.1, 115.0);
+            SetSkill(SkillName.Wrestling, 110.1, 115.0);
+			SetSkill(SkillName.Necromancy, 120.0);
+            SetSkill(SkillName.SpiritSpeak, 120.0);
+            SetSkill(SkillName.Anatomy, 10.0, 20.0);
+
+            Fame = 24000;
+            Karma = -24000;
+
+            VirtualArmor = 20;
+            Hue = 902;
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+
+            SetSpecialAbility(SpecialAbility.LifeDrain);
+        }
+
+        public override void GetProperties(ObjectPropertyList list)
+        {
+            base.GetProperties(list);
+
+            list.Add("#{0}", 1154453 + (int)m_Type); // Shadowlord of ..
+        }
+
+        public Shadowlord(Serial serial)
+            : base(serial)
+        {
+            m_Instances.Add(this);
+        }
+
+        public override void OnAfterDelete()
+        {
+            m_Instances.Remove(this);
+
+            base.OnAfterDelete();
+        }
+
+        public override bool AlwaysMurderer { get { return true; } }
+
+        public override int GetAngerSound() { return 1550; }
+        public override int GetHurtSound() { return 1552; }
+        public override int GetDeathSound() { return 1551; }
+        
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private Shadowlord Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(180))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((Shadowlord)p);
+            }
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    Stop();
+                }
+            }
+        }
+
+        public static Shadowlord Spawn(Point3D platLoc, Map platMap)
+        {
+            if (m_Instances.Count > 0)
+                return null;
+
+            Shadowlord creature = new Shadowlord();
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.SuperBoss, 4);
+            AddLoot(LootPack.FilthyRich);
+        }
+
+        public override void CheckReflect(Mobile caster, ref bool reflect)
+        {
+            int c = 0;
+            IPooledEnumerable eable = GetMobilesInRange(20);
+
+            foreach (Mobile m in eable)
+            {
+                if (m != null && m is DarkWisp)
+                    c++;
+                continue;
+            }
+            eable.Free();
+            if (c > 0)
+                reflect = true; // Reflect spells if ShadowLord having wisps around
+        }
+
+        public override void OnDrainLife(Mobile victim)
+        {
+            if (Map == null)
+                return;
+
+            ArrayList list = new ArrayList();
+            int count = 0;
+            IPooledEnumerable eable = GetMobilesInRange(20);
+
+            foreach (Mobile m in eable)
+            {
+                if (m == this || !CanBeHarmful(m))
+                {
+                    if (m is DarkWisp) { count++; }
+                    continue;
+                }
+
+                if (m is BaseCreature && (((BaseCreature)m).Controlled || ((BaseCreature)m).Summoned || ((BaseCreature)m).Team != Team))
+                    list.Add(m);
+                else if (m.Player)
+                    list.Add(m);
+            }
+
+            eable.Free();
+
+            foreach (Mobile m in list)
+            {
+                (new DarkWisp()).MoveToWorld(new Point3D(Location), Map);
+                int teleportchance = Hits / HitsMax;
+
+                if (teleportchance < Utility.RandomDouble() && m.Alive)
+                {
+                    switch (Utility.Random(6))
+                    {
+                        case 0: m.MoveToWorld(new Point3D(6431, 1664, 0), Map); break;
+                        case 1: m.MoveToWorld(new Point3D(6432, 1634, 0), Map); break;
+                        case 2: m.MoveToWorld(new Point3D(6401, 1657, 0), Map); break;
+                        case 3: m.MoveToWorld(new Point3D(6401, 1637, 0), Map); break;
+                        default: m.MoveToWorld(new Point3D(Location), Map); break;
+                    }
+                }
+            }
+        }
+
+        public override void OnDeath(Container c)
+        {
+            List<DamageStore> rights = GetLootingRights();
+
+            foreach (DamageStore ds in rights.Where(s => s.m_HasRight))
+            {
+                int luck = ds.m_Mobile is PlayerMobile ? ((PlayerMobile)ds.m_Mobile).RealLuck : ds.m_Mobile.Luck;
+                int chance = 75 + (luck / 15);
+
+                if (chance > Utility.Random(5000))
+                {
+                    Mobile m = ds.m_Mobile;
+                    Item artifact = Loot.Construct(ArtifactDrops[Utility.Random(ArtifactDrops.Length)]);
+
+                    if (artifact != null)
+                    {
+                        if (m.Backpack == null || !m.Backpack.TryDropItem(m, artifact, false))
+                        {
+                            m.BankBox.DropItem(artifact);
+                            m.SendMessage("For your valor in combating the fallen beast, a special reward has been placed in your bankbox.");
+                        }
+                        else
+                            m.SendLocalizedMessage(1062317); // For your valor in combating the fallen beast, a special reward has been bestowed on you.
+                    }
+                }
+            }
+
+            base.OnDeath(c);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0); // version
+
+            writer.Write((int)m_Type);
+
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            switch (version)
+            {
+                case 0:
+                    {
+                        m_Type = (ShadowlordType)reader.ReadInt();
+
+                        break;
+                    }
+            }
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+    }
+}

Scripts/Services/ExploringTheDeep/Mobiles/ShipBat.cs

@@ -0,0 +1,68 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a ship bat corpse")]
+    public class ShipBat : VampireBat
+    {
+        [Constructable]
+        public ShipBat()
+            : base()
+        {
+            Name = "a ship bat";
+            Body = 317;
+            BaseSoundID = 0x270;
+
+            SetStr(120);
+            SetDex(120);
+            SetInt(101);
+
+            SetHits(85, 96);
+
+            SetDamage(4, 12);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 15, 20);
+            SetResistance(ResistanceType.Fire, 15, 25);
+            SetResistance(ResistanceType.Cold, 10, 15);
+            SetResistance(ResistanceType.Poison, 15, 25);
+            SetResistance(ResistanceType.Energy, 10, 15);
+
+            //SetSkill( SkillName.MagicResist, 70.1, 95.0 );
+            SetSkill(SkillName.Tactics, 45.0, 55.0);
+            SetSkill(SkillName.Wrestling, 90.0, 100.0);
+
+            Fame = 1000;
+            Karma = -1000;
+
+            VirtualArmor = 14;
+        }
+
+        public override void GenerateLoot()
+        {
+            AddLoot(LootPack.Poor);
+        }
+
+        public override int GetIdleSound()
+        {
+            return 0x29B;
+        }
+
+        public ShipBat(Serial serial) : base(serial)
+        {
+        }
+
+        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/Services/ExploringTheDeep/Mobiles/ShipRat.cs

@@ -0,0 +1,85 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a ship rat corpse")]
+    public class ShipRat : BaseCreature
+    {
+        [Constructable]
+        public ShipRat()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "Ship Rat";
+            this.Body = 0xD7;
+            this.BaseSoundID = 0x188;
+
+            this.SetStr(32, 74);
+            this.SetDex(46, 65);
+            this.SetInt(16, 30);
+
+            this.SetHits(26, 39);
+            this.SetMana(0);
+
+            this.SetDamage(4, 8);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 15, 20);
+            this.SetResistance(ResistanceType.Fire, 5, 10);
+            this.SetResistance(ResistanceType.Poison, 25, 35);
+
+            this.SetSkill(SkillName.MagicResist, 25.1, 30.0);
+            this.SetSkill(SkillName.Tactics, 29.3, 44.0);
+            this.SetSkill(SkillName.Wrestling, 29.3, 44.0);
+
+            this.Fame = 300;
+            this.Karma = -300;
+
+            this.VirtualArmor = 18;
+        }
+
+        public ShipRat(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int Meat
+        {
+            get
+            {
+                return 1;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 6;
+            }
+        }
+        public override FoodType FavoriteFood
+        {
+            get
+            {
+                return FoodType.Fish | FoodType.Meat | FoodType.FruitsAndVegies | FoodType.Eggs;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Poor);
+        }
+
+        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/Services/ExploringTheDeep/Mobiles/TheMasterInstructor.cs

@@ -0,0 +1,180 @@
+using Server.Items;
+using System;
+using System.Collections;
+using System.Collections.Generic;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an ancient liche's corpse")]
+    public class TheMasterInstructor : BaseCreature
+    {
+        private static readonly ArrayList m_Instances = new ArrayList();
+        public static ArrayList Instances { get { return m_Instances; } }
+        private SorcerersPlateController m_Controller;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public SorcerersPlateController Controller
+        {
+            get
+            {
+                return this.m_Controller;
+            }
+        }
+
+        [Constructable]
+        public TheMasterInstructor(SorcerersPlateController controller)
+            : base(AIType.AI_NecroMage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            m_Instances.Add(this);
+            m_Controller = controller;
+
+            this.Name = "Anshu";
+            this.Title = "The Master Instructor";
+            this.Body = 0x4e;
+            this.BaseSoundID = 412;
+            this.Hue = 1284;
+
+            this.SetStr(216, 305);
+            this.SetDex(96, 115);
+            this.SetInt(966, 1045);
+
+            this.SetHits(700, 800);
+
+            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, 30, 40);
+            this.SetResistance(ResistanceType.Cold, 50, 60);
+            this.SetResistance(ResistanceType.Poison, 50, 60);
+            this.SetResistance(ResistanceType.Energy, 50, 60);
+
+            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.Poisoning, 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.SetSkill(SkillName.Necromancy, 120.0);
+            this.SetSkill(SkillName.SpiritSpeak, 120.0);
+			this.SetSkill(SkillName.DetectHidden, 100.0);
+
+            this.Fame = 23000;
+            this.Karma = -23000;
+
+            this.VirtualArmor = 60;
+            this.PackNecroReg(30, 275);
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+        
+        public class InternalSelfDeleteTimer : Timer
+        {
+            private TheMasterInstructor Mare;
+
+            public InternalSelfDeleteTimer(Mobile p) : base(TimeSpan.FromMinutes(60))
+            {
+                Priority = TimerPriority.FiveSeconds;
+                Mare = ((TheMasterInstructor)p);
+            }
+
+            protected override void OnTick()
+            {
+                if (Mare.Map != Map.Internal)
+                {
+                    Mare.Delete();
+                    this.Stop();
+                }
+            }
+        }
+
+        public TheMasterInstructor(Serial serial)
+            : base(serial)
+        {
+            m_Instances.Add(this);
+        }
+        
+        public override bool AlwaysMurderer { get { return true; } }
+        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 TreasureMapLevel { get { return 5; } }
+		public override bool AutoDispel { get { return true; } }
+
+        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 bool OnBeforeDeath()
+        {
+            Mobile killer = DemonKnight.FindRandomPlayer(this);
+
+            if (killer != null)
+            {
+                Item item = new StrongboxKey();
+
+                Container pack = killer.Backpack;
+
+                if (pack == null || !pack.TryDropItem(killer, item, false))
+                    killer.BankBox.DropItem(item);
+
+                killer.SendLocalizedMessage(1154489); // You received a Quest Item!
+            }
+
+            Timer.DelayCall(TimeSpan.FromMinutes(10.0), new TimerCallback(m_Controller.CreateSorcerersPlates));
+
+            return base.OnBeforeDeath();
+        }
+
+        public static TheMasterInstructor Spawn(Point3D platLoc, Map platMap, SorcerersPlateController controller)
+        {
+            if (m_Instances.Count > 0)
+                return null;
+            
+            TheMasterInstructor creature = new TheMasterInstructor(controller);
+            creature.Home = platLoc;
+            creature.RangeHome = 4;
+            creature.MoveToWorld(platLoc, platMap);
+
+            return creature;
+        }
+
+        public override void OnAfterDelete()
+        {
+            m_Instances.Remove(this);
+
+            base.OnAfterDelete();
+        }
+
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.FilthyRich, 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();
+
+            Timer SelfDeleteTimer = new InternalSelfDeleteTimer(this);
+            SelfDeleteTimer.Start();
+        }
+    }
+}