Overwrite

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

Scripts/Mobiles/Summons/AnimatedWeapon.cs

@@ -0,0 +1,108 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an animated weapon corpse")]
+    public class AnimatedWeapon : BaseCreature
+    {
+        public override bool DeleteCorpseOnDeath { get { return true; } }
+        public override bool IsHouseSummonable { get { return true; } }
+
+        public override double DispelDifficulty { get { return 0.0; } }
+        public override double DispelFocus { get { return 20.0; } }
+
+        [Constructable]
+        public AnimatedWeapon(Mobile caster, int level)
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.3, 0.6)
+        {
+            Name = "an animated weapon";
+            Body = 692;
+
+            SetStr(10 + level);
+            SetDex(10 + level);
+            SetInt(10);
+
+            SetHits(20 + (level * 3 / 2));
+            SetStam(10 + level);
+            SetMana(0);
+
+            if (level >= 120)
+                SetDamage(14, 18);
+            else if (level >= 105)
+                SetDamage(13, 17);
+            else if (level >= 90)
+                SetDamage(12, 15);
+            else if (level >= 75)
+                SetDamage(11, 14);
+            else if (level >= 60)
+                SetDamage(10, 12);
+            else if (level >= 45)
+                SetDamage(9, 11);
+            else if (level >= 30)
+                SetDamage(8, 9);
+            else
+                SetDamage(7, 8);
+
+            SetDamageType(ResistanceType.Physical, 60);
+            SetDamageType(ResistanceType.Poison, 20);
+            SetDamageType(ResistanceType.Energy, 20);
+
+            SetResistance(ResistanceType.Physical, 40, 50);
+            SetResistance(ResistanceType.Fire, 30, 40);
+            SetResistance(ResistanceType.Cold, 30, 40);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 20, 30);
+
+            SetSkill(SkillName.MagicResist, level);
+            SetSkill(SkillName.Tactics, caster.Skills[SkillName.Tactics].Value / 2);
+            SetSkill(SkillName.Wrestling, level);
+            SetSkill(SkillName.Anatomy, caster.Skills[SkillName.Anatomy].Value / 2);
+            SetSkill(SkillName.DetectHidden, 40, 50);
+
+            Fame = 0;
+            Karma = 0;
+
+            ControlSlots = 4;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x23A;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x3B8;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x23A;
+        }
+
+        public AnimatedWeapon(Serial serial) : base(serial)
+        {
+        }
+
+        public override double GetFightModeRanking(Mobile m, FightMode acqType, bool bPlayerOnly)
+        {
+            return (m.Str + m.Skills[SkillName.Tactics].Value) / Math.Max(GetDistanceToSqrt(m), 1.0);
+        }
+
+        public override bool AlwaysMurderer { get { return true; } }
+        public override bool BleedImmune { get { return true; } }
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+
+        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/Summons/BaseFamiliar.cs

@@ -0,0 +1,306 @@
+#region References
+using System.Collections.Generic;
+using System;
+using System.Linq;
+
+using Server.ContextMenus;
+using Server.Items;
+using Server.Spells.Necromancy;
+#endregion
+
+namespace Server.Mobiles
+{
+	public abstract class BaseFamiliar : BaseCreature
+	{
+		private bool m_LastHidden;
+        private long m_NextMove;
+
+        private DateTime m_SeperationStart;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public DateTime SeperationStart
+        {
+            get { return m_SeperationStart; }
+            set { m_SeperationStart = value; }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public override IDamageable Combatant
+        {
+            get { return null; }
+            set { }
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public override OrderType ControlOrder
+        {
+            get { return OrderType.Come; }
+            set { }
+        }
+
+		public BaseFamiliar()
+			: base(AIType.AI_Melee, FightMode.Closest, 10, 1, -1, -1)
+		{ }
+
+		public BaseFamiliar(Serial serial)
+			: base(serial)
+		{ }
+
+		public override bool BardImmune { get { return true; } }
+		public override Poison PoisonImmune { get { return Poison.Lethal; } }
+		public override bool Commandable { get { return false; } }
+		public override bool PlayerRangeSensitive { get { return false; } }
+        public override bool CanDetectHidden { get { return false; } }
+
+        public virtual bool RangeCheck()
+        {
+            Mobile master = ControlMaster;
+
+            if (Deleted || master == null || master.Deleted)
+                return false;
+
+            int dist = (int)master.GetDistanceToSqrt(Location);
+
+            if (master.Map != Map || dist > 15)
+            {
+                if (m_SeperationStart == DateTime.MinValue)
+                {
+                    m_SeperationStart = DateTime.UtcNow + TimeSpan.FromMinutes(60);
+                }
+                else if (m_SeperationStart < DateTime.UtcNow)
+                {
+                    Delete();
+                }
+
+                return false;
+            }
+
+            if (m_SeperationStart != DateTime.MinValue)
+            {
+                m_SeperationStart = DateTime.MinValue;
+            }
+
+            int range = 4;
+
+            if (!InRange(ControlMaster.Location, RangeHome) && InLOS(ControlMaster))
+            {
+                Point3D loc = Point3D.Zero;
+
+                if (Map == master.Map)
+                {
+                    int x = (X > master.X) ? (master.X + range) : (master.X - range);
+                    int y = (Y > master.Y) ? (master.Y + range) : (master.Y - range);
+
+                    for (int i = 0; i < 10; i++)
+                    {
+                        loc.X = x + Utility.RandomMinMax(-1, 1);
+                        loc.Y = y + Utility.RandomMinMax(-1, 1);
+
+                        loc.Z = Map.GetAverageZ(loc.X, loc.Y);
+
+                        if (Map.CanSpawnMobile(loc))
+                        {
+                            break;
+                        }
+
+                        loc = master.Location;
+                    }
+
+                    if (!Deleted)
+                    {
+                        SetLocation(loc, true);
+                    }
+                }
+
+                return false;
+            }
+
+            return true;
+        }
+
+		public override void OnThink()
+		{
+            if (Deleted || Map == null)
+			{
+				return;
+			}
+
+            Mobile master = ControlMaster;
+
+			if (master == null || master.Deleted)
+			{
+				DropPackContents();
+				EndRelease(null);
+				return;
+			}
+
+			if (m_LastHidden != master.Hidden)
+			{
+				Hidden = m_LastHidden = master.Hidden;
+			}
+
+            if (RangeCheck())
+            {
+                if (AIObject != null && AIObject.WalkMobileRange(master, 5, true, 1, 1))
+                {
+                    if (master.Combatant != null && master.InRange(master.Combatant, 1) && Core.TickCount > m_NextMove)
+                    {
+                        IDamageable combatant = master.Combatant;
+
+                        if (!InRange(combatant.Location, 1))
+                        {
+                            for (int x = combatant.X - 1; x <= combatant.X + 1; x++)
+                            {
+                                for (int y = combatant.Y - 1; y <= combatant.Y + 1; y++)
+                                {
+                                    if (x == combatant.X && y == combatant.Y)
+                                    {
+                                        continue;
+                                    }
+
+                                    Point2D p = new Point2D(x, y);
+
+                                    if (InRange(p, 1) && master.InRange(p, 1) && Map != null)
+                                    {
+                                        CurrentSpeed = .01;
+                                        AIObject.MoveTo(new Point3D(x, y, Map.GetAverageZ(x, y)), false, 0);
+                                        m_NextMove = Core.TickCount + 500;
+                                    }
+                                }
+                            }
+                        }
+                        else
+                        {
+                            CurrentSpeed = .1;
+                        }
+                    }
+                    else if (master.Combatant == null)
+                    {
+                        CurrentSpeed = .1;
+                    }
+                }
+                else
+                {
+                    CurrentSpeed = .1;
+                }
+            }
+		}
+
+		public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+		{
+			base.GetContextMenuEntries(from, list);
+
+			if (from.Alive && Controlled && from == ControlMaster && from.InRange(this, 14))
+			{
+				list.Add(new ReleaseEntry(from, this));
+			}
+		}
+
+		public virtual void BeginRelease(Mobile from)
+		{
+			if (!Deleted && Controlled && from == ControlMaster && from.CheckAlive())
+			{
+				EndRelease(from);
+			}
+		}
+
+		public virtual void EndRelease(Mobile from)
+		{
+			if (from == null || (!Deleted && Controlled && from == ControlMaster && from.CheckAlive()))
+			{
+				Effects.SendLocationParticles(
+					EffectItem.Create(Location, Map, EffectItem.DefaultDuration), 0x3728, 1, 13, 2100, 3, 5042, 0);
+				PlaySound(0x201);
+				Delete();
+			}
+		}
+
+		public virtual void DropPackContents()
+		{
+			Map map = Map;
+			Container pack = Backpack;
+
+			if (map != null && map != Map.Internal && pack != null)
+			{
+				var list = new List<Item>(pack.Items);
+
+				for (int i = 0; i < list.Count; ++i)
+				{
+					list[i].MoveToWorld(Location, map);
+				}
+			}
+		}
+
+        public static void OnHit(Mobile attacker, IDamageable defender)
+        {
+            BaseCreature check = (BaseCreature)SummonFamiliarSpell.Table[attacker];
+
+            if (check != null && check is BaseFamiliar && check.Weapon != null && check.InRange(defender.Location, check.Weapon.MaxRange))
+            {
+                check.Weapon.OnSwing(check, defender);
+            }
+
+            if (attacker is PlayerMobile)
+            {
+                foreach (var ts in ((PlayerMobile)attacker).AllFollowers.Where(m => m is BaseTalismanSummon && m.InRange(defender.Location, m.Weapon.MaxRange)))
+                {
+                    ts.Weapon.OnSwing(ts, defender);
+                }
+            }
+        }
+
+        public static void OnLogout(PlayerMobile pm)
+        {
+            if (pm == null)
+                return;
+
+            BaseCreature check = (BaseCreature)SummonFamiliarSpell.Table[pm];
+
+            if (check != null)
+                check.Delete();
+        }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			int version = reader.ReadInt();
+
+			ValidationQueue<BaseFamiliar>.Add(this);
+		}
+
+		public void Validate()
+		{
+			DropPackContents();
+			Delete();
+		}
+
+		private class ReleaseEntry : ContextMenuEntry
+		{
+			private readonly Mobile m_From;
+			private readonly BaseFamiliar m_Familiar;
+
+			public ReleaseEntry(Mobile from, BaseFamiliar familiar)
+				: base(6118, 14)
+			{
+				m_From = from;
+				m_Familiar = familiar;
+			}
+
+			public override void OnClick()
+			{
+				if (!m_Familiar.Deleted && m_Familiar.Controlled && m_From == m_Familiar.ControlMaster && m_From.CheckAlive())
+				{
+					m_Familiar.BeginRelease(m_From);
+				}
+			}
+		}
+	}
+}

Scripts/Mobiles/Summons/BladeSpirits.cs

@@ -0,0 +1,165 @@
+using System;
+using System.Collections;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a blade spirit corpse")]
+    public class BladeSpirits : BaseCreature
+    {
+        [Constructable]
+        public BladeSpirits()
+            : this(false)
+        {
+        }
+
+        [Constructable]
+        public BladeSpirits(bool summoned)
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.3, 0.6)
+        {
+            this.Name = "a blade spirit";
+            this.Body = 574;
+
+            bool weak = summoned && Siege.SiegeShard;
+
+            this.SetStr(weak ? 100 : 150);
+            this.SetDex(weak ? 100 : 150);
+            this.SetInt(100);
+
+            this.SetHits((Core.SE && !weak) ? 160 : 80);
+            this.SetStam(250);
+            this.SetMana(0);
+
+            this.SetDamage(10, 14);
+
+            this.SetDamageType(ResistanceType.Physical, 60);
+            this.SetDamageType(ResistanceType.Poison, 20);
+            this.SetDamageType(ResistanceType.Energy, 20);
+
+            this.SetResistance(ResistanceType.Physical, 30, 40);
+            this.SetResistance(ResistanceType.Fire, 40, 50);
+            this.SetResistance(ResistanceType.Cold, 30, 40);
+            this.SetResistance(ResistanceType.Poison, 100);
+            this.SetResistance(ResistanceType.Energy, 20, 30);
+
+            this.SetSkill(SkillName.MagicResist, 70.0);
+            this.SetSkill(SkillName.Tactics, 90.0);
+            this.SetSkill(SkillName.Wrestling, 90.0);
+
+            this.Fame = 0;
+            this.Karma = 0;
+
+            this.VirtualArmor = 40;
+            this.ControlSlots = (Core.SE) ? 2 : 1;
+        }
+
+        public BladeSpirits(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool DeleteCorpseOnDeath
+        {
+            get
+            {
+                return Core.AOS;
+            }
+        }
+        public override bool IsHouseSummonable
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 0.0;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 20.0;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override double GetFightModeRanking(Mobile m, FightMode acqType, bool bPlayerOnly)
+        {
+            return (m.Str + m.Skills[SkillName.Tactics].Value) / Math.Max(this.GetDistanceToSqrt(m), 1.0);
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x23A;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x3B8;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x23A;
+        }
+
+        public override void OnThink()
+        {
+            if (Core.SE && this.Summoned)
+            {
+                ArrayList spirtsOrVortexes = new ArrayList();
+                IPooledEnumerable eable = GetMobilesInRange(5);
+
+                foreach (Mobile m in eable)
+                {
+                    if (m is EnergyVortex || m is BladeSpirits)
+                    {
+                        if (((BaseCreature)m).Summoned)
+                            spirtsOrVortexes.Add(m);
+                    }
+                }
+
+                eable.Free();
+
+                while (spirtsOrVortexes.Count > 6)
+                {
+                    int index = Utility.Random(spirtsOrVortexes.Count);
+                    this.Dispel(((Mobile)spirtsOrVortexes[index]));
+                    spirtsOrVortexes.RemoveAt(index);
+                }
+            }
+
+            base.OnThink();
+        }
+
+        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/Summons/DarkWolf.cs

@@ -0,0 +1,97 @@
+using System;
+using System.Linq;
+
+using Server.Spells.Necromancy;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a dark wolf corpse")]
+    public class DarkWolfFamiliar : BaseFamiliar
+    {
+        private DateTime m_NextRestore;
+        public DarkWolfFamiliar()
+        {
+            Name = "a dark wolf";
+            Body = 99;
+            Hue = 0x901;
+            BaseSoundID = 0xE5;
+
+            SetStr(100);
+            SetDex(90);
+            SetInt(90);
+
+            SetHits(60);
+            SetStam(90);
+            SetMana(0);
+
+            SetDamage(5, 10);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 40, 50);
+            SetResistance(ResistanceType.Fire, 25, 40);
+            SetResistance(ResistanceType.Cold, 25, 40);
+            SetResistance(ResistanceType.Poison, 25, 40);
+            SetResistance(ResistanceType.Energy, 25, 40);
+
+            SetSkill(SkillName.Wrestling, 85.1, 90.0);
+            SetSkill(SkillName.Tactics, 50.0);
+
+            ControlSlots = 1;
+        }
+
+        public DarkWolfFamiliar(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public static readonly Type[] ControlTypes =
+        {
+            typeof(DireWolf), typeof(GreyWolf), typeof(TimberWolf), typeof(WhiteWolf), typeof(BakeKitsune)
+        };
+
+        public static bool CheckMastery(Mobile tamer, BaseCreature creature)
+        {
+            var familiar = (BaseCreature)SummonFamiliarSpell.Table[tamer];
+
+            if (familiar != null && !familiar.Deleted && familiar is DarkWolfFamiliar && ControlTypes.Any(t => t == creature.GetType()))
+            {
+                return true;
+            }
+
+            return false;
+        }
+
+        public override void OnThink()
+        {
+            base.OnThink();
+
+            if (DateTime.UtcNow < m_NextRestore)
+                return;
+
+            m_NextRestore = DateTime.UtcNow + TimeSpan.FromSeconds(2.0);
+
+            Mobile caster = ControlMaster;
+
+            if (caster == null)
+                caster = SummonMaster;
+
+            if (caster != null)
+                ++caster.Stam;
+        }
+
+        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/Summons/DeathAdder.cs

@@ -0,0 +1,63 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a death adder corpse")]
+    public class DeathAdder : BaseFamiliar
+    {
+        public DeathAdder()
+        {
+            this.Name = "a death adder";
+            this.Body = 0x15;
+            this.Hue = 0x455;
+            this.BaseSoundID = 219;
+
+            this.SetStr(70);
+            this.SetDex(150);
+            this.SetInt(100);
+
+            this.SetHits(50);
+            this.SetStam(150);
+            this.SetMana(0);
+
+            this.SetDamage(1, 4);
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 10);
+            this.SetResistance(ResistanceType.Poison, 100);
+
+            this.SetSkill(SkillName.Wrestling, 90.0);
+            this.SetSkill(SkillName.Tactics, 50.0);
+            this.SetSkill(SkillName.MagicResist, 100.0);
+            this.SetSkill(SkillName.Poisoning, 150.0);
+
+            this.ControlSlots = 1;
+        }
+
+        public DeathAdder(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override Poison HitPoison
+        {
+            get
+            {
+                return (0.8 >= Utility.RandomDouble() ? Poison.Greater : Poison.Deadly);
+            }
+        }
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.WriteEncodedInt(0); // version
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadEncodedInt();
+        }
+    }
+}

Scripts/Mobiles/Summons/Dummy.cs

@@ -0,0 +1,151 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    /// <summary>
+    /// This is a test creature
+    /// You can set its value in game
+    /// It die after 5 minutes, so your test server stay clean
+    /// Create a macro to help your creation "[add Dummy 1 15 7 -1 0.5 2"
+    /// 
+    /// A iTeam of negative will set a faction at random
+    /// 
+    /// Say Kill if you want them to die
+    /// 
+    /// </summary>
+    public class Dummy : BaseCreature
+    {
+        public Timer	m_Timer;
+        [Constructable]
+        public Dummy(AIType iAI, FightMode iFightMode, int iRangePerception, int iRangeFight, double dActiveSpeed, double dPassiveSpeed)
+            : base(iAI, iFightMode, iRangePerception, iRangeFight, dActiveSpeed, dPassiveSpeed)
+        {
+            this.Body = 400 + Utility.Random(2);
+            this.Hue = Utility.RandomSkinHue();
+
+            this.Skills[SkillName.DetectHidden].Base = 100;
+            this.Skills[SkillName.MagicResist].Base = 120;
+
+            this.Team = Utility.Random(3);
+
+            int iHue = 20 + this.Team * 40;
+            int jHue = 25 + this.Team * 40;
+
+            Utility.AssignRandomHair(this, iHue);
+
+            LeatherGloves glv = new LeatherGloves();
+            glv.Hue = iHue;
+            glv.LootType = LootType.Newbied;
+            this.AddItem(glv);
+
+            Container pack = new Backpack();
+
+            pack.Movable = false;
+
+            this.AddItem(pack);
+
+            this.m_Timer = new AutokillTimer(this);
+            this.m_Timer.Start();
+        }
+
+        public Dummy(Serial serial)
+            : base(serial)
+        {
+            this.m_Timer = new AutokillTimer(this);
+            this.m_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();
+        }
+
+        public override bool HandlesOnSpeech(Mobile from)
+        {
+            if (from.AccessLevel >= AccessLevel.GameMaster)
+                return true;
+
+            return base.HandlesOnSpeech(from);
+        }
+
+        public override void OnSpeech(SpeechEventArgs e)
+        {
+            base.OnSpeech(e);
+
+            if (e.Mobile.AccessLevel >= AccessLevel.GameMaster)
+            {
+                if (e.Speech == "kill")
+                {
+                    this.m_Timer.Stop();
+                    this.m_Timer.Delay = TimeSpan.FromSeconds(Utility.Random(1, 5));
+                    this.m_Timer.Start();
+                }
+            }
+        }
+
+        public override void OnTeamChange()
+        {
+            int iHue = 20 + this.Team * 40;
+            int jHue = 25 + this.Team * 40;
+
+            Item item = this.FindItemOnLayer(Layer.OuterTorso);
+
+            if (item != null)
+                item.Hue = jHue;
+
+            item = this.FindItemOnLayer(Layer.Helm);
+
+            if (item != null)
+                item.Hue = iHue;
+
+            item = this.FindItemOnLayer(Layer.Gloves);
+
+            if (item != null)
+                item.Hue = iHue;
+
+            item = this.FindItemOnLayer(Layer.Shoes);
+
+            if (item != null)
+                item.Hue = iHue;
+
+            this.HairHue = iHue;
+
+            item = this.FindItemOnLayer(Layer.MiddleTorso);
+
+            if (item != null)
+                item.Hue = iHue;
+
+            item = this.FindItemOnLayer(Layer.OuterLegs);
+
+            if (item != null)
+                item.Hue = iHue;
+        }
+
+        private class AutokillTimer : Timer
+        {
+            private readonly Dummy m_Owner;
+            public AutokillTimer(Dummy owner)
+                : base(TimeSpan.FromMinutes(5.0))
+            {
+                this.m_Owner = owner;
+                this.Priority = TimerPriority.FiveSeconds;
+            }
+
+            protected override void OnTick()
+            {
+                this.m_Owner.Kill();
+                this.Stop();
+            }
+        }
+    }
+}

Scripts/Mobiles/Summons/DummySpecific.cs

@@ -0,0 +1,813 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    /// <summary>
+    /// This is a test creature
+    /// You can set its value in game
+    /// It die after 5 minutes, so your test server stay clean
+    /// Create a macro to help your creation "[add Dummy 1 15 7 -1 0.5 2"
+    /// 
+    /// A iTeam of negative will set a faction at random
+    /// 
+    /// Say Kill if you want them to die
+    /// 
+    /// </summary>
+    public class DummyMace : Dummy
+    {
+        [Constructable]
+        public DummyMace()
+            : base(AIType.AI_Melee, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Macer
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(125, 125, 90);
+            Skills[SkillName.Macing].Base = 120;
+            Skills[SkillName.Anatomy].Base = 120;
+            Skills[SkillName.Healing].Base = 120;
+            Skills[SkillName.Tactics].Base = 120;
+
+            // Name
+            Name = "Macer";
+
+            // Equip
+            WarHammer war = new WarHammer();
+            war.Movable = true;
+            war.Crafter = this;
+            war.Quality = ItemQuality.Normal;
+            AddItem(war);
+
+            Boots bts = new Boots();
+            bts.Hue = iHue;
+            AddItem(bts);
+
+            ChainChest cht = new ChainChest();
+            cht.Movable = false;
+            cht.LootType = LootType.Newbied;
+            cht.Crafter = this;
+            cht.Quality = ItemQuality.Normal;
+            AddItem(cht);
+
+            ChainLegs chl = new ChainLegs();
+            chl.Movable = false;
+            chl.LootType = LootType.Newbied;
+            chl.Crafter = this;
+            chl.Quality = ItemQuality.Normal;
+            AddItem(chl);
+
+            PlateArms pla = new PlateArms();
+            pla.Movable = false;
+            pla.LootType = LootType.Newbied;
+            pla.Crafter = this;
+            pla.Quality = ItemQuality.Normal;
+            AddItem(pla);
+
+            Bandage band = new Bandage(50);
+            AddToBackpack(band);
+        }
+
+        public DummyMace(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();
+        }
+    }
+
+    public class DummyFence : Dummy
+    {
+        [Constructable]
+        public DummyFence()
+            : base(AIType.AI_Melee, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Fencer
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(125, 125, 90);
+            Skills[SkillName.Fencing].Base = 120;
+            Skills[SkillName.Anatomy].Base = 120;
+            Skills[SkillName.Healing].Base = 120;
+            Skills[SkillName.Tactics].Base = 120;
+
+            // Name
+            Name = "Fencer";
+
+            // Equip
+            Spear ssp = new Spear();
+            ssp.Movable = true;
+            ssp.Crafter = this;
+            ssp.Quality = ItemQuality.Normal;
+            AddItem(ssp);
+
+            Boots snd = new Boots();
+            snd.Hue = iHue;
+            snd.LootType = LootType.Newbied;
+            AddItem(snd);
+
+            ChainChest cht = new ChainChest();
+            cht.Movable = false;
+            cht.LootType = LootType.Newbied;
+            cht.Crafter = this;
+            cht.Quality = ItemQuality.Normal;
+            AddItem(cht);
+
+            ChainLegs chl = new ChainLegs();
+            chl.Movable = false;
+            chl.LootType = LootType.Newbied;
+            chl.Crafter = this;
+            chl.Quality = ItemQuality.Normal;
+            AddItem(chl);
+
+            PlateArms pla = new PlateArms();
+            pla.Movable = false;
+            pla.LootType = LootType.Newbied;
+            pla.Crafter = this;
+            pla.Quality = ItemQuality.Normal;
+            AddItem(pla);
+
+            Bandage band = new Bandage(50);
+            AddToBackpack(band);
+        }
+
+        public DummyFence(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();
+        }
+    }
+
+    public class DummySword : Dummy
+    {
+        [Constructable]
+        public DummySword()
+            : base(AIType.AI_Melee, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Swordsman
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(125, 125, 90);
+            Skills[SkillName.Swords].Base = 120;
+            Skills[SkillName.Anatomy].Base = 120;
+            Skills[SkillName.Healing].Base = 120;
+            Skills[SkillName.Tactics].Base = 120;
+            Skills[SkillName.Parry].Base = 120;
+
+            // Name
+            Name = "Swordsman";
+
+            // Equip
+            Katana kat = new Katana();
+            kat.Crafter = this;
+            kat.Movable = true;
+            kat.Quality = ItemQuality.Normal;
+            AddItem(kat);
+
+            Boots bts = new Boots();
+            bts.Hue = iHue;
+            AddItem(bts);
+
+            ChainChest cht = new ChainChest();
+            cht.Movable = false;
+            cht.LootType = LootType.Newbied;
+            cht.Crafter = this;
+            cht.Quality = ItemQuality.Normal;
+            AddItem(cht);
+
+            ChainLegs chl = new ChainLegs();
+            chl.Movable = false;
+            chl.LootType = LootType.Newbied;
+            chl.Crafter = this;
+            chl.Quality = ItemQuality.Normal;
+            AddItem(chl);
+
+            PlateArms pla = new PlateArms();
+            pla.Movable = false;
+            pla.LootType = LootType.Newbied;
+            pla.Crafter = this;
+            pla.Quality = ItemQuality.Normal;
+            AddItem(pla);
+
+            Bandage band = new Bandage(50);
+            AddToBackpack(band);
+        }
+
+        public DummySword(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();
+        }
+    }
+
+    public class DummyNox : Dummy
+    {
+        [Constructable]
+        public DummyNox()
+            : base(AIType.AI_Mage, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Nox or Pure Mage
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(90, 90, 125);
+            Skills[SkillName.Magery].Base = 120;
+            Skills[SkillName.EvalInt].Base = 120;
+            Skills[SkillName.Inscribe].Base = 100;
+            Skills[SkillName.Wrestling].Base = 120;
+            Skills[SkillName.Meditation].Base = 120;
+            Skills[SkillName.Poisoning].Base = 100;
+
+            // Name
+            Name = "Nox Mage";
+
+            // Equip
+            Spellbook book = new Spellbook();
+            book.Movable = false;
+            book.LootType = LootType.Newbied;
+            book.Content = 0xFFFFFFFFFFFFFFFF;
+            AddItem(book);
+
+            Kilt kilt = new Kilt();
+            kilt.Hue = jHue;
+            AddItem(kilt);
+
+            Sandals snd = new Sandals();
+            snd.Hue = iHue;
+            snd.LootType = LootType.Newbied;
+            AddItem(snd);
+
+            SkullCap skc = new SkullCap();
+            skc.Hue = iHue;
+            AddItem(skc);
+
+            // Spells
+            AddSpellAttack(typeof(Spells.First.MagicArrowSpell));
+            AddSpellAttack(typeof(Spells.First.WeakenSpell));
+            AddSpellAttack(typeof(Spells.Third.FireballSpell));
+            AddSpellDefense(typeof(Spells.Third.WallOfStoneSpell));
+            AddSpellDefense(typeof(Spells.First.HealSpell));
+        }
+
+        public DummyNox(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();
+        }
+    }
+
+    public class DummyStun : Dummy
+    {
+        [Constructable]
+        public DummyStun()
+            : base(AIType.AI_Mage, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Stun Mage
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(90, 90, 125);
+            Skills[SkillName.Magery].Base = 100;
+            Skills[SkillName.EvalInt].Base = 120;
+            Skills[SkillName.Anatomy].Base = 80;
+            Skills[SkillName.Wrestling].Base = 80;
+            Skills[SkillName.Meditation].Base = 100;
+            Skills[SkillName.Poisoning].Base = 100;
+
+            // Name
+            Name = "Stun Mage";
+
+            // Equip
+            Spellbook book = new Spellbook();
+            book.Movable = false;
+            book.LootType = LootType.Newbied;
+            book.Content = 0xFFFFFFFFFFFFFFFF;
+            AddItem(book);
+
+            LeatherArms lea = new LeatherArms();
+            lea.Movable = false;
+            lea.LootType = LootType.Newbied;
+            lea.Crafter = this;
+            lea.Quality = ItemQuality.Normal;
+            AddItem(lea);
+
+            LeatherChest lec = new LeatherChest();
+            lec.Movable = false;
+            lec.LootType = LootType.Newbied;
+            lec.Crafter = this;
+            lec.Quality = ItemQuality.Normal;
+            AddItem(lec);
+
+            LeatherGorget leg = new LeatherGorget();
+            leg.Movable = false;
+            leg.LootType = LootType.Newbied;
+            leg.Crafter = this;
+            leg.Quality = ItemQuality.Normal;
+            AddItem(leg);
+
+            LeatherLegs lel = new LeatherLegs();
+            lel.Movable = false;
+            lel.LootType = LootType.Newbied;
+            lel.Crafter = this;
+            lel.Quality = ItemQuality.Normal;
+            AddItem(lel);
+
+            Boots bts = new Boots();
+            bts.Hue = iHue;
+            AddItem(bts);
+
+            Cap cap = new Cap();
+            cap.Hue = iHue;
+            AddItem(cap);
+
+            // Spells
+            AddSpellAttack(typeof(Spells.First.MagicArrowSpell));
+            AddSpellAttack(typeof(Spells.First.WeakenSpell));
+            AddSpellAttack(typeof(Spells.Third.FireballSpell));
+            AddSpellDefense(typeof(Spells.Third.WallOfStoneSpell));
+            AddSpellDefense(typeof(Spells.First.HealSpell));
+        }
+
+        public DummyStun(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();
+        }
+    }
+
+    public class DummySuper : Dummy
+    {
+        [Constructable]
+        public DummySuper()
+            : base(AIType.AI_Mage, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Super Mage
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(125, 125, 125);
+            Skills[SkillName.Magery].Base = 120;
+            Skills[SkillName.EvalInt].Base = 120;
+            Skills[SkillName.Anatomy].Base = 120;
+            Skills[SkillName.Wrestling].Base = 120;
+            Skills[SkillName.Meditation].Base = 120;
+            Skills[SkillName.Poisoning].Base = 100;
+            Skills[SkillName.Inscribe].Base = 100;
+
+            // Name
+            Name = "Super Mage";
+
+            // Equip
+            Spellbook book = new Spellbook();
+            book.Movable = false;
+            book.LootType = LootType.Newbied;
+            book.Content = 0xFFFFFFFFFFFFFFFF;
+            AddItem(book);
+
+            LeatherArms lea = new LeatherArms();
+            lea.Movable = false;
+            lea.LootType = LootType.Newbied;
+            lea.Crafter = this;
+            lea.Quality = ItemQuality.Normal;
+            AddItem(lea);
+
+            LeatherChest lec = new LeatherChest();
+            lec.Movable = false;
+            lec.LootType = LootType.Newbied;
+            lec.Crafter = this;
+            lec.Quality = ItemQuality.Normal;
+            AddItem(lec);
+
+            LeatherGorget leg = new LeatherGorget();
+            leg.Movable = false;
+            leg.LootType = LootType.Newbied;
+            leg.Crafter = this;
+            leg.Quality = ItemQuality.Normal;
+            AddItem(leg);
+
+            LeatherLegs lel = new LeatherLegs();
+            lel.Movable = false;
+            lel.LootType = LootType.Newbied;
+            lel.Crafter = this;
+            lel.Quality = ItemQuality.Normal;
+            AddItem(lel);
+
+            Sandals snd = new Sandals();
+            snd.Hue = iHue;
+            snd.LootType = LootType.Newbied;
+            AddItem(snd);
+
+            JesterHat jhat = new JesterHat();
+            jhat.Hue = iHue;
+            AddItem(jhat);
+
+            Doublet dblt = new Doublet();
+            dblt.Hue = iHue;
+            AddItem(dblt);
+
+            // Spells
+            AddSpellAttack(typeof(Spells.First.MagicArrowSpell));
+            AddSpellAttack(typeof(Spells.First.WeakenSpell));
+            AddSpellAttack(typeof(Spells.Third.FireballSpell));
+            AddSpellDefense(typeof(Spells.Third.WallOfStoneSpell));
+            AddSpellDefense(typeof(Spells.First.HealSpell));
+        }
+
+        public DummySuper(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();
+        }
+    }
+
+    public class DummyHealer : Dummy
+    {
+        [Constructable]
+        public DummyHealer()
+            : base(AIType.AI_Healer, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Healer Mage
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(125, 125, 125);
+            Skills[SkillName.Magery].Base = 120;
+            Skills[SkillName.EvalInt].Base = 120;
+            Skills[SkillName.Anatomy].Base = 120;
+            Skills[SkillName.Wrestling].Base = 120;
+            Skills[SkillName.Meditation].Base = 120;
+            Skills[SkillName.Healing].Base = 100;
+
+            // Name
+            Name = "Healer";
+
+            // Equip
+            Spellbook book = new Spellbook();
+            book.Movable = false;
+            book.LootType = LootType.Newbied;
+            book.Content = 0xFFFFFFFFFFFFFFFF;
+            AddItem(book);
+
+            LeatherArms lea = new LeatherArms();
+            lea.Movable = false;
+            lea.LootType = LootType.Newbied;
+            lea.Crafter = this;
+            lea.Quality = ItemQuality.Normal;
+            AddItem(lea);
+
+            LeatherChest lec = new LeatherChest();
+            lec.Movable = false;
+            lec.LootType = LootType.Newbied;
+            lec.Crafter = this;
+            lec.Quality = ItemQuality.Normal;
+            AddItem(lec);
+
+            LeatherGorget leg = new LeatherGorget();
+            leg.Movable = false;
+            leg.LootType = LootType.Newbied;
+            leg.Crafter = this;
+            leg.Quality = ItemQuality.Normal;
+            AddItem(leg);
+
+            LeatherLegs lel = new LeatherLegs();
+            lel.Movable = false;
+            lel.LootType = LootType.Newbied;
+            lel.Crafter = this;
+            lel.Quality = ItemQuality.Normal;
+            AddItem(lel);
+
+            Sandals snd = new Sandals();
+            snd.Hue = iHue;
+            snd.LootType = LootType.Newbied;
+            AddItem(snd);
+
+            Cap cap = new Cap();
+            cap.Hue = iHue;
+            AddItem(cap);
+
+            Robe robe = new Robe();
+            robe.Hue = iHue;
+            AddItem(robe);
+        }
+
+        public DummyHealer(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();
+        }
+    }
+
+    public class DummyAssassin : Dummy
+    {
+        [Constructable]
+        public DummyAssassin()
+            : base(AIType.AI_Melee, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Hybrid Assassin
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(105, 105, 105);
+            Skills[SkillName.Magery].Base = 120;
+            Skills[SkillName.EvalInt].Base = 120;
+            Skills[SkillName.Swords].Base = 120;
+            Skills[SkillName.Tactics].Base = 120;
+            Skills[SkillName.Meditation].Base = 120;
+            Skills[SkillName.Poisoning].Base = 100;
+
+            // Name
+            Name = "Hybrid Assassin";
+
+            // Equip
+            Spellbook book = new Spellbook();
+            book.Movable = false;
+            book.LootType = LootType.Newbied;
+            book.Content = 0xFFFFFFFFFFFFFFFF;
+            AddToBackpack(book);
+
+            Katana kat = new Katana();
+            kat.Movable = false;
+            kat.LootType = LootType.Newbied;
+            kat.Crafter = this;
+            kat.Poison = Poison.Deadly;
+            kat.PoisonCharges = 12;
+            kat.Quality = ItemQuality.Normal;
+            AddToBackpack(kat);
+
+            LeatherArms lea = new LeatherArms();
+            lea.Movable = false;
+            lea.LootType = LootType.Newbied;
+            lea.Crafter = this;
+            lea.Quality = ItemQuality.Normal;
+            AddItem(lea);
+
+            LeatherChest lec = new LeatherChest();
+            lec.Movable = false;
+            lec.LootType = LootType.Newbied;
+            lec.Crafter = this;
+            lec.Quality = ItemQuality.Normal;
+            AddItem(lec);
+
+            LeatherGorget leg = new LeatherGorget();
+            leg.Movable = false;
+            leg.LootType = LootType.Newbied;
+            leg.Crafter = this;
+            leg.Quality = ItemQuality.Normal;
+            AddItem(leg);
+
+            LeatherLegs lel = new LeatherLegs();
+            lel.Movable = false;
+            lel.LootType = LootType.Newbied;
+            lel.Crafter = this;
+            lel.Quality = ItemQuality.Normal;
+            AddItem(lel);
+
+            Sandals snd = new Sandals();
+            snd.Hue = iHue;
+            snd.LootType = LootType.Newbied;
+            AddItem(snd);
+
+            Cap cap = new Cap();
+            cap.Hue = iHue;
+            AddItem(cap);
+
+            Robe robe = new Robe();
+            robe.Hue = iHue;
+            AddItem(robe);
+
+            DeadlyPoisonPotion pota = new DeadlyPoisonPotion();
+            pota.LootType = LootType.Newbied;
+            AddToBackpack(pota);
+
+            DeadlyPoisonPotion potb = new DeadlyPoisonPotion();
+            potb.LootType = LootType.Newbied;
+            AddToBackpack(potb);
+
+            DeadlyPoisonPotion potc = new DeadlyPoisonPotion();
+            potc.LootType = LootType.Newbied;
+            AddToBackpack(potc);
+
+            DeadlyPoisonPotion potd = new DeadlyPoisonPotion();
+            potd.LootType = LootType.Newbied;
+            AddToBackpack(potd);
+
+            Bandage band = new Bandage(50);
+            AddToBackpack(band);
+        }
+
+        public DummyAssassin(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();
+        }
+    }
+
+    [TypeAlias("Server.Mobiles.DummyTheif")]
+    public class DummyThief : Dummy
+    {
+        [Constructable]
+        public DummyThief()
+            : base(AIType.AI_Thief, FightMode.Closest, 15, 1, 0.2, 0.6)
+        {
+            // A Dummy Hybrid Thief
+            int iHue = 20 + Team * 40;
+            int jHue = 25 + Team * 40;
+
+            // Skills and Stats
+            InitStats(105, 105, 105);
+            Skills[SkillName.Healing].Base = 120;
+            Skills[SkillName.Anatomy].Base = 120;
+            Skills[SkillName.Stealing].Base = 120;
+            Skills[SkillName.ArmsLore].Base = 100;
+            Skills[SkillName.Meditation].Base = 120;
+            Skills[SkillName.Wrestling].Base = 120;
+
+            // Name
+            Name = "Hybrid Thief";
+
+            // Equip
+            Spellbook book = new Spellbook();
+            book.Movable = false;
+            book.LootType = LootType.Newbied;
+            book.Content = 0xFFFFFFFFFFFFFFFF;
+            AddItem(book);
+
+            LeatherArms lea = new LeatherArms();
+            lea.Movable = false;
+            lea.LootType = LootType.Newbied;
+            lea.Crafter = this;
+            lea.Quality = ItemQuality.Normal;
+            AddItem(lea);
+
+            LeatherChest lec = new LeatherChest();
+            lec.Movable = false;
+            lec.LootType = LootType.Newbied;
+            lec.Crafter = this;
+            lec.Quality = ItemQuality.Normal;
+            AddItem(lec);
+
+            LeatherGorget leg = new LeatherGorget();
+            leg.Movable = false;
+            leg.LootType = LootType.Newbied;
+            leg.Crafter = this;
+            leg.Quality = ItemQuality.Normal;
+            AddItem(leg);
+
+            LeatherLegs lel = new LeatherLegs();
+            lel.Movable = false;
+            lel.LootType = LootType.Newbied;
+            lel.Crafter = this;
+            lel.Quality = ItemQuality.Normal;
+            AddItem(lel);
+
+            Sandals snd = new Sandals();
+            snd.Hue = iHue;
+            snd.LootType = LootType.Newbied;
+            AddItem(snd);
+
+            Cap cap = new Cap();
+            cap.Hue = iHue;
+            AddItem(cap);
+
+            Robe robe = new Robe();
+            robe.Hue = iHue;
+            AddItem(robe);
+
+            Bandage band = new Bandage(50);
+            AddToBackpack(band);
+        }
+
+        public DummyThief(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/Mobiles/Summons/EnergyVortex.cs

@@ -0,0 +1,172 @@
+using System;
+using System.Collections;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an energy vortex corpse")]
+    public class EnergyVortex : BaseCreature
+    {
+        [Constructable]
+        public EnergyVortex() : this(false)
+        {
+        }
+
+        [Constructable]
+        public EnergyVortex(bool summoned)
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            Name = "an energy vortex";
+
+            if (Core.SE && 0.002 > Utility.RandomDouble()) // Per OSI FoF, it's a 1/500 chance.
+            {
+                // Llama vortex!
+                Body = 0xDC;
+                Hue = 0x76;
+            }
+            else
+            {
+                Body = 164;
+            }
+
+            bool weak = summoned && Siege.SiegeShard;
+
+            SetStr(weak ? 100 : 200);
+            SetDex(weak ? 150 : 200);
+            SetInt(100);
+
+            SetHits((Core.SE && !weak) ? 140 : 70);
+            SetStam(250);
+            SetMana(0);
+
+            SetDamage(weak ? 10 : 14, weak ? 13 : 17);
+
+            SetDamageType(ResistanceType.Physical, 0);
+            SetDamageType(ResistanceType.Energy, 100);
+
+            SetResistance(ResistanceType.Physical, 60, 70);
+            SetResistance(ResistanceType.Fire, 40, 50);
+            SetResistance(ResistanceType.Cold, 40, 50);
+            SetResistance(ResistanceType.Poison, 40, 50);
+            SetResistance(ResistanceType.Energy, 90, 100);
+
+            SetSkill(SkillName.MagicResist, 99.9);
+            SetSkill(SkillName.Tactics, 100.0);
+            SetSkill(SkillName.Wrestling, 120.0);
+
+            Fame = 0;
+            Karma = 0;
+
+            VirtualArmor = 40;
+            ControlSlots = (Core.SE) ? 2 : 1;
+        }
+
+        public EnergyVortex(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool DeleteCorpseOnDeath
+        {
+            get
+            {
+                return Summoned;
+            }
+        }
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }// Or Llama vortices will appear gray.
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 80.0;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 20.0;
+            }
+        }
+        public override bool BleedImmune
+        {
+            get
+            {
+                return true;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Lethal;
+            }
+        }
+        public override double GetFightModeRanking(Mobile m, FightMode acqType, bool bPlayerOnly)
+        {
+            return (m.Int + m.Skills[SkillName.Magery].Value) / Math.Max(GetDistanceToSqrt(m), 1.0);
+        }
+
+        public override int GetAngerSound()
+        {
+            return 0x15;
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x28;
+        }
+
+        public override void OnThink()
+        {
+            if (Core.SE && Summoned)
+            {
+                ArrayList spirtsOrVortexes = new ArrayList();
+                IPooledEnumerable eable = GetMobilesInRange(5);
+
+                foreach (Mobile m in eable)
+                {
+                    if (m is EnergyVortex || m is BladeSpirits)
+                    {
+                        if (((BaseCreature)m).Summoned)
+                            spirtsOrVortexes.Add(m);
+                    }
+                }
+
+                eable.Free();
+
+                while (spirtsOrVortexes.Count > 6)
+                {
+                    int index = Utility.Random(spirtsOrVortexes.Count);
+                    //TODO: Confim if it's the dispel with all the pretty effects or just a Deletion of it.
+                    Dispel(((Mobile)spirtsOrVortexes[index]));
+                    spirtsOrVortexes.RemoveAt(index);
+                }
+            }
+
+            base.OnThink();
+        }
+
+        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 (BaseSoundID == 263)
+                BaseSoundID = 0;
+        }
+    }
+}

Scripts/Mobiles/Summons/GargoylePet.cs

@@ -0,0 +1,103 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a gargoyle corpse")]
+    public class GargoylePet : BaseCreature
+    {
+        [Constructable]
+        public GargoylePet()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "a gargoyle pet";
+            this.Body = 730; 
+
+            this.SetStr(500, 512);
+            this.SetDex(90, 94);
+            this.SetInt(100, 107);
+
+            this.SetHits(300, 313);
+
+            this.SetDamage(11, 17);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 60);
+            this.SetResistance(ResistanceType.Fire, 40);
+            this.SetResistance(ResistanceType.Cold, 40);
+            this.SetResistance(ResistanceType.Poison, 40);
+            this.SetResistance(ResistanceType.Energy, 40);
+
+            this.SetSkill(SkillName.MagicResist, 75.5, 89.0);
+            this.SetSkill(SkillName.Tactics, 80.3, 93.8);
+            this.SetSkill(SkillName.Wrestling, 66.9, 81.5);
+
+            this.Tamable = true;
+            this.ControlSlots = 2;
+            this.MinTameSkill = 65.1;
+        }
+
+        public GargoylePet(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override int Meat
+        {
+            get
+            {
+                return 7;
+            }
+        }
+        public override int Hides
+        {
+            get
+            {
+                return 11;
+            }
+        }
+        public override HideType HideType
+        {
+            get
+            {
+                return HideType.Horned;
+            }
+        }
+        public override void GenerateLoot()
+        {
+            this.AddLoot(LootPack.Rich, 2);
+        }
+
+        public override int GetIdleSound()
+        {
+            return 1573;
+        }
+
+        public override int GetAngerSound()
+        {
+            return 1570;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 1572;
+        }
+
+        public override int GetDeathSound()
+        {
+            return 1571;
+        }
+
+        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/Summons/HordeMinion.cs

@@ -0,0 +1,290 @@
+#region References
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Server.Engines.Quests;
+using Server.Engines.Quests.Necro;
+using Server.ContextMenus;
+using Server.Gumps;
+using Server.Items;
+using Server.Network;
+#endregion
+
+namespace Server.Mobiles
+{
+	[CorpseName("a horde minion corpse")]
+	public class HordeMinionFamiliar : BaseFamiliar
+	{
+		public override bool DisplayWeight { get { return true; } }
+        public override bool CanAutoStable { get { return Backpack == null || Backpack.Items.Count == 0; } }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public override OrderType ControlOrder
+        {
+            get { return m_QuestOverride ? OrderType.None : OrderType.Come; }
+            set { }
+        }
+
+		public HordeMinionFamiliar()
+		{
+			Name = "a horde minion";
+			Body = 776;
+			BaseSoundID = 0x39D;
+
+			SetStr(100);
+			SetDex(110);
+			SetInt(100);
+
+			SetHits(70);
+			SetStam(110);
+			SetMana(0);
+
+			SetDamage(5, 10);
+
+			SetDamageType(ResistanceType.Physical, 100);
+
+			SetResistance(ResistanceType.Physical, 50, 60);
+			SetResistance(ResistanceType.Fire, 50, 55);
+			SetResistance(ResistanceType.Poison, 25, 30);
+			SetResistance(ResistanceType.Energy, 25, 30);
+
+			SetSkill(SkillName.Wrestling, 70.1, 75.0);
+			SetSkill(SkillName.Tactics, 50.0);
+
+			ControlSlots = 1;
+
+			Container pack = Backpack;
+
+			if (pack != null)
+			{
+				pack.Delete();
+			}
+
+			pack = new Backpack();
+			pack.Movable = false;
+			pack.Weight = 13.0;
+
+			AddItem(pack);
+		}
+
+		private DateTime m_NextPickup;
+        private bool m_QuestOverride;
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public bool QuestOverride
+        {
+            get { return m_QuestOverride; }
+            set
+            {
+                if (!m_QuestOverride && value)
+                {
+                    Timer.DelayCall(TimeSpan.FromSeconds(30), () =>
+                        {
+                            if (m_QuestOverride)
+                                m_QuestOverride = false;
+                        });
+                }
+
+                m_QuestOverride = value;
+            }
+        }
+
+		public override void OnThink()
+		{
+            if (ControlMaster != null && QuestOverride)
+            {
+                if (this.X == 1076 && this.Y == 450)
+                {
+                    AIObject.MoveTo(ControlMaster, false, 1);
+
+                    PlayerMobile pm = ControlMaster as PlayerMobile;
+
+                    if (pm != null)
+                    {
+                        QuestSystem qs = pm.Quest;
+
+                        if (qs is DarkTidesQuest)
+                        {
+                            QuestObjective obj = qs.FindObjective(typeof(FetchAbraxusScrollObjective));
+
+                            if (obj != null && !obj.Completed)
+                            {
+                                AddToBackpack(new ScrollOfAbraxus());
+                                obj.Complete();
+
+                                CurrentSpeed = 0.1;
+                                QuestOverride = false;
+                            }
+                        }
+                    }
+                }
+
+                return;
+            }
+
+			base.OnThink();
+
+			if (DateTime.UtcNow < m_NextPickup)
+			{
+				return;
+			}
+
+			m_NextPickup = DateTime.UtcNow + TimeSpan.FromSeconds(Utility.RandomMinMax(5, 10));
+
+			Container pack = Backpack;
+
+			if (pack == null)
+			{
+				return;
+			}
+
+			ArrayList list = new ArrayList();
+
+			foreach (Item item in GetItemsInRange(2))
+			{
+				if (item.Movable && item.Stackable)
+				{
+					list.Add(item);
+				}
+			}
+
+			int pickedUp = 0;
+
+			for (int i = 0; i < list.Count; ++i)
+			{
+				Item item = (Item)list[i];
+
+				if (!pack.CheckHold(this, item, false, true))
+				{
+					return;
+				}
+
+				bool rejected;
+				LRReason reject;
+
+				NextActionTime = Core.TickCount;
+
+				Lift(item, item.Amount, out rejected, out reject);
+
+				if (rejected)
+				{
+					continue;
+				}
+
+				Drop(this, Point3D.Zero);
+
+				if (++pickedUp == 3)
+				{
+					break;
+				}
+			}
+		}
+
+		private void ConfirmRelease_Callback(Mobile from, bool okay, object state)
+		{
+			if (okay)
+			{
+				EndRelease(from);
+			}
+		}
+
+		public override void BeginRelease(Mobile from)
+		{
+			Container pack = Backpack;
+
+			if (pack != null && pack.Items.Count > 0)
+			{
+				from.SendGump(new WarningGump(1060635, 30720, 1061672, 32512, 420, 280, ConfirmRelease_Callback, null));
+			}
+			else
+			{
+				EndRelease(from);
+			}
+		}
+
+		#region Pack Animal Methods
+		public override bool OnBeforeDeath()
+		{
+			if (!base.OnBeforeDeath())
+			{
+				return false;
+			}
+
+			PackAnimal.CombineBackpacks(this);
+
+			return true;
+		}
+
+		public override DeathMoveResult GetInventoryMoveResultFor(Item item)
+		{
+			return DeathMoveResult.MoveToCorpse;
+		}
+
+		public override bool IsSnoop(Mobile from)
+		{
+			if (PackAnimal.CheckAccess(this, from))
+			{
+				return false;
+			}
+
+			return base.IsSnoop(from);
+		}
+
+		public override bool OnDragDrop(Mobile from, Item item)
+		{
+			if (CheckFeed(from, item))
+			{
+				return true;
+			}
+
+			if (PackAnimal.CheckAccess(this, from))
+			{
+				AddToBackpack(item);
+				return true;
+			}
+
+			return base.OnDragDrop(from, item);
+		}
+
+		public override bool CheckNonlocalDrop(Mobile from, Item item, Item target)
+		{
+			return PackAnimal.CheckAccess(this, from);
+		}
+
+		public override bool CheckNonlocalLift(Mobile from, Item item)
+		{
+			return PackAnimal.CheckAccess(this, from);
+		}
+
+		public override void OnDoubleClick(Mobile from)
+		{
+			PackAnimal.TryPackOpen(this, from);
+		}
+
+		public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+		{
+			base.GetContextMenuEntries(from, list);
+
+			PackAnimal.GetContextMenuEntries(this, from, list);
+		}
+		#endregion
+
+		public HordeMinionFamiliar(Serial serial)
+			: base(serial)
+		{ }
+
+		public override void Serialize(GenericWriter writer)
+		{
+			base.Serialize(writer);
+
+			writer.Write(0);
+		}
+
+		public override void Deserialize(GenericReader reader)
+		{
+			base.Deserialize(reader);
+
+			int version = reader.ReadInt();
+		}
+	}
+}

Scripts/Mobiles/Summons/RisingColossus.cs

@@ -0,0 +1,105 @@
+using Server.Items;
+using System;
+
+namespace Server.Mobiles
+{
+    public class RisingColossus : BaseCreature
+    {
+        private int m_DispelDifficulty;
+        public override double DispelDifficulty { get { return m_DispelDifficulty; } }
+        public override double DispelFocus { get { return 45.0; } }
+
+        [Constructable]
+        public RisingColossus(Mobile m, double baseskill, double boostskill)
+            : base(AIType.AI_Mystic, FightMode.Closest, 10, 1, 0.4, 0.5)
+        {
+            int level = (int)(baseskill + boostskill);
+            int statbonus = (int)((baseskill - 83) / 1.3 + ((boostskill - 30) / 1.3) + 6);
+            int hitsbonus = (int)((baseskill - 83) * 1.14 + ((boostskill - 30) * 1.03) + 20);
+            double skillvalue = boostskill != 0 ? ((baseskill + boostskill) / 2) : ((baseskill + 20) / 2);
+
+            Name = "a rising colossus";
+            Body = 829;
+
+            SetHits(315 + hitsbonus);
+
+            SetStr(677 + statbonus);
+            SetDex(107 + statbonus);
+            SetInt(127 + statbonus);
+
+            SetDamage(level / 12, level / 10);
+
+            SetDamageType(ResistanceType.Physical, 100);
+
+            SetResistance(ResistanceType.Physical, 65, 70);
+            SetResistance(ResistanceType.Fire, 50, 55);
+            SetResistance(ResistanceType.Cold, 50, 55);
+            SetResistance(ResistanceType.Poison, 100);
+            SetResistance(ResistanceType.Energy, 65, 70);
+
+            SetSkill(SkillName.MagicResist, skillvalue);
+            SetSkill(SkillName.Tactics, skillvalue);
+            SetSkill(SkillName.Wrestling, skillvalue);
+            SetSkill(SkillName.Anatomy, skillvalue);
+            SetSkill(SkillName.Mysticism, skillvalue);
+            SetSkill(SkillName.DetectHidden, 70.0);
+            SetSkill(SkillName.EvalInt, skillvalue);
+            SetSkill(SkillName.Mysticism, m.Skills[SkillName.Mysticism].Value);
+            SetSkill(SkillName.Focus, m.Skills[SkillName.Focus].Value);
+
+            VirtualArmor = 58;
+            ControlSlots = 5;
+
+            m_DispelDifficulty = 91 + (int)((baseskill * 83) / 5.2);
+
+            SetWeaponAbility(WeaponAbility.ArmorIgnore);
+            SetWeaponAbility(WeaponAbility.CrushingBlow);
+        }
+
+        public override double GetFightModeRanking(Mobile m, FightMode acqType, bool bPlayerOnly)
+        {
+            return (m.Int + m.Skills[SkillName.Magery].Value) / Math.Max(GetDistanceToSqrt(m), 1.0);
+        }
+
+        public override bool AlwaysMurderer
+        {
+            get
+            {
+                return true;
+            }
+        }
+
+        public override int GetAttackSound()
+        {
+            return 0x627;
+        }
+
+        public override int GetHurtSound()
+        {
+            return 0x629;
+        }
+
+        public override bool BleedImmune { get { return true; } }
+        public override Poison PoisonImmune { get { return Poison.Lethal; } }
+
+        public RisingColossus(Serial serial) : base(serial)
+        {
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+            writer.Write((int)0);
+
+            writer.Write((int)m_DispelDifficulty);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+            int version = reader.ReadInt();
+
+            m_DispelDifficulty = reader.ReadInt();
+        }
+    }
+}

Scripts/Mobiles/Summons/ShadowWisp.cs

@@ -0,0 +1,114 @@
+using System;
+using System.Collections;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a shadow wisp corpse")]
+    public class ShadowWispFamiliar : BaseFamiliar
+    {
+        private DateTime m_NextFlare;
+        public ShadowWispFamiliar()
+        {
+            this.Name = "a shadow wisp";
+            this.Body = 165;
+            this.Hue = 0x901;
+            this.BaseSoundID = 466;
+
+            this.SetStr(50);
+            this.SetDex(60);
+            this.SetInt(100);
+
+            this.SetHits(50);
+            this.SetStam(60);
+            this.SetMana(0);
+
+            this.SetDamage(5, 10);
+
+            this.SetDamageType(ResistanceType.Energy, 100);
+
+            this.SetResistance(ResistanceType.Physical, 10, 15);
+            this.SetResistance(ResistanceType.Fire, 10, 15);
+            this.SetResistance(ResistanceType.Cold, 10, 15);
+            this.SetResistance(ResistanceType.Poison, 10, 15);
+            this.SetResistance(ResistanceType.Energy, 99);
+
+            this.SetSkill(SkillName.Wrestling, 40.0);
+            this.SetSkill(SkillName.Tactics, 40.0);
+
+            this.ControlSlots = 1;
+        }
+
+        public ShadowWispFamiliar(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnThink()
+        {
+            base.OnThink();
+
+            if (DateTime.UtcNow < this.m_NextFlare)
+                return;
+
+            this.m_NextFlare = DateTime.UtcNow + TimeSpan.FromSeconds(5.0 + (25.0 * Utility.RandomDouble()));
+
+            this.FixedEffect(0x37C4, 1, 12, 1109, 6);
+            this.PlaySound(0x1D3);
+
+            Timer.DelayCall(TimeSpan.FromSeconds(0.5), new TimerCallback(Flare));
+        }
+
+        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();
+        }
+
+        private void Flare()
+        {
+            Mobile caster = this.ControlMaster;
+
+            if (caster == null)
+                caster = this.SummonMaster;
+
+            if (caster == null)
+                return;
+
+            ArrayList list = new ArrayList();
+            IPooledEnumerable eable = GetMobilesInRange(5);
+
+            foreach (Mobile m in eable)
+            {
+                if (m.Player && m.Alive && !m.IsDeadBondedPet && m.Karma <= 0 && m.IsPlayer())
+                    list.Add(m);
+            }
+            eable.Free();
+
+            for (int i = 0; i < list.Count; ++i)
+            {
+                Mobile m = (Mobile)list[i];
+                bool friendly = true;
+
+                for (int j = 0; friendly && j < caster.Aggressors.Count; ++j)
+                    friendly = (caster.Aggressors[j].Attacker != m);
+
+                for (int j = 0; friendly && j < caster.Aggressed.Count; ++j)
+                    friendly = (caster.Aggressed[j].Defender != m);
+
+                if (friendly)
+                {
+                    m.FixedEffect(0x37C4, 1, 12, 1109, 3); // At player
+                    m.Mana += 1 - (m.Karma / 1000);
+                }
+            }
+        }
+    }
+}

Scripts/Mobiles/Summons/SpawnedOrcishLord.cs

@@ -0,0 +1,45 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an orcish corpse")]
+    public class SpawnedOrcishLord : OrcishLord
+    {
+        [Constructable]
+        public SpawnedOrcishLord()
+        {
+            Container pack = this.Backpack;
+
+            if (pack != null)
+                pack.Delete();
+
+            this.NoKillAwards = true;
+        }
+
+        public SpawnedOrcishLord(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            c.Delete();
+        }
+
+        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();
+            this.NoKillAwards = true;
+        }
+    }
+}

Scripts/Mobiles/Summons/SummonedAirElemental.cs

@@ -0,0 +1,80 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an air elemental corpse")]
+    public class SummonedAirElemental : BaseCreature
+    {
+        [Constructable]
+        public SummonedAirElemental()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "an air elemental";
+            this.Body = 13;
+            this.Hue = 0x4001;
+            this.BaseSoundID = 655;
+
+            this.SetStr(200);
+            this.SetDex(200);
+            this.SetInt(100);
+
+            this.SetHits(150);
+            this.SetStam(50);
+
+            this.SetDamage(6, 9);
+
+            this.SetDamageType(ResistanceType.Physical, 50);
+            this.SetDamageType(ResistanceType.Energy, 50);
+
+            this.SetResistance(ResistanceType.Physical, 40, 50);
+            this.SetResistance(ResistanceType.Fire, 30, 40);
+            this.SetResistance(ResistanceType.Cold, 35, 45);
+            this.SetResistance(ResistanceType.Poison, 50, 60);
+            this.SetResistance(ResistanceType.Energy, 70, 80);
+
+            this.SetSkill(SkillName.Meditation, 90.0);
+            this.SetSkill(SkillName.EvalInt, 70.0);
+            this.SetSkill(SkillName.Magery, 70.0);
+            this.SetSkill(SkillName.MagicResist, 60.0);
+            this.SetSkill(SkillName.Tactics, 100.0);
+            this.SetSkill(SkillName.Wrestling, 80.0);
+
+            this.VirtualArmor = 40;
+            this.ControlSlots = 2;
+        }
+
+        public SummonedAirElemental(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        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();
+
+            if (this.BaseSoundID == 263)
+                this.BaseSoundID = 655;
+        }
+    }
+}

Scripts/Mobiles/Summons/SummonedDaemon.cs

@@ -0,0 +1,87 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a daemon corpse")]
+    public class SummonedDaemon : BaseCreature
+    {
+        [Constructable]
+        public SummonedDaemon()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = NameList.RandomName("daemon");
+            this.Body = Core.AOS ? 10 : 9;
+            this.BaseSoundID = 357;
+
+            this.SetStr(200);
+            this.SetDex(110);
+            this.SetInt(150);
+
+            this.SetDamage(14, 21);
+
+            this.SetDamageType(ResistanceType.Physical, 0);
+            this.SetDamageType(ResistanceType.Poison, 100);
+
+            this.SetResistance(ResistanceType.Physical, 45, 55);
+            this.SetResistance(ResistanceType.Fire, 50, 60);
+            this.SetResistance(ResistanceType.Cold, 20, 30);
+            this.SetResistance(ResistanceType.Poison, 70, 80);
+            this.SetResistance(ResistanceType.Energy, 40, 50);
+
+            this.SetSkill(SkillName.EvalInt, 90.1, 100.0);
+            this.SetSkill(SkillName.Meditation, 90.1, 100.0);
+            this.SetSkill(SkillName.Magery, 90.1, 100.0);
+            this.SetSkill(SkillName.MagicResist, 90.1, 100.0);
+            this.SetSkill(SkillName.Tactics, 100.0);
+            this.SetSkill(SkillName.Wrestling, 98.1, 99.0);
+
+            this.VirtualArmor = 58;
+            this.ControlSlots = Core.SE ? 4 : 5;
+        }
+
+        public SummonedDaemon(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 125.0;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        public override Poison PoisonImmune
+        {
+            get
+            {
+                return Poison.Regular;
+            }
+        }// TODO: Immune to poison?
+        public override bool CanFly
+        {
+            get
+            {
+                return true;
+            }
+        }
+        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/Summons/SummonedEarthElemental.cs

@@ -0,0 +1,71 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("an earth elemental corpse")]
+    public class SummonedEarthElemental : BaseCreature
+    {
+        [Constructable]
+        public SummonedEarthElemental()
+            : base(AIType.AI_Melee, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "an earth elemental";
+            this.Body = 14;
+            this.BaseSoundID = 268;
+
+            this.SetStr(200);
+            this.SetDex(70);
+            this.SetInt(70);
+
+            this.SetHits(180);
+
+            this.SetDamage(14, 21);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 65, 75);
+            this.SetResistance(ResistanceType.Fire, 40, 50);
+            this.SetResistance(ResistanceType.Cold, 40, 50);
+            this.SetResistance(ResistanceType.Poison, 40, 50);
+            this.SetResistance(ResistanceType.Energy, 40, 50);
+
+            this.SetSkill(SkillName.MagicResist, 65.0);
+            this.SetSkill(SkillName.Tactics, 100.0);
+            this.SetSkill(SkillName.Wrestling, 90.0);
+
+            this.VirtualArmor = 34;
+            this.ControlSlots = 2;
+        }
+
+        public SummonedEarthElemental(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        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/Summons/SummonedFireElemental.cs

@@ -0,0 +1,75 @@
+using System;
+using Server.Items;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a fire elemental corpse")]
+    public class SummonedFireElemental : BaseCreature
+    {
+        [Constructable]
+        public SummonedFireElemental()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "a fire elemental";
+            this.Body = 15;
+            this.BaseSoundID = 838;
+
+            this.SetStr(200);
+            this.SetDex(200);
+            this.SetInt(100);
+
+            this.SetDamage(9, 14);
+
+            this.SetDamageType(ResistanceType.Physical, 0);
+            this.SetDamageType(ResistanceType.Fire, 100);
+
+            this.SetResistance(ResistanceType.Physical, 50, 60);
+            this.SetResistance(ResistanceType.Fire, 70, 80);
+            this.SetResistance(ResistanceType.Cold, 0, 10);
+            this.SetResistance(ResistanceType.Poison, 50, 60);
+            this.SetResistance(ResistanceType.Energy, 50, 60);
+
+            this.SetSkill(SkillName.EvalInt, 90.0);
+            this.SetSkill(SkillName.Magery, 90.0);
+            this.SetSkill(SkillName.MagicResist, 85.0);
+            this.SetSkill(SkillName.Tactics, 100.0);
+            this.SetSkill(SkillName.Wrestling, 92.0);
+
+            this.VirtualArmor = 40;
+            this.ControlSlots = 4;
+
+            this.AddItem(new LightSource());
+        }
+
+        public SummonedFireElemental(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        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/Summons/SummonedPaladin.cs

@@ -0,0 +1,253 @@
+using System;
+using Server.Items;
+using Server.Mobiles;
+
+namespace Server.Engines.Quests.Necro
+{
+    public class SummonedPaladin : BaseCreature
+    {
+        private PlayerMobile m_Necromancer;
+        private bool m_ToDelete;
+        public SummonedPaladin(PlayerMobile necromancer)
+            : base(AIType.AI_Melee, FightMode.Aggressor, 10, 1, 0.2, 0.4)
+        {
+            this.m_Necromancer = necromancer;
+
+            this.InitStats(45, 30, 5);
+            this.Title = "the Paladin";
+
+            this.Hue = 0x83F3;
+
+            this.Female = false;
+            this.Body = 0x190;
+            this.Name = NameList.RandomName("male");
+
+            Utility.AssignRandomHair(this);
+            Utility.AssignRandomFacialHair(this, false);
+
+            this.FacialHairHue = this.HairHue;
+
+            this.AddItem(new Boots(0x1));
+            this.AddItem(new ChainChest());
+            this.AddItem(new ChainLegs());
+            this.AddItem(new RingmailArms());
+            this.AddItem(new PlateHelm());
+            this.AddItem(new PlateGloves());
+            this.AddItem(new PlateGorget());
+
+            this.AddItem(new Cloak(0xCF));
+
+            this.AddItem(new ThinLongsword());
+
+            this.SetSkill(SkillName.Swords, 50.0);
+            this.SetSkill(SkillName.Tactics, 50.0);
+
+            this.PackGold(500);
+        }
+
+        public SummonedPaladin(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override bool ClickTitle
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public override bool PlayerRangeSensitive
+        {
+            get
+            {
+                return false;
+            }
+        }
+        public static void BeginSummon(PlayerMobile player)
+        {
+            new SummonTimer(player).Start();
+        }
+
+        public override bool IsHarmfulCriminal(IDamageable target)
+        {
+            if (target is Mobile && (Mobile)target == this.m_Necromancer)
+                return false;
+
+            return base.IsHarmfulCriminal(target);
+        }
+
+        public override void OnThink()
+        {
+            if (!this.m_ToDelete && !this.Frozen)
+            {
+                if (this.m_Necromancer == null || this.m_Necromancer.Deleted || this.m_Necromancer.Map == Map.Internal)
+                {
+                    this.Delete();
+                    return;
+                }
+
+                if (this.Combatant != this.m_Necromancer)
+                    this.Combatant = this.m_Necromancer;
+
+                if (!this.m_Necromancer.Alive)
+                {
+                    QuestSystem qs = this.m_Necromancer.Quest;
+
+                    if (qs is DarkTidesQuest && qs.FindObjective(typeof(FindMardothEndObjective)) == null)
+                        qs.AddObjective(new FindMardothEndObjective(false));
+
+                    this.Say(1060139, this.m_Necromancer.Name); // You have made my work easy for me, ~1_NAME~.  My task here is done.
+
+                    this.m_ToDelete = true;
+
+                    Timer.DelayCall(TimeSpan.FromSeconds(5.0), new TimerCallback(Delete));
+                }
+                else if (this.m_Necromancer.Map != this.Map || this.GetDistanceToSqrt(this.m_Necromancer) > this.RangePerception + 1)
+                {
+                    Effects.SendLocationParticles(EffectItem.Create(this.Location, this.Map, EffectItem.DefaultDuration), 0x3728, 10, 10, 2023);
+                    Effects.SendLocationParticles(EffectItem.Create(this.m_Necromancer.Location, this.m_Necromancer.Map, EffectItem.DefaultDuration), 0x3728, 10, 10, 5023);
+
+                    this.Map = this.m_Necromancer.Map;
+                    this.Location = this.m_Necromancer.Location;
+
+                    this.PlaySound(0x1FE);
+
+                    this.Say(1060140); // You cannot escape me, knave of evil!
+                }
+            }
+
+            base.OnThink();
+        }
+
+        public override void OnDeath(Container c)
+        {
+            base.OnDeath(c);
+
+            QuestSystem qs = this.m_Necromancer.Quest;
+
+            if (qs is DarkTidesQuest && qs.FindObjective(typeof(FindMardothEndObjective)) == null)
+                qs.AddObjective(new FindMardothEndObjective(true));
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+
+            writer.Write((Mobile)this.m_Necromancer);
+            writer.Write((bool)this.m_ToDelete);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            this.m_Necromancer = reader.ReadMobile() as PlayerMobile;
+            this.m_ToDelete = reader.ReadBool();
+
+            if (this.m_ToDelete)
+                this.Delete();
+        }
+
+        private class SummonTimer : Timer
+        {
+            private readonly PlayerMobile m_Player;
+            private SummonedPaladin m_Paladin;
+            private int m_Step;
+            public SummonTimer(PlayerMobile player)
+                : base(TimeSpan.FromSeconds(4.0))
+            {
+                this.Priority = TimerPriority.FiftyMS;
+
+                this.m_Player = player;
+            }
+
+            protected override void OnTick()
+            {
+                if (this.m_Player.Deleted)
+                {
+                    if (this.m_Step > 0)
+                        this.m_Paladin.Delete();
+
+                    return;
+                }
+
+                if (this.m_Step > 0 && this.m_Paladin.Deleted)
+                    return;
+
+                if (this.m_Step == 0)
+                {
+                    SummonedPaladinMoongate moongate = new SummonedPaladinMoongate();
+                    moongate.MoveToWorld(new Point3D(2091, 1348, -90), Map.Malas);
+
+                    Effects.PlaySound(moongate.Location, moongate.Map, 0x20E);
+
+                    this.m_Paladin = new SummonedPaladin(this.m_Player);
+                    this.m_Paladin.Frozen = true;
+
+                    this.m_Paladin.Location = moongate.Location;
+                    this.m_Paladin.Map = moongate.Map;
+
+                    this.Delay = TimeSpan.FromSeconds(2.0);
+                    this.Start();
+                }
+                else if (this.m_Step == 1)
+                {
+                    this.m_Paladin.Direction = this.m_Paladin.GetDirectionTo(this.m_Player);
+                    this.m_Paladin.Say(1060122); // STOP WICKED ONE!
+
+                    this.Delay = TimeSpan.FromSeconds(3.0);
+                    this.Start();
+                }
+                else
+                {
+                    this.m_Paladin.Frozen = false;
+
+                    this.m_Paladin.Say(1060123); // I will slay you before I allow you to complete your evil rites!
+
+                    this.m_Paladin.Combatant = this.m_Player;
+                }
+
+                this.m_Step++;
+            }
+        }
+    }
+
+    public class SummonedPaladinMoongate : Item
+    {
+        public SummonedPaladinMoongate()
+            : base(0xF6C)
+        {
+            this.Movable = false;
+            this.Hue = 0x482;
+            this.Light = LightType.Circle300;
+
+            Timer.DelayCall(TimeSpan.FromSeconds(10.0), new TimerCallback(Delete));
+        }
+
+        public SummonedPaladinMoongate(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();
+
+            this.Delete();
+        }
+    }
+}

Scripts/Mobiles/Summons/SummonedWaterElemental.cs

@@ -0,0 +1,76 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a water elemental corpse")]
+    public class SummonedWaterElemental : BaseCreature
+    {
+        [Constructable]
+        public SummonedWaterElemental()
+            : base(AIType.AI_Mage, FightMode.Closest, 10, 1, 0.2, 0.4)
+        {
+            this.Name = "a water elemental";
+            this.Body = 16;
+            this.BaseSoundID = 278;
+
+            this.SetStr(200);
+            this.SetDex(70);
+            this.SetInt(100);
+
+            this.SetHits(165);
+
+            this.SetDamage(12, 16);
+
+            this.SetDamageType(ResistanceType.Physical, 0);
+            this.SetDamageType(ResistanceType.Cold, 100);
+
+            this.SetResistance(ResistanceType.Physical, 50, 60);
+            this.SetResistance(ResistanceType.Fire, 20, 30);
+            this.SetResistance(ResistanceType.Cold, 70, 80);
+            this.SetResistance(ResistanceType.Poison, 45, 55);
+            this.SetResistance(ResistanceType.Energy, 40, 50);
+
+            this.SetSkill(SkillName.Meditation, 90.0);
+            this.SetSkill(SkillName.EvalInt, 80.0);
+            this.SetSkill(SkillName.Magery, 80.0);
+            this.SetSkill(SkillName.MagicResist, 75.0);
+            this.SetSkill(SkillName.Tactics, 100.0);
+            this.SetSkill(SkillName.Wrestling, 85.0);
+
+            this.VirtualArmor = 40;
+            this.ControlSlots = 3;
+            this.CanSwim = true;
+        }
+
+        public SummonedWaterElemental(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public override double DispelDifficulty
+        {
+            get
+            {
+                return 117.5;
+            }
+        }
+        public override double DispelFocus
+        {
+            get
+            {
+                return 45.0;
+            }
+        }
+        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/Summons/VampireBat.cs

@@ -0,0 +1,57 @@
+using System;
+
+namespace Server.Mobiles
+{
+    [CorpseName("a vampire bat corpse")]
+    public class VampireBatFamiliar : BaseFamiliar
+    {
+        public VampireBatFamiliar()
+        {
+            this.Name = "a vampire bat";
+            this.Body = 317;
+            this.BaseSoundID = 0x270;
+
+            this.SetStr(120);
+            this.SetDex(120);
+            this.SetInt(100);
+
+            this.SetHits(90);
+            this.SetStam(120);
+            this.SetMana(0);
+
+            this.SetDamage(5, 10);
+
+            this.SetDamageType(ResistanceType.Physical, 100);
+
+            this.SetResistance(ResistanceType.Physical, 10, 15);
+            this.SetResistance(ResistanceType.Fire, 10, 15);
+            this.SetResistance(ResistanceType.Cold, 10, 15);
+            this.SetResistance(ResistanceType.Poison, 10, 15);
+            this.SetResistance(ResistanceType.Energy, 10, 15);
+
+            this.SetSkill(SkillName.Wrestling, 95.1, 100.0);
+            this.SetSkill(SkillName.Tactics, 50.0);
+
+            this.ControlSlots = 1;
+        }
+
+        public VampireBatFamiliar(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();
+        }
+    }
+}